@aaronshaf/confluence-cli 0.1.15

package/src/test/dependency-sorter.test.ts

@@ -0,0 +1,384 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { extractLocalLinks, sortByDependencies } from '../lib/dependency-sorter.js';
+import type { PushCandidate } from '../lib/file-scanner.js';
+
+describe('dependency-sorter', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = mkdtempSync(join(tmpdir(), 'cn-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('extractLocalLinks', () => {
+    test('extracts simple markdown links to .md files', () => {
+      const content = 'Check out [my page](other-page.md) for more info.';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual(['other-page.md']);
+    });
+
+    test('extracts multiple links', () => {
+      const content = `
+# Documentation
+
+See [intro](intro.md) for getting started.
+Then read [guide](guide.md) for details.
+`;
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual(['intro.md', 'guide.md']);
+    });
+
+    test('extracts links with relative paths', () => {
+      const content = 'See [parent](../parent.md) and [child](subdir/child.md).';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual(['../parent.md', 'subdir/child.md']);
+    });
+
+    test('ignores http links', () => {
+      const content = 'See [external](http://example.com/page.md) for more.';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual([]);
+    });
+
+    test('ignores https links', () => {
+      const content = 'See [secure](https://example.com/page.md) for more.';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual([]);
+    });
+
+    test('removes anchor fragments from links', () => {
+      const content = 'See [section](guide.md#installation) for setup.';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual(['guide.md']);
+    });
+
+    test('handles nested brackets in link text', () => {
+      const content = 'See [text [nested]](page.md) for info.';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual(['page.md']);
+    });
+
+    test('returns empty array for content with no links', () => {
+      const content = '# Just a heading\n\nSome plain text.';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual([]);
+    });
+
+    test('returns empty array for links to non-md files', () => {
+      const content = 'See [image](photo.png) and [doc](file.pdf).';
+
+      const links = extractLocalLinks(content);
+
+      expect(links).toEqual([]);
+    });
+  });
+
+  describe('sortByDependencies', () => {
+    function createCandidate(path: string, type: 'new' | 'modified' = 'new'): PushCandidate {
+      return {
+        path,
+        type,
+        title: path.replace('.md', ''),
+      };
+    }
+
+    test('returns original order when no files have links', () => {
+      writeFileSync(join(testDir, 'a.md'), '# File A');
+      writeFileSync(join(testDir, 'b.md'), '# File B');
+      writeFileSync(join(testDir, 'c.md'), '# File C');
+
+      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md'), createCandidate('c.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      expect(sorted.map((c) => c.path)).toEqual(['a.md', 'b.md', 'c.md']);
+    });
+
+    test('sorts linear chain so dependencies come first', () => {
+      // A links to B, B links to C
+      // Expected order: C, B, A
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B\nSee [C](c.md)');
+      writeFileSync(join(testDir, 'c.md'), '# C');
+
+      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md'), createCandidate('c.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      expect(sorted.map((c) => c.path)).toEqual(['c.md', 'b.md', 'a.md']);
+    });
+
+    test('handles diamond dependency pattern', () => {
+      // A -> B, A -> C, B -> D, C -> D
+      // Expected: D first, then B and C (in any order), then A
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md) and [C](c.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B\nSee [D](d.md)');
+      writeFileSync(join(testDir, 'c.md'), '# C\nSee [D](d.md)');
+      writeFileSync(join(testDir, 'd.md'), '# D');
+
+      const candidates: PushCandidate[] = [
+        createCandidate('a.md'),
+        createCandidate('b.md'),
+        createCandidate('c.md'),
+        createCandidate('d.md'),
+      ];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+
+      const paths = sorted.map((c) => c.path);
+      // D must come before B and C
+      expect(paths.indexOf('d.md')).toBeLessThan(paths.indexOf('b.md'));
+      expect(paths.indexOf('d.md')).toBeLessThan(paths.indexOf('c.md'));
+      // B and C must come before A
+      expect(paths.indexOf('b.md')).toBeLessThan(paths.indexOf('a.md'));
+      expect(paths.indexOf('c.md')).toBeLessThan(paths.indexOf('a.md'));
+    });
+
+    test('detects and reports simple circular dependency', () => {
+      // A -> B, B -> A
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B\nSee [A](a.md)');
+
+      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      // Should detect cycle
+      expect(cycles.length).toBeGreaterThan(0);
+      // Both files should still be in output
+      expect(sorted).toHaveLength(2);
+    });
+
+    test('detects longer cycles', () => {
+      // A -> B -> C -> A
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B\nSee [C](c.md)');
+      writeFileSync(join(testDir, 'c.md'), '# C\nSee [A](a.md)');
+
+      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md'), createCandidate('c.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles.length).toBeGreaterThan(0);
+      // All files should still be in output
+      expect(sorted).toHaveLength(3);
+    });
+
+    test('ignores links to files not in candidates', () => {
+      // A links to B (candidate) and X (not a candidate)
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md) and [X](x.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B');
+      writeFileSync(join(testDir, 'x.md'), '# X (already synced)');
+
+      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      // B should come before A because A depends on B
+      expect(sorted.map((c) => c.path)).toEqual(['b.md', 'a.md']);
+    });
+
+    test('handles links in subdirectories', () => {
+      mkdirSync(join(testDir, 'docs'));
+
+      // docs/a.md links to docs/b.md
+      writeFileSync(join(testDir, 'docs', 'a.md'), '# A\nSee [B](b.md)');
+      writeFileSync(join(testDir, 'docs', 'b.md'), '# B');
+
+      const candidates: PushCandidate[] = [createCandidate('docs/a.md'), createCandidate('docs/b.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      expect(sorted.map((c) => c.path)).toEqual(['docs/b.md', 'docs/a.md']);
+    });
+
+    test('handles cross-directory links', () => {
+      mkdirSync(join(testDir, 'guides'));
+      mkdirSync(join(testDir, 'reference'));
+
+      // guides/a.md links to reference/b.md
+      writeFileSync(join(testDir, 'guides', 'a.md'), '# A\nSee [B](../reference/b.md)');
+      writeFileSync(join(testDir, 'reference', 'b.md'), '# B');
+
+      const candidates: PushCandidate[] = [createCandidate('guides/a.md'), createCandidate('reference/b.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      expect(sorted.map((c) => c.path)).toEqual(['reference/b.md', 'guides/a.md']);
+    });
+
+    test('handles empty candidate list', () => {
+      const { sorted, cycles } = sortByDependencies([], testDir);
+
+      expect(sorted).toEqual([]);
+      expect(cycles).toEqual([]);
+    });
+
+    test('handles single candidate with no links', () => {
+      writeFileSync(join(testDir, 'only.md'), '# Only file');
+
+      const candidates: PushCandidate[] = [createCandidate('only.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      expect(sorted).toEqual(candidates);
+    });
+
+    test('handles single candidate with self-link', () => {
+      writeFileSync(join(testDir, 'self.md'), '# Self\nSee [Self](self.md)');
+
+      const candidates: PushCandidate[] = [createCandidate('self.md')];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      // Self-link creates a cycle
+      expect(cycles.length).toBeGreaterThan(0);
+      expect(sorted).toHaveLength(1);
+    });
+
+    test('preserves candidate type and title', () => {
+      writeFileSync(join(testDir, 'new.md'), '# New\nSee [modified](modified.md)');
+      writeFileSync(join(testDir, 'modified.md'), '# Modified');
+
+      const candidates: PushCandidate[] = [
+        { path: 'new.md', type: 'new', title: 'New Page' },
+        { path: 'modified.md', type: 'modified', title: 'Modified Page', pageId: '123' },
+      ];
+
+      const { sorted } = sortByDependencies(candidates, testDir);
+
+      // modified.md should come first (dependency)
+      expect(sorted[0]).toEqual({
+        path: 'modified.md',
+        type: 'modified',
+        title: 'Modified Page',
+        pageId: '123',
+      });
+      expect(sorted[1]).toEqual({
+        path: 'new.md',
+        type: 'new',
+        title: 'New Page',
+      });
+    });
+
+    test('handles mixed candidates with and without dependencies', () => {
+      // A -> B, C has no links, D -> E
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B');
+      writeFileSync(join(testDir, 'c.md'), '# C (independent)');
+      writeFileSync(join(testDir, 'd.md'), '# D\nSee [E](e.md)');
+      writeFileSync(join(testDir, 'e.md'), '# E');
+
+      const candidates: PushCandidate[] = [
+        createCandidate('a.md'),
+        createCandidate('b.md'),
+        createCandidate('c.md'),
+        createCandidate('d.md'),
+        createCandidate('e.md'),
+      ];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+
+      const paths = sorted.map((c) => c.path);
+      // B before A
+      expect(paths.indexOf('b.md')).toBeLessThan(paths.indexOf('a.md'));
+      // E before D
+      expect(paths.indexOf('e.md')).toBeLessThan(paths.indexOf('d.md'));
+      // All files included
+      expect(paths).toHaveLength(5);
+    });
+
+    test('gracefully handles unreadable files', () => {
+      writeFileSync(join(testDir, 'readable.md'), '# Readable\nSee [unreadable](unreadable.md)');
+      // unreadable.md doesn't exist as a file, but is in candidates
+
+      const candidates: PushCandidate[] = [createCandidate('readable.md'), createCandidate('unreadable.md')];
+
+      // Should not throw, even though unreadable.md can't be read
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles).toEqual([]);
+      expect(sorted).toHaveLength(2);
+    });
+
+    test('prioritizes new pages before modified pages in cycles', () => {
+      // Create circular dependency: modified -> new -> modified
+      // The new page should be pushed first so it gets a page_id,
+      // allowing the modified page to resolve links to it
+      mkdirSync(join(testDir, 'getting-started'));
+      mkdirSync(join(testDir, 'tools'));
+
+      writeFileSync(join(testDir, 'getting-started', 'onboarding.md'), '# Onboarding\nSee [CLI](../tools/cli.md)');
+      writeFileSync(join(testDir, 'tools', 'cli.md'), '# CLI\nSee [Onboarding](../getting-started/onboarding.md)');
+
+      const candidates: PushCandidate[] = [
+        { path: 'getting-started/onboarding.md', type: 'modified', title: 'Onboarding', pageId: '123' },
+        { path: 'tools/cli.md', type: 'new', title: 'CLI' },
+      ];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      // Should detect the cycle
+      expect(cycles.length).toBeGreaterThan(0);
+      // Both files should be in output
+      expect(sorted).toHaveLength(2);
+      // New page should come FIRST (before modified) so it gets created first
+      expect(sorted[0].type).toBe('new');
+      expect(sorted[0].path).toBe('tools/cli.md');
+      expect(sorted[1].type).toBe('modified');
+      expect(sorted[1].path).toBe('getting-started/onboarding.md');
+    });
+
+    test('maintains alphabetical order within same type in cycles', () => {
+      // All new pages in a cycle should maintain alphabetical order
+      writeFileSync(join(testDir, 'c.md'), '# C\nSee [A](a.md)');
+      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
+      writeFileSync(join(testDir, 'b.md'), '# B\nSee [C](c.md)');
+
+      const candidates: PushCandidate[] = [
+        { path: 'c.md', type: 'new', title: 'C' },
+        { path: 'a.md', type: 'new', title: 'A' },
+        { path: 'b.md', type: 'new', title: 'B' },
+      ];
+
+      const { sorted, cycles } = sortByDependencies(candidates, testDir);
+
+      expect(cycles.length).toBeGreaterThan(0);
+      // All same type (new), should preserve original order from candidates array
+      // Original order is c, a, b
+      expect(sorted.map((c) => c.path)).toEqual(['c.md', 'a.md', 'b.md']);
+    });
+  });
+});

package/src/test/errors.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  ConfigError,
+  FileSystemError,
+  ParseError,
+  ValidationError,
+  ApiError,
+  RateLimitError,
+  AuthError,
+  SyncError,
+  NetworkError,
+  SpaceNotFoundError,
+  PageNotFoundError,
+  VersionConflictError,
+  FolderNotFoundError,
+  EXIT_CODES,
+  getExitCodeForError,
+} from '../lib/errors.js';
+
+describe('Error types', () => {
+  describe('ConfigError', () => {
+    test('has correct _tag', () => {
+      const error = new ConfigError('Test error');
+      expect(error._tag).toBe('ConfigError');
+      expect(error.message).toBe('Test error');
+      expect(error.name).toBe('ConfigError');
+    });
+  });
+
+  describe('FileSystemError', () => {
+    test('has correct _tag', () => {
+      const error = new FileSystemError('File not found');
+      expect(error._tag).toBe('FileSystemError');
+      expect(error.message).toBe('File not found');
+    });
+  });
+
+  describe('ParseError', () => {
+    test('has correct _tag', () => {
+      const error = new ParseError('Invalid JSON');
+      expect(error._tag).toBe('ParseError');
+    });
+  });
+
+  describe('ValidationError', () => {
+    test('has correct _tag', () => {
+      const error = new ValidationError('Invalid config');
+      expect(error._tag).toBe('ValidationError');
+    });
+  });
+
+  describe('ApiError', () => {
+    test('has correct _tag and statusCode', () => {
+      const error = new ApiError('Not found', 404);
+      expect(error._tag).toBe('ApiError');
+      expect(error.statusCode).toBe(404);
+    });
+  });
+
+  describe('RateLimitError', () => {
+    test('has correct _tag and retryAfter', () => {
+      const error = new RateLimitError('Too many requests', 60);
+      expect(error._tag).toBe('RateLimitError');
+      expect(error.retryAfter).toBe(60);
+    });
+
+    test('handles undefined retryAfter', () => {
+      const error = new RateLimitError('Too many requests');
+      expect(error.retryAfter).toBeUndefined();
+    });
+  });
+
+  describe('AuthError', () => {
+    test('has correct _tag and statusCode', () => {
+      const error = new AuthError('Unauthorized', 401);
+      expect(error._tag).toBe('AuthError');
+      expect(error.statusCode).toBe(401);
+    });
+  });
+
+  describe('SyncError', () => {
+    test('has correct _tag', () => {
+      const error = new SyncError('Sync failed');
+      expect(error._tag).toBe('SyncError');
+    });
+  });
+
+  describe('NetworkError', () => {
+    test('has correct _tag', () => {
+      const error = new NetworkError('Connection failed');
+      expect(error._tag).toBe('NetworkError');
+    });
+  });
+
+  describe('SpaceNotFoundError', () => {
+    test('has correct _tag and spaceKey', () => {
+      const error = new SpaceNotFoundError('TEST');
+      expect(error._tag).toBe('SpaceNotFoundError');
+      expect(error.spaceKey).toBe('TEST');
+      expect(error.message).toBe('Space not found: TEST');
+    });
+  });
+
+  describe('PageNotFoundError', () => {
+    test('has correct _tag and pageId', () => {
+      const error = new PageNotFoundError('123456');
+      expect(error._tag).toBe('PageNotFoundError');
+      expect(error.pageId).toBe('123456');
+      expect(error.message).toBe('Page not found: 123456');
+    });
+  });
+
+  describe('VersionConflictError', () => {
+    test('has correct _tag and versions', () => {
+      const error = new VersionConflictError(3, 5);
+      expect(error._tag).toBe('VersionConflictError');
+      expect(error.localVersion).toBe(3);
+      expect(error.remoteVersion).toBe(5);
+      expect(error.message).toContain('local version 3');
+      expect(error.message).toContain('remote version 5');
+    });
+  });
+
+  describe('FolderNotFoundError', () => {
+    test('has correct _tag and folderId', () => {
+      const error = new FolderNotFoundError('folder-123');
+      expect(error._tag).toBe('FolderNotFoundError');
+      expect(error.folderId).toBe('folder-123');
+      expect(error.message).toBe('Folder not found: folder-123');
+    });
+  });
+});
+
+describe('EXIT_CODES', () => {
+  test('has all expected codes', () => {
+    expect(EXIT_CODES.SUCCESS).toBe(0);
+    expect(EXIT_CODES.GENERAL_ERROR).toBe(1);
+    expect(EXIT_CODES.CONFIG_ERROR).toBe(2);
+    expect(EXIT_CODES.AUTH_ERROR).toBe(3);
+    expect(EXIT_CODES.NETWORK_ERROR).toBe(4);
+    expect(EXIT_CODES.SPACE_NOT_FOUND).toBe(5);
+    expect(EXIT_CODES.INVALID_ARGUMENTS).toBe(6);
+    expect(EXIT_CODES.PAGE_NOT_FOUND).toBe(7);
+    expect(EXIT_CODES.VERSION_CONFLICT).toBe(8);
+    expect(EXIT_CODES.FOLDER_NOT_FOUND).toBe(9);
+  });
+});
+
+describe('getExitCodeForError', () => {
+  test('returns CONFIG_ERROR for ConfigError', () => {
+    const error = new ConfigError('Test');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.CONFIG_ERROR);
+  });
+
+  test('returns CONFIG_ERROR for ValidationError', () => {
+    const error = new ValidationError('Test');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.CONFIG_ERROR);
+  });
+
+  test('returns AUTH_ERROR for AuthError', () => {
+    const error = new AuthError('Test', 401);
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.AUTH_ERROR);
+  });
+
+  test('returns NETWORK_ERROR for NetworkError', () => {
+    const error = new NetworkError('Test');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.NETWORK_ERROR);
+  });
+
+  test('returns NETWORK_ERROR for RateLimitError', () => {
+    const error = new RateLimitError('Test');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.NETWORK_ERROR);
+  });
+
+  test('returns SPACE_NOT_FOUND for SpaceNotFoundError', () => {
+    const error = new SpaceNotFoundError('TEST');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.SPACE_NOT_FOUND);
+  });
+
+  test('returns PAGE_NOT_FOUND for PageNotFoundError', () => {
+    const error = new PageNotFoundError('123456');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.PAGE_NOT_FOUND);
+  });
+
+  test('returns VERSION_CONFLICT for VersionConflictError', () => {
+    const error = new VersionConflictError(3, 5);
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.VERSION_CONFLICT);
+  });
+
+  test('returns FOLDER_NOT_FOUND for FolderNotFoundError', () => {
+    const error = new FolderNotFoundError('folder-123');
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.FOLDER_NOT_FOUND);
+  });
+
+  test('returns GENERAL_ERROR for other errors', () => {
+    const error = new ApiError('Test', 500);
+    expect(getExitCodeForError(error)).toBe(EXIT_CODES.GENERAL_ERROR);
+  });
+});