@aaronshaf/confluence-cli 0.1.15

package/src/test/markdown.test.ts

@@ -0,0 +1,443 @@
+import { describe, expect, test } from 'bun:test';
+import { MarkdownConverter } from '../lib/markdown/converter.js';
+import { slugify, generateUniqueFilename } from '../lib/markdown/slugify.js';
+import {
+  createFrontmatter,
+  serializeMarkdown,
+  parseMarkdown,
+  extractPageId,
+  extractH1Title,
+  stripH1Title,
+} from '../lib/markdown/frontmatter.js';
+
+describe('slugify', () => {
+  test('converts title to lowercase', () => {
+    expect(slugify('Hello World')).toBe('hello-world');
+  });
+
+  test('replaces spaces with hyphens', () => {
+    expect(slugify('hello world test')).toBe('hello-world-test');
+  });
+
+  test('removes special characters', () => {
+    expect(slugify('Hello! World?')).toBe('hello-world');
+    expect(slugify('Test (with) [brackets]')).toBe('test-with-brackets');
+  });
+
+  test('collapses multiple hyphens', () => {
+    expect(slugify('hello---world')).toBe('hello-world');
+    expect(slugify('test - - test')).toBe('test-test');
+  });
+
+  test('trims hyphens from start and end', () => {
+    expect(slugify('  hello world  ')).toBe('hello-world');
+    expect(slugify('-hello-world-')).toBe('hello-world');
+  });
+
+  test('handles empty string', () => {
+    expect(slugify('')).toBe('');
+  });
+
+  test('handles string with only special characters', () => {
+    expect(slugify('!@#$%')).toBe('');
+  });
+});
+
+describe('generateUniqueFilename', () => {
+  test('returns simple filename when no conflicts', () => {
+    const existing = new Set<string>();
+    expect(generateUniqueFilename('Hello World', existing)).toBe('hello-world.md');
+  });
+
+  test('appends counter for conflicts', () => {
+    const existing = new Set(['hello-world.md']);
+    expect(generateUniqueFilename('Hello World', existing)).toBe('hello-world-2.md');
+  });
+
+  test('increments counter for multiple conflicts', () => {
+    const existing = new Set(['hello-world.md', 'hello-world-2.md', 'hello-world-3.md']);
+    expect(generateUniqueFilename('Hello World', existing)).toBe('hello-world-4.md');
+  });
+
+  test('supports custom extension', () => {
+    const existing = new Set<string>();
+    expect(generateUniqueFilename('test', existing, '.txt')).toBe('test.txt');
+  });
+});
+
+describe('createFrontmatter', () => {
+  test('creates frontmatter from page', () => {
+    const page = {
+      id: 'page-123',
+      title: 'Test Page',
+      spaceId: 'space-123',
+      parentId: 'page-parent',
+      authorId: 'user-123',
+      createdAt: '2024-01-01T00:00:00Z',
+      version: {
+        number: 1,
+        createdAt: '2024-01-01T00:00:00Z',
+        authorId: 'user-456',
+      },
+      _links: {
+        webui: '/spaces/TEST/pages/page-123',
+      },
+    };
+
+    const frontmatter = createFrontmatter(page, [], 'Parent Page', 'https://test.atlassian.net');
+
+    expect(frontmatter.page_id).toBe('page-123');
+    expect(frontmatter.title).toBe('Test Page');
+    expect(frontmatter.version).toBe(1);
+    expect(frontmatter.parent_id).toBe('page-parent');
+    expect(frontmatter.parent_title).toBe('Parent Page');
+    expect(frontmatter.url).toBe('https://test.atlassian.net/wiki/spaces/TEST/pages/page-123');
+    expect(frontmatter.synced_at).toBeDefined();
+  });
+
+  test('includes labels', () => {
+    const page = {
+      id: 'page-123',
+      title: 'Test Page',
+      spaceId: 'space-123',
+    };
+
+    const labels = [
+      { id: 'label-1', name: 'important' },
+      { id: 'label-2', name: 'draft' },
+    ];
+
+    const frontmatter = createFrontmatter(page, labels);
+
+    expect(frontmatter.labels).toEqual(['important', 'draft']);
+  });
+
+  test('includes child_count when provided', () => {
+    const page = {
+      id: 'page-123',
+      title: 'Test Page',
+      spaceId: 'space-123',
+    };
+
+    const frontmatter = createFrontmatter(page, [], undefined, undefined, undefined, undefined, 5);
+
+    expect(frontmatter.child_count).toBe(5);
+  });
+
+  test('child_count is undefined when not provided', () => {
+    const page = {
+      id: 'page-123',
+      title: 'Test Page',
+      spaceId: 'space-123',
+    };
+
+    const frontmatter = createFrontmatter(page, []);
+
+    expect(frontmatter.child_count).toBeUndefined();
+  });
+
+  test('child_count can be zero', () => {
+    const page = {
+      id: 'page-123',
+      title: 'Test Page',
+      spaceId: 'space-123',
+    };
+
+    const frontmatter = createFrontmatter(page, [], undefined, undefined, undefined, undefined, 0);
+
+    expect(frontmatter.child_count).toBe(0);
+  });
+});
+
+describe('serializeMarkdown and parseMarkdown', () => {
+  test('serializes and parses markdown with frontmatter', () => {
+    const frontmatter = {
+      page_id: 'page-123',
+      title: 'Test Page',
+      space_key: 'TEST',
+      synced_at: '2024-01-01T00:00:00Z',
+    };
+    const content = '# Hello World\n\nThis is test content.';
+
+    const markdown = serializeMarkdown(frontmatter, content);
+    const parsed = parseMarkdown(markdown);
+
+    expect(parsed.frontmatter.page_id).toBe('page-123');
+    expect(parsed.frontmatter.title).toBe('Test Page');
+    expect(parsed.content.trim()).toBe(content);
+  });
+
+  test('handles empty content', () => {
+    const frontmatter = {
+      page_id: 'page-123',
+      title: 'Empty Page',
+      space_key: 'TEST',
+      synced_at: '2024-01-01T00:00:00Z',
+    };
+
+    const markdown = serializeMarkdown(frontmatter, '');
+    const parsed = parseMarkdown(markdown);
+
+    expect(parsed.frontmatter.page_id).toBe('page-123');
+    expect(parsed.content.trim()).toBe('');
+  });
+});
+
+describe('extractPageId', () => {
+  test('extracts page ID from markdown', () => {
+    const markdown = `---
+page_id: page-123
+title: Test
+---
+
+Content here`;
+
+    expect(extractPageId(markdown)).toBe('page-123');
+  });
+
+  test('returns undefined when no frontmatter', () => {
+    const markdown = '# Just content\n\nNo frontmatter here.';
+    expect(extractPageId(markdown)).toBeUndefined();
+  });
+
+  test('returns undefined when no page_id in frontmatter', () => {
+    const markdown = `---
+title: Test
+---
+
+Content`;
+
+    expect(extractPageId(markdown)).toBeUndefined();
+  });
+});
+
+describe('extractH1Title', () => {
+  test('extracts H1 from content', () => {
+    const content = '# My Page Title\n\nSome content here.';
+    expect(extractH1Title(content)).toBe('My Page Title');
+  });
+
+  test('returns first H1 when multiple exist', () => {
+    const content = '# First Title\n\n## Subtitle\n\n# Second Title';
+    expect(extractH1Title(content)).toBe('First Title');
+  });
+
+  test('returns undefined when no H1 exists', () => {
+    const content = '## Subtitle\n\nContent without H1.';
+    expect(extractH1Title(content)).toBeUndefined();
+  });
+
+  test('returns undefined for empty content', () => {
+    expect(extractH1Title('')).toBeUndefined();
+  });
+
+  test('handles H1 with leading/trailing whitespace', () => {
+    const content = '#   Spaced Title   \n\nContent';
+    expect(extractH1Title(content)).toBe('Spaced Title');
+  });
+
+  test('does not match H1 inside code blocks', () => {
+    // This regex matches the first # at start of line, which may be in code
+    // Current implementation would match - but that's acceptable since code blocks
+    // at the very start of a file are unusual
+    const content = 'Some text\n# Real Title\n\nMore content';
+    expect(extractH1Title(content)).toBe('Real Title');
+  });
+
+  test('matches H1 not at start of content', () => {
+    const content = '\n\n# Title After Newlines\n\nContent';
+    expect(extractH1Title(content)).toBe('Title After Newlines');
+  });
+});
+
+describe('stripH1Title', () => {
+  test('strips H1 from start of content', () => {
+    const content = '# My Title\n\nSome content here.';
+    expect(stripH1Title(content)).toBe('Some content here.');
+  });
+
+  test('strips H1 with extra newlines', () => {
+    const content = '# Title\n\n\nContent with extra newlines.';
+    expect(stripH1Title(content)).toBe('Content with extra newlines.');
+  });
+
+  test('returns content unchanged if no H1', () => {
+    const content = 'No heading here.\n\nJust paragraphs.';
+    expect(stripH1Title(content)).toBe('No heading here.\n\nJust paragraphs.');
+  });
+
+  test('only strips first H1', () => {
+    const content = '# First Title\n\nContent\n\n# Second Title\n\nMore content';
+    expect(stripH1Title(content)).toBe('Content\n\n# Second Title\n\nMore content');
+  });
+
+  test('handles content starting with H1 with no following content', () => {
+    const content = '# Just a Title';
+    expect(stripH1Title(content)).toBe('');
+  });
+
+  test('handles empty content', () => {
+    expect(stripH1Title('')).toBe('');
+  });
+});
+
+describe('MarkdownConverter', () => {
+  test('converts simple HTML to markdown', () => {
+    const converter = new MarkdownConverter();
+    const html = '<p>Hello <strong>world</strong>!</p>';
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('Hello');
+    expect(markdown).toContain('**world**');
+  });
+
+  test('converts headings', () => {
+    const converter = new MarkdownConverter();
+    const html = '<h1>Title</h1><h2>Subtitle</h2>';
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('# Title');
+    expect(markdown).toContain('## Subtitle');
+  });
+
+  test('converts lists', () => {
+    const converter = new MarkdownConverter();
+    const html = '<ul><li>Item 1</li><li>Item 2</li></ul>';
+    const markdown = converter.convert(html);
+
+    // Turndown uses 3 spaces after bullet marker
+    expect(markdown).toContain('-   Item 1');
+    expect(markdown).toContain('-   Item 2');
+  });
+
+  test('converts links', () => {
+    const converter = new MarkdownConverter();
+    const html = '<a href="https://example.com">Link</a>';
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('[Link](https://example.com)');
+  });
+
+  test('handles code blocks', () => {
+    const converter = new MarkdownConverter();
+    const html = '<pre><code>const x = 1;</code></pre>';
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('const x = 1;');
+  });
+
+  test('handles Confluence code macro with language', () => {
+    const converter = new MarkdownConverter();
+    const html = `<ac:structured-macro ac:name="code" ac:schema-version="1">
+      <ac:parameter ac:name="language">bash</ac:parameter>
+      <ac:plain-text-body><![CDATA[echo "hello world"
+ls -la]]></ac:plain-text-body>
+    </ac:structured-macro>`;
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('```bash');
+    expect(markdown).toContain('echo "hello world"');
+    expect(markdown).toContain('ls -la');
+    expect(markdown).toContain('```');
+  });
+
+  test('handles Confluence code macro without language', () => {
+    const converter = new MarkdownConverter();
+    const html = `<ac:structured-macro ac:name="code" ac:schema-version="1">
+      <ac:plain-text-body><![CDATA[some plain code]]></ac:plain-text-body>
+    </ac:structured-macro>`;
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('```');
+    expect(markdown).toContain('some plain code');
+  });
+
+  test('handles Confluence code macro with special characters', () => {
+    const converter = new MarkdownConverter();
+    const html = `<ac:structured-macro ac:name="code" ac:schema-version="1">
+      <ac:parameter ac:name="language">javascript</ac:parameter>
+      <ac:plain-text-body><![CDATA[if (x < 5 && y > 3) {
+  console.log("test");
+}]]></ac:plain-text-body>
+    </ac:structured-macro>`;
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('```javascript');
+    expect(markdown).toContain('if (x < 5 && y > 3)');
+    expect(markdown).toContain('console.log("test")');
+  });
+
+  test('converts tables with GFM plugin', () => {
+    const converter = new MarkdownConverter();
+    const html = `
+      <table>
+        <thead>
+          <tr><th>Col 1</th><th>Col 2</th></tr>
+        </thead>
+        <tbody>
+          <tr><td>A</td><td>B</td></tr>
+        </tbody>
+      </table>
+    `;
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('Col 1');
+    expect(markdown).toContain('Col 2');
+    expect(markdown).toContain('|');
+  });
+
+  test('removes empty paragraphs', () => {
+    const converter = new MarkdownConverter();
+    const html = '<p></p><p>Content</p><p></p>';
+    const markdown = converter.convert(html);
+
+    expect(markdown.trim()).toBe('Content');
+  });
+
+  test('convertPage creates markdown with frontmatter and H1 heading', () => {
+    const converter = new MarkdownConverter();
+    const page = {
+      id: 'page-123',
+      title: 'Test Page',
+      spaceId: 'space-123',
+      body: {
+        storage: {
+          value: '<p>Hello World</p>',
+        },
+      },
+    };
+
+    const { markdown } = converter.convertPage(page);
+
+    expect(markdown).toContain('page_id: page-123');
+    expect(markdown).toContain('title: Test Page');
+    // H1 heading should be added from page title
+    expect(markdown).toContain('# Test Page');
+    expect(markdown).toContain('Hello World');
+  });
+
+  test('converts Confluence user references to @mentions', () => {
+    const converter = new MarkdownConverter();
+    const html = `
+      <p>Contact <ac:link><ri:user ri:account-id="5f123abc" /></ac:link> for help.</p>
+    `;
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('@5f123abc');
+    expect(markdown).not.toContain('ac:link');
+    expect(markdown).not.toContain('ri:user');
+  });
+
+  test('converts standalone ri:user elements to @mentions', () => {
+    const converter = new MarkdownConverter();
+    const html = `
+      <table>
+        <tr><td><ri:user ri:account-id="user123" /></td></tr>
+      </table>
+    `;
+    const markdown = converter.convert(html);
+
+    expect(markdown).toContain('@user123');
+    expect(markdown).not.toContain('ri:user');
+  });
+});

package/src/test/mocks/handlers.ts

@@ -0,0 +1,228 @@
+import { HttpResponse, http } from 'msw';
+import {
+  AttachmentsResponseSchema,
+  CommentsResponseSchema,
+  FolderSchema,
+  SearchResponseSchema,
+  SpaceSchema,
+  SpacesResponseSchema,
+  PagesResponseSchema,
+  PageSchema,
+  UserSchema,
+} from '../../lib/confluence-client/types.js';
+import {
+  createValidAttachment,
+  createValidFolder,
+  createValidPage,
+  createValidSpace,
+  validateAndReturn,
+} from '../msw-schema-validation.js';
+
+/**
+ * Shared MSW handlers with schema validation
+ * These handlers ensure all mock responses conform to our Effect schemas
+ *
+ * IMPORTANT: These are DEFAULT/FALLBACK handlers that prevent unhandled requests.
+ * Individual tests should override these with server.use() for specific test scenarios.
+ */
+export const handlers = [
+  // Confluence spaces mock
+  http.get('*/wiki/api/v2/spaces', ({ request }) => {
+    const url = new URL(request.url);
+    const keys = url.searchParams.get('keys');
+
+    if (keys) {
+      // Return specific space
+      const space = createValidSpace({ key: keys });
+      const response = { results: [space] };
+      return HttpResponse.json(validateAndReturn(SpacesResponseSchema, response, 'Spaces by key'));
+    }
+
+    // Return default spaces list
+    const spaces = [
+      createValidSpace({ id: 'space-1', key: 'TEST', name: 'Test Space' }),
+      createValidSpace({ id: 'space-2', key: 'DOCS', name: 'Documentation' }),
+    ];
+
+    return HttpResponse.json(validateAndReturn(SpacesResponseSchema, { results: spaces }, 'Spaces List'));
+  }),
+
+  // Confluence single space mock
+  http.get('*/wiki/api/v2/spaces/:spaceId', ({ params }) => {
+    const space = createValidSpace({ id: params.spaceId as string });
+    return HttpResponse.json(validateAndReturn(SpaceSchema, space, 'Single Space'));
+  }),
+
+  // Confluence pages in space mock
+  http.get('*/wiki/api/v2/spaces/:spaceId/pages', ({ params }) => {
+    const pages = [
+      createValidPage({ id: 'page-1', title: 'Home', spaceId: params.spaceId as string }),
+      createValidPage({
+        id: 'page-2',
+        title: 'Getting Started',
+        spaceId: params.spaceId as string,
+        parentId: 'page-1',
+      }),
+    ];
+
+    return HttpResponse.json(validateAndReturn(PagesResponseSchema, { results: pages }, 'Pages in Space'));
+  }),
+
+  // Confluence single page mock
+  http.get('*/wiki/api/v2/pages/:pageId', ({ params }) => {
+    const page = createValidPage({
+      id: params.pageId as string,
+      title: 'Test Page',
+      body: '<p>Test content</p>',
+    });
+
+    return HttpResponse.json(validateAndReturn(PageSchema, page, 'Single Page'));
+  }),
+
+  // Confluence child pages mock
+  http.get('*/wiki/api/v2/pages/:pageId/children', () => {
+    return HttpResponse.json(validateAndReturn(PagesResponseSchema, { results: [] }, 'Child Pages'));
+  }),
+
+  // Confluence labels mock
+  http.get('*/wiki/api/v2/pages/:pageId/labels', () => {
+    return HttpResponse.json({ results: [] });
+  }),
+
+  // Confluence folder mock
+  http.get('*/wiki/api/v2/folders/:folderId', ({ params }) => {
+    const folder = createValidFolder({
+      id: params.folderId as string,
+      title: 'Test Folder',
+      parentId: 'page-1',
+      parentType: 'page',
+    });
+    return HttpResponse.json(validateAndReturn(FolderSchema, folder, 'Single Folder'));
+  }),
+
+  // Confluence create folder mock
+  http.post('*/wiki/api/v2/folders', async ({ request }) => {
+    const body = (await request.json()) as { spaceId: string; title: string; parentId?: string };
+    const folder = createValidFolder({
+      id: `folder-${Date.now()}`,
+      title: body.title,
+      parentId: body.parentId || null,
+    });
+    return HttpResponse.json(validateAndReturn(FolderSchema, folder, 'Created Folder'));
+  }),
+
+  // Confluence move page mock (v1 API)
+  // Response body varies and is not validated by the client
+  http.put('*/wiki/rest/api/content/:pageId/move/:position/:targetId', () => {
+    return HttpResponse.json({});
+  }),
+
+  // Confluence footer comments mock
+  http.get('*/wiki/api/v2/pages/:pageId/footer-comments', () => {
+    return HttpResponse.json(validateAndReturn(CommentsResponseSchema, { results: [] }, 'Footer Comments'));
+  }),
+
+  // Confluence attachments mock
+  http.get('*/wiki/api/v2/pages/:pageId/attachments', () => {
+    return HttpResponse.json(validateAndReturn(AttachmentsResponseSchema, { results: [] }, 'Attachments'));
+  }),
+
+  // Upload attachment mock (v1 API)
+  http.post('*/wiki/rest/api/content/:pageId/child/attachment', () => {
+    const attachment = createValidAttachment({ id: `att-${Date.now()}`, title: 'uploaded-file.png' });
+    return HttpResponse.json({ results: [attachment] });
+  }),
+
+  // Delete attachment mock
+  http.delete('*/wiki/api/v2/attachments/:attachmentId', () => {
+    return new HttpResponse(null, { status: 204 });
+  }),
+
+  // Delete page mock
+  http.delete('*/wiki/api/v2/pages/:pageId', () => {
+    return new HttpResponse(null, { status: 204 });
+  }),
+
+  // Add label mock (v1 API)
+  http.post('*/wiki/rest/api/content/:pageId/label', () => {
+    return HttpResponse.json([]);
+  }),
+
+  // Remove label mock (v1 API)
+  http.delete('*/wiki/rest/api/content/:pageId/label/:labelName', () => {
+    return new HttpResponse(null, { status: 204 });
+  }),
+
+  // Search mock (v1 API)
+  http.get('*/wiki/rest/api/search', ({ request }) => {
+    const url = new URL(request.url);
+    const cql = url.searchParams.get('cql') || '';
+    if (cql.includes('type=folder')) {
+      return HttpResponse.json(validateAndReturn(SearchResponseSchema, { results: [] }, 'Search (folder)'));
+    }
+    return HttpResponse.json(
+      validateAndReturn(
+        SearchResponseSchema,
+        {
+          results: [
+            {
+              id: 'page-123',
+              title: 'Test Page',
+              type: 'page',
+              content: {
+                id: 'page-123',
+                type: 'page',
+                title: 'Test Page',
+                _links: { webui: '/wiki/spaces/TEST/pages/page-123' },
+              },
+              excerpt: 'Test content excerpt',
+            },
+          ],
+          totalSize: 1,
+          start: 0,
+          limit: 10,
+        },
+        'Search',
+      ),
+    );
+  }),
+
+  // Confluence user mock (v1 API - v2 doesn't have user endpoint)
+  http.get('*/wiki/rest/api/user', ({ request }) => {
+    const url = new URL(request.url);
+    const accountId = url.searchParams.get('accountId') || 'unknown';
+    // Generate unique user data based on accountId for realistic test coverage
+    const shortId = accountId.slice(0, 8);
+    const user = {
+      accountId,
+      displayName: `User ${shortId}`,
+      email: `user-${shortId}@example.com`,
+    };
+    return HttpResponse.json(validateAndReturn(UserSchema, user, 'User'));
+  }),
+
+  // CATCH-ALL: Return 404 for any unhandled requests
+  http.get('*', ({ request }) => {
+    console.warn(`[MSW] Unhandled GET request: ${request.url}`);
+    return HttpResponse.json(
+      { errorMessages: ['Unhandled request - add a handler for this endpoint'] },
+      { status: 404 },
+    );
+  }),
+
+  http.post('*', ({ request }) => {
+    console.warn(`[MSW] Unhandled POST request: ${request.url}`);
+    return HttpResponse.json(
+      { errorMessages: ['Unhandled request - add a handler for this endpoint'] },
+      { status: 404 },
+    );
+  }),
+
+  http.put('*', ({ request }) => {
+    console.warn(`[MSW] Unhandled PUT request: ${request.url}`);
+    return HttpResponse.json(
+      { errorMessages: ['Unhandled request - add a handler for this endpoint'] },
+      { status: 404 },
+    );
+  }),
+];