@elisra-devops/docgen-data-provider 1.101.0 → 1.103.0

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

@@ -1126,6 +1126,62 @@ describe('ResultDataProvider', () => {
   });
 
   describe('getMewpL2CoverageFlatResults', () => {
+    it('should split SR prefix into SR # + L2 REQ Title while preserving full title', () => {
+      const row = (resultDataProvider as any).createMewpCoverageRow(
+        {
+          workItemId: 5054,
+          requirementId: 'SR0054',
+          title: 'SR0054 - Engine startup coverage',
+          owner: 'ESUK',
+          subSystem: 'Propulsion',
+          responsibility: 'ESUK',
+        },
+        'Pass',
+        { id: '', title: '', responsibility: '' },
+        { l3Id: '', l3Title: '', l4Id: '', l4Title: '' }
+      );
+
+      expect(row).toEqual(
+        expect.objectContaining({
+          'L2 REQ ID': '5054',
+          'SR #': 'SR0054',
+          'L2 REQ Title': 'Engine startup coverage',
+          'L2 REQ Full Title': 'SR0054 - Engine startup coverage',
+          'L2 Owner': 'ESUK',
+          'L2 SubSystem': 'Propulsion',
+        })
+      );
+    });
+
+    it('should keep full title when title is only the SR token', () => {
+      const row = (resultDataProvider as any).createMewpCoverageRow(
+        {
+          workItemId: 9999,
+          requirementId: 'SR9999',
+          title: 'SR9999',
+          owner: 'IL',
+          subSystem: '',
+          responsibility: 'IL',
+        },
+        'Not Run',
+        { id: '', title: '', responsibility: '' },
+        { l3Id: '', l3Title: '', l4Id: '', l4Title: '' }
+      );
+
+      expect(row['L2 REQ Title']).toBe('SR9999');
+      expect(row['L2 REQ Full Title']).toBe('SR9999');
+      expect(row['L2 Owner']).toBe('IL');
+    });
+
+    it('should resolve L2 run status precedence: Fail > Not Run > Pass', () => {
+      const resolve = (resultDataProvider as any).resolveMewpL2RunStatus.bind(resultDataProvider as any);
+
+      expect(resolve({ passed: 2, failed: 1, notRun: 3, hasAnyTestCase: true })).toBe('Fail');
+      expect(resolve({ passed: 5, failed: 0, notRun: 1, hasAnyTestCase: true })).toBe('Not Run');
+      expect(resolve({ passed: 1, failed: 0, notRun: 0, hasAnyTestCase: true })).toBe('Pass');
+      expect(resolve({ passed: 0, failed: 0, notRun: 0, hasAnyTestCase: true })).toBe('Not Run');
+    });
+
     it('should fetch MEWP scoped test data from selected suites', async () => {
       jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       const scopedSpy = jest
@@ -1234,7 +1290,7 @@ describe('ResultDataProvider', () => {
       expect(result).toEqual(
         expect.objectContaining({
           sheetName: expect.stringContaining('MEWP L2 Coverage'),
-          columnOrder: expect.arrayContaining(['L2 REQ ID', 'L2 REQ Title', 'L2 Run Status']),
+          columnOrder: expect.arrayContaining(['L2 REQ ID', 'SR #', 'L2 REQ Title', 'L2 Owner', 'L2 Run Status']),
         })
       );
 
@@ -1980,6 +2036,338 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should parse requirement mentions only from the assumptions section in test-case description', 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: 121, testCaseName: 'TC 121' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 121,
+                workItemFields: [
+                  { key: 'Steps', value: '<steps></steps>' },
+                  {
+                    key: 'System.Description',
+                    value: `
+                      <p>Some intro text</p>
+                      <b><u>Trial specific assumptions, constraints, dependencies and requirements</u></b>
+                      <p>- VVRM-1 &amp; SR0100 - some text 1</p>
+                      <p>- VVRM-3 &amp; SR0588 - some text 2</p>
+                      <p>- SR1234, SR5678, SR1212</p>
+                      <p>some other text</p>
+                      <u><b>another title</b></u>
+                      <p>SR2242</p>
+                    `,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 8100,
+          requirementId: 'SR0100',
+          baseKey: 'SR0100',
+          title: 'Req 100',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 8588,
+          requirementId: 'SR0588',
+          baseKey: 'SR0588',
+          title: 'Req 588',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 91234,
+          requirementId: 'SR1234',
+          baseKey: 'SR1234',
+          title: 'Req 1234',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 95678,
+          requirementId: 'SR5678',
+          baseKey: 'SR5678',
+          title: 'Req 5678',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 91212,
+          requirementId: 'SR1212',
+          baseKey: 'SR1212',
+          title: 'Req 1212',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 92242,
+          requirementId: 'SR2242',
+          baseKey: 'SR2242',
+          title: 'Req 2242',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest
+        .spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase')
+        .mockResolvedValueOnce(new Map([[121, { baseKeys: new Set<string>(), fullCodes: new Set<string>() }]]));
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: '',
+          expected: '',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect(result.rows).toHaveLength(1);
+      const directionA = String(result.rows[0]['Mentioned but Not Linked'] || '');
+      expect(directionA).toContain('Assumptions:');
+      expect(directionA).toContain('SR0100');
+      expect(directionA).toContain('SR0588');
+      expect(directionA).toContain('SR1234');
+      expect(directionA).toContain('SR5678');
+      expect(directionA).toContain('SR1212');
+      expect(directionA).not.toContain('SR2242');
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          'Validation Status': 'Fail',
+        })
+      );
+    });
+
+    it('should detect assumptions heading case-insensitively in description', 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: 122, testCaseName: 'TC 122' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 122,
+                workItemFields: [
+                  { key: 'Steps', value: '<steps></steps>' },
+                  {
+                    key: 'System.Description',
+                    value: `
+                      <p>Intro</p>
+                      <b><u>TRIAL SPECIFIC ASSUMPTIONS, constraints</u></b>
+                      <p>- SR0501</p>
+                    `,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 8501,
+          requirementId: 'SR0501',
+          baseKey: 'SR0501',
+          title: 'Req 501',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            122,
+            {
+              baseKeys: new Set(['SR0501']),
+              fullCodes: new Set(['SR0501']),
+            },
+          ],
+        ])
+      );
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: '',
+          expected: '',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+    });
+
+    it('should treat compact <u><b>...</b></u> titles as section boundaries in description parsing', 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: 123, testCaseName: 'TC 123' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 123,
+                workItemFields: [
+                  { key: 'Steps', value: '<steps></steps>' },
+                  {
+                    key: 'System.Description',
+                    value:
+                      '<b><u>Trial specific assumptions, constraints, dependencies and requirements</u></b><p>SR0100</p><u><b>another title</b></u><p>SR2242</p>',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 8100,
+          requirementId: 'SR0100',
+          baseKey: 'SR0100',
+          title: 'Req 100',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 82242,
+          requirementId: 'SR2242',
+          baseKey: 'SR2242',
+          title: 'Req 2242',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest
+        .spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase')
+        .mockResolvedValueOnce(new Map([[123, { baseKeys: new Set<string>(), fullCodes: new Set<string>() }]]));
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: '',
+          expected: '',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect(result.rows).toHaveLength(1);
+      const directionA = String(result.rows[0]['Mentioned but Not Linked'] || '');
+      expect(directionA).toContain('Assumptions: SR0100');
+      expect(directionA).not.toContain('SR2242');
+    });
+
+    it('should treat nested <u> titles as section boundaries in description parsing', 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: 124, testCaseName: 'TC 124' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 124,
+                workItemFields: [
+                  { key: 'Steps', value: '<steps></steps>' },
+                  {
+                    key: 'System.Description',
+                    value:
+                      '<u>Trial specific assumptions, constraints, dependencies and requirements</u><p>SR0100</p><u><u>Nested title</u></u><p>SR2242</p>',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 9100,
+          requirementId: 'SR0100',
+          baseKey: 'SR0100',
+          title: 'Req 100',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+        {
+          workItemId: 92242,
+          requirementId: 'SR2242',
+          baseKey: 'SR2242',
+          title: 'Req 2242',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest
+        .spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase')
+        .mockResolvedValueOnce(new Map([[124, { baseKeys: new Set<string>(), fullCodes: new Set<string>() }]]));
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+        {
+          stepId: '1',
+          stepPosition: '1',
+          action: '',
+          expected: '',
+          isSharedStepTitle: false,
+        },
+      ]);
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect(result.rows).toHaveLength(1);
+      const directionA = String(result.rows[0]['Mentioned but Not Linked'] || '');
+      expect(directionA).toContain('Assumptions: SR0100');
+      expect(directionA).not.toContain('SR2242');
+    });
+
     it('should emit Direction A rows only for specifically mentioned child requirements', async () => {
       jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);