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

package/package.json

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

package/src/modules/ResultDataProvider.ts

@@ -762,6 +762,37 @@ export default class ResultDataProvider {
         allRequirements,
         scopedRequirementKeys?.size ? scopedRequirementKeys : undefined
       );
+      const linkedFullCodesByTestCase = new Map<number, Set<string>>();
+      const linkedFamilyCodesAcrossTestCases = new Map<string, Set<string>>();
+      const linkedFullCodesAcrossTestCases = new Set<string>();
+      const linkedBaseKeysAcrossTestCases = new Set<string>();
+
+      for (const [linkedTestCaseId, links] of linkedRequirementsByTestCase.entries()) {
+        const rawFullCodes = links?.fullCodes || new Set<string>();
+        const filteredFullCodes =
+          scopedRequirementKeys?.size && rawFullCodes.size > 0
+            ? new Set<string>(
+                [...rawFullCodes].filter((code) =>
+                  scopedRequirementKeys.has(this.toRequirementKey(code))
+                )
+              )
+            : rawFullCodes;
+        linkedFullCodesByTestCase.set(linkedTestCaseId, filteredFullCodes);
+
+        for (const code of filteredFullCodes) {
+          const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(code);
+          if (!normalizedCode) continue;
+          linkedFullCodesAcrossTestCases.add(normalizedCode);
+
+          const baseKey = this.toRequirementKey(normalizedCode);
+          if (!baseKey) continue;
+          linkedBaseKeysAcrossTestCases.add(baseKey);
+          if (!linkedFamilyCodesAcrossTestCases.has(baseKey)) {
+            linkedFamilyCodesAcrossTestCases.set(baseKey, new Set<string>());
+          }
+          linkedFamilyCodesAcrossTestCases.get(baseKey)!.add(normalizedCode);
+        }
+      }
 
       const rows: MewpInternalValidationRow[] = [];
       const stepsXmlByTestCase = this.buildTestCaseStepsXmlMap(testData);
@@ -844,18 +875,7 @@ export default class ResultDataProvider {
           [...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
 
-        const linkedFullCodesRaw = linkedRequirementsByTestCase.get(testCaseId)?.fullCodes || new Set<string>();
-        const linkedFullCodes =
-          scopedRequirementKeys?.size && linkedFullCodesRaw.size > 0
-            ? new Set<string>(
-                [...linkedFullCodesRaw].filter((code) =>
-                  scopedRequirementKeys.has(this.toRequirementKey(code))
-                )
-              )
-            : linkedFullCodesRaw;
-        const linkedBaseKeys = new Set<string>(
-          [...linkedFullCodes].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
-        );
+        const linkedFullCodes = linkedFullCodesByTestCase.get(testCaseId) || new Set<string>();
 
         const mentionedCodesByBase = new Map<string, Set<string>>();
         for (const code of mentionedL2Only) {
@@ -865,13 +885,14 @@ export default class ResultDataProvider {
           mentionedCodesByBase.get(baseKey)!.add(code);
         }
 
-        // Context-based direction A logic:
-        // 1) If no member of family is linked -> report only base SR (Step X: SR0054).
-        // 2) If family is partially linked -> report only specific missing members.
-        // 3) If family fully linked -> report nothing for that family.
+        // Direction A logic:
+        // 1) Base mention ("SR0054") is parent-level and considered covered only when
+        //    the whole family is covered across scoped test cases:
+        //    - if family has children, all children must be linked;
+        //    - if family has no children, the base item itself must be linked.
+        // 2) Child mention ("SR0054-1") is exact-match and checked across scoped test cases.
         const missingBaseWhenFamilyUncovered = new Set<string>();
         const missingSpecificMentionedNoFamily = new Set<string>();
-        const missingFamilyMembers = new Set<string>();
         for (const [baseKey, mentionedCodes] of mentionedCodesByBase.entries()) {
           const familyCodes = requirementFamilies.get(baseKey);
           const mentionedCodesList = [...mentionedCodes];
@@ -879,30 +900,27 @@ export default class ResultDataProvider {
           const mentionedSpecificMembers = mentionedCodesList.filter((code) => /-\d+$/.test(code));
 
           if (familyCodes?.size) {
-            // Base mention ("SR0054") validates against child coverage when children exist.
-            // If no child variants exist, fallback to the single standalone requirement code.
+            const familyLinkedCodes = linkedFamilyCodesAcrossTestCases.get(baseKey) || new Set<string>();
+
+            // Base mention ("SR0054") requires full family coverage across selected test cases.
             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);
-                  }
-                }
+              const normalizedFamilyMembers = [...familyCodes]
+                .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
+                .filter((code) => !!code);
+              const specificFamilyMembers = normalizedFamilyMembers.filter((code) => /-\d+$/.test(code));
+              const requiredFamilyMembers =
+                specificFamilyMembers.length > 0 ? specificFamilyMembers : normalizedFamilyMembers;
+              const isWholeFamilyCovered = requiredFamilyMembers.every((memberCode) =>
+                familyLinkedCodes.has(memberCode)
+              );
+              if (!isWholeFamilyCovered) {
+                missingBaseWhenFamilyUncovered.add(baseKey);
               }
-              continue;
             }
 
-            // Specific mention ("SR0054-1") validates as exact-match only.
+            // Specific mention ("SR0054-1") validates as exact-match only across scoped test cases.
             for (const code of mentionedSpecificMembers) {
-              if (!linkedFullCodes.has(code)) {
+              if (!familyLinkedCodes.has(code)) {
                 missingSpecificMentionedNoFamily.add(code);
               }
             }
@@ -913,10 +931,10 @@ export default class ResultDataProvider {
           for (const code of mentionedCodes) {
             const hasSpecificSuffix = /-\d+$/.test(code);
             if (hasSpecificSuffix) {
-              if (!linkedFullCodes.has(code)) {
+              if (!linkedFullCodesAcrossTestCases.has(code)) {
                 missingSpecificMentionedNoFamily.add(code);
               }
-            } else if (!linkedBaseKeys.has(baseKey)) {
+            } else if (!linkedBaseKeysAcrossTestCases.has(baseKey)) {
               missingBaseWhenFamilyUncovered.add(baseKey);
             }
           }
@@ -929,15 +947,26 @@ export default class ResultDataProvider {
           if (!baseKey) return false;
           return !mentionedBaseKeys.has(baseKey);
         });
-        const mentionedButNotLinkedByStep = new Map<string, Set<string>>();
+        const mentionedButNotLinkedByStep = new Map<
+          string,
+          { baseIds: Set<string>; specificIds: Set<string> }
+        >();
         const appendMentionedButNotLinked = (requirementId: string, stepRef: string) => {
           const normalizedRequirementId = this.normalizeMewpRequirementCodeWithSuffix(requirementId);
           if (!normalizedRequirementId) return;
           const normalizedStepRef = String(stepRef || 'Step ?').trim() || 'Step ?';
           if (!mentionedButNotLinkedByStep.has(normalizedStepRef)) {
-            mentionedButNotLinkedByStep.set(normalizedStepRef, new Set<string>());
+            mentionedButNotLinkedByStep.set(normalizedStepRef, {
+              baseIds: new Set<string>(),
+              specificIds: new Set<string>(),
+            });
+          }
+          const entry = mentionedButNotLinkedByStep.get(normalizedStepRef)!;
+          if (/-\d+$/.test(normalizedRequirementId)) {
+            entry.specificIds.add(normalizedRequirementId);
+          } else {
+            entry.baseIds.add(normalizedRequirementId);
           }
-          mentionedButNotLinkedByStep.get(normalizedStepRef)!.add(normalizedRequirementId);
         };
 
         const sortedMissingSpecificMentionedNoFamily = [...missingSpecificMentionedNoFamily].sort((a, b) =>
@@ -946,7 +975,6 @@ export default class ResultDataProvider {
         const sortedMissingBaseWhenFamilyUncovered = [...missingBaseWhenFamilyUncovered].sort((a, b) =>
           a.localeCompare(b)
         );
-        const sortedMissingFamilyMembers = [...missingFamilyMembers].sort((a, b) => a.localeCompare(b));
         for (const code of sortedMissingSpecificMentionedNoFamily) {
           const stepRef = mentionedCodeFirstStep.get(code) || 'Step ?';
           appendMentionedButNotLinked(code, stepRef);
@@ -955,11 +983,6 @@ export default class ResultDataProvider {
           const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
           appendMentionedButNotLinked(baseKey, stepRef);
         }
-        for (const code of sortedMissingFamilyMembers) {
-          const baseKey = this.toRequirementKey(code);
-          const stepRef = mentionedBaseFirstStep.get(baseKey) || 'Step ?';
-          appendMentionedButNotLinked(code, stepRef);
-        }
 
         const sortedExtraLinked = [...new Set(extraLinked)]
           .map((code) => this.normalizeMewpRequirementCodeWithSuffix(code))
@@ -978,12 +1001,23 @@ export default class ResultDataProvider {
             if (stepOrderA !== stepOrderB) return stepOrderA - stepOrderB;
             return String(a[0]).localeCompare(String(b[0]));
           })
-          .map(([stepRef, requirementIds]) => {
-            const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
-            return `${stepRef}: ${groupedRequirementList}`;
+          .map(([stepRef, requirementIdsByType]) => {
+            const specificCodes = [...requirementIdsByType.specificIds].sort((a, b) =>
+              this.compareMewpRequirementCodes(a, b)
+            );
+            const specificFamilies = new Set<string>(
+              specificCodes.map((code) => this.toRequirementKey(code)).filter((code) => !!code)
+            );
+            const baseCodes = [...requirementIdsByType.baseIds]
+              .filter((baseCode) => !specificFamilies.has(baseCode))
+              .sort((a, b) => this.compareMewpRequirementCodes(a, b));
+            const displayCodes = [...specificCodes, ...baseCodes];
+            if (displayCodes.length === 0) return `${stepRef}:`;
+            return `${stepRef}: ${displayCodes.join('; ')}`.trim();
           })
-          .join('\n');
-        const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked);
+          .join('\n')
+          .trim();
+        const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked).trim();
         const validationStatus: 'Pass' | 'Fail' =
           mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
         if (validationStatus === 'Fail') diagnostics.failingRows += 1;
@@ -993,8 +1027,7 @@ export default class ResultDataProvider {
             `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
             `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${
               sortedMissingSpecificMentionedNoFamily.length +
-              sortedMissingBaseWhenFamilyUncovered.length +
-              sortedMissingFamilyMembers.length
+              sortedMissingBaseWhenFamilyUncovered.length
             } ` +
             `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
             `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`
@@ -2615,6 +2648,36 @@ export default class ResultDataProvider {
     return `SR${match[1]}`;
   }
 
+  private compareMewpRequirementCodes(a: string, b: string): number {
+    const normalizeComparableCode = (value: string): { base: number; hasSuffix: number; suffix: number; raw: string } => {
+      const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(value);
+      const match = /^SR(\d+)(?:-(\d+))?$/i.exec(normalizedCode);
+      if (!match) {
+        return {
+          base: Number.POSITIVE_INFINITY,
+          hasSuffix: 1,
+          suffix: Number.POSITIVE_INFINITY,
+          raw: String(value || ''),
+        };
+      }
+
+      return {
+        base: Number(match[1]),
+        hasSuffix: match[2] ? 1 : 0,
+        suffix: match[2] ? Number(match[2]) : -1,
+        raw: normalizedCode,
+      };
+    };
+
+    const left = normalizeComparableCode(a);
+    const right = normalizeComparableCode(b);
+
+    if (left.base !== right.base) return left.base - right.base;
+    if (left.hasSuffix !== right.hasSuffix) return left.hasSuffix - right.hasSuffix;
+    if (left.suffix !== right.suffix) return left.suffix - right.suffix;
+    return left.raw.localeCompare(right.raw);
+  }
+
   private formatRequirementCodesGroupedByFamily(codes: Iterable<string>): string {
     const byBaseKey = new Map<string, Set<string>>();
     for (const rawCode of codes || []) {
@@ -2628,11 +2691,12 @@ export default class ResultDataProvider {
     if (byBaseKey.size === 0) return '';
 
     return [...byBaseKey.entries()]
-      .sort((a, b) => a[0].localeCompare(b[0]))
+      .sort((a, b) => this.compareMewpRequirementCodes(a[0], b[0]))
       .map(([baseKey, members]) => {
-        const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+        const sortedMembers = [...members].sort((a, b) => this.compareMewpRequirementCodes(a, b));
         if (sortedMembers.length <= 1) return sortedMembers[0];
-        return `${baseKey}: ${sortedMembers.join(', ')}`;
+        // Direction B display is family-level when multiple members exist.
+        return baseKey;
       })
       .join('\n');
   }

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

@@ -1937,7 +1937,7 @@ describe('ResultDataProvider', () => {
       );
     });
 
-    it('should emit Direction A rows with step context for missing sibling links', async () => {
+    it('should emit Direction A rows only for specifically mentioned child requirements', 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([
@@ -1981,7 +1981,7 @@ describe('ResultDataProvider', () => {
           stepId: '2',
           stepPosition: '2',
           action: '',
-          expected: 'SR0001; SR0002',
+          expected: 'SR0001-1',
           isSharedStepTitle: false,
         },
       ]);
@@ -2003,6 +2003,72 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should keep explicit child IDs when multiple specifically mentioned children are missing', 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: 111, testCaseName: 'TC 111' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 111,
+                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 5101,
+          requirementId: 'SR0054-1',
+          baseKey: 'SR0054',
+          title: 'Req child 1',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 5102,
+          requirementId: 'SR0054-2',
+          baseKey: 'SR0054',
+          title: 'Req child 2',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest
+        .spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase')
+        .mockResolvedValueOnce(new Map([[111, { baseKeys: new Set<string>(), fullCodes: new Set<string>() }]]));
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '4',
+          stepPosition: '4',
+          action: '',
+          expected: 'SR0054-1; SR0054-2',
+          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': 111,
+          'Mentioned but Not Linked': 'Step 4: SR0054-1; SR0054-2',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Fail',
+        })
+      );
+    });
+
     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 }]);
@@ -2077,6 +2143,115 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should support cross-test-case family coverage when siblings are linked on different test cases', 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: 501, testCaseName: 'TC 501 - sibling 1' },
+            { testCaseId: 502, testCaseName: 'TC 502 - sibling 2' },
+          ],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 501,
+                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-501\"></steps>' }],
+              },
+            },
+            {
+              workItem: {
+                id: 502,
+                workItemFields: [{ key: 'Steps', value: '<steps id=\"mock-steps-tc-502\"></steps>' }],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 9301,
+          requirementId: 'SR0054-1',
+          baseKey: 'SR0054',
+          title: 'SR0054 child 1',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 9302,
+          requirementId: 'SR0054-2',
+          baseKey: 'SR0054',
+          title: 'SR0054 child 2',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            501,
+            {
+              baseKeys: new Set(['SR0054']),
+              fullCodes: new Set(['SR0054-1']),
+            },
+          ],
+          [
+            502,
+            {
+              baseKeys: new Set(['SR0054']),
+              fullCodes: new Set(['SR0054-2']),
+            },
+          ],
+        ])
+      );
+      jest
+        .spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps')
+        .mockResolvedValueOnce([
+          {
+            stepId: '1',
+            stepPosition: '1',
+            action: 'Parent mention on first test case',
+            expected: 'SR0054',
+            isSharedStepTitle: false,
+          },
+        ])
+        .mockResolvedValueOnce([
+          {
+            stepId: '1',
+            stepPosition: '1',
+            action: 'Parent mention on second test case',
+            expected: 'SR0054',
+            isSharedStepTitle: false,
+          },
+        ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      const byTestCase = new Map<number, any>(
+        result.rows.map((row: any) => [Number(row['Test Case ID']), row])
+      );
+      expect(byTestCase.get(501)).toEqual(
+        expect.objectContaining({
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+      expect(byTestCase.get(502)).toEqual(
+        expect.objectContaining({
+          '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 }]);
@@ -2151,7 +2326,9 @@ describe('ResultDataProvider', () => {
 
       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('SR0054');
+      expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).not.toContain('SR0054-1');
+      expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).not.toContain('SR0054-2');
       expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).toContain('SR0100-1');
     });
 
@@ -2562,7 +2739,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\nSR0511: SR0511-1, SR0511-2',
+          'Mentioned but Not Linked': 'Step 1: SR0095-3; SR0511',
           'Linked but Not Mentioned': 'SR8888',
           'Validation Status': 'Fail',
         })