@elisra-devops/docgen-data-provider 1.74.0 → 1.76.0

package/bin/tests/modules/ResultDataProvider.test.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tfs_1 = require("../../helpers/tfs");
 const ResultDataProvider_1 = require("../../modules/ResultDataProvider");
 const logger_1 = require("../../utils/logger");
+const axios_1 = require("axios");
+const XLSX = require("xlsx");
 // Mock dependencies
 jest.mock('../../helpers/tfs');
 jest.mock('../../utils/logger');
@@ -22,6 +24,12 @@ describe('ResultDataProvider', () => {
     const mockToken = 'mock-token';
     const mockProjectName = 'test-project';
     const mockTestPlanId = '12345';
+    const buildWorkbookBuffer = (rows) => {
+        const worksheet = XLSX.utils.aoa_to_sheet(rows);
+        const workbook = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(workbook, worksheet, 'Sheet1');
+        return XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
+    };
     beforeEach(() => {
         jest.clearAllMocks();
         resultDataProvider = new ResultDataProvider_1.default(mockOrgUrl, mockToken);
@@ -857,85 +865,6 @@ describe('ResultDataProvider', () => {
         });
     });
     describe('getMewpL2CoverageFlatResults', () => {
-        it('should support query-mode requirement scope for MEWP coverage', async () => {
-            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
-            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
-            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
-                {
-                    testPointsItems: [{ testCaseId: 101, lastRunId: 10, lastResultId: 20, testCaseName: 'TC 101' }],
-                    testCasesItems: [
-                        {
-                            workItem: {
-                                id: 101,
-                                workItemFields: [{ key: 'System.Title', value: 'TC 101' }],
-                            },
-                        },
-                    ],
-                },
-            ]);
-            jest.spyOn(resultDataProvider, 'fetchMewpRequirementTypeNames').mockResolvedValueOnce([
-                'Requirement',
-            ]);
-            jest.spyOn(resultDataProvider, 'fetchWorkItemsByIds').mockResolvedValueOnce([
-                {
-                    id: 9001,
-                    fields: {
-                        'System.WorkItemType': 'Requirement',
-                        'System.Title': 'Requirement from query',
-                        'Custom.CustomerId': 'SR3001',
-                        'System.AreaPath': 'MEWP\\IL',
-                    },
-                    relations: [
-                        {
-                            rel: 'Microsoft.VSTS.Common.TestedBy-Forward',
-                            url: 'https://dev.azure.com/org/_apis/wit/workItems/101',
-                        },
-                    ],
-                },
-            ]);
-            jest.spyOn(resultDataProvider, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([
-                {
-                    testCaseId: 101,
-                    testCase: { id: 101, name: 'TC 101' },
-                    iteration: {
-                        actionResults: [{ action: 'Validate SR3001', expected: '', outcome: 'Passed' }],
-                    },
-                },
-            ]);
-            const TicketsProviderMock = require('../../modules/TicketsDataProvider').default;
-            TicketsProviderMock.mockImplementationOnce(() => ({
-                GetQueryResultsFromWiql: jest.fn().mockResolvedValue({
-                    fetchedWorkItems: [
-                        {
-                            id: 9001,
-                            fields: {
-                                'System.WorkItemType': 'Requirement',
-                                'System.Title': 'Requirement from query',
-                                'Custom.CustomerId': 'SR3001',
-                                'System.AreaPath': 'MEWP\\IL',
-                            },
-                        },
-                    ],
-                }),
-            }));
-            const result = await resultDataProvider.getMewpL2CoverageFlatResults('123', mockProjectName, [1], {
-                linkedQueryMode: 'query',
-                testAssociatedQuery: { wiql: { href: 'https://example.com/wiql' } },
-            });
-            const row = result.rows.find((item) => item['Customer ID'] === 'SR3001');
-            expect(row).toEqual(expect.objectContaining({
-                'Title (Customer name)': 'Requirement from query',
-                'Responsibility - SAPWBS (ESUK/IL)': 'IL',
-                'Test case id': 101,
-                'Test case title': 'TC 101',
-                'Number of passed steps': 1,
-                'Number of failed steps': 0,
-                'Number of not run tests': 0,
-            }));
-            expect(TicketsProviderMock).toHaveBeenCalled();
-            const instance = TicketsProviderMock.mock.results[0].value;
-            expect(instance.GetQueryResultsFromWiql).toHaveBeenCalledWith('https://example.com/wiql', true, expect.any(Map));
-        });
         it('should map SR ids from steps and output requirement-test-case coverage rows', async () => {
             jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
             jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
@@ -959,6 +888,8 @@ describe('ResultDataProvider', () => {
                 {
                     workItemId: 5001,
                     requirementId: 'SR1001',
+                    baseKey: 'SR1001',
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
                     title: 'Covered requirement',
                     responsibility: 'ESUK',
                     linkedTestCaseIds: [101],
@@ -966,6 +897,8 @@ describe('ResultDataProvider', () => {
                 {
                     workItemId: 5002,
                     requirementId: 'SR1002',
+                    baseKey: 'SR1002',
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
                     title: 'Referenced from non-linked step text',
                     responsibility: 'IL',
                     linkedTestCaseIds: [],
@@ -973,6 +906,8 @@ describe('ResultDataProvider', () => {
                 {
                     workItemId: 5003,
                     requirementId: 'SR1003',
+                    baseKey: 'SR1003',
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
                     title: 'Not covered by any test case',
                     responsibility: 'IL',
                     linkedTestCaseIds: [],
@@ -986,11 +921,11 @@ describe('ResultDataProvider', () => {
                         actionResults: [
                             {
                                 action: 'Validate <b>S</b><b>R</b> 1 0 0 1 happy path',
-                                expected: '',
+                                expected: '<b>S</b><b>R</b> 1 0 0 1',
                                 outcome: 'Passed',
                             },
-                            { action: 'Validate SR1001 failed flow', expected: '&nbsp;', outcome: 'Failed' },
-                            { action: '', expected: 'Pending S R 1 0 0 1 scenario', outcome: 'Unspecified' },
+                            { action: 'Validate SR1001 failed flow', expected: 'SR1001', outcome: 'Failed' },
+                            { action: '', expected: 'S R 1 0 0 1', outcome: 'Unspecified' },
                         ],
                     },
                 },
@@ -1007,48 +942,59 @@ describe('ResultDataProvider', () => {
                     stepId: '1',
                     stepPosition: '1',
                     action: 'Definition contains SR1002',
-                    expected: '',
+                    expected: 'SR1002',
                     isSharedStepTitle: false,
                 },
             ]);
             const result = await resultDataProvider.getMewpL2CoverageFlatResults('123', mockProjectName, [1]);
             expect(result).toEqual(expect.objectContaining({
                 sheetName: expect.stringContaining('MEWP L2 Coverage'),
-                columnOrder: expect.arrayContaining(['Customer ID', 'Test case id', 'Number of not run tests']),
+                columnOrder: expect.arrayContaining(['L2 REQ ID', 'L2 REQ Title', 'L2 Run Status']),
             }));
-            const covered = result.rows.find((row) => row['Customer ID'] === 'SR1001' && row['Test case id'] === 101);
-            const inferredByStepText = result.rows.find((row) => row['Customer ID'] === 'SR1002' && row['Test case id'] === 102);
-            const uncovered = result.rows.find((row) => row['Customer ID'] === 'SR1003' &&
-                (row['Test case id'] === '' || row['Test case id'] === undefined || row['Test case id'] === null));
+            const covered = result.rows.find((row) => row['L2 REQ ID'] === 'SR1001');
+            const inferredByStepText = result.rows.find((row) => row['L2 REQ ID'] === 'SR1002');
+            const uncovered = result.rows.find((row) => row['L2 REQ ID'] === 'SR1003');
             expect(covered).toEqual(expect.objectContaining({
-                'Title (Customer name)': 'Covered requirement',
-                'Responsibility - SAPWBS (ESUK/IL)': 'ESUK',
-                'Test case title': 'TC 101',
-                'Number of passed steps': 1,
-                'Number of failed steps': 1,
-                'Number of not run tests': 1,
+                'L2 REQ Title': 'Covered requirement',
+                'L2 SubSystem': '',
+                'L2 Run Status': 'Fail',
+                'Bug ID': '',
+                'L3 REQ ID': '',
+                'L4 REQ ID': '',
             }));
             expect(inferredByStepText).toEqual(expect.objectContaining({
-                'Title (Customer name)': 'Referenced from non-linked step text',
-                'Responsibility - SAPWBS (ESUK/IL)': 'IL',
-                'Test case title': 'TC 102',
-                'Number of passed steps': 0,
-                'Number of failed steps': 0,
-                'Number of not run tests': 1,
+                'L2 REQ Title': 'Referenced from non-linked step text',
+                'L2 SubSystem': '',
+                'L2 Run Status': 'Not Run',
             }));
             expect(uncovered).toEqual(expect.objectContaining({
-                'Title (Customer name)': 'Not covered by any test case',
-                'Responsibility - SAPWBS (ESUK/IL)': 'IL',
-                'Test case title': '',
-                'Number of passed steps': 0,
-                'Number of failed steps': 0,
-                'Number of not run tests': 0,
+                'L2 REQ Title': 'Not covered by any test case',
+                'L2 SubSystem': '',
+                'L2 Run Status': 'Not Run',
             }));
         });
         it('should extract SR ids from HTML/spacing and return unique ids per step text', () => {
-            const text = 'A: <b>S</b><b>R</b> 0 0 0 1; B: SR0002; C: S R 0 0 0 3; D: SR0002; E: &lt;b&gt;SR&lt;/b&gt;0004';
+            const text = '<b>S</b><b>R</b> 0 0 0 1; SR0002; S R 0 0 0 3; SR0002; &lt;b&gt;SR&lt;/b&gt;0004';
             const codes = resultDataProvider.extractRequirementCodesFromText(text);
-            expect([...codes].sort()).toEqual(['SR1', 'SR2', 'SR3', 'SR4']);
+            expect([...codes].sort()).toEqual(['SR0001', 'SR0002', 'SR0003', 'SR0004']);
+        });
+        it('should keep only clean SR tokens and ignore noisy version/VVRM fragments', () => {
+            const extract = (text) => [...resultDataProvider.extractRequirementCodesFromText(text)].sort();
+            expect(extract('SR12413; SR24513; SR25135 VVRM2425')).toEqual(['SR12413', 'SR24513']);
+            expect(extract('SR12413; SR12412; SR12413-V3.24')).toEqual(['SR12412', 'SR12413']);
+            expect(extract('SR12413; SR12412; SR12413 V3.24')).toEqual(['SR12412', 'SR12413']);
+            expect(extract('SR12413, SR12412, SR12413-V3.24')).toEqual(['SR12412', 'SR12413']);
+            const extractWithSuffix = (text) => [
+                ...resultDataProvider.extractRequirementCodesFromExpectedText(text, true),
+            ].sort();
+            expect(extractWithSuffix('SR0095-2,3; SR0100-1,2,3,4')).toEqual([
+                'SR0095-2',
+                'SR0095-3',
+                'SR0100-1',
+                'SR0100-2',
+                'SR0100-3',
+                'SR0100-4',
+            ]);
         });
         it('should not backfill definition steps as not-run when a real run exists but has no action results', async () => {
             jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
@@ -1070,6 +1016,8 @@ describe('ResultDataProvider', () => {
                 {
                     workItemId: 7001,
                     requirementId: 'SR2001',
+                    baseKey: 'SR2001',
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
                     title: 'Has run but no actions',
                     responsibility: 'ESUK',
                     linkedTestCaseIds: [101],
@@ -1097,12 +1045,10 @@ describe('ResultDataProvider', () => {
                 },
             ]);
             const result = await resultDataProvider.getMewpL2CoverageFlatResults('123', mockProjectName, [1]);
-            const row = result.rows.find((item) => item['Customer ID'] === 'SR2001' && item['Test case id'] === 101);
+            const row = result.rows.find((item) => item['L2 REQ ID'] === 'SR2001');
             expect(parseSpy).not.toHaveBeenCalled();
             expect(row).toEqual(expect.objectContaining({
-                'Number of passed steps': 0,
-                'Number of failed steps': 0,
-                'Number of not run tests': 0,
+                'L2 Run Status': 'Not Run',
             }));
         });
         it('should not infer requirement id from unrelated SR text in non-identifier fields', () => {
@@ -1111,7 +1057,1241 @@ describe('ResultDataProvider', () => {
                 'Custom.CustomerId': 'customer id unknown',
                 'System.Title': 'Requirement without explicit SR code',
             }, 4321);
-            expect(requirementId).toBe('4321');
+            expect(requirementId).toBe('SR4321');
+        });
+        it('should derive responsibility from Custom.SAPWBS when present', () => {
+            const responsibility = resultDataProvider.deriveMewpResponsibility({
+                'Custom.SAPWBS': 'IL',
+                'System.AreaPath': 'MEWP\\ESUK',
+            });
+            expect(responsibility).toBe('IL');
+        });
+        it('should derive responsibility from AreaPath suffix ATP/ATP\\\\ESUK when SAPWBS is empty', () => {
+            const esuk = resultDataProvider.deriveMewpResponsibility({
+                'Custom.SAPWBS': '',
+                'System.AreaPath': 'MEWP\\Customer Requirements\\Level 2\\ATP\\ESUK',
+            });
+            const il = resultDataProvider.deriveMewpResponsibility({
+                'Custom.SAPWBS': '',
+                'System.AreaPath': 'MEWP\\Customer Requirements\\Level 2\\ATP',
+            });
+            expect(esuk).toBe('ESUK');
+            expect(il).toBe('IL');
+        });
+        it('should emit additive rows for bugs and L3/L4 links without bug duplication', () => {
+            const requirements = [
+                {
+                    requirementId: 'SR5303',
+                    baseKey: 'SR5303',
+                    title: 'Req 5303',
+                    subSystem: 'Power',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [101],
+                },
+            ];
+            const requirementIndex = new Map([
+                [
+                    'SR5303',
+                    new Map([
+                        [
+                            101,
+                            {
+                                passed: 0,
+                                failed: 1,
+                                notRun: 0,
+                            },
+                        ],
+                    ]),
+                ],
+            ]);
+            const observedTestCaseIdsByRequirement = new Map([
+                ['SR5303', new Set([101])],
+            ]);
+            const linkedRequirementsByTestCase = new Map([
+                [
+                    101,
+                    {
+                        baseKeys: new Set(['SR5303']),
+                        fullCodes: new Set(['SR5303']),
+                        bugIds: new Set([10003, 20003]),
+                    },
+                ],
+            ]);
+            const externalBugsByTestCase = new Map([
+                [
+                    101,
+                    [
+                        { id: 10003, title: 'Bug 10003', responsibility: 'Elisra', requirementBaseKey: 'SR5303' },
+                        { id: 20003, title: 'Bug 20003', responsibility: 'ESUK', requirementBaseKey: 'SR5303' },
+                    ],
+                ],
+            ]);
+            const l3l4ByBaseKey = new Map([
+                [
+                    'SR5303',
+                    [
+                        { id: '9003', title: 'L3 9003', level: 'L3' },
+                        { id: '9103', title: 'L4 9103', level: 'L4' },
+                    ],
+                ],
+            ]);
+            const rows = resultDataProvider.buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, l3l4ByBaseKey, externalBugsByTestCase);
+            expect(rows).toHaveLength(4);
+            expect(rows.map((row) => row['Bug ID'])).toEqual([10003, 20003, '', '']);
+            expect(rows[2]).toEqual(expect.objectContaining({
+                'L3 REQ ID': '9003',
+                'L4 REQ ID': '',
+            }));
+            expect(rows[3]).toEqual(expect.objectContaining({
+                'L3 REQ ID': '',
+                'L4 REQ ID': '9103',
+            }));
+        });
+        it('should not emit bug rows from ADO-linked bug ids when external bugs source is empty', () => {
+            const requirements = [
+                {
+                    requirementId: 'SR5304',
+                    baseKey: 'SR5304',
+                    title: 'Req 5304',
+                    subSystem: 'Power',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [101],
+                },
+            ];
+            const requirementIndex = new Map([
+                [
+                    'SR5304',
+                    new Map([
+                        [
+                            101,
+                            {
+                                passed: 0,
+                                failed: 1,
+                                notRun: 0,
+                            },
+                        ],
+                    ]),
+                ],
+            ]);
+            const observedTestCaseIdsByRequirement = new Map([
+                ['SR5304', new Set([101])],
+            ]);
+            const linkedRequirementsByTestCase = new Map([
+                [
+                    101,
+                    {
+                        baseKeys: new Set(['SR5304']),
+                        fullCodes: new Set(['SR5304']),
+                        bugIds: new Set([55555]), // must be ignored in MEWP coverage mode
+                    },
+                ],
+            ]);
+            const rows = resultDataProvider.buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, new Map(), new Map());
+            expect(rows).toHaveLength(1);
+            expect(rows[0]['L2 Run Status']).toBe('Fail');
+            expect(rows[0]['Bug ID']).toBe('');
+            expect(rows[0]['Bug Title']).toBe('');
+            expect(rows[0]['Bug Responsibility']).toBe('');
+        });
+        it('should fallback bug responsibility from requirement when external bug row has unknown responsibility', () => {
+            const requirements = [
+                {
+                    requirementId: 'SR5305',
+                    baseKey: 'SR5305',
+                    title: 'Req 5305',
+                    subSystem: 'Auth',
+                    responsibility: 'IL',
+                    linkedTestCaseIds: [202],
+                },
+            ];
+            const requirementIndex = new Map([
+                [
+                    'SR5305',
+                    new Map([
+                        [
+                            202,
+                            {
+                                passed: 0,
+                                failed: 1,
+                                notRun: 0,
+                            },
+                        ],
+                    ]),
+                ],
+            ]);
+            const observedTestCaseIdsByRequirement = new Map([
+                ['SR5305', new Set([202])],
+            ]);
+            const linkedRequirementsByTestCase = new Map([
+                [
+                    202,
+                    {
+                        baseKeys: new Set(['SR5305']),
+                        fullCodes: new Set(['SR5305']),
+                        bugIds: new Set(),
+                    },
+                ],
+            ]);
+            const externalBugsByTestCase = new Map([
+                [
+                    202,
+                    [
+                        {
+                            id: 99001,
+                            title: 'External bug without SAPWBS',
+                            responsibility: 'Unknown',
+                            requirementBaseKey: 'SR5305',
+                        },
+                    ],
+                ],
+            ]);
+            const rows = resultDataProvider.buildMewpCoverageRows(requirements, requirementIndex, observedTestCaseIdsByRequirement, linkedRequirementsByTestCase, new Map(), externalBugsByTestCase);
+            expect(rows).toHaveLength(1);
+            expect(rows[0]['Bug ID']).toBe(99001);
+            expect(rows[0]['Bug Responsibility']).toBe('Elisra');
+        });
+    });
+    describe('getMewpInternalValidationFlatResults', () => {
+        it('should skip test cases with no in-scope expected requirements and no linked requirements', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [
+                        { testCaseId: 101, testCaseName: 'TC 101' },
+                        { testCaseId: 102, testCaseName: 'TC 102' },
+                    ],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 101,
+                                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+                            },
+                        },
+                        {
+                            workItem: {
+                                id: 102,
+                                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 5001,
+                    requirementId: 'SR0001',
+                    baseKey: 'SR0001',
+                    title: 'Req 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [101],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(new Map([[101, { baseKeys: new Set(['SR0001']), fullCodes: new Set(['SR0001']) }]]));
+            jest
+                .spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps')
+                .mockResolvedValueOnce([
+                {
+                    stepId: '1',
+                    stepPosition: '1',
+                    action: '',
+                    expected: 'SR0001',
+                    isSharedStepTitle: false,
+                },
+            ])
+                .mockResolvedValueOnce([
+                {
+                    stepId: '1',
+                    stepPosition: '1',
+                    action: '',
+                    expected: '',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(2);
+            expect(result.rows).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    'Test Case ID': 101,
+                    'Validation Status': 'Pass',
+                    'Mentioned but Not Linked': '',
+                    'Linked but Not Mentioned': '',
+                }),
+                expect.objectContaining({
+                    'Test Case ID': 102,
+                    'Validation Status': 'Pass',
+                    'Mentioned but Not Linked': '',
+                    'Linked but Not Mentioned': '',
+                }),
+            ]));
+        });
+        it('should ignore non-L2 SR mentions and still report only real L2 discrepancies', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 101, testCaseName: 'TC 101' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 101,
+                                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 5001,
+                    requirementId: 'SR0001',
+                    baseKey: 'SR0001',
+                    title: 'Req 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [101],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(new Map());
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '1',
+                    stepPosition: '1',
+                    action: '',
+                    expected: 'SR0001; SR9999',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(1);
+            expect(result.rows[0]).toEqual(expect.objectContaining({
+                'Test Case ID': 101,
+                'Mentioned but Not Linked': 'Step 1: SR0001',
+                'Linked but Not Mentioned': '',
+                'Validation Status': 'Fail',
+            }));
+        });
+        it('should emit Direction A rows with step context for missing sibling links', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 101, testCaseName: 'TC 101' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 101,
+                                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 5001,
+                    requirementId: 'SR0001',
+                    baseKey: 'SR0001',
+                    title: 'Req parent',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [101],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 5002,
+                    requirementId: 'SR0001-1',
+                    baseKey: 'SR0001',
+                    title: 'Req child',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(new Map([[101, { baseKeys: new Set(['SR0001']), fullCodes: new Set(['SR0001']) }]]));
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '2',
+                    stepPosition: '2',
+                    action: '',
+                    expected: 'SR0001; SR0002',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    'Test Case ID': 101,
+                    'Mentioned but Not Linked': expect.stringContaining('Step 2: SR0001-1'),
+                    'Validation Status': 'Fail',
+                }),
+            ]));
+        });
+        it('should not duplicate Direction A discrepancy when same requirement is repeated in multiple steps', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 101, testCaseName: 'TC 101' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 101,
+                                workItemFields: [{ key: 'Steps', value: '<steps></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 5001,
+                    requirementId: 'SR0001',
+                    baseKey: 'SR0001',
+                    title: 'Req 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest
+                .spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase')
+                .mockResolvedValueOnce(new Map());
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '1',
+                    stepPosition: '1',
+                    action: '',
+                    expected: 'SR0001',
+                    isSharedStepTitle: false,
+                },
+                {
+                    stepId: '2',
+                    stepPosition: '2',
+                    action: '',
+                    expected: 'SR0001',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(1);
+            expect(result.rows[0]).toEqual(expect.objectContaining({
+                'Test Case ID': 101,
+                'Mentioned but Not Linked': 'Step 1: SR0001',
+                'Linked but Not Mentioned': '',
+                'Validation Status': 'Fail',
+            }));
+        });
+        it('should produce one detailed row per test case with correct bidirectional discrepancies', async () => {
+            const mockDetailedStepsByTestCase = new Map([
+                [
+                    201,
+                    [
+                        {
+                            stepId: '1',
+                            stepPosition: '1',
+                            action: 'Validate parent SR0511 and SR0095 siblings',
+                            expected: '<b>sr0511</b>; SR0095-2,3; VVRM-05',
+                            isSharedStepTitle: false,
+                        },
+                        {
+                            stepId: '2',
+                            stepPosition: '2',
+                            action: 'Noisy requirement-like token should be ignored',
+                            expected: 'SR0511-V3.24',
+                            isSharedStepTitle: false,
+                        },
+                        {
+                            stepId: '3',
+                            stepPosition: '3',
+                            action: 'Regression note',
+                            expected: 'Verification note only',
+                            isSharedStepTitle: false,
+                        },
+                    ],
+                ],
+                [
+                    202,
+                    [
+                        {
+                            stepId: '1',
+                            stepPosition: '1',
+                            action: 'Linked SR0200 exists but is not cleanly mentioned in expected result',
+                            expected: 'VVRM-22; SR0200 V3.1',
+                            isSharedStepTitle: false,
+                        },
+                        {
+                            stepId: '2',
+                            stepPosition: '2',
+                            action: 'Execution notes',
+                            expected: 'Notes without SR requirement token',
+                            isSharedStepTitle: false,
+                        },
+                    ],
+                ],
+                [
+                    203,
+                    [
+                        {
+                            stepId: '1',
+                            stepPosition: '1',
+                            action: 'Primary requirement validation for SR0100-1',
+                            expected: '<i>SR0100-1</i>',
+                            isSharedStepTitle: false,
+                        },
+                        {
+                            stepId: '3',
+                            stepPosition: '3',
+                            action: 'Repeated mention should not create duplicate mismatch',
+                            expected: 'SR0100-1; SR0100-1',
+                            isSharedStepTitle: false,
+                        },
+                    ],
+                ],
+            ]);
+            const mockLinkedRequirementsByTestCase = new Map([
+                [
+                    201,
+                    {
+                        baseKeys: new Set(['SR0511', 'SR0095', 'SR8888']),
+                        fullCodes: new Set(['SR0511', 'SR0095-2', 'SR8888']),
+                    },
+                ],
+                [
+                    202,
+                    {
+                        baseKeys: new Set(['SR0200']),
+                        fullCodes: new Set(['SR0200']),
+                    },
+                ],
+                [
+                    203,
+                    {
+                        baseKeys: new Set(['SR0100']),
+                        fullCodes: new Set(['SR0100-1']),
+                    },
+                ],
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [
+                        { testCaseId: 201, testCaseName: 'TC 201 - Mixed discrepancies' },
+                        { testCaseId: 202, testCaseName: 'TC 202 - Link only' },
+                        { testCaseId: 203, testCaseName: 'TC 203 - Fully valid' },
+                    ],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 201,
+                                workItemFields: [{ key: 'Steps', value: '<steps id="mock-steps-tc-201"></steps>' }],
+                            },
+                        },
+                        {
+                            workItem: {
+                                id: 202,
+                                workItemFields: [{ key: 'Steps', value: '<steps id="mock-steps-tc-202"></steps>' }],
+                            },
+                        },
+                        {
+                            workItem: {
+                                id: 203,
+                                workItemFields: [{ key: 'Steps', value: '<steps id="mock-steps-tc-203"></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 6001,
+                    requirementId: 'SR0511',
+                    baseKey: 'SR0511',
+                    title: 'Parent 0511',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [201],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 6002,
+                    requirementId: 'SR0511-1',
+                    baseKey: 'SR0511',
+                    title: 'Child 0511-1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+                {
+                    workItemId: 6003,
+                    requirementId: 'SR0511-2',
+                    baseKey: 'SR0511',
+                    title: 'Child 0511-2',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+                {
+                    workItemId: 6004,
+                    requirementId: 'SR0095-2',
+                    baseKey: 'SR0095',
+                    title: 'SR0095 child 2',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+                {
+                    workItemId: 6005,
+                    requirementId: 'SR0095-3',
+                    baseKey: 'SR0095',
+                    title: 'SR0095 child 3',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+                {
+                    workItemId: 6006,
+                    requirementId: 'SR0200',
+                    baseKey: 'SR0200',
+                    title: 'SR0200 standalone',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [202],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 6007,
+                    requirementId: 'SR0100-1',
+                    baseKey: 'SR0100',
+                    title: 'SR0100 child 1',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [203],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+            ]);
+            jest
+                .spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase')
+                .mockResolvedValueOnce(mockLinkedRequirementsByTestCase);
+            jest
+                .spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps')
+                .mockImplementation(async (...args) => {
+                const stepsXml = String((args === null || args === void 0 ? void 0 : args[0]) || '');
+                const testCaseMatch = /mock-steps-tc-(\d+)/i.exec(stepsXml);
+                const testCaseId = Number((testCaseMatch === null || testCaseMatch === void 0 ? void 0 : testCaseMatch[1]) || 0);
+                return mockDetailedStepsByTestCase.get(testCaseId) || [];
+            });
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(3);
+            const byTestCase = new Map(result.rows.map((row) => [row['Test Case ID'], row]));
+            expect(new Set(result.rows.map((row) => row['Test Case ID']))).toEqual(new Set([201, 202, 203]));
+            expect(byTestCase.get(201)).toEqual(expect.objectContaining({
+                'Test Case Title': 'TC 201 - Mixed discrepancies',
+                'Mentioned but Not Linked': 'Step 1: SR0095-3, SR0511-1, SR0511-2',
+                'Linked but Not Mentioned': 'SR8888',
+                'Validation Status': 'Fail',
+            }));
+            expect(String(byTestCase.get(201)['Mentioned but Not Linked'] || '')).not.toContain('VVRM');
+            expect(byTestCase.get(202)).toEqual(expect.objectContaining({
+                'Test Case Title': 'TC 202 - Link only',
+                'Mentioned but Not Linked': '',
+                'Linked but Not Mentioned': 'SR0200',
+                'Validation Status': 'Fail',
+            }));
+            expect(byTestCase.get(203)).toEqual(expect.objectContaining({
+                'Test Case Title': 'TC 203 - Fully valid',
+                'Mentioned but Not Linked': '',
+                'Linked but Not Mentioned': '',
+                'Validation Status': 'Pass',
+            }));
+            expect(resultDataProvider.testStepParserHelper.parseTestSteps).toHaveBeenCalledTimes(3);
+            const parseCalls = resultDataProvider.testStepParserHelper.parseTestSteps.mock.calls;
+            const parsedCaseIds = parseCalls
+                .map(([xml]) => {
+                const match = /mock-steps-tc-(\d+)/i.exec(String(xml || ''));
+                return Number((match === null || match === void 0 ? void 0 : match[1]) || 0);
+            })
+                .filter((id) => Number.isFinite(id) && id > 0);
+            expect(new Set(parsedCaseIds)).toEqual(new Set([201, 202, 203]));
+        });
+        it('should parse TC-0042 mixed expected text and keep only valid SR requirement codes', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([
+                {
+                    testPointsItems: [{ testCaseId: 42, testCaseName: 'TC-0042' }],
+                    testCasesItems: [
+                        {
+                            workItem: {
+                                id: 42,
+                                workItemFields: [{ key: 'Steps', value: '<steps id="mock-steps-tc-0042"></steps>' }],
+                            },
+                        },
+                    ],
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+                {
+                    workItemId: 7001,
+                    requirementId: 'SR0036',
+                    baseKey: 'SR0036',
+                    title: 'SR0036',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7002,
+                    requirementId: 'SR0215',
+                    baseKey: 'SR0215',
+                    title: 'SR0215',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7003,
+                    requirementId: 'SR0539',
+                    baseKey: 'SR0539',
+                    title: 'SR0539',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7004,
+                    requirementId: 'SR0348',
+                    baseKey: 'SR0348',
+                    title: 'SR0348',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7005,
+                    requirementId: 'SR0027',
+                    baseKey: 'SR0027',
+                    title: 'SR0027',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7006,
+                    requirementId: 'SR0041',
+                    baseKey: 'SR0041',
+                    title: 'SR0041',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7007,
+                    requirementId: 'SR0550',
+                    baseKey: 'SR0550',
+                    title: 'SR0550',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7008,
+                    requirementId: 'SR0550-2',
+                    baseKey: 'SR0550',
+                    title: 'SR0550-2',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2\\MOP',
+                },
+                {
+                    workItemId: 7009,
+                    requirementId: 'SR0817',
+                    baseKey: 'SR0817',
+                    title: 'SR0817',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7010,
+                    requirementId: 'SR0818',
+                    baseKey: 'SR0818',
+                    title: 'SR0818',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+                {
+                    workItemId: 7011,
+                    requirementId: 'SR0859',
+                    baseKey: 'SR0859',
+                    title: 'SR0859',
+                    responsibility: 'ESUK',
+                    linkedTestCaseIds: [],
+                    areaPath: 'MEWP\\Customer Requirements\\Level 2',
+                },
+            ]);
+            jest
+                .spyOn(resultDataProvider, 'buildLinkedRequirementsByTestCase')
+                .mockResolvedValueOnce(new Map([
+                [
+                    42,
+                    {
+                        baseKeys: new Set([
+                            'SR0036',
+                            'SR0215',
+                            'SR0539',
+                            'SR0348',
+                            'SR0041',
+                            'SR0550',
+                            'SR0817',
+                            'SR0818',
+                            'SR0859',
+                        ]),
+                        fullCodes: new Set([
+                            'SR0036',
+                            'SR0215',
+                            'SR0539',
+                            'SR0348',
+                            'SR0041',
+                            'SR0550',
+                            'SR0550-2',
+                            'SR0817',
+                            'SR0818',
+                            'SR0859',
+                        ]),
+                    },
+                ],
+            ]));
+            jest.spyOn(resultDataProvider.testStepParserHelper, 'parseTestSteps').mockResolvedValueOnce([
+                {
+                    stepId: '1',
+                    stepPosition: '1',
+                    action: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.',
+                    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. (SR0036; SR0215; VVRM-1; SR0817-V3.2; SR0818-V3.3; SR0859-V3.4)',
+                    isSharedStepTitle: false,
+                },
+                {
+                    stepId: '2',
+                    stepPosition: '2',
+                    action: 'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.',
+                    expected: 'Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. (SR0539; SR0348; VVRM-1)',
+                    isSharedStepTitle: false,
+                },
+                {
+                    stepId: '3',
+                    stepPosition: '3',
+                    action: 'Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.',
+                    expected: 'Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. (SR0027, SR0036; SR0041; VVRM-2)',
+                    isSharedStepTitle: false,
+                },
+                {
+                    stepId: '4',
+                    stepPosition: '4',
+                    action: 'Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.',
+                    expected: 'Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. (SR0550-2)',
+                    isSharedStepTitle: false,
+                },
+                {
+                    stepId: '5',
+                    stepPosition: '5',
+                    action: 'Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit.',
+                    expected: 'Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit. (VVRM-1)',
+                    isSharedStepTitle: false,
+                },
+                {
+                    stepId: '6',
+                    stepPosition: '6',
+                    action: 'Neque porro quisquam est qui dolorem ipsum quia dolor sit amet consectetur adipisci velit.',
+                    expected: 'Neque porro quisquam est qui dolorem ipsum quia dolor sit amet consectetur adipisci velit. (SR0041; SR0550; VVRM-3)',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            const result = await resultDataProvider.getMewpInternalValidationFlatResults('123', mockProjectName, [1]);
+            expect(result.rows).toHaveLength(1);
+            expect(result.rows[0]).toEqual(expect.objectContaining({
+                'Test Case ID': 42,
+                'Test Case Title': 'TC-0042',
+                'Mentioned but Not Linked': 'Step 3: SR0027',
+                'Linked but Not Mentioned': 'SR0817; SR0818; SR0859',
+                'Validation Status': 'Fail',
+            }));
+            expect(String(result.rows[0]['Mentioned but Not Linked'] || '')).not.toContain('VVRM');
+            expect(String(result.rows[0]['Linked but Not Mentioned'] || '')).not.toContain('VVRM');
+        });
+    });
+    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 = [
+                { testSuiteId: 10, suiteName: 'Rel10 / Validation' },
+                { testSuiteId: 11, suiteName: 'Rel11 / Validation' },
+            ];
+            const allSuites = [
+                { testSuiteId: 10, suiteName: 'Rel10 / Validation' },
+                { testSuiteId: 11, suiteName: 'Rel11 / Validation' },
+            ];
+            const rawTestData = [
+                {
+                    suiteName: 'Rel10 / Validation',
+                    testPointsItems: [
+                        { testCaseId: 501, lastRunId: 100, lastResultId: 200 },
+                        { testCaseId: 502, lastRunId: 300, lastResultId: 400 },
+                    ],
+                    testCasesItems: [{ workItem: { id: 501 } }, { workItem: { id: 502 } }],
+                },
+                {
+                    suiteName: 'Rel11 / Validation',
+                    testPointsItems: [
+                        { testCaseId: 501, lastRunId: 0, lastResultId: 0 },
+                        { testCaseId: 502, lastRunId: 500, lastResultId: 600 },
+                    ],
+                    testCasesItems: [{ workItem: { id: 501 } }, { workItem: { id: 502 } }],
+                },
+            ];
+            const fetchSuitesSpy = jest
+                .spyOn(resultDataProvider, 'fetchTestSuites')
+                .mockResolvedValueOnce(suites)
+                .mockResolvedValueOnce(allSuites);
+            const fetchDataSpy = jest
+                .spyOn(resultDataProvider, 'fetchTestData')
+                .mockResolvedValueOnce(rawTestData);
+            const scoped = await resultDataProvider.fetchMewpScopedTestData('123', mockProjectName, [11], true);
+            expect(fetchSuitesSpy).toHaveBeenCalledTimes(2);
+            expect(fetchDataSpy).toHaveBeenCalledTimes(1);
+            expect(scoped).toHaveLength(1);
+            const selectedPoints = scoped[0].testPointsItems;
+            const tc501 = selectedPoints.find((item) => item.testCaseId === 501);
+            const tc502 = selectedPoints.find((item) => item.testCaseId === 502);
+            expect(tc501).toEqual(expect.objectContaining({ lastRunId: 100, lastResultId: 200 }));
+            expect(tc502).toEqual(expect.objectContaining({ lastRunId: 500, lastResultId: 600 }));
+        });
+    });
+    describe('MEWP external ingestion validation/parsing', () => {
+        const validBugsSource = {
+            name: 'bugs.xlsx',
+            url: 'https://minio.local/mewp-external-ingestion/MEWP/mewp-external-ingestion/bugs/bugs.xlsx',
+            sourceType: 'mewpExternalIngestion',
+        };
+        const validL3L4Source = {
+            name: 'l3l4.xlsx',
+            url: 'https://minio.local/mewp-external-ingestion/MEWP/mewp-external-ingestion/l3l4/l3l4.xlsx',
+            sourceType: 'mewpExternalIngestion',
+        };
+        it('should validate external files when required columns exist in A3 header row', async () => {
+            const bugsBuffer = buildWorkbookBuffer([
+                ['', '', '', '', ''],
+                ['', '', '', '', ''],
+                ['Elisra_SortIndex', 'SR', 'TargetWorkItemId', 'Title', 'TargetState'],
+                ['101', 'SR0001', '9001', 'Bug one', 'Active'],
+            ]);
+            const l3l4Buffer = buildWorkbookBuffer([
+                ['', '', '', '', '', '', '', ''],
+                ['', '', '', '', '', '', '', ''],
+                [
+                    'SR',
+                    'AREA 34',
+                    'TargetWorkItemId Level 3',
+                    'TargetTitleLevel3',
+                    'TargetStateLevel 3',
+                    'TargetWorkItemIdLevel 4',
+                    'TargetTitleLevel4',
+                    'TargetStateLevel 4',
+                ],
+                ['SR0001', 'Level 3', '7001', 'Req L3', 'Active', '', '', ''],
+            ]);
+            const axiosSpy = jest
+                .spyOn(axios_1.default, 'get')
+                .mockResolvedValueOnce({ data: bugsBuffer, headers: {} })
+                .mockResolvedValueOnce({ data: l3l4Buffer, headers: {} });
+            const result = await resultDataProvider.validateMewpExternalFiles({
+                externalBugsFile: validBugsSource,
+                externalL3L4File: validL3L4Source,
+            });
+            expect(axiosSpy).toHaveBeenCalledTimes(2);
+            expect(result.valid).toBe(true);
+            expect(result.bugs).toEqual(expect.objectContaining({
+                valid: true,
+                headerRow: 'A3',
+                matchedRequiredColumns: 5,
+            }));
+            expect(result.l3l4).toEqual(expect.objectContaining({
+                valid: true,
+                headerRow: 'A3',
+                matchedRequiredColumns: 8,
+            }));
+        });
+        it('should accept A1 fallback header row for backward compatibility', async () => {
+            const bugsBuffer = buildWorkbookBuffer([
+                ['Elisra_SortIndex', 'SR', 'TargetWorkItemId', 'Title', 'TargetState'],
+                ['101', 'SR0001', '9001', 'Bug one', 'Active'],
+            ]);
+            jest.spyOn(axios_1.default, 'get').mockResolvedValueOnce({ data: bugsBuffer, headers: {} });
+            const result = await resultDataProvider.validateMewpExternalFiles({
+                externalBugsFile: validBugsSource,
+            });
+            expect(result.valid).toBe(true);
+            expect(result.bugs).toEqual(expect.objectContaining({
+                valid: true,
+                headerRow: 'A1',
+            }));
+        });
+        it('should fail validation when required columns are missing', async () => {
+            const invalidBuffer = buildWorkbookBuffer([
+                ['', '', ''],
+                ['', '', ''],
+                ['Elisra_SortIndex', 'TargetWorkItemId', 'TargetState'],
+                ['101', '9001', 'Active'],
+            ]);
+            jest.spyOn(axios_1.default, 'get').mockResolvedValueOnce({ data: invalidBuffer, headers: {} });
+            const result = await resultDataProvider.validateMewpExternalFiles({
+                externalBugsFile: validBugsSource,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.bugs).toEqual(expect.objectContaining({
+                valid: false,
+                matchedRequiredColumns: 3,
+                missingRequiredColumns: expect.arrayContaining(['SR', 'Title']),
+            }));
+        });
+        it('should reject files from non-dedicated bucket/object path', async () => {
+            var _a;
+            const result = await resultDataProvider.validateMewpExternalFiles({
+                externalBugsFile: {
+                    name: 'bugs.xlsx',
+                    url: 'https://minio.local/mewp-external-ingestion/MEWP/other-prefix/bugs.xlsx',
+                    sourceType: 'mewpExternalIngestion',
+                },
+            });
+            expect(result.valid).toBe(false);
+            expect(((_a = result.bugs) === null || _a === void 0 ? void 0 : _a.message) || '').toContain('Invalid object path');
+        });
+        it('should filter external bugs by SR/state and dedupe by bug+requirement', async () => {
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+                {
+                    Elisra_SortIndex: '101',
+                    SR: 'SR0001',
+                    TargetWorkItemId: '9001',
+                    Title: 'Bug one',
+                    TargetState: 'Active',
+                    SAPWBS: 'ESUK',
+                },
+                {
+                    Elisra_SortIndex: '101',
+                    SR: 'SR0001',
+                    TargetWorkItemId: '9001',
+                    Title: 'Bug one duplicate',
+                    TargetState: 'Active',
+                },
+                {
+                    Elisra_SortIndex: '101',
+                    SR: '',
+                    TargetWorkItemId: '9002',
+                    Title: 'Missing SR',
+                    TargetState: 'Active',
+                },
+                {
+                    Elisra_SortIndex: '101',
+                    SR: 'SR0002',
+                    TargetWorkItemId: '9003',
+                    Title: 'Closed bug',
+                    TargetState: 'Closed',
+                },
+            ]);
+            const map = await resultDataProvider.loadExternalBugsByTestCase(validBugsSource);
+            const bugs = map.get(101) || [];
+            expect(bugs).toHaveLength(1);
+            expect(bugs[0]).toEqual(expect.objectContaining({
+                id: 9001,
+                requirementBaseKey: 'SR0001',
+                responsibility: 'ESUK',
+            }));
+        });
+        it('should require Elisra_SortIndex and ignore rows that only provide WorkItemId', async () => {
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+                {
+                    WorkItemId: '101',
+                    SR: 'SR0001',
+                    TargetWorkItemId: '9010',
+                    Title: 'Bug without Elisra_SortIndex',
+                    TargetState: 'Active',
+                },
+            ]);
+            const map = await resultDataProvider.loadExternalBugsByTestCase(validBugsSource);
+            expect(map.size).toBe(0);
+        });
+        it('should parse external L3/L4 file using AREA 34 semantics and terminal-state filtering', async () => {
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+                {
+                    SR: 'SR0001',
+                    'AREA 34': 'Level 4',
+                    'TargetWorkItemId Level 3': '7001',
+                    TargetTitleLevel3: 'L4 From Level3 Column',
+                    'TargetStateLevel 3': 'Active',
+                },
+                {
+                    SR: 'SR0001',
+                    'AREA 34': 'Level 3',
+                    'TargetWorkItemId Level 3': '7002',
+                    TargetTitleLevel3: 'L3 Requirement',
+                    'TargetStateLevel 3': 'Active',
+                    'TargetWorkItemIdLevel 4': '7003',
+                    TargetTitleLevel4: 'L4 Requirement',
+                    'TargetStateLevel 4': 'Closed',
+                },
+            ]);
+            const map = await resultDataProvider.loadExternalL3L4ByBaseKey(validL3L4Source);
+            expect(map.get('SR0001')).toEqual([
+                { id: '7002', title: 'L3 Requirement', level: 'L3' },
+                { id: '7001', title: 'L4 From Level3 Column', level: 'L4' },
+            ]);
+        });
+        it('should exclude external open L3/L4 rows when SAPWBS resolves to ESUK', async () => {
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+                {
+                    SR: 'SR0001',
+                    'AREA 34': 'Level 3',
+                    'TargetWorkItemId Level 3': '7101',
+                    TargetTitleLevel3: 'L3 ESUK',
+                    'TargetStateLevel 3': 'Active',
+                    'TargetSapWbsLevel 3': 'ESUK',
+                    'TargetWorkItemIdLevel 4': '7201',
+                    TargetTitleLevel4: 'L4 IL',
+                    'TargetStateLevel 4': 'Active',
+                    'TargetSapWbsLevel 4': 'IL',
+                },
+                {
+                    SR: 'SR0001',
+                    'AREA 34': 'Level 3',
+                    'TargetWorkItemId Level 3': '7102',
+                    TargetTitleLevel3: 'L3 IL',
+                    'TargetStateLevel 3': 'Active',
+                    'TargetSapWbsLevel 3': 'IL',
+                },
+            ]);
+            const map = await resultDataProvider.loadExternalL3L4ByBaseKey(validL3L4Source);
+            expect(map.get('SR0001')).toEqual([
+                { id: '7102', title: 'L3 IL', level: 'L3' },
+                { id: '7201', title: 'L4 IL', level: 'L4' },
+            ]);
+        });
+        it('should fallback L3/L4 SAPWBS exclusion from SR-mapped requirement when row SAPWBS is empty', async () => {
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce([
+                {
+                    SR: 'SR0001',
+                    'AREA 34': 'Level 3',
+                    'TargetWorkItemId Level 3': '7301',
+                    TargetTitleLevel3: 'L3 From ESUK Requirement',
+                    'TargetStateLevel 3': 'Active',
+                    'TargetSapWbsLevel 3': '',
+                },
+                {
+                    SR: 'SR0002',
+                    'AREA 34': 'Level 3',
+                    'TargetWorkItemId Level 3': '7302',
+                    TargetTitleLevel3: 'L3 From IL Requirement',
+                    'TargetStateLevel 3': 'Active',
+                    'TargetSapWbsLevel 3': '',
+                },
+            ]);
+            const map = await resultDataProvider.loadExternalL3L4ByBaseKey(validL3L4Source, new Map([
+                ['SR0001', 'ESUK'],
+                ['SR0002', 'IL'],
+            ]));
+            expect(map.has('SR0001')).toBe(false);
+            expect(map.get('SR0002')).toEqual([{ id: '7302', title: 'L3 From IL Requirement', level: 'L3' }]);
+        });
+        it('should resolve bug responsibility from AreaPath when SAPWBS is empty', () => {
+            const fromEsukAreaPath = resultDataProvider.resolveBugResponsibility({
+                'Custom.SAPWBS': '',
+                'System.AreaPath': 'MEWP\\Customer Requirements\\Level 2\\ATP\\ESUK',
+            });
+            const fromIlAreaPath = resultDataProvider.resolveBugResponsibility({
+                'Custom.SAPWBS': '',
+                'System.AreaPath': 'MEWP\\Customer Requirements\\Level 2\\ATP',
+            });
+            const unknown = resultDataProvider.resolveBugResponsibility({
+                'Custom.SAPWBS': '',
+                'System.AreaPath': 'MEWP\\Other\\Area',
+            });
+            expect(fromEsukAreaPath).toBe('ESUK');
+            expect(fromIlAreaPath).toBe('Elisra');
+            expect(unknown).toBe('Unknown');
+        });
+        it('should handle 1000 external bug rows and keep only in-scope parsed items', async () => {
+            const rows = [];
+            for (let i = 1; i <= 1000; i++) {
+                rows.push({
+                    Elisra_SortIndex: String(4000 + (i % 20)),
+                    SR: `SR${String(6000 + (i % 50)).padStart(4, '0')}`,
+                    TargetWorkItemId: String(900000 + i),
+                    Title: `Bug ${i}`,
+                    TargetState: i % 10 === 0 ? 'Closed' : 'Active',
+                    SAPWBS: i % 2 === 0 ? 'ESUK' : 'IL',
+                });
+            }
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce(rows);
+            const startedAt = Date.now();
+            const map = await resultDataProvider.loadExternalBugsByTestCase({
+                name: 'bulk-bugs.xlsx',
+                url: 'https://minio.local/mewp-external-ingestion/MEWP/mewp-external-ingestion/bugs/bulk-bugs.xlsx',
+                sourceType: 'mewpExternalIngestion',
+            });
+            const elapsedMs = Date.now() - startedAt;
+            const totalParsed = [...map.values()].reduce((sum, items) => sum + ((items === null || items === void 0 ? void 0 : items.length) || 0), 0);
+            expect(totalParsed).toBe(900); // every 10th row is closed and filtered out
+            expect(elapsedMs).toBeLessThan(5000);
+        });
+        it('should handle 1000 external L3/L4 rows and map all active links', async () => {
+            const rows = [];
+            for (let i = 1; i <= 1000; i++) {
+                rows.push({
+                    SR: `SR${String(7000 + (i % 25)).padStart(4, '0')}`,
+                    'AREA 34': i % 3 === 0 ? 'Level 4' : 'Level 3',
+                    'TargetWorkItemId Level 3': String(800000 + i),
+                    TargetTitleLevel3: `L3/L4 Title ${i}`,
+                    'TargetStateLevel 3': i % 11 === 0 ? 'Resolved' : 'Active',
+                    'TargetWorkItemIdLevel 4': String(810000 + i),
+                    TargetTitleLevel4: `L4 Title ${i}`,
+                    'TargetStateLevel 4': i % 13 === 0 ? 'Closed' : 'Active',
+                });
+            }
+            const mewpExternalTableUtils = resultDataProvider.mewpExternalTableUtils;
+            jest.spyOn(mewpExternalTableUtils, 'loadExternalTableRows').mockResolvedValueOnce(rows);
+            const startedAt = Date.now();
+            const map = await resultDataProvider.loadExternalL3L4ByBaseKey({
+                name: 'bulk-l3l4.xlsx',
+                url: 'https://minio.local/mewp-external-ingestion/MEWP/mewp-external-ingestion/l3l4/bulk-l3l4.xlsx',
+                sourceType: 'mewpExternalIngestion',
+            });
+            const elapsedMs = Date.now() - startedAt;
+            const totalLinks = [...map.values()].reduce((sum, items) => sum + ((items === null || items === void 0 ? void 0 : items.length) || 0), 0);
+            expect(totalLinks).toBeGreaterThan(700);
+            expect(elapsedMs).toBeLessThan(5000);
+        });
+    });
+    describe('MEWP high-volume requirement token parsing', () => {
+        it('should parse 1000 expected-result requirement tokens with noisy fragments', () => {
+            const tokens = [];
+            for (let i = 1; i <= 1000; i++) {
+                const code = `SR${String(10000 + i)}`;
+                tokens.push(code);
+                if (i % 100 === 0)
+                    tokens.push(`${code} V3.24`);
+                if (i % 125 === 0)
+                    tokens.push(`${code} VVRM2425`);
+            }
+            const sourceText = tokens.join('; ');
+            const startedAt = Date.now();
+            const codes = resultDataProvider.extractRequirementCodesFromText(sourceText);
+            const elapsedMs = Date.now() - startedAt;
+            expect(codes.size).toBe(1000);
+            expect(codes.has('SR10001')).toBe(true);
+            expect(codes.has('SR11000')).toBe(true);
+            expect(elapsedMs).toBeLessThan(3000);
         });
     });
     describe('fetchResultDataForTestReporter (runResultField switch)', () => {