@aaronshaf/confluence-cli 0.1.15

package/src/test/space-config.test.ts

@@ -0,0 +1,516 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  createSpaceConfig,
+  readSpaceConfig,
+  writeSpaceConfig,
+  hasSpaceConfig,
+  updateLastSync,
+  updatePageSyncInfo,
+  removePageSyncInfo,
+  getTrackedPageIds,
+  updateFolderSyncInfo,
+  getFolderByPath,
+  getFolderById,
+  removeFolderSyncInfo,
+  type SpaceConfigWithState,
+  type FolderSyncInfo,
+} from '../lib/space-config.js';
+
+describe('space-config', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `cn-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('createSpaceConfig', () => {
+    test('creates config with required fields', () => {
+      const config = createSpaceConfig('TEST', 'space-123', 'Test Space');
+
+      expect(config.spaceKey).toBe('TEST');
+      expect(config.spaceId).toBe('space-123');
+      expect(config.spaceName).toBe('Test Space');
+      expect(config.pages).toEqual({});
+      expect(config.lastSync).toBeUndefined();
+    });
+  });
+
+  describe('hasSpaceConfig', () => {
+    test('returns false when no config exists', () => {
+      expect(hasSpaceConfig(testDir)).toBe(false);
+    });
+
+    test('returns true when config exists', () => {
+      const configPath = join(testDir, '.confluence.json');
+      writeFileSync(configPath, JSON.stringify({ spaceKey: 'TEST' }));
+
+      expect(hasSpaceConfig(testDir)).toBe(true);
+    });
+  });
+
+  describe('readSpaceConfig', () => {
+    test('returns null when no config exists', () => {
+      const config = readSpaceConfig(testDir);
+      expect(config).toBeNull();
+    });
+
+    test('reads valid config', () => {
+      // Per ADR-0024: pages is now Record<string, string> (pageId -> localPath)
+      const testConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        lastSync: '2024-01-01T00:00:00Z',
+        pages: {
+          'page-1': 'home.md',
+        },
+      };
+
+      const configPath = join(testDir, '.confluence.json');
+      writeFileSync(configPath, JSON.stringify(testConfig));
+
+      const config = readSpaceConfig(testDir);
+
+      expect(config).not.toBeNull();
+      expect(config?.spaceKey).toBe('TEST');
+      expect(config?.spaceName).toBe('Test Space');
+      expect(config?.pages['page-1']).toBe('home.md');
+    });
+
+    test('migrates legacy format to new format', () => {
+      // Legacy format: pages contain full PageSyncInfo objects
+      const legacyConfig = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': {
+            pageId: 'page-1',
+            version: 5,
+            lastModified: '2024-01-14T08:00:00Z',
+            localPath: 'docs/intro.md',
+            title: 'Introduction',
+          },
+          'page-2': {
+            pageId: 'page-2',
+            version: 3,
+            localPath: 'docs/setup.md',
+            title: 'Setup Guide',
+          },
+        },
+      };
+
+      const configPath = join(testDir, '.confluence.json');
+      writeFileSync(configPath, JSON.stringify(legacyConfig));
+
+      const config = readSpaceConfig(testDir);
+
+      // Should be migrated to new format
+      expect(config).not.toBeNull();
+      expect(config?.pages['page-1']).toBe('docs/intro.md');
+      expect(config?.pages['page-2']).toBe('docs/setup.md');
+
+      // Verify the file was rewritten with new format
+      const savedContent = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(savedContent.pages['page-1']).toBe('docs/intro.md');
+      expect(savedContent.pages['page-2']).toBe('docs/setup.md');
+    });
+
+    test('returns null for invalid JSON', () => {
+      const configPath = join(testDir, '.confluence.json');
+      writeFileSync(configPath, 'invalid json');
+
+      const config = readSpaceConfig(testDir);
+      expect(config).toBeNull();
+    });
+  });
+
+  describe('writeSpaceConfig', () => {
+    test('writes config to file', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      writeSpaceConfig(testDir, config);
+
+      const configPath = join(testDir, '.confluence.json');
+      expect(existsSync(configPath)).toBe(true);
+
+      const saved = JSON.parse(readFileSync(configPath, 'utf-8'));
+      expect(saved.spaceKey).toBe('TEST');
+    });
+  });
+
+  describe('updateLastSync', () => {
+    test('adds lastSync timestamp', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const updated = updateLastSync(config);
+
+      expect(updated.lastSync).toBeDefined();
+      if (updated.lastSync) {
+        expect(new Date(updated.lastSync).getTime()).toBeGreaterThan(0);
+      }
+    });
+
+    test('does not mutate original config', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const updated = updateLastSync(config);
+
+      expect(config.lastSync).toBeUndefined();
+      expect(updated).not.toBe(config);
+    });
+  });
+
+  describe('updatePageSyncInfo', () => {
+    test('adds new page', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      // Per ADR-0024: Only pageId and localPath are stored
+      const updated = updatePageSyncInfo(config, {
+        pageId: 'page-1',
+        localPath: 'home.md',
+      });
+
+      expect(updated.pages['page-1']).toBeDefined();
+      expect(updated.pages['page-1']).toBe('home.md');
+    });
+
+    test('updates existing page', () => {
+      // Per ADR-0024: pages is now Record<string, string>
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': 'home.md',
+        },
+      };
+
+      const updated = updatePageSyncInfo(config, {
+        pageId: 'page-1',
+        localPath: 'new-home.md',
+      });
+
+      expect(updated.pages['page-1']).toBe('new-home.md');
+    });
+
+    test('does not mutate original config', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const updated = updatePageSyncInfo(config, {
+        pageId: 'page-1',
+        localPath: 'home.md',
+      });
+
+      expect(Object.keys(config.pages)).toHaveLength(0);
+      expect(updated).not.toBe(config);
+    });
+  });
+
+  describe('removePageSyncInfo', () => {
+    test('removes existing page', () => {
+      // Per ADR-0024: pages is now Record<string, string>
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': 'home.md',
+          'page-2': 'getting-started.md',
+        },
+      };
+
+      const updated = removePageSyncInfo(config, 'page-1');
+
+      expect(updated.pages['page-1']).toBeUndefined();
+      expect(updated.pages['page-2']).toBeDefined();
+    });
+
+    test('does nothing for non-existent page', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const updated = removePageSyncInfo(config, 'page-1');
+
+      expect(Object.keys(updated.pages)).toHaveLength(0);
+    });
+  });
+
+  describe('getTrackedPageIds', () => {
+    test('returns all tracked page IDs', () => {
+      // Per ADR-0024: pages is now Record<string, string>
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': 'home.md',
+          'page-2': 'getting-started.md',
+          'page-3': 'api.md',
+        },
+      };
+
+      const ids = getTrackedPageIds(config);
+
+      expect(ids).toHaveLength(3);
+      expect(ids).toContain('page-1');
+      expect(ids).toContain('page-2');
+      expect(ids).toContain('page-3');
+    });
+
+    test('returns empty array for no pages', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const ids = getTrackedPageIds(config);
+
+      expect(ids).toHaveLength(0);
+    });
+  });
+
+  describe('updateFolderSyncInfo', () => {
+    test('adds new folder', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const folderInfo: FolderSyncInfo = {
+        folderId: 'folder-1',
+        title: 'docs',
+        localPath: 'docs',
+      };
+
+      const updated = updateFolderSyncInfo(config, folderInfo);
+
+      expect(updated.folders).toBeDefined();
+      expect(updated.folders?.['folder-1']).toBeDefined();
+      expect(updated.folders?.['folder-1'].title).toBe('docs');
+      expect(updated.folders?.['folder-1'].localPath).toBe('docs');
+    });
+
+    test('updates existing folder', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {
+          'folder-1': {
+            folderId: 'folder-1',
+            title: 'docs',
+            localPath: 'docs',
+          },
+        },
+      };
+
+      const folderInfo: FolderSyncInfo = {
+        folderId: 'folder-1',
+        title: 'documentation',
+        localPath: 'docs',
+      };
+
+      const updated = updateFolderSyncInfo(config, folderInfo);
+
+      expect(updated.folders?.['folder-1'].title).toBe('documentation');
+    });
+
+    test('does not mutate original config', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const folderInfo: FolderSyncInfo = {
+        folderId: 'folder-1',
+        title: 'docs',
+        localPath: 'docs',
+      };
+
+      const updated = updateFolderSyncInfo(config, folderInfo);
+
+      expect(config.folders).toBeUndefined();
+      expect(updated).not.toBe(config);
+    });
+  });
+
+  describe('getFolderByPath', () => {
+    test('returns folder matching path', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {
+          'folder-1': { folderId: 'folder-1', title: 'docs', localPath: 'docs' },
+          'folder-2': { folderId: 'folder-2', title: 'api', parentId: 'folder-1', localPath: 'docs/api' },
+        },
+      };
+
+      const folder = getFolderByPath(config, 'docs/api');
+
+      expect(folder).toBeDefined();
+      expect(folder?.folderId).toBe('folder-2');
+      expect(folder?.title).toBe('api');
+    });
+
+    test('returns undefined for non-existent path', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {
+          'folder-1': { folderId: 'folder-1', title: 'docs', localPath: 'docs' },
+        },
+      };
+
+      const folder = getFolderByPath(config, 'nonexistent');
+
+      expect(folder).toBeUndefined();
+    });
+
+    test('returns undefined when no folders exist', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const folder = getFolderByPath(config, 'docs');
+
+      expect(folder).toBeUndefined();
+    });
+  });
+
+  describe('getFolderById', () => {
+    test('returns folder by ID', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {
+          'folder-1': { folderId: 'folder-1', title: 'docs', localPath: 'docs' },
+          'folder-2': { folderId: 'folder-2', title: 'api', localPath: 'docs/api' },
+        },
+      };
+
+      const folder = getFolderById(config, 'folder-1');
+
+      expect(folder).toBeDefined();
+      expect(folder?.title).toBe('docs');
+    });
+
+    test('returns undefined for non-existent ID', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {
+          'folder-1': { folderId: 'folder-1', title: 'docs', localPath: 'docs' },
+        },
+      };
+
+      const folder = getFolderById(config, 'nonexistent');
+
+      expect(folder).toBeUndefined();
+    });
+  });
+
+  describe('removeFolderSyncInfo', () => {
+    test('removes existing folder', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {
+          'folder-1': { folderId: 'folder-1', title: 'docs', localPath: 'docs' },
+          'folder-2': { folderId: 'folder-2', title: 'api', localPath: 'docs/api' },
+        },
+      };
+
+      const updated = removeFolderSyncInfo(config, 'folder-1');
+
+      expect(updated.folders?.['folder-1']).toBeUndefined();
+      expect(updated.folders?.['folder-2']).toBeDefined();
+    });
+
+    test('does nothing for non-existent folder', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+        folders: {},
+      };
+
+      const updated = removeFolderSyncInfo(config, 'folder-1');
+
+      expect(Object.keys(updated.folders || {})).toHaveLength(0);
+    });
+
+    test('handles config with no folders field', () => {
+      const config: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const updated = removeFolderSyncInfo(config, 'folder-1');
+
+      expect(updated.folders).toBeUndefined();
+    });
+  });
+});

package/src/test/spaces.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from 'bun:test';
+import { HttpResponse, http } from 'msw';
+import { ConfluenceClient } from '../lib/confluence-client/client.js';
+import { createValidSpace } from './msw-schema-validation.js';
+import { server } from './setup-msw.js';
+
+const testConfig = {
+  confluenceUrl: 'https://test.atlassian.net',
+  email: 'test@example.com',
+  apiToken: 'test-token',
+};
+
+describe('ConfluenceClient - spaces', () => {
+  test('lists spaces', async () => {
+    const client = new ConfluenceClient(testConfig);
+    const response = await client.getSpaces();
+    expect(response.results).toBeArray();
+    expect(response.results.length).toBeGreaterThan(0);
+    expect(response.results[0]).toHaveProperty('key');
+    expect(response.results[0]).toHaveProperty('name');
+  });
+
+  test('returns specific space by key', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/spaces', ({ request }) => {
+        const url = new URL(request.url);
+        const keys = url.searchParams.get('keys');
+        if (keys === 'DOCS') {
+          return HttpResponse.json({
+            results: [createValidSpace({ id: 'space-docs', key: 'DOCS', name: 'Documentation' })],
+          });
+        }
+        return HttpResponse.json({ results: [] });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    const space = await client.getSpaceByKey('DOCS');
+    expect(space.key).toBe('DOCS');
+    expect(space.name).toBe('Documentation');
+  });
+
+  test('throws on 401', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/spaces', () => {
+        return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await expect(client.getSpaces()).rejects.toThrow();
+  });
+});