@elisra-devops/docgen-data-provider 1.81.0 → 1.83.0

package/package.json

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

package/src/models/mewp-reporting.ts

@@ -16,7 +16,6 @@ export interface MewpCoverageRequestOptions {
   useRelFallback?: boolean;
   externalBugsFile?: MewpExternalFileRef | null;
   externalL3L4File?: MewpExternalFileRef | null;
-  mergeDuplicateL2Cells?: boolean;
 }
 
 export interface MewpInternalValidationRequestOptions {

package/src/modules/ResultDataProvider.ts

@@ -864,7 +864,13 @@ export default class ResultDataProvider {
           return !linkedBaseKeys.has(baseKey);
         });
         const missingFamily = [...expectedFamilyCodes].filter((code) => !linkedFullCodes.has(code));
-        const extraLinked = [...linkedFullCodes].filter((code) => !expectedFamilyCodes.has(code));
+        // 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) => {
+          const baseKey = this.toRequirementKey(code);
+          if (!baseKey) return false;
+          return !mentionedBaseKeys.has(baseKey);
+        });
         const mentionedButNotLinkedByStep = new Map<string, Set<string>>();
         const appendMentionedButNotLinked = (requirementId: string, stepRef: string) => {
           const normalizedRequirementId = this.normalizeMewpRequirementCodeWithSuffix(requirementId);
@@ -1113,8 +1119,20 @@ export default class ResultDataProvider {
         l4Title: existing.l4Title || l4Title,
       });
     }
+    const normalizedPairs = [...deduped.values()];
+    const l3KeysWithAnyL4 = new Set(
+      normalizedPairs
+        .filter((item) => !!String(item?.l3Id || '').trim() && !!String(item?.l4Id || '').trim())
+        .map((item) => String(item?.l3Id || '').trim().toLowerCase())
+    );
+    const filtered = normalizedPairs.filter((item) => {
+      const l3Id = String(item?.l3Id || '').trim();
+      const l4Id = String(item?.l4Id || '').trim();
+      if (!l3Id || !!l4Id) return true;
+      return !l3KeysWithAnyL4.has(l3Id.toLowerCase());
+    });
 
-    return [...deduped.values()].sort((a, b) => {
+    return filtered.sort((a, b) => {
       const l3Compare = String(a?.l3Id || '').localeCompare(String(b?.l3Id || ''));
       if (l3Compare !== 0) return l3Compare;
       return String(a?.l4Id || '').localeCompare(String(b?.l4Id || ''));

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

@@ -1428,6 +1428,84 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should drop standalone L3 row when same L3 has one or more L4 links', () => {
+      const requirements = [
+        {
+          requirementId: 'SR5310',
+          baseKey: 'SR5310',
+          title: 'Req 5310',
+          subSystem: 'Power',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [111],
+        },
+      ];
+
+      const requirementIndex = new Map([
+        [
+          'SR5310',
+          new Map([
+            [
+              111,
+              {
+                passed: 1,
+                failed: 0,
+                notRun: 0,
+              },
+            ],
+          ]),
+        ],
+      ]);
+
+      const observedTestCaseIdsByRequirement = new Map<string, Set<number>>([
+        ['SR5310', new Set([111])],
+      ]);
+
+      const linkedRequirementsByTestCase = new Map([
+        [
+          111,
+          {
+            baseKeys: new Set(['SR5310']),
+            fullCodes: new Set(['SR5310']),
+            bugIds: new Set(),
+          },
+        ],
+      ]);
+
+      const l3l4ByBaseKey = new Map([
+        [
+          'SR5310',
+          [
+            { l3Id: '9003', l3Title: 'L3 9003', l4Id: '', l4Title: '' },
+            { l3Id: '9003', l3Title: 'L3 9003', l4Id: '9103', l4Title: 'L4 9103' },
+            { l3Id: '9003', l3Title: 'L3 9003', l4Id: '9104', l4Title: 'L4 9104' },
+          ],
+        ],
+      ]);
+
+      const rows = (resultDataProvider as any).buildMewpCoverageRows(
+        requirements,
+        requirementIndex,
+        observedTestCaseIdsByRequirement,
+        linkedRequirementsByTestCase,
+        l3l4ByBaseKey,
+        new Map()
+      );
+
+      expect(rows).toHaveLength(2);
+      expect(rows[0]).toEqual(
+        expect.objectContaining({
+          'L3 REQ ID': '9003',
+          'L4 REQ ID': '9103',
+        })
+      );
+      expect(rows[1]).toEqual(
+        expect.objectContaining({
+          'L3 REQ ID': '9003',
+          'L4 REQ ID': '9104',
+        })
+      );
+    });
+
     it('should not emit bug rows from ADO-linked bug ids when external bugs source is empty', () => {
       const requirements = [
         {
@@ -1825,6 +1903,69 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should not flag linked child as Direction B when parent family is mentioned in Expected Result', 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: 301, testCaseName: 'TC 301' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 301,
+                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 7001,
+          requirementId: 'SR0054',
+          baseKey: 'SR0054',
+          title: 'Parent 0054',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            301,
+            {
+              baseKeys: new Set(['SR0054']),
+              fullCodes: new Set(['SR0054-1']),
+            },
+          ],
+        ])
+      );
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: '',
+          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': 301,
+          'Linked but Not Mentioned': '',
+        })
+      );
+    });
+
     it('should produce one detailed row per test case with correct bidirectional discrepancies', async () => {
       const mockDetailedStepsByTestCase = new Map<number, any[]>([
         [