bitbucket-datacenter-mcp 0.2.0

package/src/__tests__/bitbucket-service.test.ts

@@ -0,0 +1,4626 @@
+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: BitbucketService;
+  const mockProjectKey = 'TEST';
+  const mockRepositorySlug = 'test-repo';
+  const mockPullRequestId = '123';
+  let tempHome: string;
+  let homedirSpy: jest.SpyInstance;
+  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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as any).warning).toMatch(/multi-line ```suggestion/);
+      // single-line anchor: no multiline fields sent
+      const sentAnchor = (PullRequestsService.createComment2 as jest.Mock).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 as jest.Mock).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 as any).warning).toBeUndefined();
+    });
+
+    it('should handle API errors gracefully', async () => {
+      const mockError = new Error('API Error');
+      (PullRequestsService.createComment2 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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: string;
+
+    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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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: never[] = [];
+      (PullRequestsService.getReviewers as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).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 as jest.Mock).mockResolvedValue({});
+
+      await bitbucketService.updateProject('PROJ');
+
+      expect(ProjectService.updateProject).toHaveBeenCalledWith('PROJ', { key: 'PROJ' });
+    });
+
+    it('should delete a project and return an ack', async () => {
+      (ProjectService.deleteProject as jest.Mock).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 as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+      const result = await bitbucketService.deleteProject('PROJ');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});