@elisra-devops/docgen-data-provider 1.85.0 → 1.87.0

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

@@ -1603,6 +1603,195 @@ describe('ResultDataProvider', () => {
                 }),
             ]));
         });
+        it('should pass when a base SR mention is fully covered by its only linked child', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 402, testCaseName: 'TC 402 - Single child covered' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 402,
+                                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-402\"></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 9101,
+                    requirementId: 'SR0054',
+                    baseKey: 'SR0054',
+                    title: 'SR0054 parent',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 9102,
+                    requirementId: 'SR0054-1',
+                    baseKey: 'SR0054',
+                    title: 'SR0054 child 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(new Map([
+                [
+                    402,
+                    {
+                        baseKeys: new Set(['SR0054']),
+                        fullCodes: new Set(['SR0054-1']),
+                    },
+                ],
+            ]));
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '3',
+                    stepPosition: '3',
+                    action: 'Validate family root',
+                    expected: 'SR0054',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(1);
+            expect(result.rows[0]).toEqual(expect.objectContaining({
+                'Test Case ID': 402,
+                'Mentioned but Not Linked': '',
+                'Linked but Not Mentioned': '',
+                'Validation Status': 'Pass',
+            }));
+        });
+        it('should group linked-but-not-mentioned requirements by SR family', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 403, testCaseName: 'TC 403 - Linked only' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 403,
+                                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-403\"></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 9201,
+                    requirementId: 'SR0054-1',
+                    baseKey: 'SR0054',
+                    title: 'SR0054 child 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 9202,
+                    requirementId: 'SR0054-2',
+                    baseKey: 'SR0054',
+                    title: 'SR0054 child 2',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 9203,
+                    requirementId: 'SR0100-1',
+                    baseKey: 'SR0100',
+                    title: 'SR0100 child 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(new Map([
+                [
+                    403,
+                    {
+                        baseKeys: new Set(['SR0054', 'SR0100']),
+                        fullCodes: new Set(['SR0054-1', 'SR0054-2', 'SR0100-1']),
+                    },
+                ],
+            ]));
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '1',
+                    stepPosition: '1',
+                    action: 'Action only',
+                    expected: '',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(1);
+            expect(String(result.rows[0]['Mentioned but Not Linked'] || '')).toBe('');
+            expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).toContain('SR0054: SR0054-1, SR0054-2');
+            expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).toContain('SR0100-1');
+        });
+        it('should report only base SR when an entire mentioned family is uncovered', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 401, testCaseName: 'TC 401 - Family uncovered' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 401,
+                                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-401\"></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 9001,
+                    requirementId: 'SR0054-1',
+                    baseKey: 'SR0054',
+                    title: 'SR0054 child 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 9002,
+                    requirementId: 'SR0054-2',
+                    baseKey: 'SR0054',
+                    title: 'SR0054 child 2',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(new Map([[401, { baseKeys: new Set(), fullCodes: new Set() }]]));
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '3',
+                    stepPosition: '3',
+                    action: 'Validate family root',
+                    expected: 'SR0054',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(1);
+            expect(result.rows[0]).toEqual(expect.objectContaining({
+                'Test Case ID': 401,
+                'Mentioned but Not Linked': 'Step 3: SR0054',
+                'Linked but Not Mentioned': '',
+                'Validation Status': 'Fail',
+            }));
+            expect(String(result.rows[0]['Mentioned but Not Linked'] || '')).not.toContain('SR0054-1');
+            expect(String(result.rows[0]['Mentioned but Not Linked'] || '')).not.toContain('SR0054-2');
+        });
         it('should not duplicate Direction A discrepancy when same requirement is repeated in multiple steps', async () => {
             jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
             jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
@@ -1913,7 +2102,7 @@ describe('ResultDataProvider', () => {
             expect(new Set(result.rows.map((row) => row['Test Case ID']))).toEqual(new Set([201, 202, 203]));
             expect(byTestCase.get(201)).toEqual(expect.objectContaining({
                 'Test Case Title': 'TC 201 - Mixed discrepancies',
-                'Mentioned but Not Linked': 'Step 1: SR0095-3, SR0511-1, SR0511-2',
+                'Mentioned but Not Linked': 'Step 1: SR0095-3; SR0511: SR0511-1, SR0511-2',
                 'Linked but Not Mentioned': 'SR8888',
                 'Validation Status': 'Fail',
             }));
@@ -2208,6 +2397,101 @@ describe('ResultDataProvider', () => {
             }));
         });
     });
+    describe('buildLinkedRequirementsByTestCase', () => {
+        it('should map linked requirements only for supported test-case requirement relation types', async () => {
+            var _a, _b, _c, _d;
+            const requirements = [
+                {
+                    workItemId: 7001,
+                    requirementId: 'SR0054-1',
+                    baseKey: 'SR0054',
+                    linkedTestCaseIds: [],
+                },
+            ];
+            const testData = [
+                {
+                    testCasesItems: [{ workItem: { id: 1001 } }],
+                    testPointsItems: [],
+                },
+            ];
+            const fetchByIdsSpy = jest
+                .spyOn(resultDataProvider, 'fetchWorkItemsByIds')
+                .mockImplementation(async (...args) => {
+                const ids = Array.isArray(args === null || args === void 0 ? void 0 : args[1]) ? args[1] : [];
+                const includeRelations = !!(args === null || args === void 0 ? void 0 : args[2]);
+                if (includeRelations) {
+                    return [
+                        {
+                            id: 1001,
+                            relations: [
+                                {
+                                    rel: 'Microsoft.VSTS.Common.TestedBy-Reverse',
+                                    url: 'https://dev.azure.com/org/project/_apis/wit/workItems/7001',
+                                },
+                                {
+                                    rel: 'System.LinkTypes.Related',
+                                    url: 'https://dev.azure.com/org/project/_apis/wit/workItems/7001',
+                                },
+                            ],
+                        },
+                    ];
+                }
+                return ids.map((id) => ({
+                    id,
+                    fields: {
+                        'System.WorkItemType': id === 7001 ? 'Requirement' : 'Test Case',
+                    },
+                }));
+            });
+            const linked = await resultDataProvider.buildLinkedRequirementsByTestCase(requirements, testData, mockProjectName);
+            expect(fetchByIdsSpy).toHaveBeenCalled();
+            expect((_b = (_a = linked.get(1001)) === null || _a === void 0 ? void 0 : _a.baseKeys) === null || _b === void 0 ? void 0 : _b.has('SR0054')).toBe(true);
+            expect((_d = (_c = linked.get(1001)) === null || _c === void 0 ? void 0 : _c.fullCodes) === null || _d === void 0 ? void 0 : _d.has('SR0054-1')).toBe(true);
+        });
+        it('should ignore unsupported relation types when linking test case to requirements', async () => {
+            var _a, _b, _c, _d;
+            const requirements = [
+                {
+                    workItemId: 7002,
+                    requirementId: 'SR0099-1',
+                    baseKey: 'SR0099',
+                    linkedTestCaseIds: [],
+                },
+            ];
+            const testData = [
+                {
+                    testCasesItems: [{ workItem: { id: 1002 } }],
+                    testPointsItems: [],
+                },
+            ];
+            jest.spyOn(resultDataProvider, 'fetchWorkItemsByIds').mockImplementation(async (...args) => {
+                const ids = Array.isArray(args === null || args === void 0 ? void 0 : args[1]) ? args[1] : [];
+                const includeRelations = !!(args === null || args === void 0 ? void 0 : args[2]);
+                if (includeRelations) {
+                    return [
+                        {
+                            id: 1002,
+                            relations: [
+                                {
+                                    rel: 'System.LinkTypes.Related',
+                                    url: 'https://dev.azure.com/org/project/_apis/wit/workItems/7002',
+                                },
+                            ],
+                        },
+                    ];
+                }
+                return ids.map((id) => ({
+                    id,
+                    fields: {
+                        'System.WorkItemType': id === 7002 ? 'Requirement' : 'Test Case',
+                    },
+                }));
+            });
+            const linked = await resultDataProvider.buildLinkedRequirementsByTestCase(requirements, testData, mockProjectName);
+            expect((_b = (_a = linked.get(1002)) === null || _a === void 0 ? void 0 : _a.baseKeys) === null || _b === void 0 ? void 0 : _b.has('SR0099')).toBe(false);
+            expect((_d = (_c = linked.get(1002)) === null || _c === void 0 ? void 0 : _c.fullCodes) === null || _d === void 0 ? void 0 : _d.has('SR0099-1')).toBe(false);
+        });
+    });
     describe('MEWP rel fallback scoping', () => {
         it('should fallback to previous Rel run when latest selected Rel has no run for a test case', async () => {
             const suites = [