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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisra-devops/docgen-data-provider",
-  "version": "1.85.0",
+  "version": "1.86.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,48 @@ 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);
+          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);
+              }
+            }
+            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 +921,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);
@@ -941,7 +972,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(', ')}'`
         );

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

@@ -1986,6 +1986,74 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    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 }]);
@@ -2662,6 +2730,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 = [