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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisra-devops/docgen-data-provider",
-  "version": "1.91.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

@@ -886,8 +886,10 @@ export default class ResultDataProvider {
         }
 
         // Direction A logic:
-        // 1) Base mention ("SR0054") is parent-level only and considered covered
-        //    if any member of that family is linked across scoped test cases.
+        // 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>();
@@ -900,9 +902,18 @@ export default class ResultDataProvider {
           if (familyCodes?.size) {
             const familyLinkedCodes = linkedFamilyCodesAcrossTestCases.get(baseKey) || new Set<string>();
 
-            // Base mention ("SR0054") is satisfied by any linked member in the same family.
+            // Base mention ("SR0054") requires full family coverage across selected test cases.
             if (hasBaseMention) {
-              if (familyLinkedCodes.size === 0) {
+              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);
               }
             }
@@ -936,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) =>
@@ -979,8 +1001,19 @@ export default class ResultDataProvider {
             if (stepOrderA !== stepOrderB) return stepOrderA - stepOrderB;
             return String(a[0]).localeCompare(String(b[0]));
           })
-          .map(([stepRef, requirementIds]) => {
-            return this.formatStepScopedRequirementGroups(stepRef, requirementIds);
+          .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')
           .trim();
@@ -2645,19 +2678,6 @@ export default class ResultDataProvider {
     return left.raw.localeCompare(right.raw);
   }
 
-  private formatStepScopedRequirementGroups(stepRef: string, requirementIds: Iterable<string>): string {
-    const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
-    if (!groupedRequirementList) return `${stepRef}:`;
-
-    const groupedLines = groupedRequirementList
-      .split('\n')
-      .map((line) => String(line || '').trim())
-      .filter((line) => line.length > 0);
-
-    if (groupedLines.length <= 1) return `${stepRef}: ${groupedLines[0] || ''}`.trim();
-    return `${stepRef}:\n${groupedLines.map((line) => `- ${line}`).join('\n')}`.trim();
-  }
-
   private formatRequirementCodesGroupedByFamily(codes: Iterable<string>): string {
     const byBaseKey = new Map<string, Set<string>>();
     for (const rawCode of codes || []) {
@@ -2675,12 +2695,7 @@ export default class ResultDataProvider {
       .map(([baseKey, members]) => {
         const sortedMembers = [...members].sort((a, b) => this.compareMewpRequirementCodes(a, b));
         if (sortedMembers.length <= 1) return sortedMembers[0];
-
-        const nonBaseMembers = sortedMembers.filter((member) => member !== baseKey);
-        if (nonBaseMembers.length > 0) {
-          return `${baseKey}: ${nonBaseMembers.join(', ')}`;
-        }
-
+        // Direction B display is family-level when multiple members exist.
         return baseKey;
       })
       .join('\n');

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

@@ -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 }]);
@@ -2260,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');
     });
 
@@ -2671,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',
+          'Mentioned but Not Linked': 'Step 1: SR0095-3; SR0511',
           'Linked but Not Mentioned': 'SR8888',
           'Validation Status': 'Fail',
         })