@aaronshaf/confluence-cli 0.1.15

package/src/test/comments.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 { server } from './setup-msw.js';
+
+const testConfig = {
+  confluenceUrl: 'https://test.atlassian.net',
+  email: 'test@example.com',
+  apiToken: 'test-token',
+};
+
+describe('ConfluenceClient - getFooterComments', () => {
+  test('returns empty comments by default', async () => {
+    const client = new ConfluenceClient(testConfig);
+    const response = await client.getFooterComments('page-123');
+    expect(response.results).toBeArray();
+    expect(response.results.length).toBe(0);
+  });
+
+  test('returns comments when present', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId/footer-comments', () => {
+        return HttpResponse.json({
+          results: [
+            {
+              id: 'comment-1',
+              body: { storage: { value: '<p>Test comment</p>', representation: 'storage' } },
+              authorId: 'user-123',
+              createdAt: new Date().toISOString(),
+            },
+          ],
+        });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    const response = await client.getFooterComments('page-123');
+    expect(response.results.length).toBe(1);
+    expect(response.results[0].id).toBe('comment-1');
+    expect(response.results[0].body?.storage?.value).toContain('Test comment');
+  });
+
+  test('throws on API error', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId/footer-comments', () => {
+        return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await expect(client.getFooterComments('page-123')).rejects.toThrow();
+  });
+});

package/src/test/config.test.ts

@@ -0,0 +1,209 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { Effect } from 'effect';
+import { ConfigManager } from '../lib/config.js';
+import { ConfigError, FileSystemError, ValidationError } from '../lib/errors.js';
+
+describe('ConfigManager', () => {
+  let testDir: string;
+  let originalEnv: string | undefined;
+
+  beforeEach(() => {
+    // Create a temporary directory for test config
+    testDir = join(tmpdir(), `cn-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+
+    // Override config path
+    originalEnv = process.env.CN_CONFIG_PATH;
+    process.env.CN_CONFIG_PATH = testDir;
+  });
+
+  afterEach(() => {
+    // Cleanup
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+
+    // Restore environment
+    if (originalEnv !== undefined) {
+      process.env.CN_CONFIG_PATH = originalEnv;
+    } else {
+      delete process.env.CN_CONFIG_PATH;
+    }
+  });
+
+  describe('validateUrl', () => {
+    test('accepts valid Confluence Cloud URLs', () => {
+      expect(ConfigManager.validateUrl('https://example.atlassian.net')).toBe(true);
+      expect(ConfigManager.validateUrl('https://my-company.atlassian.net')).toBe(true);
+    });
+
+    test('rejects invalid URLs', () => {
+      expect(ConfigManager.validateUrl('http://example.atlassian.net')).toBe(false);
+      expect(ConfigManager.validateUrl('https://example.com')).toBe(false);
+      expect(ConfigManager.validateUrl('https://atlassian.net')).toBe(false);
+      expect(ConfigManager.validateUrl('example.atlassian.net')).toBe(false);
+    });
+  });
+
+  describe('validateEmail', () => {
+    test('accepts valid email addresses', () => {
+      expect(ConfigManager.validateEmail('user@example.com')).toBe(true);
+      expect(ConfigManager.validateEmail('test.user@company.co.uk')).toBe(true);
+    });
+
+    test('rejects invalid email addresses', () => {
+      expect(ConfigManager.validateEmail('invalid')).toBe(false);
+      expect(ConfigManager.validateEmail('user@')).toBe(false);
+      expect(ConfigManager.validateEmail('@example.com')).toBe(false);
+      expect(ConfigManager.validateEmail('user @example.com')).toBe(false);
+    });
+  });
+
+  describe('hasConfig', () => {
+    test('returns false when no config exists', () => {
+      const manager = new ConfigManager();
+      expect(manager.hasConfig()).toBe(false);
+    });
+
+    test('returns true when config exists', () => {
+      const configPath = join(testDir, 'config.json');
+      writeFileSync(
+        configPath,
+        JSON.stringify({ confluenceUrl: 'https://test.atlassian.net', email: 'test@example.com', apiToken: 'token' }),
+      );
+
+      const manager = new ConfigManager();
+      expect(manager.hasConfig()).toBe(true);
+    });
+  });
+
+  describe('getConfig', () => {
+    test('returns null when no config exists', async () => {
+      const manager = new ConfigManager();
+      const config = await manager.getConfig();
+      expect(config).toBeNull();
+    });
+
+    test('returns config when it exists', async () => {
+      const configPath = join(testDir, 'config.json');
+      const testConfig = {
+        confluenceUrl: 'https://test.atlassian.net',
+        email: 'test@example.com',
+        apiToken: 'test-token',
+      };
+      writeFileSync(configPath, JSON.stringify(testConfig));
+
+      const manager = new ConfigManager();
+      const config = await manager.getConfig();
+
+      expect(config).not.toBeNull();
+      expect(config?.confluenceUrl).toBe(testConfig.confluenceUrl);
+      expect(config?.email).toBe(testConfig.email);
+      expect(config?.apiToken).toBe(testConfig.apiToken);
+    });
+
+    test('returns null for invalid JSON', async () => {
+      const configPath = join(testDir, 'config.json');
+      writeFileSync(configPath, 'invalid json');
+
+      const manager = new ConfigManager();
+      const config = await manager.getConfig();
+      expect(config).toBeNull();
+    });
+  });
+
+  describe('getConfigEffect', () => {
+    test('fails with ConfigError when no config exists', async () => {
+      const manager = new ConfigManager();
+
+      const result = await Effect.runPromise(Effect.either(manager.getConfigEffect()));
+
+      expect(result._tag).toBe('Left');
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(ConfigError);
+      }
+    });
+
+    test('succeeds with config when it exists', async () => {
+      const configPath = join(testDir, 'config.json');
+      const testConfig = {
+        confluenceUrl: 'https://test.atlassian.net',
+        email: 'test@example.com',
+        apiToken: 'test-token',
+      };
+      writeFileSync(configPath, JSON.stringify(testConfig));
+
+      const manager = new ConfigManager();
+      const result = await Effect.runPromise(Effect.either(manager.getConfigEffect()));
+
+      expect(result._tag).toBe('Right');
+      if (result._tag === 'Right') {
+        expect(result.right.confluenceUrl).toBe(testConfig.confluenceUrl);
+      }
+    });
+  });
+
+  describe('setConfig', () => {
+    test('saves valid config', async () => {
+      const manager = new ConfigManager();
+      const testConfig = {
+        confluenceUrl: 'https://test.atlassian.net',
+        email: 'test@example.com',
+        apiToken: 'test-token',
+      };
+
+      await manager.setConfig(testConfig);
+
+      const config = await manager.getConfig();
+      expect(config?.confluenceUrl).toBe(testConfig.confluenceUrl);
+      expect(config?.email).toBe(testConfig.email);
+    });
+
+    test('throws for invalid config', async () => {
+      const manager = new ConfigManager();
+      const invalidConfig = {
+        confluenceUrl: 'invalid-url',
+        email: 'test@example.com',
+        apiToken: 'test-token',
+      };
+
+      expect(async () => {
+        await manager.setConfig(invalidConfig as any);
+      }).toThrow();
+    });
+  });
+
+  describe('setConfigEffect', () => {
+    test('succeeds with valid config', async () => {
+      const manager = new ConfigManager();
+      const testConfig = {
+        confluenceUrl: 'https://test.atlassian.net',
+        email: 'test@example.com',
+        apiToken: 'test-token',
+      };
+
+      const result = await Effect.runPromise(Effect.either(manager.setConfigEffect(testConfig)));
+
+      expect(result._tag).toBe('Right');
+    });
+
+    test('fails with ValidationError for invalid config', async () => {
+      const manager = new ConfigManager();
+      const invalidConfig = {
+        confluenceUrl: 'invalid-url',
+        email: 'test@example.com',
+        apiToken: 'test-token',
+      };
+
+      const result = await Effect.runPromise(Effect.either(manager.setConfigEffect(invalidConfig as any)));
+
+      expect(result._tag).toBe('Left');
+      if (result._tag === 'Left') {
+        expect(result.left).toBeInstanceOf(ValidationError);
+      }
+    });
+  });
+});