@elisra-devops/docgen-data-provider 1.93.0 → 1.95.0

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

@@ -333,6 +333,21 @@ describe('ResultDataProvider', () => {
           testCaseUrl: 'https://dev.azure.com/organization/test-project/_workitems/edit/1',
         });
       });
+
+      it('should include pointAsOfTimestamp when lastUpdatedDate is available', () => {
+        const testPoint = {
+          testCaseReference: { id: 1, name: 'Test Case 1' },
+          lastUpdatedDate: '2025-01-01T12:34:56Z',
+        };
+
+        const result = (resultDataProvider as any).mapTestPoint(testPoint, mockProjectName);
+
+        expect(result).toEqual(
+          expect.objectContaining({
+            pointAsOfTimestamp: '2025-01-01T12:34:56.000Z',
+          })
+        );
+      });
     });
 
     describe('calculateGroupResultSummary', () => {
@@ -679,6 +694,34 @@ describe('ResultDataProvider', () => {
 
       // Assert
       expect(result).toEqual(mockTestCases.value);
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        expect.stringContaining(
+          `/_apis/testplan/Plans/${mockTestPlanId}/Suites/${mockSuiteId}/TestCase?witFields=Microsoft.VSTS.TCM.Steps,System.Rev`
+        ),
+        mockToken
+      );
+    });
+  });
+
+  describe('resolveSuiteTestCaseRevision', () => {
+    it('should resolve System.Rev from workItemFields', () => {
+      const revision = (resultDataProvider as any).resolveSuiteTestCaseRevision({
+        workItem: {
+          workItemFields: [{ key: 'System.Rev', value: '12' }],
+        },
+      });
+
+      expect(revision).toBe(12);
+    });
+
+    it('should resolve System.Rev case-insensitively from workItem fields map', () => {
+      const revision = (resultDataProvider as any).resolveSuiteTestCaseRevision({
+        workItem: {
+          fields: { 'system.rev': 14 },
+        },
+      });
+
+      expect(revision).toBe(14);
     });
   });
 
@@ -837,7 +880,7 @@ describe('ResultDataProvider', () => {
       const result = await (resultDataProvider as any).fetchCrossTestPoints(mockProjectName, [1, 2]);
 
       expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        'https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps&includePointDetails=true',
+        'https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps,System.Rev&includePointDetails=true',
         mockToken
       );
       expect(result).toHaveLength(2);
@@ -3862,7 +3905,9 @@ describe('ResultDataProvider', () => {
         true,
         [],
         false,
-        point
+        point,
+        false,
+        true
       );
 
       expect(TFSServices.getItemContent).toHaveBeenCalledWith(
@@ -3874,6 +3919,196 @@ describe('ResultDataProvider', () => {
       expect(res).toEqual(expect.objectContaining({ testCaseRevision: 9 }));
     });
 
+    it('should ignore point asOf timestamp when runless asOf mode is disabled', async () => {
+      const point = {
+        testCaseId: '123',
+        testCaseName: 'TC 123',
+        outcome: 'passed',
+        pointAsOfTimestamp: '2025-01-01T12:34:56Z',
+        suiteTestCase: {
+          workItem: {
+            id: 123,
+            rev: 9,
+            workItemFields: [{ key: 'Microsoft.VSTS.TCM.Steps', value: '<steps></steps>' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 123,
+        rev: 9,
+        fields: {
+          'System.State': 'Active',
+          'System.CreatedDate': '2024-01-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'System.Title': 'Title 123',
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: null,
+      });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point
+      );
+
+      const calledUrls = (TFSServices.getItemContent as jest.Mock).mock.calls.map((args: any[]) => String(args[0]));
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/123?asOf='))).toBe(false);
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/123/revisions/9'))).toBe(true);
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 9 }));
+    });
+
+    it('should fetch no-run test case by asOf timestamp when pointAsOfTimestamp is available', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockReset();
+      const point = {
+        testCaseId: '123',
+        testCaseName: 'TC 123',
+        outcome: 'passed',
+        pointAsOfTimestamp: '2025-01-01T12:34:56Z',
+        suiteTestCase: {
+          workItem: {
+            id: 123,
+            rev: 9,
+            workItemFields: [{ key: 'Microsoft.VSTS.TCM.Steps', value: '<steps></steps>' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 123,
+        rev: 6,
+        fields: {
+          'System.State': 'Active',
+          'System.CreatedDate': '2024-01-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'System.Title': 'Title 123',
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: null,
+      });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point,
+        false,
+        true
+      );
+
+      const calledUrls = (TFSServices.getItemContent as jest.Mock).mock.calls.map((args: any[]) => String(args[0]));
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/123?asOf='))).toBe(true);
+      expect(calledUrls.some((url: string) => url.includes('/revisions/9'))).toBe(false);
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 6 }));
+    });
+
+    it('should fallback to suite revision when asOf fetch fails', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockReset();
+      const point = {
+        testCaseId: '456',
+        testCaseName: 'TC 456',
+        outcome: 'Not Run',
+        pointAsOfTimestamp: '2025-02-01T00:00:00Z',
+        suiteTestCase: {
+          workItem: {
+            id: 456,
+            workItemFields: [{ key: 'System.Rev', value: '11' }],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock)
+        .mockRejectedValueOnce(new Error('asOf failed'))
+        .mockResolvedValueOnce({
+          id: 456,
+          rev: 11,
+          fields: {
+            'System.State': 'Active',
+            'System.CreatedDate': '2024-01-01T00:00:00',
+            'Microsoft.VSTS.TCM.Priority': 1,
+            'System.Title': 'Title 456',
+            'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+          },
+          relations: [],
+        });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point,
+        false,
+        true
+      );
+
+      const calledUrls = (TFSServices.getItemContent as jest.Mock).mock.calls.map((args: any[]) => String(args[0]));
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/456?asOf='))).toBe(true);
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/456/revisions/11'))).toBe(true);
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 11 }));
+    });
+
+    it('should resolve no-run revision from System.Rev in suite test-case fields', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockReset();
+      const point = {
+        testCaseId: '321',
+        testCaseName: 'TC 321',
+        outcome: 'Not Run',
+        suiteTestCase: {
+          workItem: {
+            id: 321,
+            workItemFields: [
+              { key: 'System.Rev', value: '13' },
+              { key: 'Microsoft.VSTS.TCM.Steps', value: '<steps></steps>' },
+            ],
+          },
+        },
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 321,
+        rev: 13,
+        fields: {
+          'System.State': 'Design',
+          'System.CreatedDate': '2024-05-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'System.Title': 'Title 321',
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: [],
+      });
+
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '0',
+        '0',
+        true,
+        [],
+        false,
+        point
+      );
+
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        expect.stringContaining('/_apis/wit/workItems/321/revisions/13?$expand=all'),
+        mockToken
+      );
+      expect(res).toEqual(expect.objectContaining({ testCaseRevision: 13 }));
+    });
+
     it('should append linked relations and filter testCaseWorkItemField when isTestReporter=true and isQueryMode=false', async () => {
       (TFSServices.getItemContent as jest.Mock).mockReset();
 
@@ -5045,6 +5280,35 @@ describe('ResultDataProvider', () => {
       expect(fetchStrategy).not.toHaveBeenCalled();
       expect(result).toEqual([]);
     });
+
+    it('should keep points without run/result IDs when test reporter mode is enabled', async () => {
+      const testData = [
+        {
+          testSuiteId: 1,
+          testPointsItems: [{ testCaseId: 10, lastRunId: 101, lastResultId: 201 }, { testCaseId: 11 }],
+        },
+      ];
+      const fetchStrategy = jest
+        .fn()
+        .mockResolvedValueOnce({ testCaseId: 10 })
+        .mockResolvedValueOnce({ testCaseId: 11 });
+
+      const result = await (resultDataProvider as any).fetchAllResultDataBase(
+        testData,
+        mockProjectName,
+        true,
+        fetchStrategy
+      );
+
+      expect(fetchStrategy).toHaveBeenCalledTimes(2);
+      expect(fetchStrategy).toHaveBeenNthCalledWith(
+        2,
+        mockProjectName,
+        1,
+        expect.objectContaining({ testCaseId: 11 })
+      );
+      expect(result).toEqual([{ testCaseId: 10 }, { testCaseId: 11 }]);
+    });
   });
 
   describe('fetchResultDataBase', () => {
@@ -5071,6 +5335,26 @@ describe('ResultDataProvider', () => {
       expect(fetchResultMethod).toHaveBeenCalled();
       expect(result).toBeDefined();
     });
+
+    it('should call fetch method with runId/resultId as 0 when point has no run history', async () => {
+      const point = { testCaseId: 15, lastRunId: undefined, lastResultId: undefined };
+      const fetchResultMethod = jest.fn().mockResolvedValue({
+        testCase: { id: 15, name: 'TC 15' },
+        testSuite: { name: 'S' },
+        iterationDetails: [],
+      });
+      const createResponseObject = jest.fn().mockReturnValue({ id: 15 });
+
+      await (resultDataProvider as any).fetchResultDataBase(
+        mockProjectName,
+        'suite-no-runs',
+        point,
+        fetchResultMethod,
+        createResponseObject
+      );
+
+      expect(fetchResultMethod).toHaveBeenCalledWith(mockProjectName, '0', '0');
+    });
   });
 
   describe('getCombinedResultsSummary', () => {
@@ -5460,6 +5744,86 @@ describe('ResultDataProvider', () => {
         })
       );
     });
+
+    it('should return test-level row with empty step fields when suite has no run history', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan 12');
+      jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([
+        {
+          testSuiteId: 300,
+          suiteId: 300,
+          suiteName: 'suite no runs',
+          parentSuiteId: 100,
+          parentSuiteName: 'Rel3',
+          suitePath: 'Root/Rel3/suite no runs',
+          testGroupName: 'suite no runs',
+        },
+      ]);
+
+      jest.spyOn(resultDataProvider as any, 'fetchTestData').mockResolvedValueOnce([
+        {
+          testSuiteId: 300,
+          suiteId: 300,
+          suiteName: 'suite no runs',
+          parentSuiteId: 100,
+          parentSuiteName: 'Rel3',
+          suitePath: 'Root/Rel3/suite no runs',
+          testGroupName: 'suite no runs',
+          testPointsItems: [
+            {
+              testCaseId: 55,
+              testCaseName: 'TC 55',
+              outcome: 'Not Run',
+              testPointId: 9001,
+              lastRunId: undefined,
+              lastResultId: undefined,
+              lastResultDetails: undefined,
+            },
+          ],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 55,
+                workItemFields: [{ key: 'System.Rev', value: 4 }],
+              },
+            },
+          ],
+        },
+      ]);
+
+      jest.spyOn(resultDataProvider as any, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([
+        {
+          testCaseId: 55,
+          testCase: { id: 55, name: 'TC 55' },
+          testSuite: { name: 'suite no runs' },
+          executionDate: '',
+          testCaseResult: { resultMessage: 'Not Run', url: '' },
+          customFields: {},
+          runBy: '',
+          iteration: undefined,
+          lastRunId: undefined,
+          lastResultId: undefined,
+        },
+      ]);
+
+      const result = await resultDataProvider.getTestReporterFlatResults(
+        mockTestPlanId,
+        mockProjectName,
+        undefined,
+        [],
+        false
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          testCaseId: 55,
+          testRunId: undefined,
+          testPointId: 9001,
+          stepOutcome: undefined,
+          stepStepIdentifier: '',
+        })
+      );
+    });
   });
 
   describe('getCombinedResultsSummary - appendix branches', () => {