@atlassian-dc-mcp/bitbucket 0.9.9 → 0.9.10

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

@@ -11,7 +11,12 @@ jest.mock('../bitbucket-client/index.js', () => ({
   PullRequestsService: {
     streamRawDiff2: jest.fn(),
     createComment2: jest.fn(),
-    streamChanges1: jest.fn()
+    streamChanges1: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    getPage: jest.fn(),
+    getReviewers: jest.fn(),
+    get3: jest.fn()
   },
   OpenAPI: {
     BASE: '',
@@ -115,6 +120,576 @@ describe('BitbucketService', () => {
     });
   });
 
+  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 = {
@@ -370,6 +945,566 @@ describe('BitbucketService', () => {
     });
   });
 
+  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).toBe(mockPullRequest);
+      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).toBe(mockPullRequest);
+      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).toBe(mockPullRequest);
+      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).toBe(mockUpdatedPR);
+      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).toBe(mockUpdatedPR);
+      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).toBe(mockUpdatedPR);
+      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).toBe(mockUpdatedPR);
+      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).toBe(mockUpdatedPR);
+      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).toBe(mockUpdatedPR);
+      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('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('validateConfig', () => {
     const originalEnv = process.env;