@elisra-devops/docgen-data-provider 1.121.0 → 1.123.0

package/src/tests/modules/gitDataProvider.test.ts

@@ -1558,6 +1558,151 @@ describe('GitDataProvider - GetCommitBatch', () => {
     expect(result).toHaveLength(0);
   });
 
+  it('should enrich commit workItems with WIs linked from WI development section', async () => {
+    // commitsbatch returns only the commit-side linked WI (e.g. from commit message "#277476").
+    // WIs linked from the WI side (ADO development section) must be merged via the per-commit
+    // /workItems endpoint.
+    const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+    const itemVersion = { version: 'main', versionType: 'branch' };
+    const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+
+    const mockCommitsResponse = {
+      data: {
+        count: 1,
+        value: [
+          {
+            commitId: 'd465de7abc',
+            committer: { name: 'Dev', date: '2024-01-01T00:00:00Z' },
+            comment: 'fix: link WI-277476',
+            workItems: [{ id: 277476, url: 'https://tfs/wi/277476' }],
+          },
+        ],
+      },
+    };
+    const mockEmptyPage = { data: { count: 0, value: [] } };
+    // Per-commit endpoint returns the 2 WI-side linked items in addition to the commit-side one.
+    const mockPerCommitWi = {
+      value: [
+        { id: 277476, url: 'https://tfs/wi/277476' }, // duplicate — must be deduplicated
+        { id: 285957, url: 'https://tfs/wi/285957' },
+        { id: 284959, url: 'https://tfs/wi/284959' },
+      ],
+    };
+
+    (TFSServices as any).postRequest
+      .mockResolvedValueOnce(mockCommitsResponse)
+      .mockResolvedValueOnce(mockEmptyPage);
+    (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockPerCommitWi);
+
+    const result = await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion);
+
+    expect(result).toHaveLength(1);
+    const workItems = result[0].commit.workItems;
+    const ids = workItems.map((wi: any) => wi.id).sort((a: number, b: number) => a - b);
+    expect(ids).toEqual([277476, 284959, 285957]);
+    // Per-commit endpoint was called with correct URL
+    expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+      `${gitUrl}/commits/d465de7abc/workItems?api-version=5.1`,
+      mockToken
+    );
+  });
+
+  it('should handle per-commit WI enrichment failure gracefully and log a warning', async () => {
+    const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+    const itemVersion = { version: 'main', versionType: 'branch' };
+    const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+
+    const mockCommitsResponse = {
+      data: {
+        count: 1,
+        value: [
+          {
+            commitId: 'aabbcc',
+            committer: { name: 'Dev', date: '2024-01-01T00:00:00Z' },
+            comment: 'fix',
+            workItems: [{ id: 100, url: 'https://tfs/wi/100' }],
+          },
+        ],
+      },
+    };
+    const mockEmptyPage = { data: { count: 0, value: [] } };
+
+    (TFSServices as any).postRequest
+      .mockResolvedValueOnce(mockCommitsResponse)
+      .mockResolvedValueOnce(mockEmptyPage);
+    (TFSServices.getItemContent as jest.Mock).mockRejectedValueOnce(new Error('network error'));
+
+    const result = await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].commit.workItems).toEqual([{ id: 100, url: 'https://tfs/wi/100' }]);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('per-commit WI enrichment failed'));
+  });
+
+  it('should initialize workItems from absent field when per-commit endpoint returns WIs', async () => {
+    // Commit arrives from commitsbatch with workItems absent (not [] but undefined).
+    const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+    const itemVersion = { version: 'main', versionType: 'branch' };
+    const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+
+    const mockCommitsResponse = {
+      data: {
+        count: 1,
+        value: [
+          {
+            commitId: 'ccddee',
+            committer: { name: 'Dev', date: '2024-01-01T00:00:00Z' },
+            comment: 'no commit-side WI',
+            // workItems intentionally absent
+          },
+        ],
+      },
+    };
+    const mockEmptyPage = { data: { count: 0, value: [] } };
+    const mockPerCommitWi = { value: [{ id: 999, url: 'https://tfs/wi/999' }] };
+
+    (TFSServices as any).postRequest
+      .mockResolvedValueOnce(mockCommitsResponse)
+      .mockResolvedValueOnce(mockEmptyPage);
+    (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockPerCommitWi);
+
+    const result = await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].commit.workItems.map((wi: any) => wi.id)).toEqual([999]);
+  });
+
+  it('should leave workItems unchanged when per-commit endpoint returns empty list', async () => {
+    const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+    const itemVersion = { version: 'main', versionType: 'branch' };
+    const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+
+    const mockCommitsResponse = {
+      data: {
+        count: 1,
+        value: [
+          {
+            commitId: 'ff0011',
+            committer: { name: 'Dev', date: '2024-01-01T00:00:00Z' },
+            comment: 'fix',
+            workItems: [{ id: 42, url: 'https://tfs/wi/42' }],
+          },
+        ],
+      },
+    };
+    const mockEmptyPage = { data: { count: 0, value: [] } };
+
+    (TFSServices as any).postRequest
+      .mockResolvedValueOnce(mockCommitsResponse)
+      .mockResolvedValueOnce(mockEmptyPage);
+    (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({ value: [] });
+
+    const result = await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].commit.workItems.map((wi: any) => wi.id)).toEqual([42]);
+  });
+
   it('should include specificItemPath when provided', async () => {
     // Arrange
     const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';

package/src/tests/modules/pipelineDataProvider.test.ts

@@ -247,7 +247,7 @@ describe('PipelinesDataProvider', () => {
 
       // Assert
       expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs/${runId}`,
+        `${mockOrgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs/${runId}?$expand=resources`,
         mockToken
       );
       expect(result).toEqual(mockResponse);
@@ -1319,12 +1319,14 @@ describe('PipelinesDataProvider', () => {
         data: { value: [] },
         headers: {},
       });
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
-        value: [
-          { id: 100, result: 'succeeded' },
-          { id: 99, result: 'succeeded' },
-        ],
-      });
+      (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce({}) // getRepoDefaultBranch (no defaultBranch → ancestry short-circuits)
+        .mockResolvedValueOnce({
+          value: [
+            { id: 100, result: 'succeeded' },
+            { id: 99, result: 'succeeded' },
+          ],
+        });
 
       jest.spyOn(pipelinesDataProvider as any, 'getPipelineRunDetails').mockResolvedValueOnce({
         resources: {
@@ -1432,6 +1434,7 @@ describe('PipelinesDataProvider', () => {
         headers: {},
       });
       (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce({}) // getRepoDefaultBranch (no defaultBranch → ancestry short-circuits)
         .mockResolvedValueOnce(mockRunHistory)
         .mockResolvedValueOnce(mockPipelineDetails);
 
@@ -1500,7 +1503,9 @@ describe('PipelinesDataProvider', () => {
         data: { value: [] },
         headers: {},
       });
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({ value: [] });
+      (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce({})           // getRepoDefaultBranch — no defaultBranch, ancestry exits
+        .mockResolvedValueOnce({ value: [] }); // GetPipelineRunHistory (legacy path)
 
       const result = await pipelinesDataProvider.findPreviousPipeline(
         'project1',
@@ -1521,7 +1526,9 @@ describe('PipelinesDataProvider', () => {
         data: { value: [buildCandidate(100, 'refs/heads/main'), buildCandidate(101, 'refs/heads/main')] },
         headers: {},
       });
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({});
+      (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce({})           // getRepoDefaultBranch — no defaultBranch, ancestry exits
+        .mockResolvedValueOnce({ value: [] }); // GetPipelineRunHistory (legacy path)
 
       const result = await pipelinesDataProvider.findPreviousPipeline(
         'project1',
@@ -1557,7 +1564,9 @@ describe('PipelinesDataProvider', () => {
         data: { value: [] },
         headers: {},
       });
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({ value: [] });
+      (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce({})           // getRepoDefaultBranch — no defaultBranch, ancestry exits
+        .mockResolvedValueOnce({ value: [] }); // GetPipelineRunHistory (legacy path)
 
       const result = await pipelinesDataProvider.findPreviousPipeline(
         'project1',
@@ -1595,6 +1604,139 @@ describe('PipelinesDataProvider', () => {
         pipelinesDataProvider.findPreviousPipeline('project1', '123', 100, targetPipelineRun)
       ).rejects.toThrow('Pipeline discovery exceeded 50 pages');
     });
+
+    describe('ancestry-walk fallback', () => {
+      const featureTargetPipelineRun = {
+        resources: {
+          repositories: {
+            self: {
+              repository: { id: 'repo1' },
+              version: 'C3-B',
+              refName: 'refs/heads/feature/x',
+            },
+          },
+        },
+      } as unknown as PipelineRun;
+
+      beforeEach(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should return ancestry-resolved build when same-branch has no match', async () => {
+        // same-branch search: no candidates (empty)
+        (TFSServices.getItemContentWithHeaders as jest.Mock)
+          .mockResolvedValueOnce({ data: { value: [] }, headers: {} }) // same-branch
+          .mockResolvedValueOnce({                                       // ancestry default-branch page
+            data: {
+              value: [
+                buildCandidate(90, 'refs/heads/main'),  // id=90, sourceVersion='sha-90'
+                buildCandidate(70, 'refs/heads/main'),  // id=70, sourceVersion='sha-70'
+              ],
+            },
+            headers: {},
+          });
+
+        // getRepoDefaultBranch
+        (TFSServices.getItemContent as jest.Mock)
+          .mockResolvedValueOnce({ defaultBranch: 'refs/heads/main' })  // getRepoDefaultBranch
+          .mockResolvedValueOnce({ commonCommit: 'C3' })                // getMergeBase
+          .mockResolvedValueOnce({ commonCommit: 'unrelated-sha' })     // isCommitAncestorOf sha-90 vs C3 => false
+          .mockResolvedValueOnce({ commonCommit: 'sha-70' });           // isCommitAncestorOf sha-70 vs C3 => sha-70 == sha-70 -> true
+
+        const result = await pipelinesDataProvider.findPreviousPipeline(
+          'project1',
+          '123',
+          100,
+          featureTargetPipelineRun
+        );
+
+        expect(result).toBe(70);
+      });
+
+      it('should return undefined when ancestry walk finds no ancestor match', async () => {
+        (TFSServices.getItemContentWithHeaders as jest.Mock)
+          .mockResolvedValueOnce({ data: { value: [] }, headers: {} })  // same-branch
+          .mockResolvedValueOnce({                                        // ancestry default-branch page
+            data: { value: [buildCandidate(90, 'refs/heads/main')] },
+            headers: {},
+          });
+
+        (TFSServices.getItemContent as jest.Mock)
+          .mockResolvedValueOnce({ defaultBranch: 'refs/heads/main' })  // getRepoDefaultBranch
+          .mockResolvedValueOnce({ commonCommit: 'C3' })                // getMergeBase
+          .mockResolvedValueOnce({ commonCommit: 'unrelated-sha' })     // isCommitAncestorOf => false
+          .mockResolvedValueOnce({ value: [] });                         // GetPipelineRunHistory (legacy path)
+
+        const result = await pipelinesDataProvider.findPreviousPipeline(
+          'project1',
+          '123',
+          100,
+          featureTargetPipelineRun
+        );
+
+        expect(result).toBeUndefined();
+      });
+
+      it('should return undefined (not throw) when getRepoDefaultBranch fails', async () => {
+        (TFSServices.getItemContentWithHeaders as jest.Mock)
+          .mockResolvedValueOnce({ data: { value: [] }, headers: {} }); // same-branch
+
+        (TFSServices.getItemContent as jest.Mock)
+          .mockRejectedValueOnce(new Error('repo not found'))            // getRepoDefaultBranch throws
+          .mockResolvedValueOnce({ value: [] });                         // GetPipelineRunHistory (legacy path)
+
+        const result = await pipelinesDataProvider.findPreviousPipeline(
+          'project1',
+          '123',
+          100,
+          featureTargetPipelineRun
+        );
+
+        expect(result).toBeUndefined();
+      });
+
+      it('should not invoke ancestry walk when same-branch search finds a match', async () => {
+        (TFSServices.getItemContentWithHeaders as jest.Mock).mockResolvedValueOnce({
+          data: { value: [buildCandidate(90, 'refs/heads/feature/x')] },
+          headers: {},
+        });
+
+        const getItemContentSpy = jest.spyOn(TFSServices, 'getItemContent');
+
+        const result = await pipelinesDataProvider.findPreviousPipeline(
+          'project1',
+          '123',
+          100,
+          featureTargetPipelineRun
+        );
+
+        expect(result).toBe(90);
+        // getRepoDefaultBranch / getMergeBase are called via getItemContent — none should be called
+        const ancestryCalls = getItemContentSpy.mock.calls.filter(
+          ([url]) => typeof url === 'string' && (url.includes('git/repositories') && !url.includes('_apis/build'))
+        );
+        expect(ancestryCalls).toHaveLength(0);
+      });
+
+      it('should return undefined (not throw) when getMergeBase returns no commonCommit', async () => {
+        (TFSServices.getItemContentWithHeaders as jest.Mock)
+          .mockResolvedValueOnce({ data: { value: [] }, headers: {} }); // same-branch
+
+        (TFSServices.getItemContent as jest.Mock)
+          .mockResolvedValueOnce({ defaultBranch: 'refs/heads/main' })  // getRepoDefaultBranch
+          .mockResolvedValueOnce({})                                     // getMergeBase returns no commonCommit
+          .mockResolvedValueOnce({ value: [] });                         // GetPipelineRunHistory (legacy path)
+
+        const result = await pipelinesDataProvider.findPreviousPipeline(
+          'project1',
+          '123',
+          100,
+          featureTargetPipelineRun
+        );
+
+        expect(result).toBeUndefined();
+      });
+    });
   });
 
   describe('private helper methods', () => {