feat: first cut at publishing tool

tests/engine/PublishEngine.test.ts

@@ -0,0 +1,379 @@
+/**
+ * PublishEngine Unit Tests
+ *
+ * Tests the site upload engine that publishes generated site content
+ * via SCP or rsync to a remote server.
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import path from 'path';
+import { PublishEngine, type PublishCredentials, type PublishResult } from '../../src/main/engine/PublishEngine';
+
+// Hoist mock variables so they're available inside vi.mock factories
+const {
+  mockStat, mockUploadFile, mockMkdir, mockClose, mockScpClient,
+  mockReaddir, mockFsStat, mockAccess,
+  mockRsync,
+} = vi.hoisted(() => {
+  const mockStat = vi.fn();
+  const mockUploadFile = vi.fn();
+  const mockMkdir = vi.fn();
+  const mockClose = vi.fn();
+  const mockScpClient = {
+    stat: mockStat,
+    uploadFile: mockUploadFile,
+    mkdir: mockMkdir,
+    close: mockClose,
+  };
+  const mockReaddir = vi.fn();
+  const mockFsStat = vi.fn();
+  const mockAccess = vi.fn();
+  const mockRsync = vi.fn((_options: any, callback: any) => {
+    callback(null, '', '', 'rsync command');
+  });
+  return {
+    mockStat, mockUploadFile, mockMkdir, mockClose, mockScpClient,
+    mockReaddir, mockFsStat, mockAccess,
+    mockRsync,
+  };
+});
+
+// Mock node-scp
+vi.mock('node-scp', () => ({
+  Client: vi.fn().mockResolvedValue(mockScpClient),
+  default: vi.fn().mockResolvedValue(mockScpClient),
+}));
+
+// Mock rsyncwrapper
+vi.mock('rsyncwrapper', () => ({
+  default: mockRsync,
+}));
+
+// Mock fs/promises
+vi.mock('fs/promises', () => ({
+  default: {
+    readdir: (...args: any[]) => mockReaddir(...args),
+    stat: (...args: any[]) => mockFsStat(...args),
+    access: (...args: any[]) => mockAccess(...args),
+  },
+  readdir: (...args: any[]) => mockReaddir(...args),
+  stat: (...args: any[]) => mockFsStat(...args),
+  access: (...args: any[]) => mockAccess(...args),
+}));
+
+// Mock fs
+vi.mock('fs', () => ({
+  default: { constants: { F_OK: 0 } },
+  constants: { F_OK: 0 },
+}));
+
+describe('PublishEngine', () => {
+  let engine: PublishEngine;
+  const dataDir = '/projects/test-project';
+
+  const defaultCredentials: PublishCredentials = {
+    sshHost: 'example.com',
+    sshUser: 'deploy',
+    sshRemotePath: '/var/www/html',
+    sshMode: 'scp',
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    engine = new PublishEngine();
+    engine.setProjectContext('test-project', dataDir);
+
+    // Default: directories exist, files are regular files
+    mockAccess.mockResolvedValue(undefined);
+    mockFsStat.mockResolvedValue({ isDirectory: () => false, isFile: () => true, mtimeMs: Date.now() });
+    mockReaddir.mockResolvedValue([]);
+    mockStat.mockRejectedValue(new Error('No such file')); // Remote file doesn't exist → upload
+    mockUploadFile.mockResolvedValue(undefined);
+    mockMkdir.mockResolvedValue(undefined);
+    mockClose.mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor and project context', () => {
+    it('should be instantiated via getPublishEngine singleton', async () => {
+      const { getPublishEngine } = await import('../../src/main/engine/PublishEngine');
+      const e1 = getPublishEngine();
+      const e2 = getPublishEngine();
+      expect(e1).toBe(e2);
+    });
+
+    it('should throw if no project context is set', async () => {
+      const noContextEngine = new PublishEngine();
+      await expect(
+        noContextEngine.uploadSite(defaultCredentials, vi.fn()),
+      ).rejects.toThrow('No project context');
+    });
+  });
+
+  describe('credential validation', () => {
+    it('should throw if sshHost is empty', async () => {
+      await expect(
+        engine.uploadSite({ ...defaultCredentials, sshHost: '' }, vi.fn()),
+      ).rejects.toThrow('SSH host is required');
+    });
+
+    it('should throw if sshUser is empty', async () => {
+      await expect(
+        engine.uploadSite({ ...defaultCredentials, sshUser: '' }, vi.fn()),
+      ).rejects.toThrow('SSH user is required');
+    });
+
+    it('should throw if sshRemotePath is empty', async () => {
+      await expect(
+        engine.uploadSite({ ...defaultCredentials, sshRemotePath: '' }, vi.fn()),
+      ).rejects.toThrow('Remote path is required');
+    });
+  });
+
+  describe('directory validation', () => {
+    it('should throw if html directory does not exist', async () => {
+      mockAccess.mockImplementation(async (p: string) => {
+        if ((p as string).endsWith('html')) throw new Error('ENOENT');
+      });
+
+      await expect(
+        engine.uploadSite(defaultCredentials, vi.fn()),
+      ).rejects.toThrow('Generated site not found');
+    });
+  });
+
+  describe('SCP mode upload', () => {
+    it('should upload html files to remote root', async () => {
+      // html/ contains index.html
+      mockReaddir.mockImplementation(async (dir: string, opts?: any) => {
+        if (dir === path.join(dataDir, 'html') && opts?.withFileTypes) {
+          return [{ name: 'index.html', isDirectory: () => false, isFile: () => true }];
+        }
+        return [];
+      });
+
+      mockFsStat.mockResolvedValue({
+        isDirectory: () => false,
+        isFile: () => true,
+        mtimeMs: Date.now(),
+      });
+
+      const onProgress = vi.fn();
+      const result = await engine.uploadSite(defaultCredentials, onProgress);
+
+      expect(result.htmlFilesUploaded).toBeGreaterThanOrEqual(0);
+      expect(onProgress).toHaveBeenCalled();
+    });
+
+    it('should upload thumbnail files to remote thumbnails/', async () => {
+      mockReaddir.mockImplementation(async (dir: string, opts?: any) => {
+        if (dir === path.join(dataDir, 'html') && opts?.withFileTypes) {
+          return [];
+        }
+        if (dir === path.join(dataDir, 'thumbnails') && opts?.withFileTypes) {
+          return [{ name: 'thumb1.jpg', isDirectory: () => false, isFile: () => true }];
+        }
+        return [];
+      });
+
+      mockFsStat.mockResolvedValue({
+        isDirectory: () => false,
+        isFile: () => true,
+        mtimeMs: Date.now(),
+      });
+
+      const result = await engine.uploadSite(defaultCredentials, vi.fn());
+
+      expect(result.thumbnailFilesUploaded).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should only upload image files from media, not .meta sidecars', async () => {
+      mockReaddir.mockImplementation(async (dir: string, opts?: any) => {
+        if (dir === path.join(dataDir, 'html') && opts?.withFileTypes) {
+          return [];
+        }
+        if (dir === path.join(dataDir, 'thumbnails') && opts?.withFileTypes) {
+          return [];
+        }
+        if (dir === path.join(dataDir, 'media') && opts?.withFileTypes) {
+          return [
+            { name: 'photo.jpg', isDirectory: () => false, isFile: () => true },
+            { name: 'photo.jpg.meta', isDirectory: () => false, isFile: () => true },
+            { name: 'document.pdf', isDirectory: () => false, isFile: () => true },
+            { name: 'document.pdf.meta', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      mockFsStat.mockResolvedValue({
+        isDirectory: () => false,
+        isFile: () => true,
+        mtimeMs: Date.now(),
+      });
+
+      const result = await engine.uploadSite(defaultCredentials, vi.fn());
+
+      // Should upload photo.jpg and document.pdf, but NOT .meta files
+      expect(result.mediaFilesUploaded).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should skip files that are not newer than remote', async () => {
+      const remoteTime = Date.now() / 1000; // SSH stats use seconds
+      const localTimeOlder = (remoteTime - 100) * 1000; // local is older (ms)
+
+      mockReaddir.mockImplementation(async (dir: string, opts?: any) => {
+        if (dir === path.join(dataDir, 'html') && opts?.withFileTypes) {
+          return [{ name: 'old.html', isDirectory: () => false, isFile: () => true }];
+        }
+        return [];
+      });
+
+      mockFsStat.mockResolvedValue({
+        isDirectory: () => false,
+        isFile: () => true,
+        mtimeMs: localTimeOlder,
+      });
+
+      // Remote file exists and is newer
+      mockStat.mockResolvedValue({ mtime: remoteTime });
+
+      const result = await engine.uploadSite(defaultCredentials, vi.fn());
+
+      // File should be skipped since remote is newer
+      expect(mockUploadFile).not.toHaveBeenCalled();
+      expect(result.filesSkipped).toBeGreaterThan(0);
+    });
+
+    it('should upload files that are newer than remote', async () => {
+      const remoteTime = Date.now() / 1000 - 100; // Remote is 100s old
+      const localTimeNewer = Date.now(); // local is current (ms)
+
+      mockReaddir.mockImplementation(async (dir: string, opts?: any) => {
+        if (dir === path.join(dataDir, 'html') && opts?.withFileTypes) {
+          return [{ name: 'new.html', isDirectory: () => false, isFile: () => true }];
+        }
+        return [];
+      });
+
+      mockFsStat.mockResolvedValue({
+        isDirectory: () => false,
+        isFile: () => true,
+        mtimeMs: localTimeNewer,
+      });
+
+      mockStat.mockResolvedValue({ mtime: remoteTime });
+
+      const result = await engine.uploadSite(defaultCredentials, vi.fn());
+
+      expect(mockUploadFile).toHaveBeenCalled();
+      expect(result.htmlFilesUploaded).toBeGreaterThan(0);
+    });
+
+    it('should recurse into subdirectories', async () => {
+      mockReaddir.mockImplementation(async (dir: string, opts?: any) => {
+        if (dir === path.join(dataDir, 'html') && opts?.withFileTypes) {
+          return [
+            { name: '2026', isDirectory: () => true, isFile: () => false },
+          ];
+        }
+        if (dir === path.join(dataDir, 'html', '2026') && opts?.withFileTypes) {
+          return [
+            { name: 'post.html', isDirectory: () => false, isFile: () => true },
+          ];
+        }
+        return [];
+      });
+
+      mockFsStat.mockResolvedValue({
+        isDirectory: () => false,
+        isFile: () => true,
+        mtimeMs: Date.now(),
+      });
+
+      const result = await engine.uploadSite(defaultCredentials, vi.fn());
+
+      expect(mockMkdir).toHaveBeenCalled(); // Should create remote subdir
+      expect(result.htmlFilesUploaded).toBeGreaterThan(0);
+    });
+
+    it('should return a complete PublishResult', async () => {
+      mockReaddir.mockResolvedValue([]);
+
+      const result = await engine.uploadSite(defaultCredentials, vi.fn());
+
+      expect(result).toHaveProperty('htmlFilesUploaded');
+      expect(result).toHaveProperty('thumbnailFilesUploaded');
+      expect(result).toHaveProperty('mediaFilesUploaded');
+      expect(result).toHaveProperty('filesSkipped');
+      expect(typeof result.htmlFilesUploaded).toBe('number');
+      expect(typeof result.thumbnailFilesUploaded).toBe('number');
+      expect(typeof result.mediaFilesUploaded).toBe('number');
+      expect(typeof result.filesSkipped).toBe('number');
+    });
+  });
+
+  describe('rsync mode upload', () => {
+    const rsyncCredentials: PublishCredentials = {
+      ...defaultCredentials,
+      sshMode: 'rsync',
+    };
+
+    it('should call rsync for html directory', async () => {
+      const rsync = (await import('rsyncwrapper')).default;
+
+      const result = await engine.uploadSite(rsyncCredentials, vi.fn());
+
+      expect(rsync).toHaveBeenCalled();
+      expect(result.htmlFilesUploaded).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should use --update and --times flags for incremental transfer', async () => {
+      const rsync = (await import('rsyncwrapper')).default;
+
+      await engine.uploadSite(rsyncCredentials, vi.fn());
+
+      // Check that rsync was called with update semantics
+      const calls = vi.mocked(rsync).mock.calls;
+      expect(calls.length).toBeGreaterThan(0);
+      for (const [options] of calls) {
+        expect(options.args).toContain('--update');
+        expect(options.times).toBe(true);
+        expect(options.recursive).toBe(true);
+      }
+    });
+
+    it('should exclude .meta files when syncing media', async () => {
+      const rsync = (await import('rsyncwrapper')).default;
+
+      await engine.uploadSite(rsyncCredentials, vi.fn());
+
+      const calls = vi.mocked(rsync).mock.calls;
+      // Find the media sync call (dest contains /media)
+      const mediaCall = calls.find(([opts]) =>
+        typeof opts.dest === 'string' && opts.dest.includes('/media'),
+      );
+      if (mediaCall) {
+        expect(mediaCall[0].exclude).toContain('*.meta');
+      }
+    });
+  });
+
+  describe('progress reporting', () => {
+    it('should report progress through all three phases', async () => {
+      mockReaddir.mockResolvedValue([]);
+
+      const onProgress = vi.fn();
+      await engine.uploadSite(defaultCredentials, onProgress);
+
+      // Should have called onProgress at least once per phase
+      expect(onProgress).toHaveBeenCalled();
+      const progressValues = onProgress.mock.calls.map(([p]: [number]) => p);
+      // Should reach 100
+      expect(progressValues[progressValues.length - 1]).toBe(100);
+    });
+  });
+});