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

package/package.json

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

@@ -848,18 +848,6 @@ export default class ResultDataProvider {
           [...mentionedL2Only].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
 
-        const expectedFamilyCodes = new Set<string>();
-        for (const baseKey of mentionedBaseKeys) {
-          const familyCodes = requirementFamilies.get(baseKey);
-          if (familyCodes?.size) {
-            familyCodes.forEach((code) => expectedFamilyCodes.add(code));
-          } else {
-            for (const code of mentionedL2Only) {
-              if (this.toRequirementKey(code) === baseKey) expectedFamilyCodes.add(code);
-            }
-          }
-        }
-
         const linkedFullCodesRaw = linkedRequirementsByTestCase.get(testCaseId)?.fullCodes || new Set<string>();
         const linkedFullCodes =
           scopedRequirementKeys?.size && linkedFullCodesRaw.size > 0
@@ -873,14 +861,69 @@ export default class ResultDataProvider {
           [...linkedFullCodes].map((code) => this.toRequirementKey(code)).filter((code) => !!code)
         );
 
-        const missingMentioned = [...mentionedL2Only].filter((code) => {
+        const mentionedCodesByBase = new Map<string, Set<string>>();
+        for (const code of mentionedL2Only) {
           const baseKey = this.toRequirementKey(code);
-          if (!baseKey) return false;
-          const hasSpecificSuffix = /-\d+$/.test(code);
-          if (hasSpecificSuffix) return !linkedFullCodes.has(code);
-          return !linkedBaseKeys.has(baseKey);
-        });
-        const missingFamily = [...expectedFamilyCodes].filter((code) => !linkedFullCodes.has(code));
+          if (!baseKey) continue;
+          if (!mentionedCodesByBase.has(baseKey)) mentionedCodesByBase.set(baseKey, new Set<string>());
+          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.
+        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];
+          const hasBaseMention = mentionedCodesList.some((code) => !/-\d+$/.test(code));
+          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.
+            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;
+          }
+
+          // Fallback path when family data is unavailable for this base key.
+          for (const code of mentionedCodes) {
+            const hasSpecificSuffix = /-\d+$/.test(code);
+            if (hasSpecificSuffix) {
+              if (!linkedFullCodes.has(code)) missingSpecificMentionedNoFamily.add(code);
+            } else if (!linkedBaseKeys.has(baseKey)) {
+              missingBaseWhenFamilyUncovered.add(baseKey);
+            }
+          }
+        }
+
         // Direction B is family-based: if any member of a family is mentioned in Expected Result,
         // linked members of that same family are not considered "linked but not mentioned".
         const extraLinked = [...linkedFullCodes].filter((code) => {
@@ -899,13 +942,22 @@ export default class ResultDataProvider {
           mentionedButNotLinkedByStep.get(normalizedStepRef)!.add(normalizedRequirementId);
         };
 
-        const sortedMissingMentioned = [...new Set(missingMentioned)].sort((a, b) => a.localeCompare(b));
-        const sortedMissingFamily = [...new Set(missingFamily)].sort((a, b) => a.localeCompare(b));
-        for (const code of sortedMissingMentioned) {
+        const sortedMissingSpecificMentionedNoFamily = [...missingSpecificMentionedNoFamily].sort((a, b) =>
+          a.localeCompare(b)
+        );
+        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);
         }
-        for (const code of sortedMissingFamily) {
+        for (const baseKey of sortedMissingBaseWhenFamilyUncovered) {
+          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);
@@ -929,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;
@@ -941,7 +993,11 @@ export default class ResultDataProvider {
           `MEWP internal validation parse diagnostics: ` +
             `testCaseId=${testCaseId} parsedSteps=${executableSteps.length} ` +
             `stepsWithMentions=${mentionEntries.length} customerIdsFound=${mentionedL2Only.size} ` +
-            `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${sortedMissingMentioned.length + sortedMissingFamily.length} ` +
+            `linkedRequirements=${linkedFullCodes.size} mentionedButNotLinked=${
+              sortedMissingSpecificMentionedNoFamily.length +
+              sortedMissingBaseWhenFamilyUncovered.length +
+              sortedMissingFamilyMembers.length
+            } ` +
             `linkedButNotMentioned=${sortedExtraLinked.length} status=${validationStatus} ` +
             `customerIdSample='${[...mentionedL2Only].slice(0, 5).join(', ')}'`
         );
@@ -2700,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,226 @@ 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 }]);
+      jest.spyOn(resultDataProvider as any, '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 as any, '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 as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([[401, { baseKeys: new Set<string>(), fullCodes: new Set<string>() }]])
+      );
+      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': 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 as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
@@ -2325,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',
         })
@@ -2662,6 +2882,115 @@ describe('ResultDataProvider', () => {
     });
   });
 
+  describe('buildLinkedRequirementsByTestCase', () => {
+    it('should map linked requirements only for supported test-case requirement relation types', async () => {
+      const requirements = [
+        {
+          workItemId: 7001,
+          requirementId: 'SR0054-1',
+          baseKey: 'SR0054',
+          linkedTestCaseIds: [],
+        },
+      ];
+      const testData = [
+        {
+          testCasesItems: [{ workItem: { id: 1001 } }],
+          testPointsItems: [],
+        },
+      ];
+
+      const fetchByIdsSpy = jest
+        .spyOn(resultDataProvider as any, 'fetchWorkItemsByIds')
+        .mockImplementation(async (...args: any[]) => {
+          const ids = Array.isArray(args?.[1]) ? args[1] : [];
+          const includeRelations = !!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 as any).buildLinkedRequirementsByTestCase(
+        requirements,
+        testData,
+        mockProjectName
+      );
+
+      expect(fetchByIdsSpy).toHaveBeenCalled();
+      expect(linked.get(1001)?.baseKeys?.has('SR0054')).toBe(true);
+      expect(linked.get(1001)?.fullCodes?.has('SR0054-1')).toBe(true);
+    });
+
+    it('should ignore unsupported relation types when linking test case to requirements', async () => {
+      const requirements = [
+        {
+          workItemId: 7002,
+          requirementId: 'SR0099-1',
+          baseKey: 'SR0099',
+          linkedTestCaseIds: [],
+        },
+      ];
+      const testData = [
+        {
+          testCasesItems: [{ workItem: { id: 1002 } }],
+          testPointsItems: [],
+        },
+      ];
+
+      jest.spyOn(resultDataProvider as any, 'fetchWorkItemsByIds').mockImplementation(async (...args: any[]) => {
+        const ids = Array.isArray(args?.[1]) ? args[1] : [];
+        const includeRelations = !!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 as any).buildLinkedRequirementsByTestCase(
+        requirements,
+        testData,
+        mockProjectName
+      );
+
+      expect(linked.get(1002)?.baseKeys?.has('SR0099')).toBe(false);
+      expect(linked.get(1002)?.fullCodes?.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 = [