@elisra-devops/docgen-data-provider 1.92.0 → 1.94.0

package/bin/tests/modules/ResultDataProvider.test.js

@@ -558,6 +558,25 @@ describe('ResultDataProvider', () => {
             const result = await resultDataProvider.fetchTestCasesBySuiteId(mockProjectName, mockTestPlanId, mockSuiteId);
             // Assert
             expect(result).toEqual(mockTestCases.value);
+            expect(tfs_1.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.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.resolveSuiteTestCaseRevision({
+                workItem: {
+                    fields: { 'system.rev': 14 },
+                },
+            });
+            expect(revision).toBe(14);
         });
     });
     describe('mapTestPointForCrossPlans', () => {
@@ -691,7 +710,7 @@ describe('ResultDataProvider', () => {
                 lastResultDetails: { duration: 5, dateCompleted: '2023-01-01', runBy: { displayName: 'User' } },
             });
             const result = await resultDataProvider.fetchCrossTestPoints(mockProjectName, [1, 2]);
-            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith('https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps&includePointDetails=true', mockToken);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith('https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps,System.Rev&includePointDetails=true', mockToken);
             expect(result).toHaveLength(2);
             const tc1 = result.find((r) => r.testCaseId === 1);
             expect(tc1.lastResultDetails).toEqual(expect.objectContaining({
@@ -2490,7 +2509,7 @@ describe('ResultDataProvider', () => {
                 'Test Case ID': 42,
                 'Test Case Title': 'TC-0042',
                 'Mentioned but Not Linked': 'Step 3: SR0027',
-                'Linked but Not Mentioned': 'SR0817\nSR0818\nSR0859',
+                'Linked but Not Mentioned': 'SR0817; SR0818; SR0859',
                 'Validation Status': 'Fail',
             }));
             expect(String(result.rows[0]['Mentioned but Not Linked'] || '')).not.toContain('VVRM');
@@ -3220,6 +3239,38 @@ describe('ResultDataProvider', () => {
             expect(calledUrls.some((url) => url.includes('?asOf='))).toBe(false);
             expect(res).toEqual(expect.objectContaining({ testCaseRevision: 9 }));
         });
+        it('should resolve no-run revision from System.Rev in suite test-case fields', async () => {
+            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' },
+            };
+            tfs_1.TFSServices.getItemContent.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.fetchResultDataBasedOnWiBase(mockProjectName, '0', '0', true, [], false, point);
+            expect(tfs_1.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 () => {
             tfs_1.TFSServices.getItemContent.mockReset();
             const selectedFields = ['associatedBug@linked', 'System.Title@testCaseWorkItemField'];
@@ -4061,6 +4112,22 @@ 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.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', () => {
         it('should fetch result data for a point', async () => {
@@ -4078,6 +4145,17 @@ 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.fetchResultDataBase(mockProjectName, 'suite-no-runs', point, fetchResultMethod, createResponseObject);
+            expect(fetchResultMethod).toHaveBeenCalledWith(mockProjectName, '0', '0');
+        });
     });
     describe('getCombinedResultsSummary', () => {
         it('should return combined results summary with expected content controls', async () => {
@@ -4373,6 +4451,73 @@ describe('ResultDataProvider', () => {
                 stepStepIdentifier: '1',
             }));
         });
+        it('should return test-level row with empty step fields when suite has no run history', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan 12');
+            jest.spyOn(resultDataProvider, '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, '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, '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', () => {
         it('should use mapAttachmentsUrl when stepAnalysis.generateRunAttachments is enabled and stepExecution.runAttachmentMode != planOnly', async () => {