Feature: Collaborative Notes Pane for the Editor screen

packages/decap-cms-backend-github/src/__tests__/implementation.spec.js

@@ -13,6 +13,17 @@ describe('github backend implementation', () => {
     },
   };
 
+  const configWithNotes = {
+    backend: {
+      repo: 'owner/repo',
+      open_authoring: false,
+      api_root: 'https://api.github.com',
+    },
+    editor: {
+      notes: true,
+    },
+  };
+
   const createObjectURL = jest.fn();
   global.URL = {
     createObjectURL,
@@ -358,4 +369,327 @@ describe('github backend implementation', () => {
       });
     });
   });
+  describe('notes implementation', () => {
+    const mockAPI = {
+      getEntryNotes: jest.fn(),
+      addNoteToEntry: jest.fn(),
+      updateEntryNote: jest.fn(),
+      deleteEntryNote: jest.fn(),
+      closeEntryNotesIssue: jest.fn(),
+      closeIssueOnPublish: jest.fn(),
+      reopenIssueOnUnpublish: jest.fn(),
+      readFile: jest.fn(),
+      deleteUnpublishedEntry: jest.fn().mockResolvedValue(undefined),
+      publishUnpublishedEntry: jest.fn().mockResolvedValue(undefined),
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    describe('getNotes', () => {
+      it('should retrieve notes for an entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(configWithNotes);
+        gitHubImplementation.api = mockAPI;
+
+        const mockNotes = [
+          {
+            id: '1',
+            author: 'user1',
+            avatarUrl: 'https://avatar.url',
+            text: 'Test note',
+            timestamp: '2025-01-01T00:00:00Z',
+            resolved: false,
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(mockNotes);
+
+        const result = await gitHubImplementation.getNotes('posts', 'my-post');
+
+        expect(result).toEqual([
+          {
+            ...mockNotes[0],
+            entrySlug: 'my-post',
+          },
+        ]);
+        expect(mockAPI.getEntryNotes).toHaveBeenCalledWith('posts', 'my-post');
+      });
+
+      it('should return empty array on error', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockRejectedValue(new Error('API Error'));
+
+        const result = await gitHubImplementation.getNotes('posts', 'my-post');
+
+        expect(result).toEqual([]);
+        expect(console.error).toHaveBeenCalledWith('Failed to get notes:', expect.any(Error));
+      });
+    });
+
+    describe('addNote', () => {
+      it('should add a note to an entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({
+          login: 'testuser',
+          name: 'Test User',
+          avatar_url: 'https://avatar.url',
+        });
+
+        const noteData = {
+          text: 'New note',
+          timestamp: '2025-01-01T00:00:00Z',
+          resolved: false,
+        };
+
+        mockAPI.addNoteToEntry.mockResolvedValue('comment-123');
+        mockAPI.readFile.mockResolvedValue('title: My Post Title\n\nContent');
+
+        const result = await gitHubImplementation.addNote('posts', 'my-post', noteData);
+
+        expect(result).toMatchObject({
+          text: 'New note',
+          author: 'testuser',
+          avatarUrl: 'https://avatar.url',
+          entrySlug: 'my-post',
+          resolved: false,
+          id: 'comment-123',
+        });
+        expect(mockAPI.addNoteToEntry).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+          expect.objectContaining({
+            text: 'New note',
+            author: 'testuser',
+          }),
+          'My Post Title',
+        );
+      });
+
+      it('should handle missing entry title gracefully', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+        gitHubImplementation.token = 'test-token';
+        gitHubImplementation.currentUser = jest.fn().mockResolvedValue({
+          login: 'testuser',
+          avatar_url: 'https://avatar.url',
+        });
+
+        const noteData = {
+          text: 'New note',
+          timestamp: '2025-01-01T00:00:00Z',
+        };
+
+        mockAPI.addNoteToEntry.mockResolvedValue('comment-123');
+        mockAPI.readFile.mockRejectedValue(new Error('Not found'));
+
+        const result = await gitHubImplementation.addNote('posts', 'my-post', noteData);
+
+        expect(mockAPI.addNoteToEntry).toHaveBeenCalledWith(
+          'posts',
+          'my-post',
+          expect.any(Object),
+          undefined,
+        );
+        expect(result.id).toBe('comment-123');
+      });
+    });
+
+    describe('updateNote', () => {
+      it('should update an existing note', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            author: 'user1',
+            avatarUrl: 'https://avatar.url',
+            text: 'Original text',
+            timestamp: '2025-01-01T00:00:00Z',
+            resolved: false,
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.updateEntryNote.mockResolvedValue(undefined);
+
+        const updates = { text: 'Updated text', resolved: true };
+        const result = await gitHubImplementation.updateNote('posts', 'my-post', 'note-1', updates);
+
+        expect(result).toEqual({
+          ...existingNotes[0],
+          text: 'Updated text',
+          resolved: true,
+        });
+        expect(mockAPI.updateEntryNote).toHaveBeenCalledWith('note-1', result);
+      });
+
+      it('should throw error if note not found', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockResolvedValue([]);
+
+        await expect(
+          gitHubImplementation.updateNote('posts', 'my-post', 'non-existent', {}),
+        ).rejects.toThrow('Note with ID non-existent not found');
+      });
+    });
+
+    describe('deleteNote', () => {
+      it('should delete an existing note', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            author: 'user1',
+            text: 'Test note',
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.deleteEntryNote.mockResolvedValue(undefined);
+
+        await gitHubImplementation.deleteNote('posts', 'my-post', 'note-1');
+
+        expect(mockAPI.deleteEntryNote).toHaveBeenCalledWith('note-1');
+      });
+
+      it('should throw error if note not found', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockResolvedValue([]);
+
+        await expect(
+          gitHubImplementation.deleteNote('posts', 'my-post', 'non-existent'),
+        ).rejects.toThrow('Note with ID non-existent not found');
+      });
+    });
+
+    describe('toggleNoteResolution', () => {
+      it('should toggle note resolved status from false to true', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            author: 'user1',
+            avatarUrl: 'https://avatar.url',
+            text: 'Test note',
+            timestamp: '2025-01-01T00:00:00Z',
+            resolved: false,
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.updateEntryNote.mockResolvedValue(undefined);
+
+        const result = await gitHubImplementation.toggleNoteResolution(
+          'posts',
+          'my-post',
+          'note-1',
+        );
+
+        expect(result.resolved).toBe(true);
+        expect(mockAPI.updateEntryNote).toHaveBeenCalledWith(
+          'note-1',
+          expect.objectContaining({ resolved: true }),
+        );
+      });
+
+      it('should toggle note resolved status from true to false', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        const existingNotes = [
+          {
+            id: 'note-1',
+            resolved: true,
+            entrySlug: 'my-post',
+          },
+        ];
+
+        mockAPI.getEntryNotes.mockResolvedValue(existingNotes);
+        mockAPI.updateEntryNote.mockResolvedValue(undefined);
+
+        const result = await gitHubImplementation.toggleNoteResolution(
+          'posts',
+          'my-post',
+          'note-1',
+        );
+
+        expect(result.resolved).toBe(false);
+      });
+
+      it('should throw error if note not found', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.getEntryNotes.mockResolvedValue([]);
+
+        await expect(
+          gitHubImplementation.toggleNoteResolution('posts', 'my-post', 'non-existent'),
+        ).rejects.toThrow('Note with ID non-existent not found');
+      });
+    });
+
+    describe('reopenIssueForUnpublishedEntry', () => {
+      it('should reopen issue for unpublished entry', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        mockAPI.reopenIssueOnUnpublish.mockResolvedValue(undefined);
+
+        await gitHubImplementation.reopenIssueForUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.reopenIssueOnUnpublish).toHaveBeenCalledWith('posts', 'my-post');
+      });
+    });
+
+    describe('deleteUnpublishedEntry with notes cleanup', () => {
+      it('should delete entry and close associated notes issue', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI; // Just use mockAPI directly
+
+        await gitHubImplementation.deleteUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.deleteUnpublishedEntry).toHaveBeenCalledWith('posts', 'my-post');
+        expect(mockAPI.closeEntryNotesIssue).toHaveBeenCalledWith('posts', 'my-post');
+      });
+
+      it('should continue deletion even if closing issue fails', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+        mockAPI.closeEntryNotesIssue.mockRejectedValue(new Error('Issue close failed'));
+
+        await gitHubImplementation.deleteUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.deleteUnpublishedEntry).toHaveBeenCalledWith('posts', 'my-post');
+      });
+    });
+
+    describe('publishUnpublishedEntry with issue cleanup', () => {
+      it('should publish entry and close issue', async () => {
+        const gitHubImplementation = new GitHubImplementation(config);
+        gitHubImplementation.api = mockAPI;
+
+        await gitHubImplementation.publishUnpublishedEntry('posts', 'my-post');
+
+        expect(mockAPI.publishUnpublishedEntry).toHaveBeenCalledWith('posts', 'my-post');
+        expect(mockAPI.closeIssueOnPublish).toHaveBeenCalledWith('posts', 'my-post');
+      });
+    });
+  });
 });