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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisra-devops/docgen-data-provider",
-  "version": "1.86.0",
+  "version": "1.87.0",
   "description": "A document generator data provider, aimed to retrive data from azure devops",
   "repository": {
     "type": "git",

package/src/modules/ResultDataProvider.ts

@@ -878,15 +878,36 @@ export default class ResultDataProvider {
         const missingFamilyMembers = new Set<string>();
         for (const [baseKey, mentionedCodes] of mentionedCodesByBase.entries()) {
           const familyCodes = requirementFamilies.get(baseKey);
+          const mentionedCodesList = [...mentionedCodes];
+          const hasBaseMention = mentionedCodesList.some((code) => !/-\d+$/.test(code));
+          const mentionedSpecificMembers = mentionedCodesList.filter((code) => /-\d+$/.test(code));
+
           if (familyCodes?.size) {
-            const missingInFamily = [...familyCodes].filter((code) => !linkedFullCodes.has(code));
-            if (missingInFamily.length === 0) continue;
-            const linkedInFamilyCount = familyCodes.size - missingInFamily.length;
-            if (linkedInFamilyCount === 0) {
-              missingBaseWhenFamilyUncovered.add(baseKey);
-            } else {
-              for (const code of missingInFamily) {
-                missingFamilyMembers.add(code);
+            // Base mention ("SR0054") validates against child coverage when children exist.
+            // If no child variants exist, fallback to the single standalone requirement code.
+            if (hasBaseMention) {
+              const familyCodesList = [...familyCodes];
+              const childFamilyCodes = familyCodesList.filter((code) => /-\d+$/.test(code));
+              const targetFamilyCodes = childFamilyCodes.length > 0 ? childFamilyCodes : familyCodesList;
+              const missingInTargetFamily = targetFamilyCodes.filter((code) => !linkedFullCodes.has(code));
+
+              if (missingInTargetFamily.length > 0) {
+                const hasAnyLinkedInFamily = familyCodesList.some((code) => linkedFullCodes.has(code));
+                if (!hasAnyLinkedInFamily) {
+                  missingBaseWhenFamilyUncovered.add(baseKey);
+                } else {
+                  for (const code of missingInTargetFamily) {
+                    missingFamilyMembers.add(code);
+                  }
+                }
+              }
+              continue;
+            }
+
+            // Specific mention ("SR0054-1") validates as exact-match only.
+            for (const code of mentionedSpecificMembers) {
+              if (!linkedFullCodes.has(code)) {
+                missingSpecificMentionedNoFamily.add(code);
               }
             }
             continue;
@@ -960,11 +981,11 @@ export default class ResultDataProvider {
             return String(a[0]).localeCompare(String(b[0]));
           })
           .map(([stepRef, requirementIds]) => {
-            const requirementList = [...requirementIds].sort((a, b) => a.localeCompare(b));
-            return `${stepRef}: ${requirementList.join(', ')}`;
+            const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
+            return `${stepRef}: ${groupedRequirementList}`;
           })
           .join('; ');
-        const linkedButNotMentioned = sortedExtraLinked.join('; ');
+        const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked);
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
@@ -2735,6 +2756,28 @@ export default class ResultDataProvider {
     return `SR${match[1]}`;
   }
 
+  private formatRequirementCodesGroupedByFamily(codes: Iterable<string>): string {
+    const byBaseKey = new Map<string, Set<string>>();
+    for (const rawCode of codes || []) {
+      const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(String(rawCode || ''));
+      if (!normalizedCode) continue;
+      const baseKey = this.toRequirementKey(normalizedCode) || normalizedCode;
+      if (!byBaseKey.has(baseKey)) byBaseKey.set(baseKey, new Set<string>());
+      byBaseKey.get(baseKey)!.add(normalizedCode);
+    }
+
+    if (byBaseKey.size === 0) return '';
+
+    return [...byBaseKey.entries()]
+      .sort((a, b) => a[0].localeCompare(b[0]))
+      .map(([baseKey, members]) => {
+        const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+        if (sortedMembers.length <= 1) return sortedMembers[0];
+        return `${baseKey}: ${sortedMembers.join(', ')}`;
+      })
+      .join('; ');
+  }
+
   private toMewpComparableText(value: any): string {
     if (value === null || value === undefined) return '';
     if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {

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

@@ -1986,6 +1986,158 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should pass when a base SR mention is fully covered by its only linked child', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+      jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+      jest.spyOn(resultDataProvider as any, '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 as any, '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 as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            402,
+            {
+              baseKeys: new Set(['SR0054']),
+              fullCodes: new Set(['SR0054-1']),
+            },
+          ],
+        ])
+      );
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '3',
+          stepPosition: '3',
+          action: 'Validate family root',
+          expected: 'SR0054',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).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 as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+      jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+      jest.spyOn(resultDataProvider as any, '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 as any, '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 as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            403,
+            {
+              baseKeys: new Set(['SR0054', 'SR0100']),
+              fullCodes: new Set(['SR0054-1', 'SR0054-2', 'SR0100-1']),
+            },
+          ],
+        ])
+      );
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: 'Action only',
+          expected: '',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).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 as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
@@ -2393,7 +2545,7 @@ describe('ResultDataProvider', () => {
       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',
         })