factory-factory 0.3.21 → 0.4.0

package/dist/src/backend/services/github/service/github-cli.service.test.js

@@ -28,6 +28,7 @@ vi.mock('@/backend/services/logger.service', () => ({
 }));
 import { execFile } from 'node:child_process';
 import { deriveCiStatusFromCheckRollup } from '../../../../shared/core/index.js';
+import { classifyError } from './github-cli/errors.js';
 import { githubCLIService } from './github-cli.service.js';
 vi.mocked(execFile).mockImplementation(mockExecFile);
 describe('GitHubCLIService', () => {
@@ -291,6 +292,11 @@ describe('GitHubCLIService', () => {
             });
         });
     });
+    describe('classifyError', () => {
+        it('classifies bad credentials and auth refresh hints as auth_required', () => {
+            expect(classifyError(new Error('HTTP 401: Bad credentials (https://api.github.com/graphql)\nTry authenticating with:  gh auth refresh -h github.com'))).toBe('auth_required');
+        });
+    });
     describe('schema validation', () => {
         describe('getPRStatus with malformed data', () => {
             it('should return null and log error when response is missing required fields', async () => {
@@ -837,6 +843,128 @@ describe('GitHubCLIService', () => {
             ]);
         });
     });
+    describe('getResolvedReviewCommentIds', () => {
+        function makeCommentsConnection(commentIds, pageInfo = {
+            hasNextPage: false,
+            endCursor: null,
+        }) {
+            return {
+                pageInfo,
+                nodes: commentIds.map((id) => ({
+                    fullDatabaseId: id === null ? null : String(id),
+                })),
+            };
+        }
+        function makeReviewThreadsResponse(threads, pageInfo = {
+            hasNextPage: false,
+            endCursor: null,
+        }) {
+            return {
+                data: {
+                    repository: {
+                        pullRequest: {
+                            reviewThreads: {
+                                pageInfo,
+                                nodes: threads.map((thread, index) => ({
+                                    id: `thread-${index}`,
+                                    isResolved: thread.isResolved,
+                                    comments: makeCommentsConnection(thread.commentIds, thread.commentsPageInfo),
+                                })),
+                            },
+                        },
+                    },
+                },
+            };
+        }
+        it('returns comment ids from resolved threads only', async () => {
+            mockExecFile.mockResolvedValue({
+                stdout: JSON.stringify(makeReviewThreadsResponse([
+                    { isResolved: true, commentIds: [1, 2] },
+                    { isResolved: false, commentIds: [3] },
+                    { isResolved: true, commentIds: [3_590_714_831, null] },
+                ])),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set([1, 2, 3_590_714_831]));
+        });
+        it('paginates review threads until hasNextPage is false', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify(makeReviewThreadsResponse([{ isResolved: true, commentIds: [1] }], {
+                    hasNextPage: true,
+                    endCursor: 'cursor-1',
+                })),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify(makeReviewThreadsResponse([{ isResolved: true, commentIds: [2] }])),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set([1, 2]));
+            expect(mockExecFile).toHaveBeenCalledTimes(2);
+            const secondQuery = mockExecFile.mock.calls[1]?.[1]?.join(' ');
+            expect(secondQuery).toContain('after: "cursor-1"');
+        });
+        it('pages through a resolved thread with more than one page of comments', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify(makeReviewThreadsResponse([
+                    {
+                        isResolved: true,
+                        commentIds: [1],
+                        commentsPageInfo: { hasNextPage: true, endCursor: 'comment-cursor-1' },
+                    },
+                    { isResolved: false, commentIds: [2] },
+                ])),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        node: {
+                            comments: makeCommentsConnection([3], {
+                                hasNextPage: true,
+                                endCursor: 'comment-cursor-2',
+                            }),
+                        },
+                    },
+                }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: { node: { comments: makeCommentsConnection([4]) } },
+                }),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set([1, 3, 4]));
+            expect(mockExecFile).toHaveBeenCalledTimes(3);
+            const tailQuery = mockExecFile.mock.calls[1]?.[1]?.join(' ');
+            expect(tailQuery).toContain('node(id: "thread-0")');
+            expect(tailQuery).toContain('after: "comment-cursor-1"');
+            const secondTailQuery = mockExecFile.mock.calls[2]?.[1]?.join(' ');
+            expect(secondTailQuery).toContain('after: "comment-cursor-2"');
+        });
+        it('returns an empty set when the PR is not found', async () => {
+            mockExecFile.mockResolvedValue({
+                stdout: JSON.stringify({ data: { repository: { pullRequest: null } } }),
+                stderr: '',
+            });
+            const result = await githubCLIService.getResolvedReviewCommentIds('owner/repo', 123);
+            expect(result).toEqual(new Set());
+        });
+        it('throws when the gh CLI call fails', async () => {
+            mockExecFile.mockRejectedValue(new Error('network down'));
+            await expect(githubCLIService.getResolvedReviewCommentIds('owner/repo', 123)).rejects.toThrow('Failed to fetch resolved review threads: network down');
+        });
+        it('throws on an invalid repo format', async () => {
+            await expect(githubCLIService.getResolvedReviewCommentIds('bad-repo', 123)).rejects.toThrow('Invalid repo format');
+            expect(mockExecFile).not.toHaveBeenCalled();
+        });
+    });
     describe('checkHealth edge cases', () => {
         it('should return generic error for non-installation failures', async () => {
             mockExecFile.mockRejectedValue(new Error('something weird'));
@@ -884,6 +1012,7 @@ describe('GitHubCLIService', () => {
                 stdout: JSON.stringify({
                     data: {
                         search: {
+                            pageInfo: { hasNextPage: false, endCursor: null },
                             nodes: [
                                 {
                                     number: 12,
@@ -921,6 +1050,113 @@ describe('GitHubCLIService', () => {
             ]);
             expect(mockExecFile).toHaveBeenCalledTimes(1);
         });
+        it('paginates review requests until GitHub search has no next page', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: true, endCursor: 'cursor-1' },
+                            nodes: [
+                                {
+                                    number: 50,
+                                    title: 'Boundary PR',
+                                    url: 'https://github.com/o/r/pull/50',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: { login: 'alice' },
+                                    createdAt: '2026-01-10T00:00:00Z',
+                                    isDraft: false,
+                                    reviewDecision: null,
+                                    additions: 1,
+                                    deletions: 2,
+                                    changedFiles: 3,
+                                },
+                            ],
+                        },
+                    },
+                }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: false, endCursor: 'cursor-2' },
+                            nodes: [
+                                {
+                                    number: 51,
+                                    title: 'Overflow PR',
+                                    url: 'https://github.com/o/r/pull/51',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: null,
+                                    createdAt: '2026-01-11T00:00:00Z',
+                                    isDraft: true,
+                                },
+                            ],
+                        },
+                    },
+                }),
+                stderr: '',
+            });
+            await expect(githubCLIService.listReviewRequests()).resolves.toEqual([
+                {
+                    number: 50,
+                    title: 'Boundary PR',
+                    url: 'https://github.com/o/r/pull/50',
+                    repository: { nameWithOwner: 'o/r' },
+                    author: { login: 'alice' },
+                    createdAt: '2026-01-10T00:00:00Z',
+                    isDraft: false,
+                    reviewDecision: null,
+                    additions: 1,
+                    deletions: 2,
+                    changedFiles: 3,
+                },
+                {
+                    number: 51,
+                    title: 'Overflow PR',
+                    url: 'https://github.com/o/r/pull/51',
+                    repository: { nameWithOwner: 'o/r' },
+                    author: { login: '' },
+                    createdAt: '2026-01-11T00:00:00Z',
+                    isDraft: true,
+                    reviewDecision: null,
+                    additions: 0,
+                    deletions: 0,
+                    changedFiles: 0,
+                },
+            ]);
+            expect(mockExecFile).toHaveBeenCalledTimes(2);
+            expect(mockExecFile.mock.calls[1]?.[1]).toEqual(expect.arrayContaining([expect.stringContaining('after: "cursor-1"')]));
+        });
+        it('caps review request pagination at 20 pages', async () => {
+            const continuingPage = {
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: true, endCursor: 'repeated-cursor' },
+                            nodes: [],
+                        },
+                    },
+                }),
+                stderr: '',
+            };
+            for (let page = 0; page < 20; page++) {
+                mockExecFile.mockResolvedValueOnce(continuingPage);
+            }
+            mockExecFile.mockRejectedValueOnce(new Error('unexpected 21st page request'));
+            try {
+                await expect(githubCLIService.listReviewRequests()).resolves.toEqual([]);
+                expect(mockExecFile).toHaveBeenCalledTimes(20);
+                expect(mockLoggerWarn).toHaveBeenCalledWith('listReviewRequests: reached MAX_PAGES limit, results may be incomplete', {
+                    totalFetched: 0,
+                    maxPages: 20,
+                });
+            }
+            finally {
+                mockExecFile.mockReset();
+            }
+        });
         it('falls back to empty array when GraphQL response is malformed', async () => {
             mockExecFile.mockResolvedValueOnce({
                 stdout: JSON.stringify({ data: { search: { nodes: 'not-an-array' } } }),
@@ -928,6 +1164,53 @@ describe('GitHubCLIService', () => {
             });
             await expect(githubCLIService.listReviewRequests()).resolves.toEqual([]);
         });
+        it('keeps fetched review requests when a later GraphQL page is malformed', async () => {
+            mockExecFile
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({
+                    data: {
+                        search: {
+                            pageInfo: { hasNextPage: true, endCursor: 'cursor-1' },
+                            nodes: [
+                                {
+                                    number: 50,
+                                    title: 'Boundary PR',
+                                    url: 'https://github.com/o/r/pull/50',
+                                    repository: { nameWithOwner: 'o/r' },
+                                    author: { login: 'alice' },
+                                    createdAt: '2026-01-10T00:00:00Z',
+                                    isDraft: false,
+                                    reviewDecision: null,
+                                    additions: 1,
+                                    deletions: 2,
+                                    changedFiles: 3,
+                                },
+                            ],
+                        },
+                    },
+                }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({ data: { search: { nodes: 'not-an-array' } } }),
+                stderr: '',
+            });
+            await expect(githubCLIService.listReviewRequests()).resolves.toEqual([
+                {
+                    number: 50,
+                    title: 'Boundary PR',
+                    url: 'https://github.com/o/r/pull/50',
+                    repository: { nameWithOwner: 'o/r' },
+                    author: { login: 'alice' },
+                    createdAt: '2026-01-10T00:00:00Z',
+                    isDraft: false,
+                    reviewDecision: null,
+                    additions: 1,
+                    deletions: 2,
+                    changedFiles: 3,
+                },
+            ]);
+        });
         it('approves PR and logs failures with contextual error', async () => {
             mockExecFile.mockResolvedValueOnce({ stdout: '', stderr: '' });
             await expect(githubCLIService.approvePR('o', 'r', 22)).resolves.toBeUndefined();
@@ -1021,6 +1304,121 @@ describe('GitHubCLIService', () => {
         });
     });
     describe('centralized exec - singleflight dedup', () => {
+        it('passes abort signals to authenticated-user lookups', async () => {
+            const controller = new AbortController();
+            mockExecFile.mockResolvedValue({ stdout: 'octocat\n', stderr: '' });
+            await expect(githubCLIService.getAuthenticatedUsername(controller.signal)).resolves.toBe('octocat');
+            expect(mockExecFile).toHaveBeenCalledWith('gh', ['api', 'user', '--jq', '.login'], expect.objectContaining({ signal: controller.signal }));
+        });
+        it('passes abort signals to PR detail child processes', async () => {
+            const controller = new AbortController();
+            mockExecFile.mockResolvedValue({
+                stdout: JSON.stringify({
+                    number: 42,
+                    title: 'PR',
+                    url: 'https://github.com/owner/repo/pull/42',
+                    author: { login: 'author' },
+                    createdAt: '2026-01-01T00:00:00Z',
+                    updatedAt: '2026-01-01T00:00:00Z',
+                    isDraft: false,
+                    state: 'OPEN',
+                    reviewDecision: null,
+                    statusCheckRollup: [],
+                    reviews: [],
+                    comments: [],
+                    labels: [],
+                    additions: 0,
+                    deletions: 0,
+                    changedFiles: 0,
+                    headRefName: 'feature',
+                    baseRefName: 'main',
+                    mergeStateStatus: 'CLEAN',
+                }),
+                stderr: '',
+            });
+            await githubCLIService.getPRFullDetails('owner/repo', 42, controller.signal);
+            expect(mockExecFile).toHaveBeenCalledWith('gh', expect.any(Array), expect.objectContaining({ signal: controller.signal }));
+        });
+        it('passes abort signals to review comment child processes', async () => {
+            const controller = new AbortController();
+            mockExecFile.mockResolvedValue({ stdout: '[]', stderr: '' });
+            await githubCLIService.getReviewComments('owner/repo', 42, undefined, controller.signal);
+            expect(mockExecFile).toHaveBeenCalledWith('gh', expect.any(Array), expect.objectContaining({ signal: controller.signal }));
+        });
+        it('does not singleflight identical signal-bound PR reads', async () => {
+            const first = new AbortController();
+            const second = new AbortController();
+            const prDetails = {
+                number: 42,
+                title: 'PR',
+                url: 'https://github.com/owner/repo/pull/42',
+                author: { login: 'author' },
+                createdAt: '2026-01-01T00:00:00Z',
+                updatedAt: '2026-01-01T00:00:00Z',
+                isDraft: false,
+                state: 'OPEN',
+                reviewDecision: null,
+                statusCheckRollup: [],
+                reviews: [],
+                comments: [],
+                labels: [],
+                additions: 0,
+                deletions: 0,
+                changedFiles: 0,
+                headRefName: 'feature',
+                baseRefName: 'main',
+                mergeStateStatus: 'CLEAN',
+            };
+            mockExecFile.mockResolvedValue({ stdout: JSON.stringify(prDetails), stderr: '' });
+            await Promise.all([
+                githubCLIService.getPRFullDetails('owner/repo', 42, first.signal),
+                githubCLIService.getPRFullDetails('owner/repo', 42, second.signal),
+            ]);
+            expect(mockExecFile).toHaveBeenCalledTimes(2);
+        });
+        it('does not spawn a signal-bound read that is cancelled while queued', async () => {
+            const prDetails = {
+                number: 42,
+                title: 'PR',
+                url: 'https://github.com/owner/repo/pull/42',
+                author: { login: 'author' },
+                createdAt: '2026-01-01T00:00:00Z',
+                updatedAt: '2026-01-01T00:00:00Z',
+                isDraft: false,
+                state: 'OPEN',
+                reviewDecision: null,
+                statusCheckRollup: [],
+                reviews: [],
+                comments: [],
+                labels: [],
+                additions: 0,
+                deletions: 0,
+                changedFiles: 0,
+                headRefName: 'feature',
+                baseRefName: 'main',
+                mergeStateStatus: 'CLEAN',
+            };
+            const releases = [];
+            mockExecFile.mockImplementation(() => new Promise((resolve) => {
+                releases.push(() => resolve({ stdout: JSON.stringify(prDetails), stderr: '' }));
+            }));
+            const blockers = Array.from({ length: 5 }, (_, index) => {
+                const controller = new AbortController();
+                return githubCLIService.getPRFullDetails('owner/repo', index + 1, controller.signal);
+            });
+            await vi.waitFor(() => expect(mockExecFile).toHaveBeenCalledTimes(5));
+            const queuedController = new AbortController();
+            const abortReason = new Error('queued request cancelled');
+            const queued = githubCLIService.getPRFullDetails('owner/repo', 99, queuedController.signal);
+            queuedController.abort(abortReason);
+            releases.shift()?.();
+            await expect(queued).rejects.toBe(abortReason);
+            expect(mockExecFile).toHaveBeenCalledTimes(5);
+            for (const release of releases) {
+                release();
+            }
+            await Promise.all(blockers);
+        });
         it('deduplicates identical concurrent read calls', async () => {
             const mockPRData = {
                 number: 42,