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

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

@@ -1341,6 +1341,81 @@ describe('ResultDataProvider', () => {
       expect(il).toBe('IL');
     });
 
+    it('should derive responsibility from Area Path alias when System.AreaPath is missing', () => {
+      const esuk = (resultDataProvider as any).deriveMewpResponsibility({
+        'Custom.SAPWBS': '',
+        'Area Path': 'MEWP\\Customer Requirements\\Level 2\\ATP\\ESUK',
+      });
+      const il = (resultDataProvider as any).deriveMewpResponsibility({
+        'Custom.SAPWBS': '',
+        'Area Path': 'MEWP\\Customer Requirements\\Level 2\\ATP',
+      });
+
+      expect(esuk).toBe('ESUK');
+      expect(il).toBe('IL');
+    });
+
+    it('should derive test-case responsibility from testCasesItems area-path fields', async () => {
+      const fetchByIdsSpy = jest
+        .spyOn(resultDataProvider as any, 'fetchWorkItemsByIds')
+        .mockResolvedValue([]);
+
+      const map = await (resultDataProvider as any).buildMewpTestCaseResponsibilityMap(
+        [
+          {
+            testCasesItems: [
+              {
+                workItem: {
+                  id: 101,
+                  workItemFields: [{ name: 'Area Path', value: 'MEWP\\Customer Requirements\\Level 2\\ATP' }],
+                },
+              },
+              {
+                workItem: {
+                  id: 102,
+                  workItemFields: [
+                    { referenceName: 'System.AreaPath', value: 'MEWP\\Customer Requirements\\Level 2\\ATP\\ESUK' },
+                  ],
+                },
+              },
+            ],
+            testPointsItems: [],
+          },
+        ],
+        mockProjectName
+      );
+
+      expect(map.get(101)).toBe('IL');
+      expect(map.get(102)).toBe('ESUK');
+      expect(fetchByIdsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should derive test-case responsibility from AreaPath even when SAPWBS exists on test-case payload', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchWorkItemsByIds').mockResolvedValue([]);
+
+      const map = await (resultDataProvider as any).buildMewpTestCaseResponsibilityMap(
+        [
+          {
+            testCasesItems: [
+              {
+                workItem: {
+                  id: 201,
+                  workItemFields: [
+                    { referenceName: 'Custom.SAPWBS', value: 'ESUK' },
+                    { referenceName: 'System.AreaPath', value: 'MEWP\\Customer Requirements\\Level 2\\ATP' },
+                  ],
+                },
+              },
+            ],
+            testPointsItems: [],
+          },
+        ],
+        mockProjectName
+      );
+
+      expect(map.get(201)).toBe('IL');
+    });
+
     it('should zip bug rows with L3/L4 pairs and avoid cross-product duplication', () => {
       const requirements = [
         {
@@ -1628,6 +1703,78 @@ describe('ResultDataProvider', () => {
       expect(rows[0]['Bug ID']).toBe(99001);
       expect(rows[0]['Bug Responsibility']).toBe('Elisra');
     });
+
+    it('should fallback bug responsibility from test case mapping when external bug row is unknown', () => {
+      const requirements = [
+        {
+          requirementId: 'SR5310',
+          baseKey: 'SR5310',
+          title: 'Req 5310',
+          subSystem: 'Power',
+          responsibility: '',
+          linkedTestCaseIds: [101],
+        },
+      ];
+
+      const requirementIndex = new Map([
+        [
+          'SR5310',
+          new Map([
+            [
+              101,
+              {
+                passed: 0,
+                failed: 1,
+                notRun: 0,
+              },
+            ],
+          ]),
+        ],
+      ]);
+
+      const observedTestCaseIdsByRequirement = new Map<string, Set<number>>([
+        ['SR5310', new Set([101])],
+      ]);
+
+      const linkedRequirementsByTestCase = new Map([
+        [
+          101,
+          {
+            baseKeys: new Set(['SR5310']),
+            fullCodes: new Set(['SR5310']),
+            bugIds: new Set([10003]),
+          },
+        ],
+      ]);
+
+      const externalBugsByTestCase = new Map([
+        [
+          101,
+          [
+            {
+              id: 10003,
+              title: 'Bug 10003',
+              responsibility: 'Unknown',
+              requirementBaseKey: 'SR5310',
+            },
+          ],
+        ],
+      ]);
+
+      const rows = (resultDataProvider as any).buildMewpCoverageRows(
+        requirements,
+        requirementIndex,
+        observedTestCaseIdsByRequirement,
+        linkedRequirementsByTestCase,
+        new Map(),
+        externalBugsByTestCase,
+        new Map(),
+        new Map([[101, 'IL']])
+      );
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0]['Bug Responsibility']).toBe('Elisra');
+    });
   });
 
   describe('getMewpInternalValidationFlatResults', () => {
@@ -1839,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 }]);
@@ -2515,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 = [