@aaronshaf/confluence-cli 0.1.15

package/src/test/push.test.ts

@@ -0,0 +1,551 @@
+import { describe, expect, test } from 'bun:test';
+import { HttpResponse, http } from 'msw';
+import { ConfluenceClient } from '../lib/confluence-client/client.js';
+import { ApiError, FolderNotFoundError, PageNotFoundError, VersionConflictError } from '../lib/errors.js';
+import { server } from './setup-msw.js';
+import { createValidFolder, createValidPage } from './msw-schema-validation.js';
+
+const testConfig = {
+  confluenceUrl: 'https://test.atlassian.net',
+  email: 'test@example.com',
+  apiToken: 'test-token',
+};
+
+describe('ConfluenceClient - Push Operations', () => {
+  describe('createPage', () => {
+    test('creates a new page successfully', async () => {
+      const newPage = createValidPage({
+        id: 'new-page-123',
+        title: 'New Test Page',
+        spaceId: 'space-1',
+        version: 1,
+      });
+
+      server.use(
+        http.post('*/wiki/api/v2/pages', async ({ request }) => {
+          const body = await request.json();
+          expect(body).toHaveProperty('title');
+          expect(body).toHaveProperty('spaceId');
+          expect(body).toHaveProperty('body');
+          return HttpResponse.json(newPage);
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const result = await client.createPage({
+        spaceId: 'space-1',
+        status: 'current',
+        title: 'New Test Page',
+        body: {
+          representation: 'storage',
+          value: '<p>Test content</p>',
+        },
+      });
+
+      expect(result.id).toBe('new-page-123');
+      expect(result.title).toBe('New Test Page');
+      expect(result.version?.number).toBe(1);
+    });
+
+    test('creates a page with parent ID', async () => {
+      const newPage = createValidPage({
+        id: 'child-page-456',
+        title: 'Child Page',
+        spaceId: 'space-1',
+        parentId: 'parent-123',
+        version: 1,
+      });
+
+      server.use(
+        http.post('*/wiki/api/v2/pages', async ({ request }) => {
+          const body = await request.json();
+          expect(body).toHaveProperty('parentId', 'parent-123');
+          return HttpResponse.json(newPage);
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const result = await client.createPage({
+        spaceId: 'space-1',
+        status: 'current',
+        title: 'Child Page',
+        parentId: 'parent-123',
+        body: {
+          representation: 'storage',
+          value: '<p>Child content</p>',
+        },
+      });
+
+      expect(result.parentId).toBe('parent-123');
+    });
+
+    test('handles 401 authentication error', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/pages', () => {
+          return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      expect(async () => {
+        await client.createPage({
+          spaceId: 'space-1',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+        });
+      }).toThrow();
+    });
+
+    test('handles 403 permission error', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/pages', () => {
+          return HttpResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      expect(async () => {
+        await client.createPage({
+          spaceId: 'space-1',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+        });
+      }).toThrow();
+    });
+  });
+
+  describe('updatePage', () => {
+    test('updates an existing page successfully', async () => {
+      const updatedPage = createValidPage({
+        id: 'page-123',
+        title: 'Updated Title',
+        version: 3,
+      });
+
+      server.use(
+        http.put('*/wiki/api/v2/pages/page-123', async ({ request }) => {
+          const body = (await request.json()) as any;
+          expect(body).toHaveProperty('title', 'Updated Title');
+          expect(body).toHaveProperty('version');
+          expect(body.version.number).toBe(3);
+          return HttpResponse.json(updatedPage);
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const result = await client.updatePage({
+        id: 'page-123',
+        status: 'current',
+        title: 'Updated Title',
+        body: {
+          representation: 'storage',
+          value: '<p>Updated content</p>',
+        },
+        version: { number: 3 },
+      });
+
+      expect(result.title).toBe('Updated Title');
+      expect(result.version?.number).toBe(3);
+    });
+
+    test('throws PageNotFoundError on 404', async () => {
+      server.use(
+        http.put('*/wiki/api/v2/pages/missing-page', () => {
+          return HttpResponse.json({ error: 'Not Found' }, { status: 404 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.updatePage({
+          id: 'missing-page',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+          version: { number: 2 },
+        });
+        expect(false).toBe(true); // Should not reach here
+      } catch (error: any) {
+        // Effect wraps errors, so we need to check the cause
+        expect(error.message).toContain('Page not found');
+        expect(error.message).toContain('missing-page');
+      }
+    });
+
+    test('throws VersionConflictError on 409', async () => {
+      server.use(
+        http.put('*/wiki/api/v2/pages/page-123', () => {
+          return HttpResponse.json({ version: { number: 5 } }, { status: 409 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.updatePage({
+          id: 'page-123',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+          version: { number: 3 },
+        });
+        expect(false).toBe(true); // Should not reach here
+      } catch (error: any) {
+        // Effect wraps errors, check the message
+        expect(error.message).toContain('Version conflict');
+        expect(error.message).toContain('3');
+        expect(error.message).toContain('5');
+      }
+    });
+
+    test('handles version conflict with missing remote version', async () => {
+      server.use(
+        http.put('*/wiki/api/v2/pages/page-123', () => {
+          return HttpResponse.json({}, { status: 409 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.updatePage({
+          id: 'page-123',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+          version: { number: 3 },
+        });
+        expect(false).toBe(true); // Should not reach here
+      } catch (error: any) {
+        // Effect wraps errors, check the message
+        expect(error.message).toContain('Version conflict');
+        expect(error.message).toContain('3');
+        expect(error.message).toContain('0');
+      }
+    });
+
+    test('handles 401 authentication error', async () => {
+      server.use(
+        http.put('*/wiki/api/v2/pages/page-123', () => {
+          return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      expect(async () => {
+        await client.updatePage({
+          id: 'page-123',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+          version: { number: 2 },
+        });
+      }).toThrow();
+    });
+
+    test('handles 403 permission error', async () => {
+      server.use(
+        http.put('*/wiki/api/v2/pages/page-123', () => {
+          return HttpResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      expect(async () => {
+        await client.updatePage({
+          id: 'page-123',
+          status: 'current',
+          title: 'Test',
+          body: { representation: 'storage', value: '<p>Test</p>' },
+          version: { number: 2 },
+        });
+      }).toThrow();
+    });
+  });
+
+  describe('Parent validation', () => {
+    test('validates parent exists before creating page', async () => {
+      // First call: check parent exists
+      server.use(
+        http.get('*/wiki/api/v2/pages/parent-123', () => {
+          return HttpResponse.json(createValidPage({ id: 'parent-123', title: 'Parent Page' }));
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const parent = await client.getPage('parent-123', false);
+      expect(parent.id).toBe('parent-123');
+    });
+
+    test('throws ApiError when parent does not exist', async () => {
+      server.use(
+        http.get('*/wiki/api/v2/pages/missing-parent', () => {
+          return HttpResponse.json({ error: 'Not Found' }, { status: 404 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.getPage('missing-parent', false);
+        expect(false).toBe(true); // Should not reach here
+      } catch (error: any) {
+        // getPage throws ApiError for 404, not PageNotFoundError
+        expect(error.message).toContain('404');
+      }
+    });
+  });
+
+  describe('Content Properties', () => {
+    test('sets content property on a page', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/pages/page-123/properties', async ({ request }) => {
+          const body = (await request.json()) as any;
+          expect(body).toHaveProperty('key', 'editor');
+          expect(body).toHaveProperty('value', 'v2');
+          return HttpResponse.json({ key: 'editor', value: 'v2' }, { status: 200 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await client.setContentProperty('page-123', 'editor', 'v2');
+      // No error means success
+    });
+
+    test('setEditorV2 sets editor property to v2', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/pages/page-456/properties', async ({ request }) => {
+          const body = (await request.json()) as any;
+          expect(body).toHaveProperty('key', 'editor');
+          expect(body).toHaveProperty('value', 'v2');
+          return HttpResponse.json({ key: 'editor', value: 'v2' }, { status: 200 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await client.setEditorV2('page-456');
+      // No error means success
+    });
+
+    test('handles 401 authentication error for content property', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/pages/page-123/properties', () => {
+          return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      expect(async () => {
+        await client.setContentProperty('page-123', 'editor', 'v2');
+      }).toThrow();
+    });
+
+    test('handles 403 permission error for content property', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/pages/page-123/properties', () => {
+          return HttpResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      expect(async () => {
+        await client.setContentProperty('page-123', 'editor', 'v2');
+      }).toThrow();
+    });
+  });
+
+  describe('movePage', () => {
+    test('moves a page to a folder successfully', async () => {
+      server.use(
+        http.put('*/wiki/rest/api/content/page-123/move/append/folder-456', () => {
+          // Response body varies and is not validated - just need 200 OK
+          return HttpResponse.json({});
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      // movePage returns void - just verify it doesn't throw
+      await client.movePage('page-123', 'folder-456', 'append');
+    });
+
+    test('throws on 404 when page not found', async () => {
+      server.use(
+        http.put('*/wiki/rest/api/content/missing-page/move/append/folder-456', () => {
+          return HttpResponse.json({ error: 'Not found' }, { status: 404 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      await expect(client.movePage('missing-page', 'folder-456')).rejects.toThrow();
+    });
+
+    test('throws on 404 when target folder not found', async () => {
+      server.use(
+        http.put('*/wiki/rest/api/content/page-123/move/append/missing-folder', () => {
+          return HttpResponse.json({ error: 'Not found' }, { status: 404 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      await expect(client.movePage('page-123', 'missing-folder')).rejects.toThrow();
+    });
+
+    test('throws on 403 permission denied', async () => {
+      server.use(
+        http.put('*/wiki/rest/api/content/page-123/move/append/folder-456', () => {
+          return HttpResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.movePage('page-123', 'folder-456');
+        expect.unreachable('Should have thrown');
+      } catch (error) {
+        expect(String(error)).toContain('Access denied');
+      }
+    });
+
+    test('handles 401 authentication error', async () => {
+      server.use(
+        http.put('*/wiki/rest/api/content/page-123/move/append/folder-456', () => {
+          return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.movePage('page-123', 'folder-456');
+        expect.unreachable('Should have thrown');
+      } catch (error) {
+        expect(String(error)).toContain('Invalid credentials');
+      }
+    });
+  });
+
+  describe('createFolder', () => {
+    test('creates a folder successfully', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/folders', async ({ request }) => {
+          const body = (await request.json()) as { spaceId: string; title: string; parentId?: string };
+          const folder = createValidFolder({
+            id: 'new-folder-123',
+            title: body.title,
+            parentId: body.parentId || null,
+          });
+          return HttpResponse.json(folder);
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const folder = await client.createFolder({
+        spaceId: 'space-123',
+        title: 'New Folder',
+      });
+
+      expect(folder.id).toBe('new-folder-123');
+      expect(folder.title).toBe('New Folder');
+      expect(folder.type).toBe('folder');
+    });
+
+    test('creates a nested folder with parent', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/folders', async ({ request }) => {
+          const body = (await request.json()) as { spaceId: string; title: string; parentId?: string };
+          const folder = createValidFolder({
+            id: 'child-folder-456',
+            title: body.title,
+            parentId: body.parentId || null,
+          });
+          return HttpResponse.json(folder);
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const folder = await client.createFolder({
+        spaceId: 'space-123',
+        title: 'Child Folder',
+        parentId: 'parent-folder-123',
+      });
+
+      expect(folder.id).toBe('child-folder-456');
+      expect(folder.parentId).toBe('parent-folder-123');
+    });
+
+    test('handles 400 duplicate folder error', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/folders', () => {
+          return HttpResponse.json({ message: 'A folder with this name already exists' }, { status: 400 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      await expect(client.createFolder({ spaceId: 'space-123', title: 'Existing Folder' })).rejects.toThrow();
+    });
+
+    test('handles 409 conflict error', async () => {
+      server.use(
+        http.post('*/wiki/api/v2/folders', () => {
+          return HttpResponse.json({ message: 'Folder already exists' }, { status: 409 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      await expect(client.createFolder({ spaceId: 'space-123', title: 'Existing Folder' })).rejects.toThrow();
+    });
+  });
+
+  describe('getFolder with retry', () => {
+    test('retries on 429 rate limit', async () => {
+      let requestCount = 0;
+
+      server.use(
+        http.get('*/wiki/api/v2/folders/folder-123', () => {
+          requestCount++;
+          if (requestCount < 2) {
+            return HttpResponse.json({ error: 'Rate limited' }, { status: 429, headers: { 'Retry-After': '1' } });
+          }
+          return HttpResponse.json(createValidFolder({ id: 'folder-123', title: 'Test Folder' }));
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const folder = await client.getFolder('folder-123');
+
+      expect(folder.id).toBe('folder-123');
+      expect(requestCount).toBe(2);
+    });
+
+    test('throws FolderNotFoundError on 404', async () => {
+      server.use(
+        http.get('*/wiki/api/v2/folders/nonexistent', () => {
+          return HttpResponse.json({ error: 'Not found' }, { status: 404 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+
+      try {
+        await client.getFolder('nonexistent');
+        expect.unreachable('Should have thrown');
+      } catch (error) {
+        expect(String(error)).toContain('Folder not found: nonexistent');
+      }
+    });
+  });
+});