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

package/package.json

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

package/src/modules/ResultDataProvider.ts

@@ -808,6 +808,34 @@ export default class ResultDataProvider {
 
       for (const testCaseId of [...allTestCaseIds].sort((a, b) => a - b)) {
         diagnostics.totalTestCases += 1;
+        const logList = (items: Iterable<string>, max = 12): string => {
+          const values = [...items].map((item) => String(item || '').trim()).filter((item) => !!item);
+          const shown = values.slice(0, max);
+          const suffix = values.length > max ? ` ...(+${values.length - max} more)` : '';
+          return shown.join(', ') + suffix;
+        };
+        const logByFamily = (items: Iterable<string>, maxFamilies = 8, maxMembers = 10): string => {
+          const map = new Map<string, Set<string>>();
+          for (const item of items || []) {
+            const normalized = this.normalizeMewpRequirementCodeWithSuffix(String(item || ''));
+            if (!normalized) continue;
+            const base = this.toRequirementKey(normalized) || normalized;
+            if (!map.has(base)) map.set(base, new Set<string>());
+            map.get(base)!.add(normalized);
+          }
+          const entries = [...map.entries()]
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .slice(0, maxFamilies)
+            .map(([base, members]) => {
+              const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+              const shownMembers = sortedMembers.slice(0, maxMembers);
+              const membersSuffix =
+                sortedMembers.length > maxMembers ? ` ...(+${sortedMembers.length - maxMembers} more)` : '';
+              return `${base}=[${shownMembers.join(', ')}${membersSuffix}]`;
+            });
+          const suffix = map.size > maxFamilies ? ` ...(+${map.size - maxFamilies} families)` : '';
+          return entries.join(' | ') + suffix;
+        };
         const stepsXml = stepsXmlByTestCase.get(testCaseId) || '';
         const parsedSteps =
           stepsXml && String(stepsXml).trim() !== ''
@@ -860,6 +888,15 @@ export default class ResultDataProvider {
         const linkedBaseKeys = new Set<string>(
           [...linkedFullCodes].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
+        const mentionStepSample = mentionEntries
+          .slice(0, 8)
+          .map((entry) => `${entry.stepRef}=[${logList(entry.codes, 6)}]`)
+          .join(' | ');
+        logger.debug(
+          `MEWP internal validation trace: testCaseId=${testCaseId} ` +
+            `mentionSteps=${mentionEntries.length} mentionStepSample='${mentionStepSample}' ` +
+            `mentionedL2ByFamily='${logByFamily(mentionedL2Only)}' linkedByFamily='${logByFamily(linkedFullCodes)}'`
+        );
 
         const mentionedCodesByBase = new Map<string, Set<string>>();
         for (const code of mentionedL2Only) {
@@ -878,29 +915,92 @@ 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));
+          let familyDecision = 'no-action';
+          let familyTargetCodes: string[] = [];
+          let familyMissingCodes: string[] = [];
+          let familyLinkedCodes: string[] = [];
+          let familyAllCodes: string[] = [];
+
           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);
+            familyAllCodes = [...familyCodes].sort((a, b) => a.localeCompare(b));
+            familyLinkedCodes = familyAllCodes.filter((code) => linkedFullCodes.has(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;
+              familyTargetCodes = [...targetFamilyCodes].sort((a, b) => a.localeCompare(b));
+              const missingInTargetFamily = targetFamilyCodes.filter((code) => !linkedFullCodes.has(code));
+              familyMissingCodes = [...missingInTargetFamily].sort((a, b) => a.localeCompare(b));
+
+              if (missingInTargetFamily.length > 0) {
+                const hasAnyLinkedInFamily = familyCodesList.some((code) => linkedFullCodes.has(code));
+                if (!hasAnyLinkedInFamily) {
+                  missingBaseWhenFamilyUncovered.add(baseKey);
+                  familyDecision = 'base-mentioned-family-uncovered';
+                } else {
+                  for (const code of missingInTargetFamily) {
+                    missingFamilyMembers.add(code);
+                  }
+                  familyDecision = 'base-mentioned-family-partial-missing-children';
+                }
+              } else {
+                familyDecision = 'base-mentioned-family-fully-covered';
+              }
+              logger.debug(
+                `MEWP internal validation family decision: testCaseId=${testCaseId} base=${baseKey} ` +
+                  `mode=baseMention mentioned='${logList(mentionedCodesList)}' familyAll='${logList(familyAllCodes)}' ` +
+                  `target='${logList(familyTargetCodes)}' linked='${logList(familyLinkedCodes)}' ` +
+                  `missing='${logList(familyMissingCodes)}' decision=${familyDecision}`
+              );
+              continue;
+            }
+
+            // Specific mention ("SR0054-1") validates as exact-match only.
+            const missingSpecificMembers: string[] = [];
+            for (const code of mentionedSpecificMembers) {
+              if (!linkedFullCodes.has(code)) {
+                missingSpecificMentionedNoFamily.add(code);
+                missingSpecificMembers.push(code);
               }
             }
+            familyDecision =
+              missingSpecificMembers.length > 0
+                ? 'specific-mentioned-exact-missing'
+                : 'specific-mentioned-exact-covered';
+            logger.debug(
+              `MEWP internal validation family decision: testCaseId=${testCaseId} base=${baseKey} ` +
+                `mode=specificMention mentioned='${logList(mentionedCodesList)}' familyAll='${logList(familyAllCodes)}' ` +
+                `linked='${logList(familyLinkedCodes)}' missingSpecific='${logList(missingSpecificMembers)}' ` +
+                `decision=${familyDecision}`
+            );
             continue;
           }
 
           // Fallback path when family data is unavailable for this base key.
+          const fallbackMissingSpecific: string[] = [];
+          let fallbackBaseMissing = false;
           for (const code of mentionedCodes) {
             const hasSpecificSuffix = /-\d+$/.test(code);
             if (hasSpecificSuffix) {
-              if (!linkedFullCodes.has(code)) missingSpecificMentionedNoFamily.add(code);
+              if (!linkedFullCodes.has(code)) {
+                missingSpecificMentionedNoFamily.add(code);
+                fallbackMissingSpecific.push(code);
+              }
             } else if (!linkedBaseKeys.has(baseKey)) {
               missingBaseWhenFamilyUncovered.add(baseKey);
+              fallbackBaseMissing = true;
             }
           }
+          logger.debug(
+            `MEWP internal validation family decision: testCaseId=${testCaseId} base=${baseKey} ` +
+              `mode=noFamilyData mentioned='${logList(mentionedCodesList)}' linkedBasePresent=${linkedBaseKeys.has(baseKey)} ` +
+              `missingSpecific='${logList(fallbackMissingSpecific)}' missingBase=${fallbackBaseMissing}`
+          );
         }
 
         // Direction B is family-based: if any member of a family is mentioned in Expected Result,
@@ -960,11 +1060,19 @@ 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 rawMentionedByStepForLog = [...mentionedButNotLinkedByStep.entries()]
+          .map(([stepRef, requirementIds]) => `${stepRef}=[${logList(requirementIds, 8)}]`)
+          .join(' | ');
+        logger.debug(
+          `MEWP internal validation grouped diagnostics: testCaseId=${testCaseId} ` +
+            `rawMentionedByStep='${rawMentionedByStepForLog}' groupedMentioned='${mentionedButNotLinked}' ` +
+            `rawLinkedOnlyByFamily='${logByFamily(sortedExtraLinked)}' groupedLinkedOnly='${linkedButNotMentioned}'`
+        );
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
@@ -2735,6 +2843,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',
         })