@aaronshaf/confluence-cli 0.1.15

package/src/test/html-converter.test.ts

@@ -0,0 +1,399 @@
+import { describe, expect, test } from 'bun:test';
+import { HtmlConverter } from '../lib/markdown/html-converter.js';
+
+describe('HtmlConverter', () => {
+  test('converts simple markdown to HTML', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('Hello **world**!');
+
+    expect(html).toContain('<strong>world</strong>');
+  });
+
+  test('converts headings', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('# Heading 1\n## Heading 2');
+
+    expect(html).toContain('<h1>Heading 1</h1>');
+    expect(html).toContain('<h2>Heading 2</h2>');
+  });
+
+  test('converts lists', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('- Item 1\n- Item 2');
+
+    expect(html).toContain('<ul>');
+    expect(html).toContain('<li>');
+    expect(html).toContain('Item 1');
+  });
+
+  test('converts inline formatting inside list items', () => {
+    const converter = new HtmlConverter();
+    const markdown =
+      '- **[ger](https://github.com/aaronshaf/ger)** - Gerrit CLI for code review\n- **[jk](https://github.com/aaronshaf/jk)** - Jenkins CLI';
+    const { html } = converter.convert(markdown);
+
+    expect(html).toContain('<ul>');
+    expect(html).toContain('<strong><a href="https://github.com/aaronshaf/ger">ger</a></strong>');
+    expect(html).toContain('<strong><a href="https://github.com/aaronshaf/jk">jk</a></strong>');
+    expect(html).toContain('Gerrit CLI for code review');
+    expect(html).not.toContain('**[ger]'); // Should not contain raw markdown
+  });
+
+  test('converts italic and strikethrough', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('Text with *italic* and ~~strikethrough~~ formatting.');
+
+    expect(html).toContain('<em>italic</em>');
+    expect(html).toContain('<del>strikethrough</del>');
+  });
+
+  test('converts line breaks and horizontal rules', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('Line 1  \nLine 2\n\n---\n\nLine 3');
+
+    expect(html).toContain('<br />');
+    expect(html).toContain('<hr />');
+  });
+
+  test('converts links', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('[Example](https://example.com)');
+
+    expect(html).toContain('<a href="https://example.com">Example</a>');
+  });
+
+  test('converts code blocks to Confluence macro', () => {
+    const converter = new HtmlConverter();
+    const markdown = '```javascript\nconst x = 1;\n```';
+    const { html } = converter.convert(markdown);
+
+    expect(html).toContain('ac:structured-macro');
+    expect(html).toContain('ac:name="code"');
+    expect(html).toContain('javascript');
+    expect(html).toContain('const x = 1;');
+  });
+
+  test('converts tables', () => {
+    const converter = new HtmlConverter();
+    const markdown = '| Col 1 | Col 2 |\n|-------|-------|\n| A | B |';
+    const { html } = converter.convert(markdown);
+
+    expect(html).toContain('<table>');
+    expect(html).toContain('<th>Col 1</th>');
+    expect(html).toContain('<td>A</td>');
+  });
+
+  test('converts blockquotes', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('> This is a quote');
+
+    expect(html).toContain('<blockquote>');
+    expect(html).toContain('This is a quote');
+  });
+
+  test('converts info panel syntax to Confluence macro', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('> **Info:** This is an info message');
+
+    expect(html).toContain('ac:structured-macro');
+    expect(html).toContain('ac:name="info"');
+    expect(html).toContain('This is an info message');
+  });
+
+  test('ensures XHTML compliance with self-closing tags', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('Line 1\n\nLine 2\n\n---');
+
+    expect(html).toContain('<hr />');
+    expect(html).not.toContain('<hr>');
+  });
+
+  test('warns about local image references', () => {
+    const converter = new HtmlConverter();
+    const { warnings } = converter.convert('![Image](./local-image.png)');
+
+    expect(warnings.length).toBeGreaterThan(0);
+    expect(warnings.some((w) => w.includes('local-image.png'))).toBe(true);
+  });
+
+  test('strips @ prefix from mentions', () => {
+    const converter = new HtmlConverter();
+    const { html, warnings } = converter.convert('Contact @user123 for help.');
+
+    // @ should be stripped, leaving just the username
+    expect(html).toContain('user123');
+    expect(html).not.toContain('@user123');
+    // No warning since we handle it by stripping
+    expect(warnings.some((w) => w.includes('mentions'))).toBe(false);
+  });
+
+  test('does not strip @ from email addresses', () => {
+    const converter = new HtmlConverter();
+    const { html } = converter.convert('Email us at support@example.com for help.');
+
+    // Email addresses should be preserved
+    expect(html).toContain('support@example.com');
+  });
+
+  test('warns about task lists', () => {
+    const converter = new HtmlConverter();
+    const { warnings } = converter.convert('- [x] Done\n- [ ] Todo');
+
+    expect(warnings.length).toBeGreaterThan(0);
+    expect(warnings.some((w) => w.includes('Task list'))).toBe(true);
+  });
+
+  test('escapes CDATA sections in code blocks', () => {
+    const converter = new HtmlConverter();
+    const markdown = '```javascript\nconst x = "]]>";\n```';
+    const { html } = converter.convert(markdown);
+
+    // Should escape ]]> to prevent breaking CDATA
+    expect(html).toContain(']]]]><![CDATA[>');
+    expect(html).not.toContain('const x = "]]>";');
+  });
+
+  test('sanitizes language identifiers in code blocks', () => {
+    const converter = new HtmlConverter();
+    const markdown = '```javascript"><script>alert("xss")</script><x lang="evil\nconsole.log("test");\n```';
+    const { html } = converter.convert(markdown);
+
+    // Should strip dangerous characters from language (quotes, angle brackets, etc.)
+    expect(html).not.toContain('"><script>');
+    expect(html).not.toContain('<x lang="evil');
+    // Should keep alphanumeric parts
+    expect(html).toContain('javascript');
+    // The sanitized version should only have safe characters
+    expect(html).toMatch(/<ac:parameter ac:name="language">[a-zA-Z0-9\-_+]*<\/ac:parameter>/);
+  });
+
+  test('sanitizes script tags in HTML passthrough', () => {
+    const converter = new HtmlConverter();
+    // Use block-level HTML which marked processes through the html renderer
+    const markdown = '<div>\nHello\n</div>\n<script>alert("xss")</script>\n<div>\nworld\n</div>';
+    const { html, warnings } = converter.convert(markdown);
+
+    // Should remove script tags
+    expect(html).not.toContain('<script>');
+    expect(html).not.toContain('alert("xss")');
+    expect(html).toContain('Hello');
+    expect(html).toContain('world');
+    // Should warn about sanitization
+    expect(warnings.some((w) => w.includes('unsafe HTML'))).toBe(true);
+  });
+
+  test('sanitizes event handlers in HTML passthrough', () => {
+    const converter = new HtmlConverter();
+    const markdown = '<div onclick="alert(\'xss\')">Click me</div>';
+    const { html, warnings } = converter.convert(markdown);
+
+    // Should remove event handlers
+    expect(html).not.toContain('onclick');
+    expect(html).not.toContain('alert');
+    expect(html).toContain('Click me');
+    // Should warn about sanitization
+    expect(warnings.some((w) => w.includes('unsafe HTML'))).toBe(true);
+  });
+
+  test('sanitizes javascript: protocol in links', () => {
+    const converter = new HtmlConverter();
+    const markdown = '<a href="javascript:alert(\'xss\')">Click</a>';
+    const { html, warnings } = converter.convert(markdown);
+
+    // Should replace javascript: with safe URL
+    expect(html).not.toContain('javascript:');
+    expect(html).toContain('href="#"');
+    expect(html).toContain('Click');
+    // Should warn about sanitization
+    expect(warnings.some((w) => w.includes('unsafe HTML'))).toBe(true);
+  });
+
+  test('allows safe HTML passthrough', () => {
+    const converter = new HtmlConverter();
+    const markdown = '<div class="highlight">Safe HTML</div>';
+    const { html, warnings } = converter.convert(markdown);
+
+    // Should pass through safe HTML
+    expect(html).toContain('<div class="highlight">');
+    expect(html).toContain('Safe HTML');
+    // Should not warn
+    expect(warnings.some((w) => w.includes('unsafe HTML'))).toBe(false);
+  });
+
+  test('converts relative .md links to Confluence page links', () => {
+    const converter = new HtmlConverter();
+    const pageLookupMap = {
+      titleToPage: new Map(),
+      idToPage: new Map([
+        [
+          'page-123',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'architecture/overview.md',
+            title: 'Architecture Overview',
+          },
+        ],
+      ]),
+      pathToPage: new Map([
+        [
+          'architecture/overview.md',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'architecture/overview.md',
+            title: 'Architecture Overview',
+          },
+        ],
+      ]),
+    };
+
+    const markdown = 'See [Architecture](./architecture/overview.md) for details.';
+    const { html } = converter.convert(markdown, '/test/space', 'home.md', 'TEST', pageLookupMap);
+
+    expect(html).toContain('<ac:link>');
+    expect(html).toContain('ri:page ri:content-title="Architecture Overview"');
+    expect(html).toContain('ri:space-key="TEST"');
+    expect(html).toContain('<ac:plain-text-link-body><![CDATA[Architecture]]></ac:plain-text-link-body>');
+  });
+
+  test('warns about broken local links', () => {
+    const converter = new HtmlConverter();
+    const pageLookupMap = {
+      titleToPage: new Map(),
+      idToPage: new Map(),
+      pathToPage: new Map(),
+    };
+
+    const markdown = 'See [Missing](./non-existent.md).';
+    const { warnings } = converter.convert(markdown, '/test/space', 'home.md', 'TEST', pageLookupMap);
+
+    expect(warnings.length).toBeGreaterThan(0);
+    expect(warnings.some((w) => w.includes('non-existent.md'))).toBe(true);
+  });
+
+  test('preserves external links unchanged', () => {
+    const converter = new HtmlConverter();
+    const pageLookupMap = {
+      titleToPage: new Map(),
+      idToPage: new Map(),
+      pathToPage: new Map(),
+    };
+
+    const markdown = 'See [Google](https://google.com) and [Example](https://example.com/page.md).';
+    const { html } = converter.convert(markdown, '/test/space', 'home.md', 'TEST', pageLookupMap);
+
+    expect(html).toContain('<a href="https://google.com">Google</a>');
+    expect(html).toContain('<a href="https://example.com/page.md">Example</a>');
+    expect(html).not.toContain('<ac:link>');
+  });
+
+  test('properly escapes XML special characters in link titles', () => {
+    const converter = new HtmlConverter();
+    const pageLookupMap = {
+      titleToPage: new Map(),
+      idToPage: new Map([
+        [
+          'page-123',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'special.md',
+            title: 'Page with <Special> & "Chars"',
+          },
+        ],
+      ]),
+      pathToPage: new Map([
+        [
+          'special.md',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'special.md',
+            title: 'Page with <Special> & "Chars"',
+          },
+        ],
+      ]),
+    };
+
+    const markdown = 'See [Special Page](./special.md).';
+    const { html } = converter.convert(markdown, '/test/space', 'home.md', 'TEST', pageLookupMap);
+
+    // Verify XML special characters are properly escaped
+    expect(html).toContain('ri:content-title="Page with &lt;Special&gt; &amp; &quot;Chars&quot;"');
+    expect(html).not.toContain('ri:content-title="Page with <Special> & "Chars""');
+  });
+
+  test('handles links in code blocks without converting them', () => {
+    const converter = new HtmlConverter();
+    const pageLookupMap = {
+      titleToPage: new Map(),
+      idToPage: new Map([
+        [
+          'page-123',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'page.md',
+            title: 'Test Page',
+          },
+        ],
+      ]),
+      pathToPage: new Map([
+        [
+          'page.md',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'page.md',
+            title: 'Test Page',
+          },
+        ],
+      ]),
+    };
+
+    const markdown = '```\n[Link](./page.md)\n```';
+    const { html } = converter.convert(markdown, '/test/space', 'home.md', 'TEST', pageLookupMap);
+
+    // Links inside code blocks should NOT be converted to Confluence links
+    expect(html).not.toContain('<ac:link>');
+    expect(html).toContain('[Link](./page.md)');
+  });
+
+  test('handles inline code with link-like syntax without converting', () => {
+    const converter = new HtmlConverter();
+    const pageLookupMap = {
+      titleToPage: new Map(),
+      idToPage: new Map([
+        [
+          'page-123',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'page.md',
+            title: 'Test Page',
+          },
+        ],
+      ]),
+      pathToPage: new Map([
+        [
+          'page.md',
+          {
+            pageId: 'page-123',
+            version: 1,
+            localPath: 'page.md',
+            title: 'Test Page',
+          },
+        ],
+      ]),
+    };
+
+    const markdown = 'Use the syntax `[Link](./page.md)` in markdown.';
+    const { html } = converter.convert(markdown, '/test/space', 'home.md', 'TEST', pageLookupMap);
+
+    // Inline code should NOT be converted
+    expect(html).toContain('<code>[Link](./page.md)</code>');
+    // But if we have a real link, it should be converted
+    expect(html.match(/<ac:link>/g)).toBeNull();
+  });
+});

package/src/test/info.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'bun:test';
+import { HttpResponse, http } from 'msw';
+import { ConfluenceClient } from '../lib/confluence-client/client.js';
+import { createValidPage } 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 - getPage (info)', () => {
+  test('returns page without body when includeBody=false', async () => {
+    const page = createValidPage({ id: 'page-123', title: 'My Page' });
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId', () => {
+        return HttpResponse.json(page);
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    const result = await client.getPage('page-123', false);
+    expect(result.id).toBe('page-123');
+    expect(result.title).toBe('My Page');
+  });
+
+  test('returns labels for a page', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId/labels', () => {
+        return HttpResponse.json({
+          results: [
+            { id: 'lbl-1', name: 'docs', prefix: 'global' },
+            { id: 'lbl-2', name: 'public', prefix: 'global' },
+          ],
+        });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    const labels = await client.getAllLabels('page-123');
+    expect(labels.length).toBe(2);
+    expect(labels[0].name).toBe('docs');
+  });
+
+  test('throws on 404', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId', () => {
+        return HttpResponse.json({ error: 'Not found' }, { status: 404 });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await expect(client.getPage('nonexistent', false)).rejects.toThrow();
+  });
+});

package/src/test/labels.test.ts

@@ -0,0 +1,70 @@
+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 - label operations', () => {
+  test('lists labels for a page', async () => {
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId/labels', () => {
+        return HttpResponse.json({
+          results: [
+            { id: 'label-1', name: 'documentation', prefix: 'global' },
+            { id: 'label-2', name: 'draft', prefix: 'global' },
+          ],
+        });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    const labels = await client.getAllLabels('page-123');
+    expect(labels.length).toBe(2);
+    expect(labels[0].name).toBe('documentation');
+    expect(labels[1].name).toBe('draft');
+  });
+
+  test('adds a label', async () => {
+    let requestBody: unknown;
+    server.use(
+      http.post('*/wiki/rest/api/content/:pageId/label', async ({ request }) => {
+        requestBody = await request.json();
+        return HttpResponse.json([]);
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await client.addLabel('page-123', 'documentation');
+    expect(requestBody).toEqual([{ prefix: 'global', name: 'documentation' }]);
+  });
+
+  test('removes a label', async () => {
+    let deletedLabel = '';
+    server.use(
+      http.delete('*/wiki/rest/api/content/:pageId/label/:labelName', ({ params }) => {
+        deletedLabel = params.labelName as string;
+        return new HttpResponse(null, { status: 204 });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await client.removeLabel('page-123', 'draft');
+    expect(deletedLabel).toBe('draft');
+  });
+
+  test('throws on 401 when adding label', async () => {
+    server.use(
+      http.post('*/wiki/rest/api/content/:pageId/label', () => {
+        return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await expect(client.addLabel('page-123', 'documentation')).rejects.toThrow();
+  });
+});