@elisra-devops/docgen-data-provider 1.99.0 → 1.101.0

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

@@ -4098,6 +4098,90 @@ describe('ResultDataProvider', () => {
             expect(result).toBe('NotApplicable');
         });
     });
+    describe('runless key/resolution edge cases', () => {
+        it('should prioritize run key over point/revision in buildIterationLookupKey', () => {
+            const key = resultDataProvider.buildIterationLookupKey({
+                testCaseId: 217916,
+                lastRunId: 101,
+                lastResultId: 202,
+                testPointId: 303,
+                testCaseRevision: 18,
+            });
+            expect(key).toBe('101-202-217916');
+        });
+        it('should treat blank run identifiers as missing and use point/revision fallback keys', () => {
+            const pointKey = resultDataProvider.buildIterationLookupKey({
+                testCaseId: 217916,
+                lastRunId: ' ',
+                lastResultId: '',
+                testPointId: 303,
+                testCaseRevision: 18,
+            });
+            const revKey = resultDataProvider.buildIterationLookupKey({
+                testCaseId: 217916,
+                lastRunId: ' ',
+                lastResultId: '',
+                testCaseRevision: 18,
+            });
+            expect(pointKey).toBe('point-303-217916');
+            expect(revKey).toBe('rev-217916-18');
+        });
+        it('should deduplicate candidate keys when primary key is already case-only', () => {
+            const keys = resultDataProvider.buildIterationLookupCandidates({
+                testCaseId: 217916,
+            });
+            expect(keys).toEqual(['217916']);
+        });
+        it('should resolve point revision from suite test case when test case revision is missing', () => {
+            const revision = resultDataProvider.resolvePointRevision({ workItem: { workItemFields: [] } }, {
+                suiteTestCase: {
+                    workItem: {
+                        workItemFields: [{ key: 'System.Rev', value: 23 }],
+                    },
+                },
+            });
+            expect(revision).toBe(23);
+        });
+        it('should short-circuit runless resolution when asOf snapshot already has steps', async () => {
+            const asOfSnapshot = { rev: 18, fields: { 'Microsoft.VSTS.TCM.Steps': '<steps><step id="1"/></steps>' } };
+            const asOfSpy = jest.spyOn(resultDataProvider, 'fetchWorkItemByAsOf').mockResolvedValueOnce(asOfSnapshot);
+            const revSpy = jest.spyOn(resultDataProvider, 'fetchWorkItemByRevision').mockResolvedValueOnce(null);
+            const latestSpy = jest.spyOn(resultDataProvider, 'fetchWorkItemLatest').mockResolvedValueOnce(null);
+            const res = await resultDataProvider.resolveRunlessTestCaseData(mockProjectName, 217916, 18, '2025-05-20T00:47:30.610Z', null, true);
+            expect(res).toBe(asOfSnapshot);
+            expect(asOfSpy).toHaveBeenCalledTimes(1);
+            expect(revSpy).not.toHaveBeenCalled();
+            expect(latestSpy).not.toHaveBeenCalled();
+        });
+        it('should keep earliest snapshot when no source has steps', async () => {
+            const asOfSnapshot = { rev: 1, fields: { 'Microsoft.VSTS.TCM.Steps': '' } };
+            jest
+                .spyOn(resultDataProvider, 'fetchWorkItemByAsOf')
+                .mockResolvedValueOnce(asOfSnapshot);
+            jest
+                .spyOn(resultDataProvider, 'fetchWorkItemByRevision')
+                .mockResolvedValueOnce({ rev: 2, fields: { 'Microsoft.VSTS.TCM.Steps': ' ' } });
+            const latestSnapshot = { rev: 3, fields: { 'Microsoft.VSTS.TCM.Steps': '' } };
+            jest.spyOn(resultDataProvider, 'fetchWorkItemLatest').mockResolvedValueOnce(latestSnapshot);
+            const res = await resultDataProvider.resolveRunlessTestCaseData(mockProjectName, 217916, 18, '2025-05-20T00:47:30.610Z', null, true);
+            expect(res).toBe(asOfSnapshot);
+        });
+        it('should return latest snapshot when only latest has steps', async () => {
+            jest
+                .spyOn(resultDataProvider, 'fetchWorkItemByAsOf')
+                .mockResolvedValueOnce({ rev: 1, fields: { 'Microsoft.VSTS.TCM.Steps': '' } });
+            jest
+                .spyOn(resultDataProvider, 'fetchWorkItemByRevision')
+                .mockResolvedValueOnce({ rev: 2, fields: { 'Microsoft.VSTS.TCM.Steps': '' } });
+            const latestSnapshot = {
+                rev: 3,
+                fields: { 'Microsoft.VSTS.TCM.Steps': '<steps><step id="1"/></steps>' },
+            };
+            jest.spyOn(resultDataProvider, 'fetchWorkItemLatest').mockResolvedValueOnce(latestSnapshot);
+            const res = await resultDataProvider.resolveRunlessTestCaseData(mockProjectName, 217916, 18, '2025-05-20T00:47:30.610Z', null, true);
+            expect(res).toBe(latestSnapshot);
+        });
+    });
     describe('createIterationsMap', () => {
         it('should create iterations map from results', () => {
             // Arrange
@@ -4132,7 +4216,7 @@ describe('ResultDataProvider', () => {
             // Assert
             expect(result['1']).toBeDefined();
         });
-        it('should map runless test reporter item with iteration by testCaseId key', () => {
+        it('should map runless test reporter item with iteration by testCaseId key when point id is missing', () => {
             const iterations = [
                 { testCaseId: 217897, lastRunId: undefined, lastResultId: undefined, iteration: { actionResults: [] } },
             ];
@@ -4140,6 +4224,34 @@ describe('ResultDataProvider', () => {
             expect(result['217897']).toBeDefined();
             expect(result['undefined-undefined-217897']).toBeUndefined();
         });
+        it('should map runless test reporter item with iteration by point-aware key when point id exists', () => {
+            const iterations = [
+                {
+                    testCaseId: 217916,
+                    testPointId: 1001,
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    iteration: { actionResults: [] },
+                },
+            ];
+            const result = resultDataProvider.createIterationsMap(iterations, true, true);
+            expect(result['point-1001-217916']).toBeDefined();
+            expect(result['217916']).toBeUndefined();
+        });
+        it('should map runless test reporter item with iteration by revision key when point id is missing', () => {
+            const iterations = [
+                {
+                    testCaseId: 217916,
+                    testCaseRevision: 18,
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    iteration: { actionResults: [] },
+                },
+            ];
+            const result = resultDataProvider.createIterationsMap(iterations, true, true);
+            expect(result['rev-217916-18']).toBeDefined();
+            expect(result['217916']).toBeUndefined();
+        });
     });
     describe('alignStepsWithIterationsBase', () => {
         it('should return empty array when no iterations', () => {
@@ -4832,13 +4944,14 @@ describe('ResultDataProvider', () => {
             const testData = [
                 {
                     testGroupName: 'G',
-                    testPointsItems: [{ testCaseId: 217916, testCaseName: 'TC 217916', testCaseUrl: 'u' }],
+                    testPointsItems: [{ testCaseId: 217916, testPointId: 1001, testCaseName: 'TC 217916', testCaseUrl: 'u' }],
                     testCasesItems: [],
                 },
             ];
             const iterations = [
                 {
                     testCaseId: 217916,
+                    testPointId: 1001,
                     lastRunId: undefined,
                     lastResultId: undefined,
                     iteration: {
@@ -4870,6 +4983,158 @@ describe('ResultDataProvider', () => {
             expect(res).toHaveLength(1);
             expect(res[0]).toEqual(expect.objectContaining({ stepNo: '1', stepStatus: 'Not Run' }));
         });
+        it('should match runless iterations by testPointId when the same testCase appears in multiple suites', () => {
+            const testData = [
+                {
+                    testGroupName: 'Suite A',
+                    testPointsItems: [{ testCaseId: 217916, testPointId: 2001, testCaseName: 'TC', testCaseUrl: 'u1' }],
+                    testCasesItems: [],
+                },
+                {
+                    testGroupName: 'Suite B',
+                    testPointsItems: [{ testCaseId: 217916, testPointId: 2002, testCaseName: 'TC', testCaseUrl: 'u2' }],
+                    testCasesItems: [],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 217916,
+                    testPointId: 2001,
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    iteration: {
+                        actionResults: [
+                            {
+                                stepIdentifier: '16',
+                                stepPosition: '1',
+                                action: 'A',
+                                expected: 'E',
+                                outcome: 'Unspecified',
+                                isSharedStepTitle: false,
+                                errorMessage: '',
+                            },
+                        ],
+                    },
+                    testCaseResult: 'Not Run',
+                    comment: '',
+                    runBy: { displayName: 'u' },
+                    failureType: '',
+                    executionDate: '',
+                    configurationName: '',
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                    customFields: {},
+                },
+                {
+                    testCaseId: 217916,
+                    testPointId: 2002,
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    iteration: { actionResults: [] },
+                    testCaseResult: 'Not Run',
+                    comment: '',
+                    runBy: { displayName: 'u' },
+                    failureType: '',
+                    executionDate: '',
+                    configurationName: '',
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                    customFields: {},
+                },
+            ];
+            const res = resultDataProvider.alignStepsWithIterationsTestReporter(testData, iterations, ['includeSteps@stepsRunProperties', 'stepRunStatus@stepsRunProperties'], true);
+            expect(res).toHaveLength(2);
+            const suiteA = res.find((row) => (row === null || row === void 0 ? void 0 : row.suiteName) === 'Suite A');
+            const suiteB = res.find((row) => (row === null || row === void 0 ? void 0 : row.suiteName) === 'Suite B');
+            expect(suiteA).toEqual(expect.objectContaining({ stepNo: '1', stepStatus: 'Not Run' }));
+            expect(suiteB).toBeDefined();
+            expect(Object.prototype.hasOwnProperty.call(suiteB, 'stepNo')).toBe(false);
+        });
+        it('should match runless iterations by revision when point id is missing and same testCase appears in multiple suites', () => {
+            const testData = [
+                {
+                    testGroupName: 'Suite A',
+                    testPointsItems: [{ testCaseId: 217916, testCaseName: 'TC', testCaseUrl: 'u1' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 217916,
+                                workItemFields: [{ key: 'System.Rev', value: 18 }],
+                            },
+                        },
+                    ],
+                },
+                {
+                    testGroupName: 'Suite B',
+                    testPointsItems: [{ testCaseId: 217916, testCaseName: 'TC', testCaseUrl: 'u2' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 217916,
+                                workItemFields: [{ key: 'System.Rev', value: 23 }],
+                            },
+                        },
+                    ],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 217916,
+                    testCaseRevision: 18,
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    iteration: {
+                        actionResults: [
+                            {
+                                stepIdentifier: '16',
+                                stepPosition: '1',
+                                action: 'A',
+                                expected: 'E',
+                                outcome: 'Unspecified',
+                                isSharedStepTitle: false,
+                                errorMessage: '',
+                            },
+                        ],
+                    },
+                    testCaseResult: 'Not Run',
+                    comment: '',
+                    runBy: { displayName: 'u' },
+                    failureType: '',
+                    executionDate: '',
+                    configurationName: '',
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                    customFields: {},
+                },
+                {
+                    testCaseId: 217916,
+                    testCaseRevision: 23,
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    iteration: { actionResults: [] },
+                    testCaseResult: 'Not Run',
+                    comment: '',
+                    runBy: { displayName: 'u' },
+                    failureType: '',
+                    executionDate: '',
+                    configurationName: '',
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                    customFields: {},
+                },
+            ];
+            const res = resultDataProvider.alignStepsWithIterationsTestReporter(testData, iterations, ['includeSteps@stepsRunProperties', 'stepRunStatus@stepsRunProperties'], true);
+            expect(res).toHaveLength(2);
+            const suiteA = res.find((row) => (row === null || row === void 0 ? void 0 : row.suiteName) === 'Suite A');
+            const suiteB = res.find((row) => (row === null || row === void 0 ? void 0 : row.suiteName) === 'Suite B');
+            expect(suiteA).toEqual(expect.objectContaining({ stepNo: '1', stepStatus: 'Not Run' }));
+            expect(suiteB).toBeDefined();
+            expect(Object.prototype.hasOwnProperty.call(suiteB, 'stepNo')).toBe(false);
+        });
     });
     describe('fetchOpenPcrData', () => {
         it('should populate both trace maps using linked work items', async () => {