bugfix-303-bugbot-first-message-bugs: Enhance tests for Execution, MergeRepository, and PrepareBranchesUseCase by adding scenarios for early returns based on release type and tag availability. Introduce new test cases for handling hotfix and release branch creation, ensuring comprehensive coverage for various edge cases and error conditions.

efraespada · efraespada · commit edac72a9024f · 2026-02-13T18:50:46.000+01:00
diff --git a/src/data/model/__tests__/execution.test.ts b/src/data/model/__tests__/execution.test.ts
@@ -710,5 +710,45 @@ describe('Execution', () => {
       expect(e.hotfix.version).toBeDefined();
       expect(e.hotfix.branch).toBe('hotfix/1.0.1');
     });
+
+    it('setup returns early when release type from GetReleaseTypeUseCase is undefined', async () => {
+      mockGetLabels.mockResolvedValue(['release']);
+      mockConfigGet.mockResolvedValue(undefined);
+      mockGetReleaseVersionInvoke.mockResolvedValue([{ executed: true, success: false }]);
+      mockGetReleaseTypeInvoke.mockResolvedValue([
+        { executed: true, success: true, payload: { releaseType: undefined } },
+      ]);
+      const issue = makeIssue({ eventName: 'issues', issue: { number: 1 } } as never);
+      const e = buildExecution({ eventName: 'issues', issue: { number: 1 } } as never, { issue });
+      await e.setup();
+      expect(e.release.version).toBeUndefined();
+      expect(e.release.branch).toBeUndefined();
+    });
+
+    it('setup returns early when getLatestTag returns undefined in release path', async () => {
+      mockGetLabels.mockResolvedValue(['release']);
+      mockConfigGet.mockResolvedValue(undefined);
+      mockGetReleaseVersionInvoke.mockResolvedValue([{ executed: true, success: false }]);
+      mockGetReleaseTypeInvoke.mockResolvedValue([
+        { executed: true, success: true, payload: { releaseType: 'Minor' } },
+      ]);
+      mockGetLatestTag.mockResolvedValue(undefined);
+      const issue = makeIssue({ eventName: 'issues', issue: { number: 1 } } as never);
+      const e = buildExecution({ eventName: 'issues', issue: { number: 1 } } as never, { issue });
+      await e.setup();
+      expect(e.release.version).toBeUndefined();
+    });
+
+    it('setup returns early when getLatestTag returns undefined in hotfix path', async () => {
+      mockGetLabels.mockResolvedValue(['hotfix']);
+      mockConfigGet.mockResolvedValue(undefined);
+      mockGetHotfixVersionInvoke.mockResolvedValue([{ executed: true, success: false }]);
+      mockGetLatestTag.mockResolvedValue(undefined);
+      const issue = makeIssue({ eventName: 'issues', issue: { number: 1 } } as never);
+      const e = buildExecution({ eventName: 'issues', issue: { number: 1 } } as never, { issue });
+      await e.setup();
+      expect(e.hotfix.baseVersion).toBeUndefined();
+      expect(e.hotfix.version).toBeUndefined();
+    });
   });
 });
diff --git a/src/data/repository/__tests__/branch_repository.test.ts b/src/data/repository/__tests__/branch_repository.test.ts
@@ -0,0 +1,202 @@
+/**
+ * Unit tests for BranchRepository: getListOfBranches, removeBranch, manageBranches.
+ */
+
+import { Execution } from '../../model/execution';
+import { BranchRepository } from '../branch_repository';
+
+jest.mock('../../../utils/logger', () => ({
+    logDebugInfo: jest.fn(),
+    logError: jest.fn(),
+}));
+
+const mockListBranches = jest.fn();
+const mockGetRef = jest.fn();
+const mockDeleteRef = jest.fn();
+const mockGraphql = jest.fn();
+
+jest.mock('@actions/github', () => ({
+    getOctokit: () => ({
+        rest: {
+            repos: {
+                listBranches: (...args: unknown[]) => mockListBranches(...args),
+            },
+            git: {
+                getRef: (...args: unknown[]) => mockGetRef(...args),
+                deleteRef: (...args: unknown[]) => mockDeleteRef(...args),
+            },
+        },
+        graphql: (...args: unknown[]) => mockGraphql(...args),
+    }),
+}));
+
+function mockExecution(overrides: Partial<Execution> = {}): Execution {
+    const e = {
+        branches: {
+            featureTree: 'feature',
+            bugfixTree: 'bugfix',
+            docsTree: 'docs',
+            choreTree: 'chore',
+        },
+        currentConfiguration: { parentBranch: undefined as string | undefined },
+        ...overrides,
+    };
+    return e as unknown as Execution;
+}
+
+describe('BranchRepository', () => {
+    const repo = new BranchRepository();
+
+    beforeEach(() => {
+        mockListBranches.mockReset();
+        mockGetRef.mockReset();
+        mockDeleteRef.mockReset();
+        mockGraphql.mockReset();
+    });
+
+    describe('getListOfBranches', () => {
+        it('returns branch names from single page', async () => {
+            mockListBranches
+                .mockResolvedValueOnce({ data: [{ name: 'main' }, { name: 'develop' }] })
+                .mockResolvedValueOnce({ data: [] });
+
+            const result = await repo.getListOfBranches('owner', 'repo', 'token');
+
+            expect(result).toEqual(['main', 'develop']);
+            expect(mockListBranches).toHaveBeenCalledWith({
+                owner: 'owner',
+                repo: 'repo',
+                per_page: 100,
+                page: 1,
+            });
+        });
+
+        it('paginates until empty data', async () => {
+            mockListBranches
+                .mockResolvedValueOnce({ data: [{ name: 'a' }] })
+                .mockResolvedValueOnce({ data: [{ name: 'b' }] })
+                .mockResolvedValueOnce({ data: [] });
+
+            const result = await repo.getListOfBranches('o', 'r', 't');
+
+            expect(result).toEqual(['a', 'b']);
+            expect(mockListBranches).toHaveBeenCalledTimes(3);
+        });
+    });
+
+    describe('removeBranch', () => {
+        it('deletes ref and returns true', async () => {
+            mockGetRef.mockResolvedValue({ data: { ref: 'refs/heads/feature/1-foo' } });
+            mockDeleteRef.mockResolvedValue({});
+
+            const result = await repo.removeBranch('owner', 'repo', 'feature/1-foo', 'token');
+
+            expect(result).toBe(true);
+            expect(mockGetRef).toHaveBeenCalledWith({
+                owner: 'owner',
+                repo: 'repo',
+                ref: 'heads/feature/1-foo',
+            });
+            expect(mockDeleteRef).toHaveBeenCalledWith({
+                owner: 'owner',
+                repo: 'repo',
+                ref: 'heads/feature/1-foo',
+            });
+        });
+
+        it('throws when getRef fails', async () => {
+            mockGetRef.mockRejectedValue(new Error('Not found'));
+
+            await expect(
+                repo.removeBranch('o', 'r', 'branch', 't'),
+            ).rejects.toThrow('Not found');
+        });
+    });
+
+    describe('manageBranches', () => {
+        it('returns error result when hotfixBranch is undefined and isHotfix is true', async () => {
+            mockListBranches
+                .mockResolvedValueOnce({ data: [] });
+            const param = mockExecution();
+            const result = await repo.manageBranches(
+                param,
+                'owner',
+                'repo',
+                1,
+                'Title',
+                'hotfix',
+                'develop',
+                undefined,
+                true,
+                'token',
+            );
+
+            expect(result).toHaveLength(1);
+            expect(result[0].success).toBe(false);
+            expect(result[0].executed).toBe(true);
+            expect(result[0].steps).toContainEqual(
+                expect.stringContaining('hotfix branch was not found'),
+            );
+        });
+
+        it('returns success executed false when branch already exists', async () => {
+            mockListBranches
+                .mockResolvedValueOnce({ data: [{ name: 'feature/1-title' }, { name: 'develop' }] })
+                .mockResolvedValueOnce({ data: [] });
+
+            const param = mockExecution();
+            const result = await repo.manageBranches(
+                param,
+                'owner',
+                'repo',
+                1,
+                'Title',
+                'feature',
+                'develop',
+                undefined,
+                false,
+                'token',
+            );
+
+            expect(result).toHaveLength(1);
+            expect(result[0].success).toBe(true);
+            expect(result[0].executed).toBe(false);
+        });
+
+        it('creates linked branch when branch does not exist', async () => {
+            mockListBranches
+                .mockResolvedValueOnce({ data: [{ name: 'develop' }] })
+                .mockResolvedValueOnce({ data: [] })
+                .mockResolvedValueOnce({ data: [] });
+            mockGraphql
+                .mockResolvedValueOnce({
+                    repository: {
+                        id: 'R_1',
+                        issue: { id: 'I_1' },
+                        ref: { target: { oid: 'abc123' } },
+                    },
+                })
+                .mockResolvedValueOnce({
+                    createLinkedBranch: { linkedBranch: { id: 'LB_1', ref: { name: 'feature/1-mytitle' } } },
+                });
+
+            const param = mockExecution();
+            const result = await repo.manageBranches(
+                param,
+                'owner',
+                'repo',
+                1,
+                'My Title',
+                'feature',
+                'develop',
+                undefined,
+                false,
+                'token',
+            );
+
+            expect(result.length).toBeGreaterThanOrEqual(1);
+            expect(result.some(r => r.success === true && r.executed === true)).toBe(true);
+            expect(mockGraphql).toHaveBeenCalledTimes(2);
+        });
+    });
+});
diff --git a/src/data/repository/__tests__/merge_repository.test.ts b/src/data/repository/__tests__/merge_repository.test.ts
@@ -14,6 +14,8 @@ const mockPullsListCommits = jest.fn();
 const mockPullsUpdate = jest.fn();
 const mockPullsMerge = jest.fn();
 const mockReposMerge = jest.fn();
+const mockChecksListForRef = jest.fn();
+const mockReposGetCombinedStatusForRef = jest.fn();
 
 jest.mock('@actions/github', () => ({
     getOctokit: () => ({
@@ -26,6 +28,10 @@ jest.mock('@actions/github', () => ({
             },
             repos: {
                 merge: (...args: unknown[]) => mockReposMerge(...args),
+                getCombinedStatusForRef: (...args: unknown[]) => mockReposGetCombinedStatusForRef(...args),
+            },
+            checks: {
+                listForRef: (...args: unknown[]) => mockChecksListForRef(...args),
             },
         },
     }),
@@ -40,6 +46,8 @@ describe('MergeRepository', () => {
         mockPullsUpdate.mockReset();
         mockPullsMerge.mockReset();
         mockReposMerge.mockReset();
+        mockChecksListForRef.mockReset();
+        mockReposGetCombinedStatusForRef.mockReset();
     });
 
     it('creates PR, updates body, merges and returns success (timeout <= 10 skips wait)', async () => {
@@ -128,4 +136,104 @@ describe('MergeRepository', () => {
         expect(result.some(r => r.success === false && r.steps?.some(s => s.includes('Failed to merge')))).toBe(true);
         expect(result.length).toBeGreaterThanOrEqual(2);
     });
+
+    it('when timeout > 10 waits for check runs (all completed) then merges', async () => {
+        mockPullsCreate.mockResolvedValue({ data: { number: 1 } });
+        mockPullsListCommits.mockResolvedValue({ data: [{ commit: { message: 'msg' } }] });
+        mockPullsUpdate.mockResolvedValue({});
+        mockPullsMerge.mockResolvedValue({});
+        mockChecksListForRef.mockResolvedValue({
+            data: {
+                check_runs: [
+                    { name: 'ci', status: 'completed', conclusion: 'success' },
+                ],
+            },
+        });
+        mockReposGetCombinedStatusForRef.mockResolvedValue({
+            data: { state: 'success', statuses: [] },
+        });
+
+        const result = await repo.mergeBranch(
+            'owner',
+            'repo',
+            'feature/1-x',
+            'develop',
+            30,
+            'token',
+        );
+
+        expect(result).toHaveLength(1);
+        expect(result[0].success).toBe(true);
+        expect(mockChecksListForRef).toHaveBeenCalledWith({
+            owner: 'owner',
+            repo: 'repo',
+            ref: 'feature/1-x',
+        });
+        expect(mockPullsMerge).toHaveBeenCalled();
+    });
+
+    it('when timeout > 10 and check runs have failure throws then direct merge fallback fails', async () => {
+        mockPullsCreate.mockResolvedValue({ data: { number: 1 } });
+        mockPullsListCommits.mockResolvedValue({ data: [] });
+        mockPullsUpdate.mockResolvedValue({});
+        mockChecksListForRef.mockResolvedValue({
+            data: {
+                check_runs: [
+                    { name: 'ci', status: 'completed', conclusion: 'failure' },
+                ],
+            },
+        });
+        mockReposGetCombinedStatusForRef.mockResolvedValue({
+            data: { state: 'success', statuses: [] },
+        });
+        mockReposMerge.mockRejectedValue(new Error('Direct merge failed'));
+
+        const result = await repo.mergeBranch('o', 'r', 'head', 'base', 30, 'token');
+
+        expect(result.some(r => r.success === false && r.steps?.some(s => s.includes('Failed to merge')))).toBe(true);
+    });
+
+    it('when timeout > 10 and no check runs uses status checks (all completed)', async () => {
+        mockPullsCreate.mockResolvedValue({ data: { number: 1 } });
+        mockPullsListCommits.mockResolvedValue({ data: [] });
+        mockPullsUpdate.mockResolvedValue({});
+        mockChecksListForRef.mockResolvedValue({
+            data: { check_runs: [] },
+        });
+        mockReposGetCombinedStatusForRef.mockResolvedValue({
+            data: { state: 'success', statuses: [{ context: 'ci', state: 'success' }] },
+        });
+        mockPullsMerge.mockResolvedValue({});
+
+        const result = await repo.mergeBranch(
+            'o', 'r', 'head', 'base', 30, 'token',
+        );
+
+        expect(result).toHaveLength(1);
+        expect(result[0].success).toBe(true);
+        expect(mockReposGetCombinedStatusForRef).toHaveBeenCalled();
+    });
+
+    it('when timeout > 10 and checks never complete throws then direct merge succeeds', async () => {
+        jest.useFakeTimers();
+        mockPullsCreate.mockResolvedValue({ data: { number: 1 } });
+        mockPullsListCommits.mockResolvedValue({ data: [] });
+        mockPullsUpdate.mockResolvedValue({});
+        mockChecksListForRef.mockResolvedValue({
+            data: {
+                check_runs: [{ name: 'ci', status: 'in_progress', conclusion: null }],
+            },
+        });
+        mockReposGetCombinedStatusForRef.mockResolvedValue({
+            data: { state: 'pending', statuses: [] },
+        });
+        mockReposMerge.mockResolvedValue({});
+
+        const promise = repo.mergeBranch('o', 'r', 'head', 'base', 30, 'token');
+        await jest.runAllTimersAsync();
+        const result = await promise;
+
+        jest.useRealTimers();
+        expect(result.some(r => r.success === true && r.steps?.some(s => s.includes('direct merge')))).toBe(true);
+    });
 });
diff --git a/src/usecase/steps/issue/__tests__/prepare_branches_use_case.test.ts b/src/usecase/steps/issue/__tests__/prepare_branches_use_case.test.ts
