@atlassian-dc-mcp/bitbucket 0.29.0 → 0.31.0

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

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { initializeRuntimeConfig } from '@atlassian-dc-mcp/common';
 import { BitbucketService } from '../bitbucket-service.js';
-import { PullRequestsService } from '../bitbucket-client/index.js';
+import { PullRequestsService, RepositoryService } from '../bitbucket-client/index.js';
 import { request as mockRequest } from '../bitbucket-client/core/request.js';
 
 // Mock the request function
@@ -25,6 +25,9 @@ jest.mock('../bitbucket-client/index.js', () => ({
     getReviewers: jest.fn(),
     get3: jest.fn()
   },
+  RepositoryService: {
+    streamRaw: jest.fn()
+  },
   OpenAPI: {
     BASE: '',
     TOKEN: '',
@@ -1209,6 +1212,78 @@ describe('BitbucketService', () => {
     });
   });
 
+  describe('getFileContent', () => {
+    const mockFileContent = 'FROM node:20-alpine\n\nWORKDIR /app\n';
+
+    it('should fetch a file at the repository default branch when at is omitted', async () => {
+      (RepositoryService.streamRaw as jest.Mock).mockResolvedValue(mockFileContent);
+
+      const result = await bitbucketService.getFileContent(mockProjectKey, mockRepositorySlug, 'Dockerfile');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockFileContent);
+      expect(RepositoryService.streamRaw).toHaveBeenCalledWith(
+        'Dockerfile',
+        mockProjectKey,
+        mockRepositorySlug,
+        undefined
+      );
+    });
+
+    it('should pass the ref through and keep nested paths intact', async () => {
+      (RepositoryService.streamRaw as jest.Mock).mockResolvedValue(mockFileContent);
+
+      await bitbucketService.getFileContent(
+        mockProjectKey,
+        mockRepositorySlug,
+        'deploy/base/configmap.yaml',
+        'refs/heads/main'
+      );
+
+      expect(RepositoryService.streamRaw).toHaveBeenCalledWith(
+        'deploy/base/configmap.yaml',
+        mockProjectKey,
+        mockRepositorySlug,
+        'refs/heads/main'
+      );
+    });
+
+    it('should strip a leading slash from the path', async () => {
+      (RepositoryService.streamRaw as jest.Mock).mockResolvedValue(mockFileContent);
+
+      await bitbucketService.getFileContent(mockProjectKey, mockRepositorySlug, '/src/index.ts');
+
+      expect(RepositoryService.streamRaw).toHaveBeenCalledWith(
+        'src/index.ts',
+        mockProjectKey,
+        mockRepositorySlug,
+        undefined
+      );
+    });
+
+    it('should normalize project key and repository slug casing', async () => {
+      (RepositoryService.streamRaw as jest.Mock).mockResolvedValue(mockFileContent);
+
+      await bitbucketService.getFileContent('test', 'TEST-REPO', 'Dockerfile');
+
+      expect(RepositoryService.streamRaw).toHaveBeenCalledWith(
+        'Dockerfile',
+        'TEST',
+        'test-repo',
+        undefined
+      );
+    });
+
+    it('should handle API errors gracefully', async () => {
+      (RepositoryService.streamRaw as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+      const result = await bitbucketService.getFileContent(mockProjectKey, mockRepositorySlug, 'missing.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 = {
@@ -2166,7 +2241,7 @@ describe('BitbucketService', () => {
       const mockComment = { id: 502, version: 4, text: 'New body', state: 'RESOLVED', severity: 'BLOCKER' };
       (PullRequestsService.updateComment2 as jest.Mock).mockResolvedValue(mockComment);
 
-      await bitbucketService.updatePullRequestComment(
+      const result = await bitbucketService.updatePullRequestComment(
         mockProjectKey,
         mockRepositorySlug,
         mockPullRequestId,
@@ -2184,6 +2259,83 @@ describe('BitbucketService', () => {
         mockRepositorySlug,
         { version: 3, text: 'New body', state: 'RESOLVED', severity: 'BLOCKER' }
       );
+      expect(result.data).toMatchObject({ state: 'RESOLVED', severity: 'BLOCKER' });
+    });
+
+    it('should resolve a comment thread by sending threadResolved true', async () => {
+      const mockComment = { id: 504, version: 3, state: 'OPEN', threadResolved: true };
+      (PullRequestsService.updateComment2 as jest.Mock).mockResolvedValue(mockComment);
+
+      const result = await bitbucketService.updatePullRequestComment(
+        mockProjectKey,
+        mockRepositorySlug,
+        mockPullRequestId,
+        '504',
+        2,
+        undefined,  // text
+        undefined,  // state
+        undefined,  // severity
+        true        // threadResolved
+      );
+
+      expect(PullRequestsService.updateComment2).toHaveBeenCalledWith(
+        mockProjectKey,
+        '504',
+        mockPullRequestId,
+        mockRepositorySlug,
+        { version: 2, threadResolved: true }
+      );
+      expect(result.data).toMatchObject({ state: 'OPEN', threadResolved: true });
+    });
+
+    it('should reopen a comment thread by sending threadResolved false', async () => {
+      const mockComment = { id: 505, version: 4, threadResolved: false };
+      (PullRequestsService.updateComment2 as jest.Mock).mockResolvedValue(mockComment);
+
+      await bitbucketService.updatePullRequestComment(
+        mockProjectKey,
+        mockRepositorySlug,
+        mockPullRequestId,
+        '505',
+        3,
+        undefined,
+        undefined,
+        undefined,
+        false
+      );
+
+      expect(PullRequestsService.updateComment2).toHaveBeenCalledWith(
+        mockProjectKey,
+        '505',
+        mockPullRequestId,
+        mockRepositorySlug,
+        { version: 3, threadResolved: false }
+      );
+    });
+
+    it('should set task state and thread resolution independently in one update', async () => {
+      const mockComment = { id: 506, version: 5, state: 'OPEN', threadResolved: true };
+      (PullRequestsService.updateComment2 as jest.Mock).mockResolvedValue(mockComment);
+
+      await bitbucketService.updatePullRequestComment(
+        mockProjectKey,
+        mockRepositorySlug,
+        mockPullRequestId,
+        '506',
+        4,
+        undefined,
+        'OPEN',
+        undefined,
+        true
+      );
+
+      expect(PullRequestsService.updateComment2).toHaveBeenCalledWith(
+        mockProjectKey,
+        '506',
+        mockPullRequestId,
+        mockRepositorySlug,
+        { version: 4, state: 'OPEN', threadResolved: true }
+      );
     });
 
     it('should propagate API errors', async () => {

package/src/__tests__/bitbucket-token-optimization.test.ts

@@ -143,6 +143,7 @@ describe('BitbucketService token optimization paths', () => {
               comments: [],
               threadResolved: false,
               state: 'OPEN',
+              severity: 'NORMAL',
             },
           },
         ],
@@ -151,6 +152,8 @@ describe('BitbucketService token optimization paths', () => {
           prAuthor: { name: 'author', displayName: 'Author' },
           commentCount: 1,
           unresolvedCount: 1,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0,
         },
       });
       expect(PullRequestsService.getActivities).toHaveBeenCalledWith('TEST', '123', 'repo', undefined, undefined, undefined, 25);
@@ -202,6 +205,8 @@ describe('BitbucketService token optimization paths', () => {
           prAuthor: { name: 'author', displayName: 'Author' },
           commentCount: 0,
           unresolvedCount: 0,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0,
         },
       });
       expect(includeResolvedResult.success).toBe(true);
@@ -238,10 +243,12 @@ describe('BitbucketService token optimization paths', () => {
                   comments: [],
                   threadResolved: true,
                   state: 'OPEN',
+                  severity: 'NORMAL',
                 },
               ],
               threadResolved: true,
               state: 'OPEN',
+              severity: 'NORMAL',
             },
           },
         ],
@@ -250,6 +257,8 @@ describe('BitbucketService token optimization paths', () => {
           prAuthor: { name: 'author', displayName: 'Author' },
           commentCount: 1,
           unresolvedCount: 0,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0,
         },
       });
     });
@@ -267,6 +276,8 @@ describe('BitbucketService token optimization paths', () => {
           prAuthor: { name: 'author', displayName: 'Author' },
           commentCount: 1,
           unresolvedCount: 1,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0,
         },
         items: ['Reviewer on src/app.ts:10: Looks good'],
       });

package/src/__tests__/merge-gateway.test.ts

@@ -0,0 +1,119 @@
+import {
+  assertRepoMergeAllowed,
+  assertTargetRefMergeAllowed,
+  resolveMergeGateway,
+} from '../merge-gateway.js';
+
+const silentWarn = () => undefined;
+
+describe('resolveMergeGateway', () => {
+  it('is disabled by default', () => {
+    const gateway = resolveMergeGateway({ env: {}, warn: silentWarn });
+    expect(gateway.enabled).toBe(false);
+    expect(gateway.repos).toEqual([]);
+  });
+
+  it('stays disabled when enabled without any repository', () => {
+    const gateway = resolveMergeGateway({ env: { BITBUCKET_MERGE_ENABLED: 'true' }, warn: silentWarn });
+    expect(gateway.enabled).toBe(false);
+  });
+
+  it('stays disabled when every configured repository entry is malformed', () => {
+    const gateway = resolveMergeGateway({
+      env: { BITBUCKET_MERGE_ENABLED: 'true', BITBUCKET_MERGE_ALLOWED_REPOS: 'demo, PROJ/a/b, */*' },
+      warn: silentWarn,
+    });
+    expect(gateway.enabled).toBe(false);
+  });
+
+  it('normalizes repository entries and de-duplicates them', () => {
+    const gateway = resolveMergeGateway({
+      env: {
+        BITBUCKET_MERGE_ENABLED: 'yes',
+        BITBUCKET_MERGE_ALLOWED_REPOS: 'proj/Demo, PROJ/demo; OTHER/*',
+      },
+      warn: silentWarn,
+    });
+    expect(gateway.enabled).toBe(true);
+    expect(gateway.repos).toEqual(['PROJ/demo', 'OTHER/*']);
+    expect(gateway.targetRefs).toEqual([]);
+  });
+
+  it('expands bare branch names into fully-qualified target refs', () => {
+    const gateway = resolveMergeGateway({
+      env: {
+        BITBUCKET_MERGE_ENABLED: '1',
+        BITBUCKET_MERGE_ALLOWED_REPOS: 'PROJ/demo',
+        BITBUCKET_MERGE_ALLOWED_TARGET_REFS: 'develop, refs/heads/release/*',
+      },
+      warn: silentWarn,
+    });
+    expect(gateway.targetRefs).toEqual(['refs/heads/develop', 'refs/heads/release/*']);
+  });
+
+  it('warns about ignored entries and about being enabled with no valid repository', () => {
+    const warnings: string[] = [];
+    resolveMergeGateway({
+      env: { BITBUCKET_MERGE_ENABLED: 'true', BITBUCKET_MERGE_ALLOWED_REPOS: 'demo' },
+      warn: message => warnings.push(message),
+    });
+    expect(warnings).toHaveLength(2);
+    expect(warnings[0]).toContain('"demo"');
+    expect(warnings[1]).toContain('stay disabled');
+  });
+});
+
+describe('assertRepoMergeAllowed', () => {
+  const gateway = resolveMergeGateway({
+    env: { BITBUCKET_MERGE_ENABLED: 'true', BITBUCKET_MERGE_ALLOWED_REPOS: 'PROJ/demo, OTHER/*' },
+    warn: silentWarn,
+  });
+
+  it('refuses everything when merging is disabled', () => {
+    expect(() => assertRepoMergeAllowed({ enabled: false, repos: [], targetRefs: [] }, 'PROJ', 'demo'))
+      .toThrow(/disabled on this server/);
+  });
+
+  it('allows an exact repository regardless of the casing used by the caller', () => {
+    expect(() => assertRepoMergeAllowed(gateway, 'proj', 'DEMO')).not.toThrow();
+  });
+
+  it('allows any repository in a wildcard project', () => {
+    expect(() => assertRepoMergeAllowed(gateway, 'OTHER', 'anything')).not.toThrow();
+  });
+
+  it('refuses a repository outside the allowed list', () => {
+    expect(() => assertRepoMergeAllowed(gateway, 'PROJ', 'other-repo')).toThrow(/not allowed in PROJ\/other-repo/);
+  });
+
+  it('does not treat a wildcard project as a prefix of another project', () => {
+    expect(() => assertRepoMergeAllowed(gateway, 'OTHERS', 'demo')).toThrow(/not allowed/);
+  });
+});
+
+describe('assertTargetRefMergeAllowed', () => {
+  const unrestricted = { enabled: true, repos: ['PROJ/demo'], targetRefs: [] };
+  const restricted = {
+    enabled: true,
+    repos: ['PROJ/demo'],
+    targetRefs: ['refs/heads/develop', 'refs/heads/release/*'],
+  };
+
+  it('allows any ref when no target-ref restriction is configured', () => {
+    expect(() => assertTargetRefMergeAllowed(unrestricted, 'refs/heads/master')).not.toThrow();
+    expect(() => assertTargetRefMergeAllowed(unrestricted, undefined)).not.toThrow();
+  });
+
+  it('allows an exact and a wildcard target ref', () => {
+    expect(() => assertTargetRefMergeAllowed(restricted, 'refs/heads/develop')).not.toThrow();
+    expect(() => assertTargetRefMergeAllowed(restricted, 'refs/heads/release/1.2')).not.toThrow();
+  });
+
+  it('refuses a target ref outside the allowed list', () => {
+    expect(() => assertTargetRefMergeAllowed(restricted, 'refs/heads/master')).toThrow(/refs\/heads\/master is not allowed/);
+  });
+
+  it('refuses when the target ref is unknown but restrictions apply', () => {
+    expect(() => assertTargetRefMergeAllowed(restricted, undefined)).toThrow(/Could not determine the target branch/);
+  });
+});

package/src/__tests__/pr-comment-mapper.test.ts

@@ -140,7 +140,8 @@ describe('PR Comment Mapper', () => {
               },
               comments: [],
               threadResolved: false,
-              state: "OPEN"
+              state: "OPEN",
+              severity: "NORMAL"
             }
           },
           {
@@ -160,13 +161,85 @@ describe('PR Comment Mapper', () => {
             displayName: "User B"
           },
           commentCount: 1,
-          unresolvedCount: 1
+          unresolvedCount: 1,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0
         }
       };
 
       expect(result).toEqual(expectedResult);
     });
 
+    it('should expose BLOCKER severity so tasks are distinguishable from normal comments', () => {
+      const blockerResponse: BitbucketPRApiResponse = {
+        ...validPRResponse,
+        values: [
+          {
+            id: 1001,
+            createdDate: 1600000000000,
+            user: createUser('reviewer1', 106, 'Reviewer One'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({
+              id: 2010,
+              text: 'Blocking: fix this',
+              severity: 'BLOCKER',
+              comments: [
+                createComment({
+                  id: 2011,
+                  text: 'Reply keeps its own severity',
+                  anchor: undefined,
+                  severity: 'NORMAL'
+                })
+              ]
+            })
+          }
+        ]
+      };
+
+      const result = simplifyBitbucketPRComments(blockerResponse) as SimplifiedPRResponse;
+      expect(result.activities[0].comment?.severity).toBe('BLOCKER');
+      expect(result.activities[0].comment?.comments[0].severity).toBe('NORMAL');
+    });
+
+    it('should count blockers and unresolved blockers by task state in the summary', () => {
+      const blockerResponse: BitbucketPRApiResponse = {
+        ...validPRResponse,
+        values: [
+          openedActivity!,
+          {
+            id: 1010,
+            createdDate: 1600000003000,
+            user: createUser('reviewer1', 106, 'Reviewer One'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({ id: 2020, text: 'Unresolved task', severity: 'BLOCKER', state: 'OPEN' })
+          },
+          {
+            id: 1011,
+            createdDate: 1600000004000,
+            user: createUser('reviewer1', 106, 'Reviewer One'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({ id: 2021, text: 'Ticked task', severity: 'BLOCKER', state: 'RESOLVED' })
+          },
+          {
+            id: 1012,
+            createdDate: 1600000005000,
+            user: createUser('reviewer1', 106, 'Reviewer One'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({ id: 2022, text: 'Just a note', severity: 'NORMAL', state: 'OPEN' })
+          }
+        ]
+      };
+
+      const result = simplifyBitbucketPRComments(blockerResponse) as SimplifiedPRResponse;
+      expect(result.summary.commentCount).toBe(3);
+      expect(result.summary.blockerCount).toBe(2);
+      expect(result.summary.unresolvedBlockerCount).toBe(1);
+    });
+
     it('should preserve nested replies recursively', () => {
       const threadedResponse: BitbucketPRApiResponse = {
         ...validPRResponse,
@@ -220,11 +293,13 @@ describe('PR Comment Mapper', () => {
               createdDate: 1600000000000,
               comments: [],
               threadResolved: false,
-              state: "OPEN"
+              state: "OPEN",
+              severity: "NORMAL"
             }
           ],
           threadResolved: false,
-          state: "OPEN"
+          state: "OPEN",
+          severity: "NORMAL"
         }
       ]);
     });
@@ -294,7 +369,8 @@ describe('PR Comment Mapper', () => {
             },
             comments: [],
             threadResolved: false,
-            state: 'OPEN'
+            state: 'OPEN',
+            severity: 'NORMAL'
           }
         }
       ]);
@@ -355,11 +431,13 @@ describe('PR Comment Mapper', () => {
             createdDate: 1600000000000,
             comments: [],
             threadResolved: true,
-            state: 'OPEN'
+            state: 'OPEN',
+            severity: 'NORMAL'
           }
         ],
         threadResolved: true,
-        state: 'OPEN'
+        state: 'OPEN',
+        severity: 'NORMAL'
       });
       expect(getCommentSummary(resolvedThreadResponse, { includeResolved: true })).toEqual([
         'User A on config.yml:6: Resolved thread root'
@@ -402,7 +480,8 @@ describe('PR Comment Mapper', () => {
           createdDate: 1600000000000,
           comments: [],
           threadResolved: false,
-          state: "OPEN"
+          state: "OPEN",
+          severity: "NORMAL"
         }
       ]);
     });
@@ -447,7 +526,8 @@ describe('PR Comment Mapper', () => {
           createdDate: 1600000000000,
           comments: [],
           threadResolved: false,
-          state: "OPEN"
+          state: "OPEN",
+          severity: "NORMAL"
         }
       ]);
 
@@ -465,7 +545,9 @@ describe('PR Comment Mapper', () => {
         summary: {
           totalActivities: 0,
           commentCount: 0,
-          unresolvedCount: 0
+          unresolvedCount: 0,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0
         }
       };
 
@@ -489,7 +571,9 @@ describe('PR Comment Mapper', () => {
         summary: {
           totalActivities: 0,
           commentCount: 0,
-          unresolvedCount: 0
+          unresolvedCount: 0,
+          blockerCount: 0,
+          unresolvedBlockerCount: 0
         }
       };