@elisra-devops/docgen-data-provider 1.83.0 → 1.85.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', () => {
@@ -2439,6 +2586,80 @@ describe('ResultDataProvider', () => {
       expect(String(result.rows[0]['Mentioned but Not Linked'] || '')).not.toContain('VVRM');
       expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).not.toContain('VVRM');
     });
+
+    it('should fallback to work-item fields for steps XML when suite payload has no workItemFields', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+      jest.spyOn(resultDataProvider as any, 'fetchMewpScopedTestData').mockResolvedValueOnce([
+        {
+          testPointsItems: [{ testCaseId: 501, testCaseName: 'TC 501' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 501,
+                workItemFields: [],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 9001,
+          requirementId: 'SR0501',
+          baseKey: 'SR0501',
+          title: 'Req 501',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [501],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            501,
+            {
+              baseKeys: new Set(['SR0501']),
+              fullCodes: new Set(['SR0501']),
+            },
+          ],
+        ])
+      );
+      jest.spyOn(resultDataProvider as any, 'fetchWorkItemsByIds').mockResolvedValueOnce([
+        {
+          id: 501,
+          fields: {
+            'Microsoft.VSTS.TCM.Steps':
+              '<steps><step id="2" type="ActionStep"><parameterizedString isformatted="true">Action</parameterizedString><parameterizedString isformatted="true">SR0501</parameterizedString></step></steps>',
+          },
+        },
+      ]);
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: 'Action',
+          expected: 'SR0501',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect((resultDataProvider as any).fetchWorkItemsByIds).toHaveBeenCalled();
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          'Test Case ID': 501,
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+    });
   });
 
   describe('MEWP rel fallback scoping', () => {
@@ -2661,6 +2882,39 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should resolve external bug responsibility from AreaPath columns when SAPWBS is empty', async () => {
+      const mewpExternalTableUtils = (resultDataProvider as any).mewpExternalTableUtils;
+      jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+        {
+          Elisra_SortIndex: '101',
+          SR: 'SR0001',
+          TargetWorkItemId: '9011',
+          Title: 'Bug from ATP\\ESUK path',
+          TargetState: 'Active',
+          SAPWBS: '',
+          AreaPath: 'MEWP\\Customer Requirements\\Level 2\\ATP\\ESUK',
+        },
+        {
+          Elisra_SortIndex: '102',
+          SR: 'SR0002',
+          TargetWorkItemId: '9012',
+          Title: 'Bug from ATP path',
+          TargetState: 'Active',
+          SAPWBS: '',
+          'System.AreaPath': 'MEWP\\Customer Requirements\\Level 2\\ATP',
+        },
+      ]);
+
+      const map = await (resultDataProvider as any).loadExternalBugsByTestCase(validBugsSource);
+      const bugs101 = map.get(101) || [];
+      const bugs102 = map.get(102) || [];
+
+      expect(bugs101).toHaveLength(1);
+      expect(bugs102).toHaveLength(1);
+      expect(bugs101[0].responsibility).toBe('ESUK');
+      expect(bugs102[0].responsibility).toBe('Elisra');
+    });
+
     it('should require Elisra_SortIndex and ignore rows that only provide WorkItemId', async () => {
       const mewpExternalTableUtils = (resultDataProvider as any).mewpExternalTableUtils;
       jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([

package/src/utils/mewpExternalIngestionUtils.ts

@@ -99,12 +99,23 @@ export default class MewpExternalIngestionUtils {
           'TargetSapWbs',
         ])
       );
+      const bugAreaPathRaw = adapters.toComparableText(
+        this.externalTableUtils.readExternalCell(row, [
+          'System.AreaPath',
+          'AreaPath',
+          'Area Path',
+          'TargetAreaPath',
+          'Target Area Path',
+          'Links.TargetWorkItem.AreaPath',
+        ])
+      );
 
       const bug: MewpBugLink = {
         id: bugId,
         title: bugTitle,
         responsibility: adapters.resolveBugResponsibility({
           'Custom.SAPWBS': bugResponsibilityRaw,
+          'System.AreaPath': bugAreaPathRaw,
         }),
         requirementBaseKey,
       };