bitbucket-datacenter-mcp 0.2.0

package/build/__tests__/bitbucket-service.test.js

@@ -0,0 +1,2824 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { initializeRuntimeConfig } from 'datacenter-mcp-core';
+import { BitbucketService } from '../bitbucket-service.js';
+import { BuildsAndDeploymentsService, DeprecatedService, ProjectService, PullRequestsService, RepositoryService } from '../bitbucket-client/index.js';
+import { request as mockRequest } from '../bitbucket-client/core/request.js';
+// Mock the request function
+jest.mock('../bitbucket-client/core/request.js', () => ({
+    request: jest.fn()
+}));
+// Mock the PullRequestsService
+jest.mock('../bitbucket-client/index.js', () => ({
+    PullRequestsService: {
+        streamRawDiff2: jest.fn(),
+        createComment2: jest.fn(),
+        updateComment2: jest.fn(),
+        streamChanges1: jest.fn(),
+        create: jest.fn(),
+        update: jest.fn(),
+        updateStatus: jest.fn(),
+        getPage: jest.fn(),
+        getReviewers: jest.fn(),
+        get3: jest.fn(),
+        getPullRequestConditions1: jest.fn(),
+        createPullRequestCondition1: jest.fn(),
+        updatePullRequestCondition1: jest.fn(),
+        deletePullRequestCondition1: jest.fn(),
+        canMerge: jest.fn(),
+        merge: jest.fn(),
+        decline: jest.fn(),
+        reopen: jest.fn(),
+        deleteComment2: jest.fn(),
+        applySuggestion: jest.fn(),
+        watch1: jest.fn(),
+        unwatch1: jest.fn(),
+        assignParticipantRole: jest.fn(),
+        unassignParticipantRole: jest.fn()
+    },
+    RepositoryService: {
+        getRestrictions1: jest.fn(),
+        createRestrictions1: jest.fn(),
+        getRestriction1: jest.fn(),
+        deleteRestriction1: jest.fn(),
+        createBranch: jest.fn(),
+        deleteBranch: jest.fn(),
+        getBranches: jest.fn(),
+        getDefaultBranch1: jest.fn(),
+        getComments: jest.fn(),
+        createComment: jest.fn(),
+        getCommit: jest.fn(),
+        streamDiff: jest.fn(),
+        streamCommits: jest.fn(),
+        streamChanges: jest.fn(),
+        streamRaw: jest.fn(),
+        getContent1: jest.fn(),
+        editFile: jest.fn(),
+        getTags: jest.fn(),
+        getTag: jest.fn(),
+        createTagForRepository: jest.fn(),
+        findWebhooks1: jest.fn(),
+        getWebhook1: jest.fn(),
+        createWebhook1: jest.fn(),
+        updateWebhook1: jest.fn(),
+        deleteWebhook1: jest.fn()
+    },
+    DeprecatedService: {
+        getBuildStatus: jest.fn()
+    },
+    BuildsAndDeploymentsService: {
+        add: jest.fn(),
+        get: jest.fn(),
+        setACodeInsightsReport: jest.fn(),
+        getACodeInsightsReport: jest.fn(),
+        deleteACodeInsightsReport: jest.fn(),
+        addAnnotations: jest.fn(),
+        getAnnotations: jest.fn(),
+        deleteAnnotations: jest.fn(),
+        getPageOfRequiredBuildsMergeChecks: jest.fn(),
+        createRequiredBuildsMergeCheck: jest.fn(),
+        updateRequiredBuildsMergeCheck: jest.fn(),
+        deleteRequiredBuildsMergeCheck: jest.fn()
+    },
+    ProjectService: {
+        createProject: jest.fn(),
+        updateProject: jest.fn(),
+        deleteProject: jest.fn(),
+        createRepository: jest.fn(),
+        updateRepository: jest.fn(),
+        forkRepository: jest.fn(),
+        deleteRepository: jest.fn()
+    },
+    OpenAPI: {
+        BASE: '',
+        TOKEN: '',
+        VERSION: ''
+    }
+}));
+describe('BitbucketService', () => {
+    let bitbucketService;
+    const mockProjectKey = 'TEST';
+    const mockRepositorySlug = 'test-repo';
+    const mockPullRequestId = '123';
+    let tempHome;
+    let homedirSpy;
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'bitbucket-service-home-'));
+        homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome);
+        Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+        initializeRuntimeConfig();
+        bitbucketService = new BitbucketService('test-host', 'test-token');
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        homedirSpy.mockRestore();
+        Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        fs.rmSync(tempHome, { recursive: true, force: true });
+    });
+    describe('getPullRequestChanges', () => {
+        it('should successfully get PR changes', async () => {
+            const mockChangesData = {
+                values: [
+                    { path: { toString: 'file.txt' }, type: 'MODIFY' }
+                ],
+                size: 1,
+                isLastPage: true
+            };
+            PullRequestsService.streamChanges1.mockResolvedValue(mockChangesData);
+            const result = await bitbucketService.getPullRequestChanges(mockProjectKey, mockRepositorySlug, mockPullRequestId);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockChangesData);
+            expect(PullRequestsService.streamChanges1).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, undefined, undefined, undefined, undefined, undefined, 25);
+        });
+        it('should successfully get PR changes with all parameters', async () => {
+            const mockChangesData = {
+                values: [
+                    { path: { toString: 'file.txt' }, type: 'MODIFY' }
+                ],
+                size: 1,
+                isLastPage: true
+            };
+            PullRequestsService.streamChanges1.mockResolvedValue(mockChangesData);
+            const result = await bitbucketService.getPullRequestChanges(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'abc123', 'RANGE', 'def456', 'true', 0, 50);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockChangesData);
+            expect(PullRequestsService.streamChanges1).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, 'abc123', 'RANGE', 'def456', 'true', 0, 50);
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            PullRequestsService.streamChanges1.mockRejectedValue(mockError);
+            const result = await bitbucketService.getPullRequestChanges(mockProjectKey, mockRepositorySlug, mockPullRequestId);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('createBranch', () => {
+        it('should successfully create a branch', async () => {
+            const mockBranch = { id: 'refs/heads/feature/login', displayId: 'feature/login' };
+            RepositoryService.createBranch.mockResolvedValue(mockBranch);
+            const result = await bitbucketService.createBranch(mockProjectKey, mockRepositorySlug, 'feature/login', 'refs/heads/master');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockBranch);
+            expect(RepositoryService.createBranch).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, { name: 'feature/login', startPoint: 'refs/heads/master' });
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.createBranch.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createBranch(mockProjectKey, mockRepositorySlug, 'feature/login', 'refs/heads/master');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('addPullRequestReviewer', () => {
+        it('should add a reviewer to a pull request', async () => {
+            const mockParticipant = { user: { name: 'reviewer1' }, role: 'REVIEWER' };
+            PullRequestsService.assignParticipantRole.mockResolvedValue(mockParticipant);
+            const result = await bitbucketService.addPullRequestReviewer(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'reviewer1');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockParticipant);
+            expect(PullRequestsService.assignParticipantRole).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, { user: { name: 'reviewer1' }, role: 'REVIEWER' });
+        });
+        it('should handle API errors gracefully', async () => {
+            PullRequestsService.assignParticipantRole.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.addPullRequestReviewer(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'reviewer1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('removePullRequestReviewer', () => {
+        it('should remove a reviewer from a pull request', async () => {
+            PullRequestsService.unassignParticipantRole.mockResolvedValue(undefined);
+            const result = await bitbucketService.removePullRequestReviewer(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'reviewer1');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ removed: true, userSlug: 'reviewer1' });
+            expect(PullRequestsService.unassignParticipantRole).toHaveBeenCalledWith(mockProjectKey, 'reviewer1', mockPullRequestId, mockRepositorySlug);
+        });
+        it('should handle API errors gracefully', async () => {
+            PullRequestsService.unassignParticipantRole.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.removePullRequestReviewer(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'reviewer1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getFileContent', () => {
+        it('should successfully get raw file content', async () => {
+            const mockContent = 'const x = 1;\nconst y = 2;\n';
+            RepositoryService.streamRaw.mockResolvedValue(mockContent);
+            const result = await bitbucketService.getFileContent(mockProjectKey, mockRepositorySlug, 'src/index.ts');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockContent);
+            expect(RepositoryService.streamRaw).toHaveBeenCalledWith('src/index.ts', mockProjectKey, mockRepositorySlug, undefined);
+        });
+        it('should pass the at ref through', async () => {
+            const mockContent = 'file content';
+            RepositoryService.streamRaw.mockResolvedValue(mockContent);
+            await bitbucketService.getFileContent(mockProjectKey, mockRepositorySlug, 'README.md', 'refs/heads/main');
+            expect(RepositoryService.streamRaw).toHaveBeenCalledWith('README.md', mockProjectKey, mockRepositorySlug, 'refs/heads/main');
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('The repository does not exist.');
+            RepositoryService.streamRaw.mockRejectedValue(mockError);
+            const result = await bitbucketService.getFileContent(mockProjectKey, mockRepositorySlug, 'missing.txt');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('The repository does not exist.');
+        });
+    });
+    describe('browseRepository', () => {
+        it('should browse the repository root by default', async () => {
+            const mockBrowse = { children: { values: [{ path: { toString: 'src' }, type: 'DIRECTORY' }] } };
+            RepositoryService.getContent1.mockResolvedValue(mockBrowse);
+            const result = await bitbucketService.browseRepository(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockBrowse);
+            expect(RepositoryService.getContent1).toHaveBeenCalledWith('', mockProjectKey, mockRepositorySlug, undefined, // noContent
+            undefined, // at
+            undefined, // size
+            undefined, // blame
+            undefined // type
+            );
+        });
+        it('should map path, at, type and blame to the generated client', async () => {
+            const mockBrowse = { type: 'FILE' };
+            RepositoryService.getContent1.mockResolvedValue(mockBrowse);
+            await bitbucketService.browseRepository(mockProjectKey, mockRepositorySlug, 'src/index.ts', 'refs/heads/main', true, true);
+            expect(RepositoryService.getContent1).toHaveBeenCalledWith('src/index.ts', mockProjectKey, mockRepositorySlug, undefined, 'refs/heads/main', undefined, 'true', // blame
+            'true' // type
+            );
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            RepositoryService.getContent1.mockRejectedValue(mockError);
+            const result = await bitbucketService.browseRepository(mockProjectKey, mockRepositorySlug, 'src');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('Code Insights', () => {
+        const commitId = 'abc123';
+        const key = 'mycompany.eslint';
+        it('setInsightReport should PUT the report', async () => {
+            const mockReport = { key, title: 'ESLint' };
+            BuildsAndDeploymentsService.setACodeInsightsReport.mockResolvedValue(mockReport);
+            const report = { title: 'ESLint', result: 'PASS' };
+            const result = await bitbucketService.setInsightReport(mockProjectKey, mockRepositorySlug, commitId, key, report);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockReport);
+            expect(BuildsAndDeploymentsService.setACodeInsightsReport).toHaveBeenCalledWith(mockProjectKey, commitId, mockRepositorySlug, key, report);
+        });
+        it('getInsightReport should GET the report', async () => {
+            BuildsAndDeploymentsService.getACodeInsightsReport.mockResolvedValue({ key });
+            const result = await bitbucketService.getInsightReport(mockProjectKey, mockRepositorySlug, commitId, key);
+            expect(result.success).toBe(true);
+            expect(BuildsAndDeploymentsService.getACodeInsightsReport).toHaveBeenCalledWith(mockProjectKey, commitId, mockRepositorySlug, key);
+        });
+        it('deleteInsightReport should DELETE and ack', async () => {
+            BuildsAndDeploymentsService.deleteACodeInsightsReport.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteInsightReport(mockProjectKey, mockRepositorySlug, commitId, key);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, key });
+        });
+        it('addInsightAnnotations should POST {annotations} and ack with count', async () => {
+            BuildsAndDeploymentsService.addAnnotations.mockResolvedValue(undefined);
+            const annotations = [
+                { externalId: 'a1', path: 'app.js', line: 3, message: 'x', severity: 'HIGH' },
+                { externalId: 'a2', path: 'app.js', line: 9, message: 'y', severity: 'LOW' }
+            ];
+            const result = await bitbucketService.addInsightAnnotations(mockProjectKey, mockRepositorySlug, commitId, key, annotations);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ added: 2, key });
+            expect(BuildsAndDeploymentsService.addAnnotations).toHaveBeenCalledWith(mockProjectKey, commitId, mockRepositorySlug, key, { annotations });
+        });
+        it('getInsightAnnotations should GET annotations', async () => {
+            BuildsAndDeploymentsService.getAnnotations.mockResolvedValue({ annotations: [] });
+            const result = await bitbucketService.getInsightAnnotations(mockProjectKey, mockRepositorySlug, commitId, key);
+            expect(result.success).toBe(true);
+            expect(BuildsAndDeploymentsService.getAnnotations).toHaveBeenCalledWith(mockProjectKey, commitId, mockRepositorySlug, key);
+        });
+        it('deleteInsightAnnotations should pass externalId and ack', async () => {
+            BuildsAndDeploymentsService.deleteAnnotations.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteInsightAnnotations(mockProjectKey, mockRepositorySlug, commitId, key, 'a1');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, key, externalId: 'a1' });
+            expect(BuildsAndDeploymentsService.deleteAnnotations).toHaveBeenCalledWith(mockProjectKey, commitId, mockRepositorySlug, key, 'a1');
+        });
+        it('should handle API errors gracefully', async () => {
+            BuildsAndDeploymentsService.getACodeInsightsReport.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getInsightReport(mockProjectKey, mockRepositorySlug, commitId, key);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('deleteBranch', () => {
+        it('should successfully delete a branch', async () => {
+            RepositoryService.deleteBranch.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteBranch(mockProjectKey, mockRepositorySlug, 'refs/heads/feature/login');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, name: 'refs/heads/feature/login' });
+            expect(RepositoryService.deleteBranch).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, { name: 'refs/heads/feature/login' });
+        });
+        it('should pass dryRun through and report not-deleted', async () => {
+            RepositoryService.deleteBranch.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteBranch(mockProjectKey, mockRepositorySlug, 'refs/heads/feature/login', true);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: false, name: 'refs/heads/feature/login' });
+            expect(RepositoryService.deleteBranch).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, { name: 'refs/heads/feature/login', dryRun: true });
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.deleteBranch.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteBranch(mockProjectKey, mockRepositorySlug, 'refs/heads/feature/login');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getBranches', () => {
+        it('should successfully get branches with default parameters', async () => {
+            const mockBranchesData = {
+                values: [
+                    { id: 'refs/heads/main', displayId: 'main', isDefault: true },
+                    { id: 'refs/heads/feature', displayId: 'feature', isDefault: false }
+                ],
+                size: 2,
+                isLastPage: true
+            };
+            RepositoryService.getBranches.mockResolvedValue(mockBranchesData);
+            const result = await bitbucketService.getBranches(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockBranchesData);
+            expect(RepositoryService.getBranches).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, // boostMatches
+            undefined, // context
+            undefined, // orderBy
+            undefined, // details
+            undefined, // filterText
+            undefined, // base
+            undefined, // start
+            25);
+        });
+        it('should pass filterText, orderBy and pagination through', async () => {
+            const mockBranchesData = { values: [], size: 0, isLastPage: true };
+            RepositoryService.getBranches.mockResolvedValue(mockBranchesData);
+            await bitbucketService.getBranches(mockProjectKey, mockRepositorySlug, 'feat', 'MODIFICATION', 10, 50);
+            expect(RepositoryService.getBranches).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, 'MODIFICATION', undefined, 'feat', undefined, 10, 50);
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            RepositoryService.getBranches.mockRejectedValue(mockError);
+            const result = await bitbucketService.getBranches(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getTags', () => {
+        it('should get tags with default parameters', async () => {
+            const mockTags = { values: [{ id: 'refs/tags/v1', displayId: 'v1' }], isLastPage: true };
+            RepositoryService.getTags.mockResolvedValue(mockTags);
+            const result = await bitbucketService.getTags(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTags);
+            expect(RepositoryService.getTags).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, // orderBy
+            undefined, // filterText
+            undefined, // start
+            25);
+        });
+        it('should pass filterText, orderBy and pagination through', async () => {
+            RepositoryService.getTags.mockResolvedValue({ values: [] });
+            await bitbucketService.getTags(mockProjectKey, mockRepositorySlug, 'rel', 'MODIFICATION', 5, 50);
+            expect(RepositoryService.getTags).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, 'MODIFICATION', 'rel', 5, 50);
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.getTags.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getTags(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getCommitComments', () => {
+        it('should get commit comments for a path', async () => {
+            const mockComments = { values: [{ id: 1, text: 'looks good' }], isLastPage: true };
+            RepositoryService.getComments.mockResolvedValue(mockComments);
+            const result = await bitbucketService.getCommitComments(mockProjectKey, mockRepositorySlug, 'abc123', 'src/app.js');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComments);
+            expect(RepositoryService.getComments).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, 'src/app.js', undefined, // since
+            undefined, // start
+            25);
+        });
+        it('should pass since and pagination through', async () => {
+            RepositoryService.getComments.mockResolvedValue({ values: [] });
+            await bitbucketService.getCommitComments(mockProjectKey, mockRepositorySlug, 'abc123', 'src/app.js', 'def456', 5, 50);
+            expect(RepositoryService.getComments).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, 'src/app.js', 'def456', 5, 50);
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.getComments.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getCommitComments(mockProjectKey, mockRepositorySlug, 'abc123', 'src/app.js');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getTag', () => {
+        it('should get a single tag by name', async () => {
+            const mockTag = { id: 'refs/tags/v1', displayId: 'v1' };
+            RepositoryService.getTag.mockResolvedValue(mockTag);
+            const result = await bitbucketService.getTag(mockProjectKey, mockRepositorySlug, 'v1');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTag);
+            expect(RepositoryService.getTag).toHaveBeenCalledWith(mockProjectKey, 'v1', mockRepositorySlug);
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.getTag.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getTag(mockProjectKey, mockRepositorySlug, 'v1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getDefaultBranch', () => {
+        it('should successfully get the default branch', async () => {
+            const mockBranch = { id: 'refs/heads/main', displayId: 'main', isDefault: true };
+            RepositoryService.getDefaultBranch1.mockResolvedValue(mockBranch);
+            const result = await bitbucketService.getDefaultBranch(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockBranch);
+            expect(RepositoryService.getDefaultBranch1).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug);
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            RepositoryService.getDefaultBranch1.mockRejectedValue(mockError);
+            const result = await bitbucketService.getDefaultBranch(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('addCommitComment', () => {
+        it('should add a general commit comment', async () => {
+            const mockComment = { id: 99, text: 'nice' };
+            RepositoryService.createComment.mockResolvedValue(mockComment);
+            const result = await bitbucketService.addCommitComment(mockProjectKey, mockRepositorySlug, 'abc123', 'nice');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComment);
+            expect(RepositoryService.createComment).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, undefined, { text: 'nice' });
+        });
+        it('should anchor the comment to a file and line', async () => {
+            RepositoryService.createComment.mockResolvedValue({ id: 100 });
+            await bitbucketService.addCommitComment(mockProjectKey, mockRepositorySlug, 'abc123', 'fix this', 'src/app.js', 12, 'ADDED');
+            expect(RepositoryService.createComment).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, undefined, { text: 'fix this', anchor: { path: 'src/app.js', line: 12, lineType: 'ADDED', fileType: 'TO' } });
+        });
+        it('should default lineType to CONTEXT when a line is given without one', async () => {
+            RepositoryService.createComment.mockResolvedValue({ id: 101 });
+            await bitbucketService.addCommitComment(mockProjectKey, mockRepositorySlug, 'abc123', 'note', 'src/app.js', 3);
+            expect(RepositoryService.createComment).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, undefined, { text: 'note', anchor: { path: 'src/app.js', line: 3, lineType: 'CONTEXT', fileType: 'TO' } });
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.createComment.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.addCommitComment(mockProjectKey, mockRepositorySlug, 'abc123', 'x');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('listBuildStatuses', () => {
+        it('should list build statuses for a commit', async () => {
+            const mockStatuses = { values: [{ key: 'build-1', state: 'SUCCESSFUL' }], isLastPage: true };
+            DeprecatedService.getBuildStatus.mockResolvedValue(mockStatuses);
+            const result = await bitbucketService.listBuildStatuses('abc123');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockStatuses);
+            expect(DeprecatedService.getBuildStatus).toHaveBeenCalledWith('abc123', undefined, undefined, 25);
+        });
+        it('should pass orderBy and pagination through', async () => {
+            DeprecatedService.getBuildStatus.mockResolvedValue({ values: [] });
+            await bitbucketService.listBuildStatuses('abc123', 'newest', 5, 50);
+            expect(DeprecatedService.getBuildStatus).toHaveBeenCalledWith('abc123', 'newest', 5, 50);
+        });
+        it('should handle API errors gracefully', async () => {
+            DeprecatedService.getBuildStatus.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.listBuildStatuses('abc123');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('addBuildStatus', () => {
+        it('should add a build status with minimal fields', async () => {
+            BuildsAndDeploymentsService.add.mockResolvedValue(undefined);
+            const result = await bitbucketService.addBuildStatus(mockProjectKey, mockRepositorySlug, 'abc123', 'SUCCESSFUL', 'build-1', 'http://ci/build/1');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ added: true, commitId: 'abc123', key: 'build-1' });
+            expect(BuildsAndDeploymentsService.add).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, { state: 'SUCCESSFUL', key: 'build-1', url: 'http://ci/build/1' });
+        });
+        it('should include optional name and description', async () => {
+            BuildsAndDeploymentsService.add.mockResolvedValue(undefined);
+            await bitbucketService.addBuildStatus(mockProjectKey, mockRepositorySlug, 'abc123', 'FAILED', 'build-2', 'http://ci/build/2', 'Unit tests', 'Failed on step 3');
+            expect(BuildsAndDeploymentsService.add).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, { state: 'FAILED', key: 'build-2', url: 'http://ci/build/2', name: 'Unit tests', description: 'Failed on step 3' });
+        });
+        it('should handle API errors gracefully', async () => {
+            BuildsAndDeploymentsService.add.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.addBuildStatus(mockProjectKey, mockRepositorySlug, 'abc123', 'SUCCESSFUL', 'build-1', 'http://ci/build/1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getBuildStatus', () => {
+        it('should get a single build status by key', async () => {
+            const mockStatus = { key: 'build-1', state: 'SUCCESSFUL' };
+            BuildsAndDeploymentsService.get.mockResolvedValue(mockStatus);
+            const result = await bitbucketService.getBuildStatus(mockProjectKey, mockRepositorySlug, 'abc123', 'build-1');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockStatus);
+            expect(BuildsAndDeploymentsService.get).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, 'build-1');
+        });
+        it('should handle API errors gracefully', async () => {
+            BuildsAndDeploymentsService.get.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getBuildStatus(mockProjectKey, mockRepositorySlug, 'abc123', 'build-1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getCommit', () => {
+        it('should successfully get a single commit', async () => {
+            const mockCommit = { id: 'abc123', message: 'Initial commit', author: { name: 'dev' } };
+            RepositoryService.getCommit.mockResolvedValue(mockCommit);
+            const result = await bitbucketService.getCommit(mockProjectKey, mockRepositorySlug, 'abc123');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockCommit);
+            expect(RepositoryService.getCommit).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, undefined);
+        });
+        it('should pass the path through', async () => {
+            RepositoryService.getCommit.mockResolvedValue({});
+            await bitbucketService.getCommit(mockProjectKey, mockRepositorySlug, 'abc123', 'src/app.js');
+            expect(RepositoryService.getCommit).toHaveBeenCalledWith(mockProjectKey, 'abc123', mockRepositorySlug, 'src/app.js');
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.getCommit.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getCommit(mockProjectKey, mockRepositorySlug, 'abc123');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('editFile', () => {
+        it('should create a new file (no sourceCommitId)', async () => {
+            const mockCommit = { id: 'newsha', message: 'add file' };
+            RepositoryService.editFile.mockResolvedValue(mockCommit);
+            const result = await bitbucketService.editFile(mockProjectKey, mockRepositorySlug, 'docs/new.md', '# Hello', 'add file', 'master');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockCommit);
+            expect(RepositoryService.editFile).toHaveBeenCalledWith('docs/new.md', mockProjectKey, mockRepositorySlug, { content: '# Hello', message: 'add file', branch: 'master' });
+        });
+        it('should pass sourceCommitId and sourceBranch when editing', async () => {
+            RepositoryService.editFile.mockResolvedValue({ id: 'sha2' });
+            await bitbucketService.editFile(mockProjectKey, mockRepositorySlug, 'README.md', 'updated', 'edit readme', 'feature/x', 'oldsha', 'master');
+            expect(RepositoryService.editFile).toHaveBeenCalledWith('README.md', mockProjectKey, mockRepositorySlug, { content: 'updated', message: 'edit readme', branch: 'feature/x', sourceCommitId: 'oldsha', sourceBranch: 'master' });
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.editFile.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.editFile(mockProjectKey, mockRepositorySlug, 'README.md', 'x', 'msg', 'master');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getCommitDiff', () => {
+        it('should get a whole-commit diff by default (empty path)', async () => {
+            const mockDiff = { diffs: [] };
+            RepositoryService.streamDiff.mockResolvedValue(mockDiff);
+            const result = await bitbucketService.getCommitDiff(mockProjectKey, mockRepositorySlug, 'abc123');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockDiff);
+            expect(RepositoryService.streamDiff).toHaveBeenCalledWith('abc123', mockRepositorySlug, '', mockProjectKey, undefined, // srcPath
+            undefined, // avatarSize
+            undefined, // filter
+            undefined, // avatarScheme
+            undefined, // contextLines
+            undefined, // autoSrcPath
+            undefined, // whitespace
+            undefined, // withComments
+            undefined // since
+            );
+        });
+        it('should pass path, contextLines, whitespace and srcPath through', async () => {
+            RepositoryService.streamDiff.mockResolvedValue({});
+            await bitbucketService.getCommitDiff(mockProjectKey, mockRepositorySlug, 'abc123', 'src/app.js', '5', 'ignore-all', 'src/old.js');
+            expect(RepositoryService.streamDiff).toHaveBeenCalledWith('abc123', mockRepositorySlug, 'src/app.js', mockProjectKey, 'src/old.js', undefined, undefined, undefined, '5', undefined, 'ignore-all', undefined, undefined);
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.streamDiff.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getCommitDiff(mockProjectKey, mockRepositorySlug, 'abc123');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('compareRefs', () => {
+        it('should compare commits by default', async () => {
+            const mockCompare = { values: [{ id: 'c1' }], isLastPage: true };
+            RepositoryService.streamCommits.mockResolvedValue(mockCompare);
+            const result = await bitbucketService.compareRefs(mockProjectKey, mockRepositorySlug, 'refs/heads/feature', 'refs/heads/master');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockCompare);
+            expect(RepositoryService.streamCommits).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, // fromRepo
+            'refs/heads/feature', 'refs/heads/master', undefined, // start
+            25);
+            expect(RepositoryService.streamChanges).not.toHaveBeenCalled();
+        });
+        it('should compare changes when compareType is changes', async () => {
+            const mockCompare = { values: [], isLastPage: true };
+            RepositoryService.streamChanges.mockResolvedValue(mockCompare);
+            await bitbucketService.compareRefs(mockProjectKey, mockRepositorySlug, 'refs/heads/feature', 'refs/heads/master', 'OTHER/repo', 'changes', 10, 50);
+            expect(RepositoryService.streamChanges).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, 'OTHER/repo', 'refs/heads/feature', 'refs/heads/master', 10, 50);
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.streamCommits.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.compareRefs(mockProjectKey, mockRepositorySlug, 'a', 'b');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('createTag', () => {
+        it('should create a lightweight tag', async () => {
+            const mockTag = { id: 'refs/tags/v2', displayId: 'v2' };
+            RepositoryService.createTagForRepository.mockResolvedValue(mockTag);
+            const result = await bitbucketService.createTag(mockProjectKey, mockRepositorySlug, 'v2', 'refs/heads/master');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTag);
+            expect(RepositoryService.createTagForRepository).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, { name: 'v2', startPoint: 'refs/heads/master' });
+        });
+        it('should include message for an annotated tag', async () => {
+            RepositoryService.createTagForRepository.mockResolvedValue({});
+            await bitbucketService.createTag(mockProjectKey, mockRepositorySlug, 'v2', 'abc123', 'Release 2');
+            expect(RepositoryService.createTagForRepository).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, { name: 'v2', startPoint: 'abc123', message: 'Release 2' });
+        });
+        it('should handle API errors gracefully', async () => {
+            RepositoryService.createTagForRepository.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createTag(mockProjectKey, mockRepositorySlug, 'v2', 'refs/heads/master');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getPullRequests', () => {
+        it('should successfully get pull requests with default parameters', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Test PR 1',
+                        state: 'OPEN',
+                        author: { user: { name: 'user1' } }
+                    },
+                    {
+                        id: 2,
+                        title: 'Test PR 2',
+                        state: 'OPEN',
+                        author: { user: { name: 'user2' } }
+                    }
+                ],
+                size: 2,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            undefined, // draft
+            undefined, // filterText
+            undefined, // state
+            undefined, // order
+            undefined, // direction
+            undefined, // start
+            25 // limit
+            );
+        });
+        it('should successfully get pull requests with state filter', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Merged PR',
+                        state: 'MERGED',
+                        author: { user: { name: 'user1' } }
+                    }
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            undefined, // draft
+            undefined, // filterText
+            'MERGED' // state
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, undefined, undefined, 'MERGED', undefined, undefined, undefined, 25);
+        });
+        it('should successfully get pull requests with text filter', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Fix bug in authentication',
+                        state: 'OPEN',
+                        author: { user: { name: 'user1' } }
+                    }
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            undefined, // draft
+            'authentication' // filterText
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, undefined, 'authentication', undefined, undefined, undefined, undefined, 25);
+        });
+        it('should successfully get pull requests with branch filter', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'PR to master',
+                        state: 'OPEN',
+                        toRef: { id: 'refs/heads/master' }
+                    }
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            'refs/heads/master' // at
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, 'refs/heads/master', undefined, undefined, undefined, undefined, undefined, undefined, undefined, 25);
+        });
+        it('should successfully get pull requests with direction filter', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Outgoing PR',
+                        state: 'OPEN'
+                    }
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            undefined, // draft
+            undefined, // filterText
+            undefined, // state
+            undefined, // order
+            'OUTGOING' // direction
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 'OUTGOING', undefined, 25);
+        });
+        it('should successfully get pull requests with order filter', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Oldest PR',
+                        state: 'OPEN',
+                        createdDate: 1234567890
+                    },
+                    {
+                        id: 2,
+                        title: 'Newer PR',
+                        state: 'OPEN',
+                        createdDate: 1234567900
+                    }
+                ],
+                size: 2,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            undefined, // draft
+            undefined, // filterText
+            undefined, // state
+            'OLDEST' // order
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, undefined, undefined, undefined, 'OLDEST', undefined, undefined, 25);
+        });
+        it('should successfully get pull requests with draft filter', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Draft PR',
+                        state: 'OPEN',
+                        draft: true
+                    }
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            'true' // draft
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, 'true', undefined, undefined, undefined, undefined, undefined, 25);
+        });
+        it('should successfully get pull requests with pagination', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 51,
+                        title: 'PR 51',
+                        state: 'OPEN'
+                    }
+                ],
+                size: 1,
+                isLastPage: false,
+                start: 50,
+                limit: 10,
+                nextPageStart: 60
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, // withAttributes
+            undefined, // at
+            undefined, // withProperties
+            undefined, // draft
+            undefined, // filterText
+            undefined, // state
+            undefined, // order
+            undefined, // direction
+            50, // start
+            10 // limit
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 50, 10);
+        });
+        it('should successfully get pull requests with all parameters', async () => {
+            const mockPullRequestsData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Complete PR test',
+                        state: 'OPEN',
+                        draft: false
+                    }
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 50
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, 'true', // withAttributes
+            'refs/heads/develop', // at
+            'true', // withProperties
+            'false', // draft
+            'test', // filterText
+            'ALL', // state
+            'NEWEST', // order
+            'INCOMING', // direction
+            0, // start
+            50 // limit
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, 'true', 'refs/heads/develop', 'true', 'false', 'test', 'ALL', 'NEWEST', 'INCOMING', 0, 50);
+        });
+        it('should handle empty results', async () => {
+            const mockPullRequestsData = {
+                values: [],
+                size: 0,
+                isLastPage: true,
+                start: 0,
+                limit: 25
+            };
+            PullRequestsService.getPage.mockResolvedValue(mockPullRequestsData);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestsData);
+            if (result.data) {
+                expect(result.data.values).toHaveLength(0);
+            }
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Failed to fetch pull requests');
+            PullRequestsService.getPage.mockRejectedValue(mockError);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Failed to fetch pull requests');
+        });
+        it('should handle permission errors', async () => {
+            const mockError = new Error('Insufficient permissions');
+            PullRequestsService.getPage.mockRejectedValue(mockError);
+            const result = await bitbucketService.getPullRequests(mockProjectKey, mockRepositorySlug, undefined, undefined, undefined, undefined, undefined, 'OPEN');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Insufficient permissions');
+        });
+    });
+    describe('getPullRequest', () => {
+        it('should successfully get a specific pull request by ID', async () => {
+            const mockPullRequestData = {
+                id: 123,
+                version: 1,
+                title: 'Feature: Add new functionality',
+                description: 'This PR adds new functionality',
+                state: 'OPEN',
+                open: true,
+                closed: false,
+                createdDate: 1234567890,
+                updatedDate: 1234567900,
+                fromRef: {
+                    id: 'refs/heads/feature-branch',
+                    displayId: 'feature-branch',
+                    latestCommit: 'abc123',
+                    repository: {
+                        slug: 'test-repo',
+                        project: { key: 'TEST' }
+                    }
+                },
+                toRef: {
+                    id: 'refs/heads/main',
+                    displayId: 'main',
+                    latestCommit: 'def456',
+                    repository: {
+                        slug: 'test-repo',
+                        project: { key: 'TEST' }
+                    }
+                },
+                author: {
+                    user: {
+                        name: 'testuser',
+                        emailAddress: 'test@example.com',
+                        displayName: 'Test User'
+                    }
+                },
+                reviewers: [
+                    {
+                        user: { name: 'reviewer1', displayName: 'Reviewer One' },
+                        approved: true
+                    }
+                ],
+                participants: []
+            };
+            PullRequestsService.get3.mockResolvedValue(mockPullRequestData);
+            const result = await bitbucketService.getPullRequest(mockProjectKey, mockRepositorySlug, '123');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPullRequestData);
+            expect(PullRequestsService.get3).toHaveBeenCalledWith(mockProjectKey, '123', mockRepositorySlug);
+        });
+        it('should handle errors when pull request does not exist', async () => {
+            const mockError = new Error('Not found');
+            PullRequestsService.get3.mockRejectedValue(mockError);
+            const result = await bitbucketService.getPullRequest(mockProjectKey, mockRepositorySlug, '999');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Not found');
+        });
+        it('should handle permission errors', async () => {
+            const mockError = new Error('Insufficient permissions');
+            PullRequestsService.get3.mockRejectedValue(mockError);
+            const result = await bitbucketService.getPullRequest(mockProjectKey, mockRepositorySlug, '123');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Insufficient permissions');
+        });
+    });
+    describe('postPullRequestComment', () => {
+        it('should successfully post a general PR comment', async () => {
+            const mockComment = {
+                id: 12345,
+                text: 'Test comment',
+                author: { displayName: 'Test User' }
+            };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Test comment');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 12345,
+                pending: false,
+            });
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, { text: 'Test comment' });
+        });
+        it('should successfully post a reply comment', async () => {
+            const mockComment = {
+                id: 12346,
+                text: 'Reply comment',
+                author: { displayName: 'Test User' }
+            };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Reply comment', 123 // parentId
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 12346,
+                pending: false,
+            });
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Reply comment',
+                parent: { id: 123 }
+            });
+        });
+        it('should successfully post a file comment', async () => {
+            const mockComment = {
+                id: 12347,
+                text: 'File comment',
+                author: { displayName: 'Test User' }
+            };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'File comment', undefined, // parentId
+            'src/test.js' // filePath
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 12347,
+                pending: false,
+            });
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'File comment',
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE'
+                }
+            });
+        });
+        it('should successfully post a line comment', async () => {
+            const mockComment = {
+                id: 12348,
+                text: 'Line comment',
+                author: { displayName: 'Test User' }
+            };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Line comment', undefined, // parentId
+            'src/test.js', // filePath
+            undefined, // startLine
+            undefined, // startLineType
+            42, // line
+            'ADDED' // lineType
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 12348,
+                pending: false,
+            });
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Line comment',
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 42,
+                    lineType: 'ADDED',
+                    fileType: 'TO'
+                }
+            });
+        });
+        it('should successfully post a multiline comment', async () => {
+            const mockComment = {
+                id: 12349,
+                text: 'Multiline comment',
+                author: { displayName: 'Test User' },
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 15,
+                    lineType: 'ADDED',
+                    fileType: 'TO',
+                    multilineMarker: { startLine: 10, startLineType: 'ADDED' },
+                    multilineSpan: { dstSpanStart: 10, dstSpanEnd: 15 }
+                }
+            };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Multiline comment', undefined, // parentId
+            'src/test.js', // filePath
+            10, // startLine
+            undefined, // startLineType (should default to lineType)
+            15, // line (end line)
+            'ADDED' // lineType
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 12349,
+                pending: false,
+                anchor: {
+                    path: 'src/test.js',
+                    line: 15,
+                    lineType: 'ADDED',
+                    startLine: 10,
+                    startLineType: 'ADDED',
+                }
+            });
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Multiline comment',
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 15,
+                    lineType: 'ADDED',
+                    fileType: 'TO',
+                    multilineMarker: { startLine: 10, startLineType: 'ADDED' },
+                    multilineSpan: { dstSpanStart: 10, dstSpanEnd: 15 }
+                }
+            });
+        });
+        it('should post a multiline comment with explicit startLineType', async () => {
+            const mockComment = {
+                id: 12350,
+                text: 'Mixed multiline comment',
+                author: { displayName: 'Test User' },
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 8,
+                    lineType: 'ADDED',
+                    fileType: 'TO',
+                    multilineMarker: { startLine: 5, startLineType: 'CONTEXT' },
+                    multilineSpan: { dstSpanStart: 5, dstSpanEnd: 8 }
+                }
+            };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Mixed multiline comment', undefined, // parentId
+            'src/test.js', // filePath
+            5, // startLine
+            'CONTEXT', // startLineType
+            8, // line (end line)
+            'ADDED' // lineType
+            );
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Mixed multiline comment',
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 8,
+                    lineType: 'ADDED',
+                    fileType: 'TO',
+                    multilineMarker: { startLine: 5, startLineType: 'CONTEXT' },
+                    multilineSpan: { dstSpanStart: 5, dstSpanEnd: 8 }
+                }
+            });
+        });
+        it('should normalize a reversed multiline range (startLine > line)', async () => {
+            PullRequestsService.createComment2.mockResolvedValue({ id: 1, anchor: { path: 'src/test.js' } });
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Reversed range', undefined, // parentId
+            'src/test.js', // filePath
+            15, // startLine (greater than line)
+            'ADDED', // startLineType
+            10, // line (end line, smaller)
+            'ADDED' // lineType
+            );
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Reversed range',
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 15,
+                    lineType: 'ADDED',
+                    fileType: 'TO',
+                    multilineMarker: { startLine: 10, startLineType: 'ADDED' },
+                    multilineSpan: { dstSpanStart: 10, dstSpanEnd: 15 }
+                }
+            });
+        });
+        it('should anchor a REMOVED multiline range to the source file', async () => {
+            PullRequestsService.createComment2.mockResolvedValue({ id: 1, anchor: { path: 'src/test.js' } });
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Removed range', undefined, // parentId
+            'src/test.js', // filePath
+            2, // startLine
+            'REMOVED', // startLineType
+            5, // line (end line)
+            'REMOVED' // lineType
+            );
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Removed range',
+                anchor: {
+                    path: 'src/test.js',
+                    diffType: 'EFFECTIVE',
+                    line: 5,
+                    lineType: 'REMOVED',
+                    fileType: 'FROM',
+                    multilineMarker: { startLine: 2, startLineType: 'REMOVED' },
+                    multilineSpan: { srcSpanStart: 2, srcSpanEnd: 5 }
+                }
+            });
+        });
+        it('should warn when a multi-line suggestion is anchored to a single line', async () => {
+            PullRequestsService.createComment2.mockResolvedValue({
+                id: 99,
+                anchor: { path: 'src/test.js', line: 5, lineType: 'ADDED' }
+            });
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, '```suggestion\nconst a = 1;\nconst b = 2;\n```', undefined, // parentId
+            'src/test.js', // filePath
+            undefined, // startLine (single-line anchor — the bug shape)
+            undefined, // startLineType
+            5, // line
+            'ADDED' // lineType
+            );
+            expect(result.success).toBe(true);
+            expect(result.data.warning).toMatch(/multi-line ```suggestion/);
+            // single-line anchor: no multiline fields sent
+            const sentAnchor = PullRequestsService.createComment2.mock.calls[0][3].anchor;
+            expect(sentAnchor.multilineMarker).toBeUndefined();
+            expect(sentAnchor.multilineSpan).toBeUndefined();
+        });
+        it('should not warn when a multi-line suggestion has a proper multiline range', async () => {
+            PullRequestsService.createComment2.mockResolvedValue({
+                id: 100,
+                anchor: { path: 'src/test.js', line: 5, lineType: 'ADDED', multilineMarker: { startLine: 4, startLineType: 'ADDED' } }
+            });
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, '```suggestion\nconst a = 1;\nconst b = 2;\n```', undefined, // parentId
+            'src/test.js', // filePath
+            4, // startLine
+            'ADDED', // startLineType
+            5, // line
+            'ADDED' // lineType
+            );
+            expect(result.success).toBe(true);
+            expect(result.data.warning).toBeUndefined();
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            PullRequestsService.createComment2.mockRejectedValue(mockError);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Test comment');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getPullRequestDiff', () => {
+        const { request: mockRequest } = require('../bitbucket-client/core/request.js');
+        it('should successfully get raw diff with minimal parameters', async () => {
+            const mockRawDiff = 'diff --git a/file.txt b/file.txt\nindex 1234567..abcdefg 100644\n--- a/file.txt\n+++ b/file.txt\n@@ -1,3 +1,4 @@\n line1\n line2\n+new line\n line3';
+            mockRequest.mockResolvedValue(mockRawDiff);
+            const result = await bitbucketService.getPullRequestDiff(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'src/file.txt');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockRawDiff);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), // OpenAPI config
+            {
+                method: 'GET',
+                url: '/api/latest/projects/{projectKey}/repos/{repositorySlug}/pull-requests/{pullRequestId}/diff/{path}',
+                path: {
+                    'path': 'src/file.txt',
+                    'projectKey': mockProjectKey,
+                    'pullRequestId': mockPullRequestId,
+                    'repositorySlug': mockRepositorySlug,
+                },
+                query: {
+                    'contextLines': undefined,
+                    'sinceId': undefined,
+                    'srcPath': undefined,
+                    'diffType': undefined,
+                    'untilId': undefined,
+                    'whitespace': undefined,
+                },
+                headers: {
+                    'Accept': 'text/plain'
+                },
+                errors: {
+                    400: `If the request was malformed.`,
+                    401: `The currently authenticated user has insufficient permissions to view the repository or pull request.`,
+                    404: `The repository or pull request does not exist.`,
+                },
+            });
+        });
+        it('should successfully get raw diff with all parameters', async () => {
+            const mockRawDiff = 'diff --git a/old/file.txt b/new/file.txt\nindex 1234567..abcdefg 100644\n--- a/old/file.txt\n+++ b/new/file.txt\n@@ -1,5 +1,6 @@\n line1\n line2\n+new line\n line3\n line4\n line5';
+            mockRequest.mockResolvedValue(mockRawDiff);
+            const result = await bitbucketService.getPullRequestDiff(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'src/file.txt', '5', // contextLines
+            'abc123', // sinceId
+            'old/file.txt', // srcPath
+            'EFFECTIVE', // diffType
+            'def456', // untilId
+            'ignore-all' // whitespace
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockRawDiff);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), // OpenAPI config
+            {
+                method: 'GET',
+                url: '/api/latest/projects/{projectKey}/repos/{repositorySlug}/pull-requests/{pullRequestId}/diff/{path}',
+                path: {
+                    'path': 'src/file.txt',
+                    'projectKey': mockProjectKey,
+                    'pullRequestId': mockPullRequestId,
+                    'repositorySlug': mockRepositorySlug,
+                },
+                query: {
+                    'contextLines': '5',
+                    'sinceId': 'abc123',
+                    'srcPath': 'old/file.txt',
+                    'diffType': 'EFFECTIVE',
+                    'untilId': 'def456',
+                    'whitespace': 'ignore-all',
+                },
+                headers: {
+                    'Accept': 'text/plain'
+                },
+                errors: {
+                    400: `If the request was malformed.`,
+                    401: `The currently authenticated user has insufficient permissions to view the repository or pull request.`,
+                    404: `The repository or pull request does not exist.`,
+                },
+            });
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            mockRequest.mockRejectedValue(mockError);
+            const result = await bitbucketService.getPullRequestDiff(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'src/file.txt');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('createPullRequest', () => {
+        it('should successfully create a PR with minimal parameters', async () => {
+            const mockPullRequest = {
+                id: 1,
+                version: 0,
+                title: 'Test PR',
+                description: 'Test description',
+                state: 'OPEN',
+                fromRef: {
+                    id: 'refs/heads/feature-branch',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                },
+                toRef: {
+                    id: 'refs/heads/main',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                }
+            };
+            PullRequestsService.create.mockResolvedValue(mockPullRequest);
+            const result = await bitbucketService.createPullRequest(mockProjectKey, mockRepositorySlug, 'Test PR', 'Test description', 'refs/heads/feature-branch', 'refs/heads/main');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 0,
+                title: 'Test PR',
+                state: 'OPEN',
+                fromRefId: 'refs/heads/feature-branch',
+                toRefId: 'refs/heads/main',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.create).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, {
+                title: 'Test PR',
+                description: 'Test description',
+                fromRef: {
+                    id: 'refs/heads/feature-branch',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                },
+                toRef: {
+                    id: 'refs/heads/main',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                }
+            });
+        });
+        it('should successfully create a PR without description', async () => {
+            const mockPullRequest = {
+                id: 2,
+                version: 0,
+                title: 'Test PR without description',
+                state: 'OPEN',
+                fromRef: {
+                    id: 'refs/heads/feature-branch',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                },
+                toRef: {
+                    id: 'refs/heads/main',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                }
+            };
+            PullRequestsService.create.mockResolvedValue(mockPullRequest);
+            const result = await bitbucketService.createPullRequest(mockProjectKey, mockRepositorySlug, 'Test PR without description', undefined, 'refs/heads/feature-branch', 'refs/heads/main');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 2,
+                version: 0,
+                title: 'Test PR without description',
+                state: 'OPEN',
+                fromRefId: 'refs/heads/feature-branch',
+                toRefId: 'refs/heads/main',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.create).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, expect.objectContaining({
+                title: 'Test PR without description',
+                description: undefined
+            }));
+        });
+        it('should successfully create a PR with reviewers', async () => {
+            const mockPullRequest = {
+                id: 3,
+                version: 0,
+                title: 'Test PR with reviewers',
+                description: 'PR with reviewers',
+                state: 'OPEN',
+                fromRef: {
+                    id: 'refs/heads/feature-branch',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                },
+                toRef: {
+                    id: 'refs/heads/main',
+                    repository: {
+                        slug: mockRepositorySlug,
+                        project: { key: mockProjectKey }
+                    }
+                },
+                reviewers: [
+                    { user: { name: 'reviewer1' } },
+                    { user: { name: 'reviewer2' } }
+                ]
+            };
+            PullRequestsService.create.mockResolvedValue(mockPullRequest);
+            const result = await bitbucketService.createPullRequest(mockProjectKey, mockRepositorySlug, 'Test PR with reviewers', 'PR with reviewers', 'refs/heads/feature-branch', 'refs/heads/main', ['reviewer1', 'reviewer2']);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 3,
+                version: 0,
+                title: 'Test PR with reviewers',
+                state: 'OPEN',
+                fromRefId: 'refs/heads/feature-branch',
+                toRefId: 'refs/heads/main',
+                reviewerCount: 2,
+            });
+            expect(PullRequestsService.create).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, expect.objectContaining({
+                title: 'Test PR with reviewers',
+                reviewers: [
+                    { user: { name: 'reviewer1' } },
+                    { user: { name: 'reviewer2' } }
+                ]
+            }));
+        });
+        it('should successfully create a PR with empty reviewers array', async () => {
+            const mockPullRequest = {
+                id: 4,
+                version: 0,
+                title: 'Test PR',
+                description: 'Test',
+                state: 'OPEN'
+            };
+            PullRequestsService.create.mockResolvedValue(mockPullRequest);
+            const result = await bitbucketService.createPullRequest(mockProjectKey, mockRepositorySlug, 'Test PR', 'Test', 'refs/heads/feature-branch', 'refs/heads/main', []);
+            expect(result.success).toBe(true);
+            expect(PullRequestsService.create).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, expect.not.objectContaining({
+                reviewers: expect.anything()
+            }));
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Failed to create PR');
+            PullRequestsService.create.mockRejectedValue(mockError);
+            const result = await bitbucketService.createPullRequest(mockProjectKey, mockRepositorySlug, 'Test PR', 'Test description', 'refs/heads/feature-branch', 'refs/heads/main');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Failed to create PR');
+        });
+    });
+    describe('updatePullRequest', () => {
+        it('should successfully update PR with only title', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 1,
+                title: 'Updated Title',
+                description: 'Original description',
+                state: 'OPEN'
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0, 'Updated Title');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 1,
+                title: 'Updated Title',
+                state: 'OPEN',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                version: 0,
+                title: 'Updated Title'
+            });
+        });
+        it('should successfully update PR with only description', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 1,
+                title: 'Original Title',
+                description: 'Updated description',
+                state: 'OPEN'
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0, undefined, 'Updated description');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 1,
+                title: 'Original Title',
+                state: 'OPEN',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                version: 0,
+                description: 'Updated description'
+            });
+        });
+        it('should successfully update PR with title and description', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 1,
+                title: 'Updated Title',
+                description: 'Updated description',
+                state: 'OPEN'
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0, 'Updated Title', 'Updated description');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 1,
+                title: 'Updated Title',
+                state: 'OPEN',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                version: 0,
+                title: 'Updated Title',
+                description: 'Updated description'
+            });
+        });
+        it('should successfully update PR with reviewers', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 1,
+                title: 'Test PR',
+                description: 'Test',
+                state: 'OPEN',
+                reviewers: [
+                    { user: { name: 'reviewer1' } },
+                    { user: { name: 'reviewer2' } },
+                    { user: { name: 'reviewer3' } }
+                ]
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0, undefined, undefined, ['reviewer1', 'reviewer2', 'reviewer3']);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 1,
+                title: 'Test PR',
+                state: 'OPEN',
+                reviewerCount: 3,
+            });
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                version: 0,
+                reviewers: [
+                    { user: { name: 'reviewer1' } },
+                    { user: { name: 'reviewer2' } },
+                    { user: { name: 'reviewer3' } }
+                ]
+            });
+        });
+        it('should successfully update PR with all parameters', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 2,
+                title: 'Updated Title',
+                description: 'Updated description',
+                state: 'OPEN',
+                reviewers: [
+                    { user: { name: 'newreviewer1' } },
+                    { user: { name: 'newreviewer2' } }
+                ]
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1, 'Updated Title', 'Updated description', ['newreviewer1', 'newreviewer2']);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 2,
+                title: 'Updated Title',
+                state: 'OPEN',
+                reviewerCount: 2,
+            });
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                version: 1,
+                title: 'Updated Title',
+                description: 'Updated description',
+                reviewers: [
+                    { user: { name: 'newreviewer1' } },
+                    { user: { name: 'newreviewer2' } }
+                ]
+            });
+        });
+        it('should successfully update PR with only version (no changes)', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 1,
+                title: 'Original Title',
+                description: 'Original description',
+                state: 'OPEN'
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 1,
+                title: 'Original Title',
+                state: 'OPEN',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                version: 0
+            });
+        });
+        it('should successfully update PR with empty reviewers array', async () => {
+            const mockUpdatedPR = {
+                id: 1,
+                version: 1,
+                title: 'Test PR',
+                description: 'Test',
+                state: 'OPEN',
+                reviewers: []
+            };
+            PullRequestsService.update.mockResolvedValue(mockUpdatedPR);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0, undefined, undefined, []);
+            expect(result.success).toBe(true);
+            expect(PullRequestsService.update).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, expect.not.objectContaining({
+                reviewers: expect.anything()
+            }));
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Failed to update PR');
+            PullRequestsService.update.mockRejectedValue(mockError);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 0, 'Updated Title');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Failed to update PR');
+        });
+        it('should handle version conflict errors', async () => {
+            const mockError = new Error('Version conflict - PR has been modified');
+            PullRequestsService.update.mockRejectedValue(mockError);
+            const result = await bitbucketService.updatePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 5, 'Updated Title');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Version conflict - PR has been modified');
+        });
+    });
+    describe('canMergePullRequest', () => {
+        it('should successfully check mergeability', async () => {
+            const mockMergeability = { canMerge: true, conflicted: false, vetoes: [] };
+            PullRequestsService.canMerge.mockResolvedValue(mockMergeability);
+            const result = await bitbucketService.canMergePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockMergeability);
+            expect(PullRequestsService.canMerge).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug);
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            PullRequestsService.canMerge.mockRejectedValue(mockError);
+            const result = await bitbucketService.canMergePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('mergePullRequest', () => {
+        it('should successfully merge a PR with minimal parameters', async () => {
+            const mockMergedPR = {
+                id: 1,
+                version: 2,
+                title: 'Test PR',
+                state: 'MERGED',
+                fromRef: { id: 'refs/heads/feature-branch' },
+                toRef: { id: 'refs/heads/main' }
+            };
+            PullRequestsService.merge.mockResolvedValue(mockMergedPR);
+            const result = await bitbucketService.mergePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 2,
+                title: 'Test PR',
+                state: 'MERGED',
+                fromRefId: 'refs/heads/feature-branch',
+                toRefId: 'refs/heads/main',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.merge).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, '1', {});
+        });
+        it('should pass message and strategyId in the request body', async () => {
+            const mockMergedPR = { id: 1, version: 2, state: 'MERGED' };
+            PullRequestsService.merge.mockResolvedValue(mockMergedPR);
+            await bitbucketService.mergePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1, 'Custom merge message', 'squash');
+            expect(PullRequestsService.merge).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, '1', { message: 'Custom merge message', strategyId: 'squash' });
+        });
+        it('should return the full response when output is full', async () => {
+            const mockMergedPR = { id: 1, version: 2, state: 'MERGED' };
+            PullRequestsService.merge.mockResolvedValue(mockMergedPR);
+            const result = await bitbucketService.mergePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1, undefined, undefined, 'full');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockMergedPR);
+        });
+        it('should handle merge veto errors gracefully', async () => {
+            const mockError = new Error('The pull request has unresolved tasks');
+            PullRequestsService.merge.mockRejectedValue(mockError);
+            const result = await bitbucketService.mergePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('The pull request has unresolved tasks');
+        });
+    });
+    describe('declinePullRequest', () => {
+        it('should successfully decline a PR', async () => {
+            const mockDeclinedPR = {
+                id: 1,
+                version: 2,
+                title: 'Test PR',
+                state: 'DECLINED'
+            };
+            PullRequestsService.decline.mockResolvedValue(mockDeclinedPR);
+            const result = await bitbucketService.declinePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 2,
+                title: 'Test PR',
+                state: 'DECLINED',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.decline).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, '1', {});
+        });
+        it('should pass an optional comment in the request body', async () => {
+            const mockDeclinedPR = { id: 1, version: 2, state: 'DECLINED' };
+            PullRequestsService.decline.mockResolvedValue(mockDeclinedPR);
+            await bitbucketService.declinePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1, 'Superseded by another PR');
+            expect(PullRequestsService.decline).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, '1', { comment: 'Superseded by another PR' });
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('API Error');
+            PullRequestsService.decline.mockRejectedValue(mockError);
+            const result = await bitbucketService.declinePullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 1);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('reopenPullRequest', () => {
+        it('should successfully reopen a declined PR', async () => {
+            const mockReopenedPR = {
+                id: 1,
+                version: 3,
+                title: 'Test PR',
+                state: 'OPEN'
+            };
+            PullRequestsService.reopen.mockResolvedValue(mockReopenedPR);
+            const result = await bitbucketService.reopenPullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 2);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                id: 1,
+                version: 3,
+                title: 'Test PR',
+                state: 'OPEN',
+                reviewerCount: 0,
+            });
+            expect(PullRequestsService.reopen).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, '2', {});
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Pull request is not declined');
+            PullRequestsService.reopen.mockRejectedValue(mockError);
+            const result = await bitbucketService.reopenPullRequest(mockProjectKey, mockRepositorySlug, mockPullRequestId, 2);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Pull request is not declined');
+        });
+    });
+    describe('getRequiredReviewers', () => {
+        it('should successfully get required reviewers', async () => {
+            const mockReviewersData = [
+                {
+                    id: 1,
+                    reviewers: [
+                        { name: 'reviewer1', emailAddress: 'reviewer1@example.com' },
+                        { name: 'reviewer2', emailAddress: 'reviewer2@example.com' }
+                    ]
+                }
+            ];
+            PullRequestsService.getReviewers.mockResolvedValue(mockReviewersData);
+            const result = await bitbucketService.getRequiredReviewers(mockProjectKey, mockRepositorySlug, 'refs/heads/feature', 'refs/heads/main');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockReviewersData);
+            expect(PullRequestsService.getReviewers).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, undefined, // targetRepoId
+            undefined, // sourceRepoId
+            'refs/heads/feature', 'refs/heads/main');
+        });
+        it('should successfully get required reviewers with all parameters', async () => {
+            const mockReviewersData = [
+                {
+                    id: 1,
+                    reviewers: [
+                        { name: 'reviewer1', emailAddress: 'reviewer1@example.com' }
+                    ]
+                }
+            ];
+            PullRequestsService.getReviewers.mockResolvedValue(mockReviewersData);
+            const result = await bitbucketService.getRequiredReviewers(mockProjectKey, mockRepositorySlug, 'refs/heads/feature', 'refs/heads/main', '123', // sourceRepoId
+            '456' // targetRepoId
+            );
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockReviewersData);
+            expect(PullRequestsService.getReviewers).toHaveBeenCalledWith(mockProjectKey, mockRepositorySlug, '456', // targetRepoId
+            '123', // sourceRepoId
+            'refs/heads/feature', 'refs/heads/main');
+        });
+        it('should handle errors when getting required reviewers', async () => {
+            const mockError = new Error('API Error');
+            PullRequestsService.getReviewers.mockRejectedValue(mockError);
+            const result = await bitbucketService.getRequiredReviewers(mockProjectKey, mockRepositorySlug, 'refs/heads/feature', 'refs/heads/main');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('API Error');
+        });
+    });
+    describe('getDashboardPullRequests', () => {
+        const { request: mockRequest } = require('../bitbucket-client/core/request.js');
+        it('should default to AUTHOR role and the package page size', async () => {
+            const mockData = {
+                values: [
+                    { id: 1, title: 'PR 1', state: 'OPEN' },
+                    { id: 2, title: 'PR 2', state: 'OPEN' }
+                ],
+                size: 2,
+                isLastPage: true
+            };
+            mockRequest.mockResolvedValue(mockData);
+            const result = await bitbucketService.getDashboardPullRequests();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), {
+                method: 'GET',
+                url: '/api/1.0/dashboard/pull-requests',
+                query: {
+                    'role': 'AUTHOR',
+                    'state': 'OPEN',
+                    'closedSince': undefined,
+                    'order': 'NEWEST',
+                    'start': undefined,
+                    'limit': 25,
+                },
+                errors: {
+                    401: 'The currently authenticated user is not permitted to access the dashboard.',
+                },
+            });
+        });
+        it('should get dashboard PRs filtered by role and state', async () => {
+            const mockData = {
+                values: [{ id: 1, title: 'My PR', state: 'OPEN' }],
+                size: 1,
+                isLastPage: true
+            };
+            mockRequest.mockResolvedValue(mockData);
+            const result = await bitbucketService.getDashboardPullRequests('REVIEWER', 'OPEN', undefined, 'NEWEST', 0, 5);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), {
+                method: 'GET',
+                url: '/api/1.0/dashboard/pull-requests',
+                query: {
+                    'role': 'REVIEWER',
+                    'state': 'OPEN',
+                    'closedSince': undefined,
+                    'order': 'NEWEST',
+                    'start': 0,
+                    'limit': 5,
+                },
+                errors: {
+                    401: 'The currently authenticated user is not permitted to access the dashboard.',
+                },
+            });
+        });
+        it('should get dashboard PRs with closedSince filter', async () => {
+            const mockData = {
+                values: [{ id: 3, title: 'Merged PR', state: 'MERGED' }],
+                size: 1,
+                isLastPage: true
+            };
+            mockRequest.mockResolvedValue(mockData);
+            const closedSince = 1700000000000;
+            const result = await bitbucketService.getDashboardPullRequests('PARTICIPANT', 'MERGED', closedSince);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), {
+                method: 'GET',
+                url: '/api/1.0/dashboard/pull-requests',
+                query: {
+                    'role': 'PARTICIPANT',
+                    'state': 'MERGED',
+                    'closedSince': closedSince,
+                    'order': 'NEWEST',
+                    'start': undefined,
+                    'limit': 25,
+                },
+                errors: {
+                    401: 'The currently authenticated user is not permitted to access the dashboard.',
+                },
+            });
+        });
+        it('should handle API errors', async () => {
+            const mockError = new Error('Unauthorized');
+            mockRequest.mockRejectedValue(mockError);
+            const result = await bitbucketService.getDashboardPullRequests();
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Unauthorized');
+        });
+    });
+    describe('getInboxPullRequests', () => {
+        const { request: mockRequest } = require('../bitbucket-client/core/request.js');
+        it('should successfully get inbox pull requests with default parameters', async () => {
+            const mockInboxData = {
+                values: [
+                    {
+                        id: 1,
+                        title: 'Fix bug',
+                        state: 'OPEN',
+                        createdDate: 1700000000000,
+                        updatedDate: 1700001000000,
+                        author: { user: { name: 'user1', displayName: 'User One' } },
+                        fromRef: { id: 'refs/heads/feature', displayId: 'feature', repository: { slug: 'repo1', project: { key: 'PROJ' } } },
+                        toRef: { id: 'refs/heads/main', displayId: 'main', repository: { slug: 'repo1', project: { key: 'PROJ' } } },
+                        reviewers: [{ user: { name: 'reviewer1' }, approved: false, status: 'UNAPPROVED' }],
+                    },
+                ],
+                size: 1,
+                isLastPage: true,
+                start: 0,
+                limit: 25,
+            };
+            mockRequest.mockResolvedValue(mockInboxData);
+            const result = await bitbucketService.getInboxPullRequests();
+            expect(result.success).toBe(true);
+            expect(result.data).toBeDefined();
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
+                method: 'GET',
+                url: '/api/latest/inbox/pull-requests',
+                query: { start: undefined, limit: 25 },
+            }));
+        });
+        it('should successfully get inbox pull requests with pagination parameters', async () => {
+            const mockInboxData = {
+                values: [
+                    {
+                        id: 2,
+                        title: 'Add feature',
+                        state: 'OPEN',
+                        createdDate: 1700000000000,
+                        updatedDate: 1700001000000,
+                        fromRef: { id: 'refs/heads/feat', displayId: 'feat', repository: { slug: 'repo1', project: { key: 'PROJ' } } },
+                        toRef: { id: 'refs/heads/main', displayId: 'main', repository: { slug: 'repo1', project: { key: 'PROJ' } } },
+                    },
+                ],
+                size: 1,
+                isLastPage: false,
+                start: 25,
+                limit: 10,
+                nextPageStart: 35,
+            };
+            mockRequest.mockResolvedValue(mockInboxData);
+            const result = await bitbucketService.getInboxPullRequests(25, 10);
+            expect(result.success).toBe(true);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
+                query: { start: 25, limit: 10 },
+            }));
+        });
+        it('should handle empty inbox', async () => {
+            const mockInboxData = {
+                values: [],
+                size: 0,
+                isLastPage: true,
+                start: 0,
+                limit: 25,
+            };
+            mockRequest.mockResolvedValue(mockInboxData);
+            const result = await bitbucketService.getInboxPullRequests();
+            expect(result.success).toBe(true);
+            expect(result.data).toBeDefined();
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Unauthorized');
+            mockRequest.mockRejectedValue(mockError);
+            const result = await bitbucketService.getInboxPullRequests();
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Unauthorized');
+        });
+    });
+    describe('validateConfig', () => {
+        const originalEnv = process.env;
+        let tempDir;
+        beforeEach(() => {
+            process.env = { ...originalEnv };
+            delete process.env.ATLASSIAN_DC_MCP_CONFIG_FILE;
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bitbucket-validate-config-'));
+            initializeRuntimeConfig({ cwd: tempDir });
+        });
+        afterEach(() => {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        });
+        afterAll(() => {
+            process.env = originalEnv;
+        });
+        it('should return empty array when all required env vars are present', () => {
+            process.env.BITBUCKET_API_TOKEN = 'test-token';
+            process.env.BITBUCKET_HOST = 'test-host';
+            const missingVars = BitbucketService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+        it('should allow anonymous access when BITBUCKET_API_TOKEN is missing', () => {
+            delete process.env.BITBUCKET_API_TOKEN;
+            process.env.BITBUCKET_HOST = 'test-host';
+            const missingVars = BitbucketService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+        it('should return missing vars when both host options are missing', () => {
+            process.env.BITBUCKET_API_TOKEN = 'test-token';
+            delete process.env.BITBUCKET_HOST;
+            delete process.env.BITBUCKET_API_BASE_PATH;
+            const missingVars = BitbucketService.validateConfig();
+            expect(missingVars).toContain('BITBUCKET_HOST or BITBUCKET_API_BASE_PATH');
+        });
+        it('should accept BITBUCKET_API_BASE_PATH as alternative to BITBUCKET_HOST', () => {
+            process.env.BITBUCKET_API_TOKEN = 'test-token';
+            delete process.env.BITBUCKET_HOST;
+            process.env.BITBUCKET_API_BASE_PATH = 'https://test-host/rest';
+            const missingVars = BitbucketService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+        it('should accept required config from the shared config file', () => {
+            const sharedConfigPath = path.join(tempDir, 'shared.env');
+            fs.writeFileSync(sharedConfigPath, 'BITBUCKET_HOST=file-host\nBITBUCKET_API_TOKEN=file-token\n');
+            process.env.ATLASSIAN_DC_MCP_CONFIG_FILE = sharedConfigPath;
+            const missingVars = BitbucketService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+    });
+    describe('updatePullRequestComment', () => {
+        it('should resolve a task by sending state RESOLVED with the version', async () => {
+            const mockComment = { id: 500, version: 2, state: 'RESOLVED', text: 'Task body' };
+            PullRequestsService.updateComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.updatePullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, '500', // commentId
+            1, // version
+            undefined, // text
+            'RESOLVED' // state
+            );
+            expect(result.success).toBe(true);
+            expect(PullRequestsService.updateComment2).toHaveBeenCalledWith(mockProjectKey, '500', mockPullRequestId, mockRepositorySlug, { version: 1, state: 'RESOLVED' });
+        });
+        it('should edit the comment text without changing state or severity', async () => {
+            const mockComment = { id: 501, version: 3, text: 'Edited text' };
+            PullRequestsService.updateComment2.mockResolvedValue(mockComment);
+            await bitbucketService.updatePullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, '501', 2, 'Edited text');
+            expect(PullRequestsService.updateComment2).toHaveBeenCalledWith(mockProjectKey, '501', mockPullRequestId, mockRepositorySlug, { version: 2, text: 'Edited text' });
+        });
+        it('should support combining text, state, and severity in a single update', async () => {
+            const mockComment = { id: 502, version: 4, text: 'New body', state: 'RESOLVED', severity: 'BLOCKER' };
+            PullRequestsService.updateComment2.mockResolvedValue(mockComment);
+            await bitbucketService.updatePullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, '502', 3, 'New body', 'RESOLVED', 'BLOCKER');
+            expect(PullRequestsService.updateComment2).toHaveBeenCalledWith(mockProjectKey, '502', mockPullRequestId, mockRepositorySlug, { version: 3, text: 'New body', state: 'RESOLVED', severity: 'BLOCKER' });
+        });
+        it('should propagate API errors', async () => {
+            PullRequestsService.updateComment2.mockRejectedValue(new Error('Conflict'));
+            const result = await bitbucketService.updatePullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, '503', 1, undefined, 'RESOLVED');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Conflict');
+        });
+    });
+    describe('postPullRequestComment - severity flag', () => {
+        it('should include severity: BLOCKER in the request body when severity is BLOCKER', async () => {
+            const mockComment = { id: 200, text: 'Task comment', author: { displayName: 'Test User' } };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Task comment', undefined, // parentId
+            undefined, // filePath
+            undefined, // startLine
+            undefined, // startLineType
+            undefined, // line
+            undefined, // lineType
+            undefined, // pending
+            'BLOCKER' // severity
+            );
+            expect(result.success).toBe(true);
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, { text: 'Task comment', severity: 'BLOCKER' });
+        });
+        it('should NOT include severity in the request body when severity is omitted', async () => {
+            const mockComment = { id: 201, text: 'Normal comment', author: { displayName: 'Test User' } };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Normal comment');
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, { text: 'Normal comment' } // no severity field
+            );
+        });
+        it('should support severity BLOCKER combined with a file/line anchor', async () => {
+            const mockComment = { id: 202, text: 'Inline task', author: { displayName: 'Test User' } };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Inline task', undefined, // parentId
+            'src/index.ts', // filePath
+            undefined, // startLine
+            undefined, // startLineType
+            10, // line
+            'ADDED', // lineType
+            undefined, // pending
+            'BLOCKER' // severity
+            );
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Inline task',
+                severity: 'BLOCKER',
+                anchor: {
+                    path: 'src/index.ts',
+                    diffType: 'EFFECTIVE',
+                    line: 10,
+                    lineType: 'ADDED',
+                    fileType: 'TO'
+                }
+            });
+        });
+    });
+    describe('postPullRequestComment - pending flag', () => {
+        it('should include state: PENDING in the request body when pending is true', async () => {
+            const mockComment = { id: 99, text: 'Draft comment', author: { displayName: 'Test User' } };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            const result = await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Draft comment', undefined, // parentId
+            undefined, // filePath
+            undefined, // startLine
+            undefined, // startLineType
+            undefined, // line
+            undefined, // lineType
+            true // pending
+            );
+            expect(result.success).toBe(true);
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, { text: 'Draft comment', state: 'PENDING' });
+        });
+        it('should NOT include pending in the request body when pending is false or omitted', async () => {
+            const mockComment = { id: 100, text: 'Normal comment', author: { displayName: 'Test User' } };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Normal comment');
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, { text: 'Normal comment' } // no pending field
+            );
+        });
+        it('should support state: PENDING combined with a file anchor', async () => {
+            const mockComment = { id: 101, text: 'Pending file comment', author: { displayName: 'Test User' } };
+            PullRequestsService.createComment2.mockResolvedValue(mockComment);
+            await bitbucketService.postPullRequestComment(mockProjectKey, mockRepositorySlug, mockPullRequestId, 'Pending file comment', undefined, // parentId
+            'src/index.ts', // filePath
+            undefined, // startLine
+            undefined, // startLineType
+            10, // line
+            'ADDED', // lineType
+            true // pending
+            );
+            expect(PullRequestsService.createComment2).toHaveBeenCalledWith(mockProjectKey, mockPullRequestId, mockRepositorySlug, {
+                text: 'Pending file comment',
+                state: 'PENDING',
+                anchor: {
+                    path: 'src/index.ts',
+                    diffType: 'EFFECTIVE',
+                    line: 10,
+                    lineType: 'ADDED',
+                    fileType: 'TO'
+                }
+            });
+        });
+    });
+    describe('submitPullRequestReview', () => {
+        const mockUserSlug = 'test-user';
+        it('should submit a NEEDS_WORK review and call updateStatus with correct args', async () => {
+            const mockParticipant = {
+                user: { name: mockUserSlug },
+                role: 'REVIEWER',
+                status: 'NEEDS_WORK'
+            };
+            PullRequestsService.updateStatus.mockResolvedValue(mockParticipant);
+            const result = await bitbucketService.submitPullRequestReview(mockProjectKey, mockRepositorySlug, mockPullRequestId, mockUserSlug, 'NEEDS_WORK');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockParticipant);
+            expect(PullRequestsService.updateStatus).toHaveBeenCalledWith(mockProjectKey, mockUserSlug, mockPullRequestId, mockRepositorySlug, { status: 'NEEDS_WORK' });
+        });
+        it('should submit an APPROVED review', async () => {
+            const mockParticipant = { user: { name: mockUserSlug }, status: 'APPROVED' };
+            PullRequestsService.updateStatus.mockResolvedValue(mockParticipant);
+            const result = await bitbucketService.submitPullRequestReview(mockProjectKey, mockRepositorySlug, mockPullRequestId, mockUserSlug, 'APPROVED');
+            expect(result.success).toBe(true);
+            expect(PullRequestsService.updateStatus).toHaveBeenCalledWith(mockProjectKey, mockUserSlug, mockPullRequestId, mockRepositorySlug, { status: 'APPROVED' });
+        });
+        it('should include lastReviewedCommit when provided', async () => {
+            const mockParticipant = { user: { name: mockUserSlug }, status: 'NEEDS_WORK' };
+            PullRequestsService.updateStatus.mockResolvedValue(mockParticipant);
+            await bitbucketService.submitPullRequestReview(mockProjectKey, mockRepositorySlug, mockPullRequestId, mockUserSlug, 'NEEDS_WORK', 'abc123def456');
+            expect(PullRequestsService.updateStatus).toHaveBeenCalledWith(mockProjectKey, mockUserSlug, mockPullRequestId, mockRepositorySlug, { status: 'NEEDS_WORK', lastReviewedCommit: 'abc123def456' });
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Forbidden');
+            PullRequestsService.updateStatus.mockRejectedValue(mockError);
+            const result = await bitbucketService.submitPullRequestReview(mockProjectKey, mockRepositorySlug, mockPullRequestId, mockUserSlug, 'APPROVED');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Forbidden');
+        });
+    });
+    describe('getUser', () => {
+        it('should fetch a user by exact slug', async () => {
+            const mockUser = { slug: 'jsmith', displayName: 'John Smith', emailAddress: 'jsmith@example.com' };
+            mockRequest.mockResolvedValue(mockUser);
+            const result = await bitbucketService.getUser('jsmith', undefined);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(mockUser);
+            expect(mockRequest).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+                method: 'GET',
+                url: '/api/latest/users/{userSlug}',
+                path: { userSlug: 'jsmith' }
+            }));
+        });
+        it('should search for users by filter string', async () => {
+            const mockUsers = { values: [{ slug: 'jsmith', displayName: 'John Smith' }], size: 1, isLastPage: true };
+            mockRequest.mockResolvedValue(mockUsers);
+            const result = await bitbucketService.getUser(undefined, 'John');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(mockUsers);
+            expect(mockRequest).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+                method: 'GET',
+                url: '/api/latest/users',
+                query: { filter: 'John' }
+            }));
+        });
+        it('should handle API errors gracefully', async () => {
+            mockRequest.mockRejectedValue(new Error('Not Found'));
+            const result = await bitbucketService.getUser('nonexistent', undefined);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Not Found');
+        });
+    });
+    describe('case-insensitive project keys and repository slugs', () => {
+        it('should uppercase projectKey and lowercase repositorySlug for getPullRequests', async () => {
+            const mockData = { values: [], size: 0, isLastPage: true };
+            PullRequestsService.getPage.mockResolvedValue(mockData);
+            await bitbucketService.getPullRequests('test', 'Test-Repo');
+            expect(PullRequestsService.getPage).toHaveBeenCalledWith('TEST', 'test-repo', undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 25);
+        });
+        it('should uppercase projectKey and lowercase repositorySlug for getPullRequest', async () => {
+            const mockData = { id: 1, title: 'Test PR' };
+            PullRequestsService.get3.mockResolvedValue(mockData);
+            await bitbucketService.getPullRequest('test', 'Test-Repo', '1');
+            expect(PullRequestsService.get3).toHaveBeenCalledWith('TEST', '1', 'test-repo');
+        });
+        it('should uppercase projectKey and lowercase repositorySlug for getPullRequestChanges', async () => {
+            const mockData = { values: [], size: 0, isLastPage: true };
+            PullRequestsService.streamChanges1.mockResolvedValue(mockData);
+            await bitbucketService.getPullRequestChanges('test', 'Test-Repo', '1');
+            expect(PullRequestsService.streamChanges1).toHaveBeenCalledWith('TEST', '1', 'test-repo', undefined, undefined, undefined, undefined, undefined, 25);
+        });
+        it('should uppercase projectKey and lowercase repositorySlug for createPullRequest', async () => {
+            const mockData = { id: 1, title: 'New PR' };
+            PullRequestsService.create.mockResolvedValue(mockData);
+            await bitbucketService.createPullRequest('test', 'Test-Repo', 'title', 'desc', 'refs/heads/feature', 'refs/heads/main');
+            expect(PullRequestsService.create).toHaveBeenCalledWith('TEST', 'test-repo', expect.objectContaining({
+                title: 'title',
+                fromRef: expect.objectContaining({
+                    repository: expect.objectContaining({
+                        slug: 'test-repo',
+                        project: { key: 'TEST' }
+                    })
+                })
+            }));
+        });
+        it('should uppercase projectKey and lowercase repositorySlug for getRequiredReviewers', async () => {
+            const mockData = [];
+            PullRequestsService.getReviewers.mockResolvedValue(mockData);
+            await bitbucketService.getRequiredReviewers('test', 'Test-Repo', 'refs/heads/feature', 'refs/heads/main');
+            expect(PullRequestsService.getReviewers).toHaveBeenCalledWith('TEST', 'test-repo', undefined, undefined, 'refs/heads/feature', 'refs/heads/main');
+        });
+    });
+    describe('pull request operations', () => {
+        it('should delete a pull request comment and return an ack', async () => {
+            PullRequestsService.deleteComment2.mockResolvedValue(undefined);
+            const result = await bitbucketService.deletePullRequestComment('test', 'Test-Repo', '123', '99', 4);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, commentId: '99' });
+            expect(PullRequestsService.deleteComment2).toHaveBeenCalledWith('TEST', '99', '123', 'test-repo', '4');
+        });
+        it('should preserve the error field when comment delete fails', async () => {
+            PullRequestsService.deleteComment2.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deletePullRequestComment('TEST', 'test-repo', '123', '99', 4);
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should apply a suggestion with a full body', async () => {
+            PullRequestsService.applySuggestion.mockResolvedValue(undefined);
+            const result = await bitbucketService.applyPullRequestSuggestion('test', 'Test-Repo', '123', '99', 2, 5, 'apply fix', 1);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ applied: true, commentId: '99' });
+            expect(PullRequestsService.applySuggestion).toHaveBeenCalledWith('TEST', '99', '123', 'test-repo', {
+                commentVersion: 2,
+                pullRequestVersion: 5,
+                message: 'apply fix',
+                suggestionIndex: 1
+            });
+        });
+        it('should apply a suggestion omitting the optional suggestion index', async () => {
+            PullRequestsService.applySuggestion.mockResolvedValue(undefined);
+            await bitbucketService.applyPullRequestSuggestion('TEST', 'test-repo', '123', '99', 2, 5, 'apply fix');
+            expect(PullRequestsService.applySuggestion).toHaveBeenCalledWith('TEST', '99', '123', 'test-repo', {
+                commentVersion: 2,
+                pullRequestVersion: 5,
+                message: 'apply fix'
+            });
+        });
+        it('should watch a pull request and return an ack', async () => {
+            PullRequestsService.watch1.mockResolvedValue(undefined);
+            const result = await bitbucketService.watchPullRequest('test', 'Test-Repo', '123');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ watching: true, pullRequestId: '123' });
+            expect(PullRequestsService.watch1).toHaveBeenCalledWith('TEST', '123', 'test-repo');
+        });
+        it('should unwatch a pull request and return an ack', async () => {
+            PullRequestsService.unwatch1.mockResolvedValue(undefined);
+            const result = await bitbucketService.unwatchPullRequest('test', 'Test-Repo', '123');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ watching: false, pullRequestId: '123' });
+            expect(PullRequestsService.unwatch1).toHaveBeenCalledWith('TEST', '123', 'test-repo');
+        });
+        it('should preserve the error field when watch fails', async () => {
+            PullRequestsService.watch1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.watchPullRequest('TEST', 'test-repo', '123');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('repository CRUD', () => {
+        it('should create a repository with default scm', async () => {
+            const mockData = { slug: 'new-repo' };
+            ProjectService.createRepository.mockResolvedValue(mockData);
+            const result = await bitbucketService.createRepository('test', 'New Repo');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(ProjectService.createRepository).toHaveBeenCalledWith('TEST', {
+                name: 'New Repo',
+                scmId: 'git'
+            });
+        });
+        it('should create a repository with a custom scm and default branch', async () => {
+            ProjectService.createRepository.mockResolvedValue({});
+            await bitbucketService.createRepository('TEST', 'Repo', 'hg', 'main');
+            expect(ProjectService.createRepository).toHaveBeenCalledWith('TEST', {
+                name: 'Repo',
+                scmId: 'hg',
+                defaultBranch: 'main'
+            });
+        });
+        it('should handle errors when creating a repository', async () => {
+            ProjectService.createRepository.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createRepository('TEST', 'Repo');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should update a repository with only the provided fields', async () => {
+            const mockData = { slug: 'renamed' };
+            ProjectService.updateRepository.mockResolvedValue(mockData);
+            const result = await bitbucketService.updateRepository('test', 'Test-Repo', 'Renamed', 'desc', 'main', 'dest');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(ProjectService.updateRepository).toHaveBeenCalledWith('TEST', 'test-repo', {
+                name: 'Renamed',
+                description: 'desc',
+                defaultBranch: 'main',
+                project: { key: 'DEST' }
+            });
+        });
+        it('should send an empty body when no update fields are provided', async () => {
+            ProjectService.updateRepository.mockResolvedValue({});
+            await bitbucketService.updateRepository('TEST', 'test-repo');
+            expect(ProjectService.updateRepository).toHaveBeenCalledWith('TEST', 'test-repo', {});
+        });
+        it('should fork a repository into a target project', async () => {
+            const mockData = { slug: 'fork' };
+            ProjectService.forkRepository.mockResolvedValue(mockData);
+            const result = await bitbucketService.forkRepository('test', 'Test-Repo', 'my-fork', 'dest');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(ProjectService.forkRepository).toHaveBeenCalledWith('TEST', 'test-repo', {
+                name: 'my-fork',
+                project: { key: 'DEST' }
+            });
+        });
+        it('should fork a repository with an empty body when no options provided', async () => {
+            ProjectService.forkRepository.mockResolvedValue({});
+            await bitbucketService.forkRepository('TEST', 'test-repo');
+            expect(ProjectService.forkRepository).toHaveBeenCalledWith('TEST', 'test-repo', {});
+        });
+        it('should delete a repository and return an ack', async () => {
+            ProjectService.deleteRepository.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteRepository('test', 'Test-Repo');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({
+                scheduledForDeletion: true,
+                projectKey: 'TEST',
+                repositorySlug: 'test-repo'
+            });
+            expect(ProjectService.deleteRepository).toHaveBeenCalledWith('TEST', 'test-repo');
+        });
+        it('should preserve the error field when delete fails', async () => {
+            ProjectService.deleteRepository.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteRepository('TEST', 'test-repo');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('webhooks', () => {
+        it('should get webhooks with normalized keys', async () => {
+            const mockData = { values: [{ id: 1 }], isLastPage: true };
+            RepositoryService.findWebhooks1.mockResolvedValue(mockData);
+            const result = await bitbucketService.getWebhooks('test', 'Test-Repo', 'repo:refs_changed', true);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.findWebhooks1).toHaveBeenCalledWith('TEST', 'test-repo', 'repo:refs_changed', true);
+        });
+        it('should handle errors when getting webhooks', async () => {
+            RepositoryService.findWebhooks1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.getWebhooks('TEST', 'test-repo');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should get a single webhook and stringify the statistics flag', async () => {
+            const mockData = { id: 7, name: 'hook' };
+            RepositoryService.getWebhook1.mockResolvedValue(mockData);
+            const result = await bitbucketService.getWebhook('test', 'Test-Repo', '7', true);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.getWebhook1).toHaveBeenCalledWith('TEST', '7', 'test-repo', 'true');
+        });
+        it('should pass undefined statistics when omitted on getWebhook', async () => {
+            RepositoryService.getWebhook1.mockResolvedValue({});
+            await bitbucketService.getWebhook('TEST', 'test-repo', '7');
+            expect(RepositoryService.getWebhook1).toHaveBeenCalledWith('TEST', '7', 'test-repo', undefined);
+        });
+        it('should create a webhook with a built request body', async () => {
+            const mockData = { id: 9 };
+            RepositoryService.createWebhook1.mockResolvedValue(mockData);
+            const result = await bitbucketService.createWebhook('test', 'Test-Repo', 'my hook', 'https://example.com/hook', ['repo:refs_changed', 'pr:opened'], true, 's3cret', false);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.createWebhook1).toHaveBeenCalledWith('TEST', 'test-repo', {
+                name: 'my hook',
+                url: 'https://example.com/hook',
+                events: ['repo:refs_changed', 'pr:opened'],
+                active: true,
+                configuration: { secret: 's3cret' },
+                sslVerificationRequired: false
+            });
+        });
+        it('should omit optional fields from the webhook body when not provided', async () => {
+            RepositoryService.createWebhook1.mockResolvedValue({ id: 1 });
+            await bitbucketService.createWebhook('TEST', 'test-repo', 'minimal', 'https://example.com/h', ['pr:merged']);
+            expect(RepositoryService.createWebhook1).toHaveBeenCalledWith('TEST', 'test-repo', {
+                name: 'minimal',
+                url: 'https://example.com/h',
+                events: ['pr:merged']
+            });
+        });
+        it('should update a webhook', async () => {
+            const mockData = { id: 5 };
+            RepositoryService.updateWebhook1.mockResolvedValue(mockData);
+            const result = await bitbucketService.updateWebhook('test', 'Test-Repo', '5', 'renamed', 'https://example.com/new', ['pr:declined'], false);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.updateWebhook1).toHaveBeenCalledWith('TEST', '5', 'test-repo', {
+                name: 'renamed',
+                url: 'https://example.com/new',
+                events: ['pr:declined'],
+                active: false
+            });
+        });
+        it('should delete a webhook and return an ack', async () => {
+            RepositoryService.deleteWebhook1.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteWebhook('test', 'Test-Repo', '5');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, webhookId: '5' });
+            expect(RepositoryService.deleteWebhook1).toHaveBeenCalledWith('TEST', '5', 'test-repo');
+        });
+        it('should preserve the error field when delete fails', async () => {
+            RepositoryService.deleteWebhook1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteWebhook('TEST', 'test-repo', '5');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('branch restrictions', () => {
+        it('should get branch restrictions with filters and default limit', async () => {
+            const mockData = { values: [{ id: 1 }], isLastPage: true };
+            RepositoryService.getRestrictions1.mockResolvedValue(mockData);
+            const result = await bitbucketService.getBranchRestrictions('test', 'Test-Repo', 'BRANCH', 'refs/heads/master', 'no-deletes');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.getRestrictions1).toHaveBeenCalledWith('TEST', 'test-repo', 'BRANCH', 'refs/heads/master', 'no-deletes', undefined, 25);
+        });
+        it('should create a branch restriction wrapped in a bulk array', async () => {
+            const mockData = { id: 1, type: 'no-deletes' };
+            RepositoryService.createRestrictions1.mockResolvedValue(mockData);
+            const result = await bitbucketService.createBranchRestriction('test', 'Test-Repo', 'no-deletes', 'BRANCH', 'refs/heads/master', 'master', ['admin'], ['devs'], [7]);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.createRestrictions1).toHaveBeenCalledWith('TEST', 'test-repo', [{
+                    type: 'no-deletes',
+                    matcher: { id: 'refs/heads/master', displayId: 'master', type: { id: 'BRANCH' } },
+                    userSlugs: ['admin'],
+                    groupNames: ['devs'],
+                    accessKeyIds: [7]
+                }]);
+        });
+        it('should omit exemption fields when not provided', async () => {
+            RepositoryService.createRestrictions1.mockResolvedValue({});
+            await bitbucketService.createBranchRestriction('TEST', 'test-repo', 'read-only', 'ANY_REF', 'ANY_REF');
+            expect(RepositoryService.createRestrictions1).toHaveBeenCalledWith('TEST', 'test-repo', [{
+                    type: 'read-only',
+                    matcher: { id: 'ANY_REF', displayId: 'ANY_REF', type: { id: 'ANY_REF' } }
+                }]);
+        });
+        it('should handle errors when creating a restriction', async () => {
+            RepositoryService.createRestrictions1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createBranchRestriction('TEST', 'test-repo', 'read-only', 'ANY_REF', 'ANY_REF');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should get a single restriction by id', async () => {
+            const mockData = { id: 5 };
+            RepositoryService.getRestriction1.mockResolvedValue(mockData);
+            const result = await bitbucketService.getBranchRestriction('test', 'Test-Repo', '5');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(RepositoryService.getRestriction1).toHaveBeenCalledWith('TEST', '5', 'test-repo');
+        });
+        it('should delete a restriction and return an ack', async () => {
+            RepositoryService.deleteRestriction1.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteBranchRestriction('test', 'Test-Repo', '5');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, id: '5' });
+            expect(RepositoryService.deleteRestriction1).toHaveBeenCalledWith('TEST', '5', 'test-repo');
+        });
+        it('should preserve the error field when delete fails', async () => {
+            RepositoryService.deleteRestriction1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteBranchRestriction('TEST', 'test-repo', '5');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('searchCode', () => {
+        const { request: mockRequest } = require('../bitbucket-client/core/request.js');
+        it('should search code with the default page size', async () => {
+            const mockData = { code: { count: 1, values: [{ repository: { slug: 'demo' } }] } };
+            mockRequest.mockResolvedValue(mockData);
+            const result = await bitbucketService.searchCode('app');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), {
+                method: 'POST',
+                url: '/search/latest/search',
+                body: {
+                    query: 'app',
+                    entities: { code: {} },
+                    limits: { primary: 25 }
+                },
+                mediaType: 'application/json',
+                errors: {
+                    400: 'The search query was malformed.',
+                    401: 'The currently authenticated user is not permitted to search.',
+                },
+            });
+        });
+        it('should pass explicit primary and secondary limits', async () => {
+            mockRequest.mockResolvedValue({ code: { count: 0, values: [] } });
+            await bitbucketService.searchCode('repo:demo TODO', 10, 5);
+            expect(mockRequest).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
+                method: 'POST',
+                url: '/search/latest/search',
+                body: {
+                    query: 'repo:demo TODO',
+                    entities: { code: {} },
+                    limits: { primary: 10, secondary: 5 }
+                },
+            }));
+        });
+        it('should handle errors when searching', async () => {
+            mockRequest.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.searchCode('app');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('default reviewer conditions', () => {
+        it('should get default reviewer conditions with normalized keys', async () => {
+            const mockData = [{ id: 1 }];
+            PullRequestsService.getPullRequestConditions1.mockResolvedValue(mockData);
+            const result = await bitbucketService.getDefaultReviewerConditions('test', 'Test-Repo');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(PullRequestsService.getPullRequestConditions1).toHaveBeenCalledWith('TEST', 'test-repo');
+        });
+        it('should create a condition mapping reviewer ids and matchers', async () => {
+            const mockData = { id: 1 };
+            PullRequestsService.createPullRequestCondition1.mockResolvedValue(mockData);
+            const result = await bitbucketService.createDefaultReviewerCondition('test', 'Test-Repo', 'ANY_REF', 'ANY_REF', 'BRANCH', 'refs/heads/main', [52], 1, undefined, 'main');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(PullRequestsService.createPullRequestCondition1).toHaveBeenCalledWith('TEST', 'test-repo', {
+                reviewers: [{ id: 52 }],
+                sourceMatcher: { id: 'ANY_REF', displayId: 'ANY_REF', type: { id: 'ANY_REF' } },
+                targetMatcher: { id: 'refs/heads/main', displayId: 'main', type: { id: 'BRANCH' } },
+                requiredApprovals: 1
+            });
+        });
+        it('should omit requiredApprovals when not provided', async () => {
+            PullRequestsService.createPullRequestCondition1.mockResolvedValue({});
+            await bitbucketService.createDefaultReviewerCondition('TEST', 'test-repo', 'ANY_REF', 'ANY_REF', 'ANY_REF', 'ANY_REF', [52]);
+            expect(PullRequestsService.createPullRequestCondition1).toHaveBeenCalledWith('TEST', 'test-repo', {
+                reviewers: [{ id: 52 }],
+                sourceMatcher: { id: 'ANY_REF', displayId: 'ANY_REF', type: { id: 'ANY_REF' } },
+                targetMatcher: { id: 'ANY_REF', displayId: 'ANY_REF', type: { id: 'ANY_REF' } }
+            });
+        });
+        it('should handle errors when creating a condition', async () => {
+            PullRequestsService.createPullRequestCondition1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createDefaultReviewerCondition('TEST', 'test-repo', 'ANY_REF', 'ANY_REF', 'ANY_REF', 'ANY_REF', [52]);
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should update a condition passing the id as a string', async () => {
+            const mockData = { id: 1, requiredApprovals: 2 };
+            PullRequestsService.updatePullRequestCondition1.mockResolvedValue(mockData);
+            const result = await bitbucketService.updateDefaultReviewerCondition('test', 'Test-Repo', '1', 'ANY_REF', 'ANY_REF', 'BRANCH', 'refs/heads/main', [52], 2, undefined, 'main');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(PullRequestsService.updatePullRequestCondition1).toHaveBeenCalledWith('TEST', '1', 'test-repo', {
+                reviewers: [{ id: 52 }],
+                sourceMatcher: { id: 'ANY_REF', displayId: 'ANY_REF', type: { id: 'ANY_REF' } },
+                targetMatcher: { id: 'refs/heads/main', displayId: 'main', type: { id: 'BRANCH' } },
+                requiredApprovals: 2
+            });
+        });
+        it('should delete a condition coercing the id to a number and return an ack', async () => {
+            PullRequestsService.deletePullRequestCondition1.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteDefaultReviewerCondition('test', 'Test-Repo', '1');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, id: '1' });
+            expect(PullRequestsService.deletePullRequestCondition1).toHaveBeenCalledWith('TEST', 1, 'test-repo');
+        });
+        it('should preserve the error field when delete fails', async () => {
+            PullRequestsService.deletePullRequestCondition1.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteDefaultReviewerCondition('TEST', 'test-repo', '1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('required builds merge checks', () => {
+        it('should get merge checks with the default page size', async () => {
+            const mockData = { values: [{ id: 1 }], isLastPage: true };
+            BuildsAndDeploymentsService.getPageOfRequiredBuildsMergeChecks.mockResolvedValue(mockData);
+            const result = await bitbucketService.getRequiredBuildsMergeChecks('test', 'Test-Repo');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(BuildsAndDeploymentsService.getPageOfRequiredBuildsMergeChecks).toHaveBeenCalledWith('TEST', 'test-repo', undefined, 25);
+        });
+        it('should create a merge check with a built body', async () => {
+            const mockData = { id: 1 };
+            BuildsAndDeploymentsService.createRequiredBuildsMergeCheck.mockResolvedValue(mockData);
+            const result = await bitbucketService.createRequiredBuildsMergeCheck('test', 'Test-Repo', ['build-foo'], 'BRANCH', 'refs/heads/master', 'master', 'BRANCH', 'refs/heads/dev', 'dev');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(BuildsAndDeploymentsService.createRequiredBuildsMergeCheck).toHaveBeenCalledWith('TEST', 'test-repo', {
+                buildParentKeys: ['build-foo'],
+                refMatcher: { id: 'refs/heads/master', displayId: 'master', type: { id: 'BRANCH' } },
+                exemptRefMatcher: { id: 'refs/heads/dev', displayId: 'dev', type: { id: 'BRANCH' } }
+            });
+        });
+        it('should omit the exempt matcher when not fully provided', async () => {
+            BuildsAndDeploymentsService.createRequiredBuildsMergeCheck.mockResolvedValue({});
+            await bitbucketService.createRequiredBuildsMergeCheck('TEST', 'test-repo', ['build-foo'], 'ANY_REF', 'ANY_REF');
+            expect(BuildsAndDeploymentsService.createRequiredBuildsMergeCheck).toHaveBeenCalledWith('TEST', 'test-repo', {
+                buildParentKeys: ['build-foo'],
+                refMatcher: { id: 'ANY_REF', displayId: 'ANY_REF', type: { id: 'ANY_REF' } }
+            });
+        });
+        it('should handle errors when creating a merge check', async () => {
+            BuildsAndDeploymentsService.createRequiredBuildsMergeCheck.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createRequiredBuildsMergeCheck('TEST', 'test-repo', ['build-foo'], 'ANY_REF', 'ANY_REF');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should update a merge check coercing the id to a number', async () => {
+            const mockData = { id: 1 };
+            BuildsAndDeploymentsService.updateRequiredBuildsMergeCheck.mockResolvedValue(mockData);
+            const result = await bitbucketService.updateRequiredBuildsMergeCheck('test', 'Test-Repo', '1', ['build-foo', 'build-bar'], 'BRANCH', 'refs/heads/master', 'master');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(BuildsAndDeploymentsService.updateRequiredBuildsMergeCheck).toHaveBeenCalledWith('TEST', 1, 'test-repo', {
+                buildParentKeys: ['build-foo', 'build-bar'],
+                refMatcher: { id: 'refs/heads/master', displayId: 'master', type: { id: 'BRANCH' } }
+            });
+        });
+        it('should delete a merge check coercing the id and return an ack', async () => {
+            BuildsAndDeploymentsService.deleteRequiredBuildsMergeCheck.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteRequiredBuildsMergeCheck('test', 'Test-Repo', '1');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, id: '1' });
+            expect(BuildsAndDeploymentsService.deleteRequiredBuildsMergeCheck).toHaveBeenCalledWith('TEST', 1, 'test-repo');
+        });
+        it('should preserve the error field when delete fails', async () => {
+            BuildsAndDeploymentsService.deleteRequiredBuildsMergeCheck.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteRequiredBuildsMergeCheck('TEST', 'test-repo', '1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('project CRUD', () => {
+        it('should create a project', async () => {
+            const mockData = { key: 'PROJ' };
+            ProjectService.createProject.mockResolvedValue(mockData);
+            const result = await bitbucketService.createProject('proj', 'My Project', 'desc');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(ProjectService.createProject).toHaveBeenCalledWith({
+                key: 'PROJ',
+                name: 'My Project',
+                description: 'desc'
+            });
+        });
+        it('should omit description when not provided on create', async () => {
+            ProjectService.createProject.mockResolvedValue({});
+            await bitbucketService.createProject('PROJ', 'My Project');
+            expect(ProjectService.createProject).toHaveBeenCalledWith({
+                key: 'PROJ',
+                name: 'My Project'
+            });
+        });
+        it('should handle errors when creating a project', async () => {
+            ProjectService.createProject.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.createProject('PROJ', 'My Project');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('should update a project with only the provided fields', async () => {
+            const mockData = { key: 'PROJ' };
+            ProjectService.updateProject.mockResolvedValue(mockData);
+            const result = await bitbucketService.updateProject('proj', 'Renamed', 'new desc');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockData);
+            expect(ProjectService.updateProject).toHaveBeenCalledWith('PROJ', {
+                key: 'PROJ',
+                name: 'Renamed',
+                description: 'new desc'
+            });
+        });
+        it('should update a project sending only the key when nothing else provided', async () => {
+            ProjectService.updateProject.mockResolvedValue({});
+            await bitbucketService.updateProject('PROJ');
+            expect(ProjectService.updateProject).toHaveBeenCalledWith('PROJ', { key: 'PROJ' });
+        });
+        it('should delete a project and return an ack', async () => {
+            ProjectService.deleteProject.mockResolvedValue(undefined);
+            const result = await bitbucketService.deleteProject('proj');
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ deleted: true, key: 'PROJ' });
+            expect(ProjectService.deleteProject).toHaveBeenCalledWith('PROJ');
+        });
+        it('should preserve the error field when delete fails', async () => {
+            ProjectService.deleteProject.mockRejectedValue(new Error('API Error'));
+            const result = await bitbucketService.deleteProject('PROJ');
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=bitbucket-service.test.js.map