| import { beforeEach, describe, expect, it, vi } from 'vitest'; |
| import { |
| captureGitDispatchContext, |
| verifyPullRequest, |
| } from '../../../src/services/argus/git-context.js'; |
|
|
| const mocks = vi.hoisted(() => ({ git: vi.fn(), spawn: vi.fn() })); |
| vi.mock('@automaker/git-utils', () => ({ execGitCommand: mocks.git })); |
| vi.mock('@automaker/platform', () => ({ spawnProcess: mocks.spawn })); |
|
|
| const baseSha = 'a'.repeat(40); |
| const headSha = 'b'.repeat(40); |
| const project = '/registered/project'; |
| const expected = { repository: 'owner/repository', baseBranch: 'main', branch: 'jules/task' }; |
| const pr = { |
| number: 11, |
| url: 'https://github.com/owner/repository/pull/11', |
| state: 'OPEN', |
| baseRefName: 'main', |
| headRefName: 'jules/task', |
| headRefOid: headSha, |
| headRepositoryOwner: { login: 'Owner' }, |
| headRepository: { name: 'Repository' }, |
| }; |
|
|
| beforeEach(() => { |
| mocks.git.mockImplementation(async (args: string[]) => { |
| if (args[0] === 'remote') return 'git@github.com:owner/repository.git\n'; |
| if (args[0] === 'symbolic-ref') return 'origin/main\n'; |
| if (args[0] === 'rev-parse') return baseSha + '\n'; |
| return ''; |
| }); |
| mocks.spawn.mockResolvedValue({ exitCode: 0, stdout: 'main\n', stderr: '' }); |
| }); |
|
|
| describe('canonical GitHub dispatch context', () => { |
| it('fetches canonical remote state and honors an explicit integration branch without a CLI lookup', async () => { |
| await expect(captureGitDispatchContext(project, 'release')).resolves.toEqual({ |
| repository: 'owner/repository', |
| baseBranch: 'release', |
| baseRemoteSha: baseSha, |
| }); |
| expect(mocks.git.mock.calls.map(([args]) => args)).toEqual([ |
| ['remote', 'get-url', 'origin'], |
| ['fetch', '--prune', 'origin'], |
| ['rev-parse', 'origin/release'], |
| ]); |
| expect(mocks.spawn).not.toHaveBeenCalled(); |
| }); |
|
|
| it('uses GitHub default branch evidence when no explicit integration branch is configured', async () => { |
| await expect(captureGitDispatchContext(project)).resolves.toMatchObject({ |
| baseBranch: 'main', |
| baseRemoteSha: baseSha, |
| }); |
| expect(mocks.spawn).toHaveBeenCalledWith( |
| expect.objectContaining({ |
| command: 'gh', |
| args: [ |
| 'repo', |
| 'view', |
| 'owner/repository', |
| '--json', |
| 'defaultBranchRef', |
| '--jq', |
| '.defaultBranchRef.name', |
| ], |
| cwd: project, |
| }) |
| ); |
| }); |
|
|
| it.each(['nonzero', 'exception', 'empty'])( |
| 'falls back to origin/HEAD after a %s GitHub lookup', |
| async (kind) => { |
| if (kind === 'exception') mocks.spawn.mockRejectedValue(new Error('unavailable')); |
| else |
| mocks.spawn.mockResolvedValue({ |
| exitCode: kind === 'nonzero' ? 1 : 0, |
| stdout: '', |
| stderr: '', |
| }); |
| await expect(captureGitDispatchContext(project)).resolves.toMatchObject({ |
| baseBranch: 'main', |
| }); |
| expect(mocks.git).toHaveBeenCalledWith( |
| ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], |
| project |
| ); |
| } |
| ); |
|
|
| it('fails closed when neither authoritative default branch lookup succeeds', async () => { |
| mocks.spawn.mockRejectedValue(new Error('unavailable')); |
| mocks.git.mockImplementation(async (args: string[]) => { |
| if (args[0] === 'remote') return 'https://github.com/owner/repository'; |
| if (args[0] === 'symbolic-ref') throw new Error('missing origin/HEAD'); |
| return ''; |
| }); |
| await expect(captureGitDispatchContext(project)).rejects.toThrow( |
| 'could not determine integration branch' |
| ); |
| expect(mocks.git.mock.calls.some(([args]) => args[0] === 'rev-parse')).toBe(false); |
| }); |
|
|
| it.each(['missing', 'non-GitHub'])( |
| 'rejects a %s origin before fetch or dispatch', |
| async (kind) => { |
| if (kind === 'missing') mocks.git.mockRejectedValue(new Error('no origin')); |
| else mocks.git.mockResolvedValue('https://other.example/owner/repository.git'); |
| await expect(captureGitDispatchContext(project)).rejects.toThrow( |
| 'GITHUB_REMOTE_REQUIRED_FOR_JULES' |
| ); |
| expect(mocks.git).toHaveBeenCalledTimes(1); |
| expect(mocks.spawn).not.toHaveBeenCalled(); |
| } |
| ); |
|
|
| it('propagates a fetch failure instead of using stale local remote state', async () => { |
| mocks.git.mockImplementation(async (args: string[]) => { |
| if (args[0] === 'remote') return 'https://github.com/owner/repository.git'; |
| throw new Error('fetch denied'); |
| }); |
| await expect(captureGitDispatchContext(project, 'main')).rejects.toThrow('fetch denied'); |
| expect(mocks.git.mock.calls.some(([args]) => args[0] === 'rev-parse')).toBe(false); |
| }); |
| }); |
|
|
| describe('Jules PR identity', () => { |
| it('returns exact head and branch only after checking repository, branch and open state', async () => { |
| mocks.spawn.mockResolvedValue({ exitCode: 0, stdout: JSON.stringify(pr), stderr: '' }); |
| await expect(verifyPullRequest(pr.url, project, expected)).resolves.toEqual({ |
| number: 11, |
| url: pr.url, |
| headSha, |
| branch: 'jules/task', |
| }); |
| await expect( |
| verifyPullRequest(pr.url, project, { repository: 'OWNER/REPOSITORY', baseBranch: 'main' }) |
| ).resolves.toMatchObject({ headSha }); |
| }); |
|
|
| it.each([ |
| { state: 'CLOSED' }, |
| { baseRefName: 'unexpected' }, |
| { headRefName: 'another-task' }, |
| { headRepositoryOwner: { login: 'fork-owner' } }, |
| { headRepository: { name: 'another-repository' } }, |
| ])('rejects mismatched PR evidence %j', async (change) => { |
| mocks.spawn.mockResolvedValue({ |
| exitCode: 0, |
| stdout: JSON.stringify({ ...pr, ...change }), |
| stderr: '', |
| }); |
| await expect(verifyPullRequest(pr.url, project, expected)).rejects.toThrow( |
| 'PR identity mismatch' |
| ); |
| }); |
|
|
| it('rejects unavailable and malformed PR evidence', async () => { |
| mocks.spawn |
| .mockResolvedValueOnce({ exitCode: 1, stdout: '', stderr: 'unavailable' }) |
| .mockResolvedValueOnce({ exitCode: 0, stdout: '{', stderr: '' }); |
| await expect(verifyPullRequest(pr.url, project, expected)).rejects.toThrow( |
| 'GITHUB_PR_LOOKUP_FAILED' |
| ); |
| await expect(verifyPullRequest(pr.url, project, expected)).rejects.toThrow(); |
| }); |
| }); |
|
|
