@elisra-devops/docgen-data-provider 1.63.13 → 1.68.0

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

@@ -0,0 +1,1942 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tfs_1 = require("../../helpers/tfs");
+const ResultDataProvider_1 = require("../../modules/ResultDataProvider");
+const logger_1 = require("../../utils/logger");
+// Mock dependencies
+jest.mock('../../helpers/tfs');
+jest.mock('../../utils/logger');
+jest.mock('../../utils/testStepParserHelper');
+jest.mock('../../modules/TicketsDataProvider', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            GetQueryResultsFromWiql: jest.fn(),
+        })),
+    };
+});
+jest.mock('p-limit', () => () => (fn) => fn());
+describe('ResultDataProvider', () => {
+    let resultDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/organization/';
+    const mockToken = 'mock-token';
+    const mockProjectName = 'test-project';
+    const mockTestPlanId = '12345';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        resultDataProvider = new ResultDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    describe('Utility methods', () => {
+        describe('flattenSuites', () => {
+            it('should flatten a hierarchical suite structure into a single-level array', () => {
+                // Arrange
+                const suites = [
+                    {
+                        id: 1,
+                        name: 'Parent 1',
+                        children: [
+                            { id: 2, name: 'Child 1' },
+                            {
+                                id: 3,
+                                name: 'Child 2',
+                                children: [{ id: 4, name: 'Grandchild 1' }],
+                            },
+                        ],
+                    },
+                    { id: 5, name: 'Parent 2' },
+                ];
+                // Act
+                const result = resultDataProvider.flattenSuites(suites);
+                // Assert
+                expect(result).toHaveLength(5);
+                expect(result.map((s) => s.id)).toEqual([1, 2, 3, 4, 5]);
+            });
+        });
+        describe('filterSuites', () => {
+            it('should filter suites based on selected suite IDs', () => {
+                // Arrange
+                const testSuites = [
+                    { id: 1, name: 'Suite 1', parentSuite: { id: 0 } },
+                    { id: 2, name: 'Suite 2', parentSuite: { id: 1 } },
+                    { id: 3, name: 'Suite 3', parentSuite: { id: 1 } },
+                ];
+                const selectedSuiteIds = [1, 3];
+                // Act
+                const result = resultDataProvider.filterSuites(testSuites, selectedSuiteIds);
+                // Assert
+                expect(result).toHaveLength(2);
+                expect(result.map((s) => s.id)).toEqual([1, 3]);
+            });
+            it('should return all suites with parent when no suite IDs are selected', () => {
+                // Arrange
+                const testSuites = [
+                    { id: 1, name: 'Suite 1', parentSuite: { id: 0 } },
+                    { id: 2, name: 'Suite 2', parentSuite: { id: 1 } },
+                    { id: 3, name: 'Suite 3', parentSuite: null },
+                ];
+                // Act
+                const result = resultDataProvider.filterSuites(testSuites);
+                // Assert
+                expect(result).toHaveLength(2);
+                expect(result.map((s) => s.id)).toEqual([1, 2]);
+            });
+        });
+        describe('buildTestGroupName', () => {
+            it('should return simple suite name when hierarchy is disabled', () => {
+                // Arrange
+                const suiteMap = new Map([[1, { id: 1, name: 'Suite 1', parentSuite: { id: 0 } }]]);
+                // Act
+                const result = resultDataProvider.buildTestGroupName(1, suiteMap, false);
+                // Assert
+                expect(result).toBe('Suite 1');
+            });
+            it('should build hierarchical name with parent info', () => {
+                // Arrange
+                const suiteMap = new Map([
+                    [1, { id: 1, name: 'Parent', parentSuite: null }],
+                    [2, { id: 2, name: 'Child', parentSuite: { id: 1 } }],
+                ]);
+                // Act
+                const result = resultDataProvider.buildTestGroupName(2, suiteMap, true);
+                // Assert
+                expect(result).toBe('Child');
+            });
+            it('should abbreviate deep hierarchies', () => {
+                // Arrange
+                const suiteMap = new Map([
+                    [1, { id: 1, name: 'Root', parentSuite: null }],
+                    [2, { id: 2, name: 'Level1', parentSuite: { id: 1 } }],
+                    [3, { id: 3, name: 'Level2', parentSuite: { id: 2 } }],
+                    [4, { id: 4, name: 'Level3', parentSuite: { id: 3 } }],
+                ]);
+                // Act
+                const result = resultDataProvider.buildTestGroupName(4, suiteMap, true);
+                // Assert
+                expect(result).toBe('Level1/.../Level3');
+            });
+        });
+        describe('convertRunStatus', () => {
+            it('should convert API status to readable format', () => {
+                // Arrange & Act & Assert
+                expect(resultDataProvider.convertRunStatus('passed')).toBe('Passed');
+                expect(resultDataProvider.convertRunStatus('failed')).toBe('Failed');
+                expect(resultDataProvider.convertRunStatus('notApplicable')).toBe('Not Applicable');
+                expect(resultDataProvider.convertRunStatus('unknown')).toBe('Not Run');
+            });
+        });
+        describe('compareActionResults', () => {
+            it('should compare version-like step positions correctly', () => {
+                // Act & Assert
+                const compare = resultDataProvider.compareActionResults;
+                expect(compare('1', '2')).toBe(-1);
+                expect(compare('2', '1')).toBe(1);
+                expect(compare('1.1', '1.2')).toBe(-1);
+                expect(compare('1.2', '1.1')).toBe(1);
+                expect(compare('1.1', '1.1')).toBe(0);
+                expect(compare('1.1.1', '1.1')).toBe(1);
+                expect(compare('1.1', '1.1.1')).toBe(-1);
+            });
+        });
+    });
+    describe('Data fetching methods', () => {
+        describe('fetchTestSuites', () => {
+            it('should fetch and process test suites correctly', async () => {
+                // Arrange
+                const mockTestSuites = {
+                    value: [
+                        {
+                            id: 1,
+                            name: 'Root Suite',
+                            children: [{ id: 2, name: 'Child Suite 1', parentSuite: { id: 1 } }],
+                        },
+                    ],
+                    count: 1,
+                };
+                tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockTestSuites);
+                // Act
+                const result = await resultDataProvider.fetchTestSuites(mockTestPlanId, mockProjectName);
+                // Assert
+                expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProjectName}/_apis/testplan/Plans/${mockTestPlanId}/Suites?asTreeView=true`, mockToken);
+                expect(result).toHaveLength(1);
+                expect(result[0]).toHaveProperty('testSuiteId', 2);
+                expect(result[0]).toHaveProperty('testGroupName');
+            });
+            it('should handle errors and return empty array', async () => {
+                // Arrange
+                const mockError = new Error('API error');
+                tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+                // Act
+                const result = await resultDataProvider.fetchTestSuites(mockTestPlanId, mockProjectName);
+                // Assert
+                expect(logger_1.default.error).toHaveBeenCalled();
+                expect(result).toEqual([]);
+            });
+        });
+        describe('fetchTestPoints', () => {
+            it('should fetch and map test points correctly', async () => {
+                // Arrange
+                const mockSuiteId = '123';
+                const mockTestPoints = {
+                    value: [
+                        {
+                            testCaseReference: { id: 1, name: 'Test Case 1' },
+                            configuration: { name: 'Config 1' },
+                            results: {
+                                outcome: 'passed',
+                                lastTestRunId: 100,
+                                lastResultId: 200,
+                                lastResultDetails: { dateCompleted: '2023-01-01', runBy: { displayName: 'Test User' } },
+                            },
+                        },
+                    ],
+                    count: 1,
+                };
+                tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockTestPoints);
+                // Act
+                const result = await resultDataProvider.fetchTestPoints(mockProjectName, mockTestPlanId, mockSuiteId);
+                // Assert
+                expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProjectName}/_apis/testplan/Plans/${mockTestPlanId}/Suites/${mockSuiteId}/TestPoint?includePointDetails=true`, mockToken);
+                expect(result).toHaveLength(1);
+                expect(result[0]).toEqual({
+                    testCaseId: 1,
+                    testCaseName: 'Test Case 1',
+                    configurationName: 'Config 1',
+                    outcome: 'passed',
+                    lastRunId: 100,
+                    lastResultId: 200,
+                    lastResultDetails: { dateCompleted: '2023-01-01', runBy: { displayName: 'Test User' } },
+                    testCaseUrl: 'https://dev.azure.com/organization/test-project/_workitems/edit/1',
+                });
+            });
+            it('should handle errors and return empty array', async () => {
+                // Arrange
+                const mockSuiteId = '123';
+                const mockError = new Error('API error');
+                tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+                // Act
+                const result = await resultDataProvider.fetchTestPoints(mockProjectName, mockTestPlanId, mockSuiteId);
+                // Assert
+                expect(logger_1.default.error).toHaveBeenCalled();
+                expect(result).toEqual([]);
+            });
+        });
+    });
+    describe('Data transformation methods', () => {
+        describe('mapTestPoint', () => {
+            it('should transform test point data correctly', () => {
+                // Arrange
+                const testPoint = {
+                    testCaseReference: { id: 1, name: 'Test Case 1' },
+                    configuration: { name: 'Config 1' },
+                    results: {
+                        outcome: 'passed',
+                        lastTestRunId: 100,
+                        lastResultId: 200,
+                        lastResultDetails: { dateCompleted: '2023-01-01', runBy: { displayName: 'Test User' } },
+                    },
+                };
+                // Act
+                const result = resultDataProvider.mapTestPoint(testPoint, mockProjectName);
+                // Assert
+                expect(result).toEqual({
+                    testCaseId: 1,
+                    testCaseName: 'Test Case 1',
+                    configurationName: 'Config 1',
+                    outcome: 'passed',
+                    lastRunId: 100,
+                    lastResultId: 200,
+                    lastResultDetails: { dateCompleted: '2023-01-01', runBy: { displayName: 'Test User' } },
+                    testCaseUrl: 'https://dev.azure.com/organization/test-project/_workitems/edit/1',
+                });
+            });
+            it('should handle missing fields', () => {
+                // Arrange
+                const testPoint = {
+                    testCaseReference: { id: 1, name: 'Test Case 1' },
+                    // No configuration or results
+                };
+                // Act
+                const result = resultDataProvider.mapTestPoint(testPoint, mockProjectName);
+                // Assert
+                expect(result).toEqual({
+                    testCaseId: 1,
+                    testCaseName: 'Test Case 1',
+                    configurationName: undefined,
+                    outcome: 'Not Run',
+                    lastRunId: undefined,
+                    lastResultId: undefined,
+                    lastResultDetails: undefined,
+                    testCaseUrl: 'https://dev.azure.com/organization/test-project/_workitems/edit/1',
+                });
+            });
+        });
+        describe('calculateGroupResultSummary', () => {
+            it('should return empty strings when includeHardCopyRun is true', () => {
+                // Arrange
+                const testPoints = [{ outcome: 'passed' }, { outcome: 'failed' }];
+                // Act
+                const result = resultDataProvider.calculateGroupResultSummary(testPoints, true);
+                // Assert
+                expect(result).toEqual({
+                    passed: '',
+                    failed: '',
+                    notApplicable: '',
+                    blocked: '',
+                    notRun: '',
+                    total: '',
+                    successPercentage: '',
+                });
+            });
+            it('should calculate summary statistics correctly', () => {
+                // Arrange
+                const testPoints = [
+                    { outcome: 'passed' },
+                    { outcome: 'passed' },
+                    { outcome: 'failed' },
+                    { outcome: 'notApplicable' },
+                    { outcome: 'blocked' },
+                    { outcome: 'something else' },
+                ];
+                // Act
+                const result = resultDataProvider.calculateGroupResultSummary(testPoints, false);
+                // Assert
+                expect(result).toEqual({
+                    passed: 2,
+                    failed: 1,
+                    notApplicable: 1,
+                    blocked: 1,
+                    notRun: 1,
+                    total: 6,
+                    successPercentage: '33.33%',
+                });
+            });
+            it('should handle empty array', () => {
+                // Arrange
+                const testPoints = [];
+                // Act
+                const result = resultDataProvider.calculateGroupResultSummary(testPoints, false);
+                // Assert
+                expect(result).toEqual({
+                    passed: 0,
+                    failed: 0,
+                    notApplicable: 0,
+                    blocked: 0,
+                    notRun: 0,
+                    total: 0,
+                    successPercentage: '0.00%',
+                });
+            });
+        });
+        describe('mapAttachmentsUrl', () => {
+            it('should map attachment URLs correctly', () => {
+                // Arrange
+                const mockRunResults = [
+                    {
+                        testCaseId: 1,
+                        lastRunId: 100,
+                        lastResultId: 200,
+                        iteration: {
+                            attachments: [{ id: 1, name: 'attachment1.png', actionPath: 'path1' }],
+                            actionResults: [{ actionPath: 'path1', stepPosition: '1.1' }],
+                        },
+                        analysisAttachments: [{ id: 2, fileName: 'analysis1.txt' }],
+                    },
+                ];
+                // Act
+                const result = resultDataProvider.mapAttachmentsUrl(mockRunResults, mockProjectName);
+                // Assert
+                expect(result[0].iteration.attachments[0].downloadUrl).toBe(`${mockOrgUrl}${mockProjectName}/_apis/test/runs/100/results/200/attachments/1/attachment1.png`);
+                expect(result[0].iteration.attachments[0].stepNo).toBe('1.1');
+                expect(result[0].analysisAttachments[0].downloadUrl).toBe(`${mockOrgUrl}${mockProjectName}/_apis/test/runs/100/results/200/attachments/2/analysis1.txt`);
+            });
+            it('should handle missing iteration', () => {
+                // Arrange
+                const mockRunResults = [
+                    {
+                        testCaseId: 1,
+                        lastRunId: 100,
+                        lastResultId: 200,
+                        // No iteration
+                        analysisAttachments: [{ id: 2, fileName: 'analysis1.txt' }],
+                    },
+                ];
+                // Act
+                const result = resultDataProvider.mapAttachmentsUrl(mockRunResults, mockProjectName);
+                // Assert
+                expect(result[0]).toEqual(mockRunResults[0]);
+            });
+        });
+    });
+    describe('formatTestResult', () => {
+        it('should format test result correctly', () => {
+            // Arrange
+            const testPoint = {
+                testCaseId: 1,
+                testCaseName: 'Test Case 1',
+                testGroupName: 'Suite 1',
+                testCaseUrl: 'https://example.com/workitems/1',
+                configurationName: 'Config 1',
+                outcome: 'passed',
+            };
+            // Act
+            const result = resultDataProvider.formatTestResult(testPoint, true, false);
+            // Assert
+            expect(result.testId).toBe(1);
+            expect(result.testName).toBe('Test Case 1');
+            expect(result.configuration).toBe('Config 1');
+            expect(result.runStatus).toBe('Passed');
+        });
+        it('should return empty strings when includeHardCopyRun is true', () => {
+            // Arrange
+            const testPoint = {
+                testCaseId: 1,
+                testCaseName: 'Test Case 1',
+                testGroupName: 'Suite 1',
+                outcome: 'passed',
+            };
+            // Act
+            const result = resultDataProvider.formatTestResult(testPoint, false, true);
+            // Assert
+            expect(result.runStatus).toBe('');
+        });
+    });
+    describe('calculateTotalSummary', () => {
+        it('should calculate total summary from summarized results', () => {
+            // Arrange
+            const summarizedResults = [
+                { groupResultSummary: { passed: 2, failed: 1, notApplicable: 0, blocked: 0, notRun: 1, total: 4 } },
+                { groupResultSummary: { passed: 3, failed: 0, notApplicable: 1, blocked: 1, notRun: 0, total: 5 } },
+            ];
+            // Act
+            const result = resultDataProvider.calculateTotalSummary(summarizedResults, false);
+            // Assert
+            expect(result.passed).toBe(5);
+            expect(result.failed).toBe(1);
+            expect(result.notApplicable).toBe(1);
+            expect(result.blocked).toBe(1);
+            expect(result.notRun).toBe(1);
+            expect(result.total).toBe(9);
+        });
+        it('should return empty strings when includeHardCopyRun is true', () => {
+            // Arrange
+            const summarizedResults = [{ groupResultSummary: { passed: 2, failed: 1, total: 3 } }];
+            // Act
+            const result = resultDataProvider.calculateTotalSummary(summarizedResults, true);
+            // Assert
+            expect(result.passed).toBe('');
+            expect(result.failed).toBe('');
+            expect(result.total).toBe('');
+        });
+    });
+    describe('flattenTestPoints', () => {
+        it('should flatten test points from suites', () => {
+            // Arrange
+            const testPoints = [
+                { testSuiteId: 1, testGroupName: 'Suite 1', testPointsItems: [{ id: 1 }, { id: 2 }] },
+                { testSuiteId: 2, testGroupName: 'Suite 2', testPointsItems: [{ id: 3 }] },
+            ];
+            // Act
+            const result = resultDataProvider.flattenTestPoints(testPoints);
+            // Assert
+            expect(result).toHaveLength(3);
+            expect(result[0].testGroupName).toBe('Suite 1');
+            expect(result[2].testGroupName).toBe('Suite 2');
+        });
+    });
+    describe('createSuiteMap', () => {
+        it('should create a map of suites by ID', () => {
+            // Arrange
+            const suites = [
+                { id: 1, name: 'Suite 1', children: [{ id: 2, name: 'Suite 2' }] },
+                { id: 3, name: 'Suite 3' },
+            ];
+            // Act
+            const result = resultDataProvider.createSuiteMap(suites);
+            // Assert
+            expect(result).toBeInstanceOf(Map);
+            expect(result.size).toBe(3);
+            expect(result.get(1).name).toBe('Suite 1');
+            expect(result.get(2).name).toBe('Suite 2');
+        });
+    });
+    describe('isNotRunStep', () => {
+        it('should return true for not run step', () => {
+            // Arrange
+            const step = { stepStatus: 'Not Run' };
+            // Act
+            const result = resultDataProvider.isNotRunStep(step);
+            // Assert
+            expect(result).toBe(true);
+        });
+        it('should return false for run step', () => {
+            // Arrange
+            const step = { stepStatus: 'Passed' };
+            // Act
+            const result = resultDataProvider.isNotRunStep(step);
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+    describe('CreateAttachmentPathIndexMap', () => {
+        it('should create map of action paths to step positions', () => {
+            // Arrange
+            const actionResults = [
+                { actionPath: 'path1', stepPosition: '1.1' },
+                { actionPath: 'path2', stepPosition: '1.2' },
+            ];
+            // Act
+            const result = resultDataProvider.CreateAttachmentPathIndexMap(actionResults);
+            // Assert
+            expect(result).toBeInstanceOf(Map);
+            expect(result.get('path1')).toBe('1.1');
+            expect(result.get('path2')).toBe('1.2');
+        });
+    });
+    describe('getTestPointsForTestCases', () => {
+        it('should fetch test points for test cases', async () => {
+            // Arrange
+            const mockTestCaseIds = ['1', '2'];
+            const mockResponse = { data: { points: [{ id: 1 }] } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await resultDataProvider.getTestPointsForTestCases(mockProjectName, mockTestCaseIds);
+            // Assert
+            expect(tfs_1.TFSServices.postRequest).toHaveBeenCalled();
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('mapActionPathToPosition', () => {
+        it('should map action paths to positions', () => {
+            // Arrange
+            const actionResults = [
+                { testId: 1, actionPath: 'path1', stepNo: '1.1' },
+                { testId: 1, actionPath: 'path2', stepNo: '1.2' },
+            ];
+            // Act
+            const result = resultDataProvider.mapActionPathToPosition(actionResults);
+            // Assert
+            expect(result).toBeInstanceOf(Map);
+            expect(result.get('1-path1')).toBe('1.1');
+            expect(result.get('1-path2')).toBe('1.2');
+        });
+    });
+    describe('fetchTestPlanName', () => {
+        it('should fetch test plan name', async () => {
+            // Arrange
+            const mockPlan = { name: 'Test Plan 1' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockPlan);
+            // Act
+            const result = await resultDataProvider.fetchTestPlanName(mockTestPlanId, mockProjectName);
+            // Assert
+            expect(result).toBe('Test Plan 1');
+        });
+        it('should return empty string on error', async () => {
+            // Arrange
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('API Error'));
+            // Act
+            const result = await resultDataProvider.fetchTestPlanName(mockTestPlanId, mockProjectName);
+            // Assert
+            expect(result).toBe('');
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('fetchTestCasesBySuiteId', () => {
+        it('should fetch test cases by suite ID', async () => {
+            // Arrange
+            const mockSuiteId = '123';
+            const mockTestCases = { value: [{ workItem: { id: 1 } }] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockTestCases);
+            // Act
+            const result = await resultDataProvider.fetchTestCasesBySuiteId(mockProjectName, mockTestPlanId, mockSuiteId);
+            // Assert
+            expect(result).toEqual(mockTestCases.value);
+        });
+    });
+    describe('mapTestPointForCrossPlans', () => {
+        it('should map test point for cross plans', () => {
+            // Arrange
+            const testPoint = {
+                testCase: { id: 1, name: 'Test Case 1' },
+                testSuite: { id: 2, name: 'Suite 1' },
+                configuration: { name: 'Config 1' },
+                outcome: 'passed',
+                lastTestRun: { id: '100' },
+                lastResult: { id: '200' },
+            };
+            // Act
+            const result = resultDataProvider.mapTestPointForCrossPlans(testPoint, mockProjectName);
+            // Assert
+            expect(result.testCaseId).toBe(1);
+            expect(result.testCaseName).toBe('Test Case 1');
+            expect(result.outcome).toBe('passed');
+            expect(result.lastRunId).toBe('100');
+        });
+        it('should provide default values for missing fields', () => {
+            // Arrange
+            const testPoint = {
+                testCase: { id: 1, name: 'Test Case 1' },
+                testSuite: { id: 2, name: 'Suite 1' },
+            };
+            // Act
+            const result = resultDataProvider.mapTestPointForCrossPlans(testPoint, mockProjectName);
+            // Assert
+            expect(result.outcome).toBe('Not Run');
+            expect(result.lastResultDetails).toBeDefined();
+            expect(result.lastResultDetails.duration).toBe(0);
+        });
+    });
+    describe('mapStepResultsForExecutionAppendix', () => {
+        it('should map step results for execution appendix', () => {
+            // Arrange
+            const detailedResults = [
+                {
+                    testId: 1,
+                    testCaseRevision: { rev: 1 },
+                    stepNo: '1.1',
+                    stepIdentifier: 'step1',
+                    stepAction: 'Do something',
+                    stepExpected: 'Something happens',
+                    stepStatus: 'Passed',
+                    stepComments: '',
+                    isSharedStepTitle: false,
+                    actionPath: 'path1',
+                },
+            ];
+            const runResultData = [
+                {
+                    testCaseId: 1,
+                    iteration: {
+                        attachments: [{ name: 'attachment.png', actionPath: 'path1', downloadUrl: 'http://example.com' }],
+                    },
+                },
+            ];
+            // Act
+            const result = resultDataProvider.mapStepResultsForExecutionAppendix(detailedResults, runResultData);
+            // Assert
+            expect(result).toBeInstanceOf(Map);
+            expect(result.has('1')).toBe(true);
+        });
+    });
+    describe('fetchCrossTestPoints', () => {
+        it('should return empty array when no test case IDs provided', async () => {
+            // Act
+            const result = await resultDataProvider.fetchCrossTestPoints(mockProjectName, []);
+            // Assert
+            expect(result).toEqual([]);
+        });
+        it('should handle error and return empty array', async () => {
+            // Arrange
+            tfs_1.TFSServices.postRequest.mockRejectedValueOnce(new Error('API Error'));
+            // Act
+            const result = await resultDataProvider.fetchCrossTestPoints(mockProjectName, [1, 2]);
+            // Assert
+            expect(result).toEqual([]);
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+        it('should return empty array when API returns invalid response format', async () => {
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce({ data: {} });
+            const result = await resultDataProvider.fetchCrossTestPoints(mockProjectName, [1, 2]);
+            expect(result).toEqual([]);
+            expect(logger_1.default.warn).toHaveBeenCalledWith('No test points found or invalid response format');
+        });
+        it('should pick the latest point per test case and map details with defaults', async () => {
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce({
+                data: {
+                    points: [
+                        {
+                            testCase: { id: 1 },
+                            lastTestRun: { id: '1' },
+                            lastResult: { id: '5' },
+                            url: 'https://example.com/points/1',
+                        },
+                        {
+                            testCase: { id: 1 },
+                            lastTestRun: { id: '2' },
+                            lastResult: { id: '1' },
+                            url: 'https://example.com/points/2',
+                        },
+                        {
+                            testCase: { id: 2 },
+                            lastTestRun: { id: '1' },
+                            lastResult: { id: '1' },
+                            url: 'https://example.com/points/3',
+                        },
+                    ],
+                },
+            });
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce({
+                testCase: { id: 1, name: 'TC 1' },
+                testSuite: { id: 10, name: 'Suite' },
+                configuration: { name: 'Config' },
+                outcome: 'passed',
+                lastTestRun: { id: '2' },
+                lastResult: { id: '1' },
+            })
+                .mockResolvedValueOnce({
+                testCase: { id: 2, name: 'TC 2' },
+                testSuite: { id: 11, name: 'Suite' },
+                configuration: { name: 'Config' },
+                outcome: 'failed',
+                lastTestRun: { id: '1' },
+                lastResult: { id: '1' },
+                lastResultDetails: { duration: 5, dateCompleted: '2023-01-01', runBy: { displayName: 'User' } },
+            });
+            const result = await resultDataProvider.fetchCrossTestPoints(mockProjectName, [1, 2]);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith('https://example.com/points/2?witFields=Microsoft.VSTS.TCM.Steps&includePointDetails=true', mockToken);
+            expect(result).toHaveLength(2);
+            const tc1 = result.find((r) => r.testCaseId === 1);
+            expect(tc1.lastResultDetails).toEqual(expect.objectContaining({
+                duration: 0,
+                runBy: expect.objectContaining({ displayName: 'No tester' }),
+            }));
+        });
+    });
+    describe('fetchLinkedWi', () => {
+        it('should fetch linked work items and filter only open Bugs/Change Requests', async () => {
+            const testItems = [
+                {
+                    testId: 1,
+                    testName: 'TC 1',
+                    testCaseUrl: 'http://example.com/tc/1',
+                    runStatus: 'Passed',
+                },
+            ];
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce({
+                value: [
+                    {
+                        id: 1,
+                        relations: [
+                            { url: `${mockOrgUrl}_apis/wit/workItems/100` },
+                            { url: `${mockOrgUrl}_apis/wit/workItems/101` },
+                        ],
+                    },
+                ],
+            })
+                .mockResolvedValueOnce({
+                value: [
+                    {
+                        id: 100,
+                        fields: {
+                            'System.WorkItemType': 'Bug',
+                            'System.State': 'Active',
+                            'System.Title': 'Open bug',
+                            'Microsoft.VSTS.Common.Severity': '1 - Critical',
+                        },
+                    },
+                    {
+                        id: 101,
+                        fields: {
+                            'System.WorkItemType': 'Bug',
+                            'System.State': 'Closed',
+                            'System.Title': 'Closed bug',
+                        },
+                    },
+                ],
+            });
+            const result = await resultDataProvider.fetchLinkedWi(mockProjectName, testItems);
+            expect(result).toHaveLength(1);
+            expect(result[0].linkItems).toHaveLength(1);
+            expect(result[0].linkItems[0]).toEqual(expect.objectContaining({
+                pcrId: 100,
+                workItemType: 'Bug',
+                title: 'Open bug',
+                pcrUrl: `${mockOrgUrl}${mockProjectName}/_workitems/edit/100`,
+            }));
+        });
+    });
+    describe('getTestReporterResults filtering', () => {
+        it('should apply errorFilterMode=both and run-step filter and return the filtered rows', async () => {
+            const testReporterRows = [
+                {
+                    testCase: {
+                        comment: 'has comment',
+                        result: { resultMessage: 'Failed in Run 1' },
+                    },
+                    stepComments: 'step comment',
+                    stepStatus: 'Failed',
+                },
+                {
+                    testCase: {
+                        comment: '',
+                        result: { resultMessage: 'Passed' },
+                    },
+                    stepComments: '',
+                    stepStatus: 'Not Run',
+                },
+            ];
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([]);
+            jest
+                .spyOn(resultDataProvider, 'alignStepsWithIterationsTestReporter')
+                .mockReturnValueOnce(testReporterRows);
+            const linkedQueryRequest = {
+                linkedQueryMode: 'none',
+                testAssociatedQuery: { wiql: { href: 'https://example.com/wiql' }, columns: [] },
+            };
+            const result = await resultDataProvider.getTestReporterResults('planId', mockProjectName, [], [], false, true, true, linkedQueryRequest, 'both');
+            expect(result).toBeDefined();
+            const first = result[0];
+            expect(first).toBeDefined();
+            expect(first.data).toHaveLength(1);
+            expect(first.data[0].stepStatus).toBe('Failed');
+        });
+        it('should filter only test case results when errorFilterMode=onlyTestCaseResult', async () => {
+            const rows = [
+                {
+                    testCase: { comment: 'c', result: { resultMessage: 'Passed' } },
+                    stepComments: '',
+                    stepStatus: 'Not Run',
+                },
+                {
+                    testCase: { comment: '', result: { resultMessage: 'Failed in Run 1' } },
+                    stepComments: '',
+                    stepStatus: 'Not Run',
+                },
+                {
+                    testCase: { comment: '', result: { resultMessage: 'Passed' } },
+                    stepComments: '',
+                    stepStatus: 'Not Run',
+                },
+            ];
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'alignStepsWithIterationsTestReporter').mockReturnValueOnce(rows);
+            const res = await resultDataProvider.getTestReporterResults('planId', mockProjectName, [], [], false, true, false, { linkedQueryMode: 'none', testAssociatedQuery: { wiql: { href: 'x' }, columns: [] } }, 'onlyTestCaseResult');
+            expect(res[0].data).toHaveLength(2);
+        });
+        it('should filter only step results when errorFilterMode=onlyTestStepsResult', async () => {
+            const rows = [
+                {
+                    testCase: { comment: '', result: { resultMessage: 'Passed' } },
+                    stepComments: 'x',
+                    stepStatus: 'Not Run',
+                },
+                {
+                    testCase: { comment: '', result: { resultMessage: 'Passed' } },
+                    stepComments: '',
+                    stepStatus: 'Failed',
+                },
+                {
+                    testCase: { comment: '', result: { resultMessage: 'Passed' } },
+                    stepComments: '',
+                    stepStatus: 'Not Run',
+                },
+            ];
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'alignStepsWithIterationsTestReporter').mockReturnValueOnce(rows);
+            const res = await resultDataProvider.getTestReporterResults('planId', mockProjectName, [], [], false, true, false, { linkedQueryMode: 'none', testAssociatedQuery: { wiql: { href: 'x' }, columns: [] } }, 'onlyTestStepsResult');
+            expect(res[0].data).toHaveLength(2);
+        });
+        it('should execute query mode and call TicketsDataProvider when linkedQueryMode=query', async () => {
+            jest.spyOn(resultDataProvider, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([]);
+            jest.spyOn(resultDataProvider, 'alignStepsWithIterationsTestReporter').mockReturnValueOnce([]);
+            const linkedQueryRequest = {
+                linkedQueryMode: 'query',
+                testAssociatedQuery: {
+                    wiql: { href: 'https://example.com/wiql' },
+                    columns: [{ referenceName: 'X', name: 'X' }],
+                },
+            };
+            await resultDataProvider.getTestReporterResults('planId', mockProjectName, [], [], false, true, false, linkedQueryRequest, 'none');
+            const TicketsProviderMock = require('../../modules/TicketsDataProvider').default;
+            expect(TicketsProviderMock).toHaveBeenCalled();
+            const instance = TicketsProviderMock.mock.results[0].value;
+            expect(instance.GetQueryResultsFromWiql).toHaveBeenCalledWith('https://example.com/wiql', true, expect.any(Map));
+        });
+    });
+    describe('fetchResultDataForTestReporter (runResultField switch)', () => {
+        it('should populate requested runResultField values including testCaseResult URL branches', async () => {
+            jest
+                .spyOn(resultDataProvider, 'fetchResultDataBase')
+                .mockImplementation(async (...args) => {
+                const testSuiteId = args[1];
+                const formatter = args[4];
+                const extra = args[5];
+                const selectedFields = extra[0];
+                const isQueryMode = extra[1];
+                const pt = extra[2];
+                return formatter({
+                    testCase: { id: 1, name: 'TC 1' },
+                    testSuite: { name: 'Suite' },
+                    testCaseRevision: 7,
+                    resolutionState: 'x',
+                    failureType: 'FT',
+                    priority: 2,
+                    outcome: 'passed',
+                    iterationDetails: [],
+                    filteredFields: { 'Custom.Field1': 'v1' },
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                }, testSuiteId, pt, selectedFields, isQueryMode);
+            });
+            const selectedFields = [
+                'priority@runResultField',
+                'testCaseResult@runResultField',
+                'testCaseComment@runResultField',
+                'failureType@runResultField',
+                'runBy@runResultField',
+                'executionDate@runResultField',
+                'configurationName@runResultField',
+                'unknownField@runResultField',
+            ];
+            const point = {
+                lastRunId: 10,
+                lastResultId: 20,
+                configurationName: 'Cfg',
+                lastResultDetails: { runBy: { displayName: 'User' }, dateCompleted: '2023-01-01' },
+            };
+            const res = await resultDataProvider.fetchResultDataForTestReporter(mockProjectName, 'suite1', point, selectedFields, false);
+            expect(res.priority).toBe(2);
+            expect(res.testCaseResult).toEqual(expect.objectContaining({
+                resultMessage: expect.stringContaining('Run 10'),
+                url: expect.stringContaining('runId=10'),
+            }));
+            expect(res.runBy).toBe('User');
+            expect(res.executionDate).toBe('2023-01-01');
+            expect(res.configurationName).toBe('Cfg');
+            expect(res.customFields).toEqual(expect.objectContaining({ field1: 'v1' }));
+        });
+        it('should set testCaseResult url empty when lastRunId/lastResultId are undefined', async () => {
+            jest
+                .spyOn(resultDataProvider, 'fetchResultDataBase')
+                .mockImplementation(async (...args) => {
+                const testSuiteId = args[1];
+                const point = args[2];
+                const formatter = args[4];
+                const extra = args[5];
+                return formatter({
+                    testCase: { id: 1, name: 'TC 1' },
+                    testSuite: { name: 'Suite' },
+                    testCaseRevision: 1,
+                    resolutionState: 'x',
+                    failureType: 'FT',
+                    priority: 1,
+                    outcome: 'passed',
+                    iterationDetails: [],
+                }, testSuiteId, point, extra[0]);
+            });
+            const res = await resultDataProvider.fetchResultDataForTestReporter(mockProjectName, 'suite1', {
+                lastRunId: undefined,
+                lastResultId: undefined,
+                configurationName: 'Cfg',
+                lastResultDetails: { runBy: { displayName: 'U' }, dateCompleted: 'd' },
+            }, ['testCaseResult@runResultField'], false);
+            expect(res.testCaseResult).toEqual(expect.objectContaining({ url: '' }));
+        });
+    });
+    describe('fetchResultDataBasedOnWiBase', () => {
+        it('should return null and warn when runId/resultId are 0 and no point is provided', async () => {
+            const res = await resultDataProvider.fetchResultDataBasedOnWiBase(mockProjectName, '0', '0');
+            expect(res).toBeNull();
+            expect(logger_1.default.warn).toHaveBeenCalled();
+        });
+        it('should build synthetic result for Active state when runId/resultId are 0 and point is provided', async () => {
+            const point = {
+                testCaseId: '123',
+                testCaseName: 'TC 123',
+                outcome: 'passed',
+                testSuite: { id: '1', name: 'Suite' },
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                id: 123,
+                rev: 7,
+                fields: {
+                    'System.State': 'Active',
+                    'System.CreatedDate': '2023-01-01T00:00:00',
+                    'Microsoft.VSTS.TCM.Priority': 2,
+                    'System.Title': 'Title 123',
+                    'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+                },
+                relations: null,
+            });
+            const selectedFields = ['System.Title@testCaseWorkItemField'];
+            const res = await resultDataProvider.fetchResultDataBasedOnWiBase(mockProjectName, '0', '0', true, selectedFields, false, point);
+            expect(res).toEqual(expect.objectContaining({
+                id: 0,
+                failureType: 'None',
+                testCaseRevision: 7,
+                stepsResultXml: '<steps></steps>',
+                filteredFields: { 'System.Title': 'Title 123' },
+            }));
+        });
+        it('should append linked relations and filter testCaseWorkItemField when isTestReporter=true and isQueryMode=false', async () => {
+            tfs_1.TFSServices.getItemContent.mockReset();
+            const selectedFields = ['associatedBug@linked', 'System.Title@testCaseWorkItemField'];
+            // 1) run result
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce({
+                testCase: { id: 123 },
+                testCaseRevision: 7,
+                testSuite: { name: 'S' },
+            })
+                // 2) attachments
+                .mockResolvedValueOnce({ value: [] })
+                // 3) wiByRevision (with relations)
+                .mockResolvedValueOnce({
+                id: 123,
+                fields: {
+                    'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+                    'System.Title': { displayName: 'My Title' },
+                },
+                relations: [{ rel: 'System.LinkTypes.Related', url: 'https://example.com/wi/200' }],
+            })
+                // 4) linked bug
+                .mockResolvedValueOnce({
+                id: 200,
+                fields: { 'System.WorkItemType': 'Bug', 'System.State': 'Active', 'System.Title': 'B200' },
+                _links: { html: { href: 'http://example.com/200' } },
+            });
+            const res = await resultDataProvider.fetchResultDataBasedOnWiBase(mockProjectName, '10', '20', true, selectedFields, false, undefined, false);
+            expect(res).toEqual(expect.objectContaining({ testCaseRevision: 7 }));
+            expect(res.filteredFields).toEqual({ 'System.Title': 'My Title' });
+            expect(res.relatedBugs).toEqual(expect.arrayContaining([expect.objectContaining({ id: 200, title: 'B200', workItemType: 'Bug' })]));
+        });
+    });
+    describe('alignStepsWithIterationsBase - additional branches', () => {
+        it('should include not-run test cases when enabled and includeItemsWithNoIterations=true (creates test-level result)', () => {
+            const testData = [
+                {
+                    testPointsItems: [{ testCaseId: 123, lastRunId: undefined, lastResultId: undefined }],
+                    testCasesItems: [
+                        { workItem: { id: 123, workItemFields: [{ key: 'Steps', value: '<steps></steps>' }] } },
+                    ],
+                },
+            ];
+            const iterations = [
+                { testCaseId: 123, lastRunId: undefined, lastResultId: undefined, iteration: null },
+            ];
+            const createResultObject = jest.fn().mockReturnValue({ ok: true });
+            const shouldProcessStepLevel = jest.fn().mockReturnValue(false);
+            const res = resultDataProvider.alignStepsWithIterationsBase(testData, iterations, true, true, true, {
+                selectedFields: [],
+                createResultObject,
+                shouldProcessStepLevel,
+            });
+            expect(res).toEqual([{ ok: true }]);
+            expect(createResultObject).toHaveBeenCalled();
+        });
+        it('should skip items without iterations when includeItemsWithNoIterations=false', () => {
+            const testData = [
+                {
+                    testPointsItems: [{ testCaseId: 123, lastRunId: undefined, lastResultId: undefined }],
+                    testCasesItems: [
+                        { workItem: { id: 123, workItemFields: [{ key: 'Steps', value: '<steps></steps>' }] } },
+                    ],
+                },
+            ];
+            const iterations = [
+                { testCaseId: 123, lastRunId: undefined, lastResultId: undefined, iteration: null },
+            ];
+            const res = resultDataProvider.alignStepsWithIterationsBase(testData, iterations, true, false, true, {
+                selectedFields: [],
+                createResultObject: jest.fn().mockReturnValue({ ok: true }),
+                shouldProcessStepLevel: jest.fn().mockReturnValue(false),
+            });
+            expect(res).toEqual([]);
+        });
+        it('should fallback to test-level result when step-level processing enabled but actionResults is empty', () => {
+            const testData = [
+                {
+                    testPointsItems: [{ testCaseId: 123, lastRunId: '10', lastResultId: '20' }],
+                    testCasesItems: [
+                        { workItem: { id: 123, workItemFields: [{ key: 'Steps', value: '<steps></steps>' }] } },
+                    ],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 123,
+                    lastRunId: '10',
+                    lastResultId: '20',
+                    iteration: { actionResults: [] },
+                },
+            ];
+            const createResultObject = jest.fn().mockReturnValue({ mode: 'test-level' });
+            const shouldProcessStepLevel = jest.fn().mockReturnValue(true);
+            const res = resultDataProvider.alignStepsWithIterationsBase(testData, iterations, false, true, false, {
+                selectedFields: ['includeSteps@stepsRunProperties'],
+                createResultObject,
+                shouldProcessStepLevel,
+            });
+            expect(res).toEqual([{ mode: 'test-level' }]);
+            expect(createResultObject).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('getCombinedResultsSummary - optional outputs', () => {
+        it('should include open PCRs, test log, appendix-a and appendix-b when enabled', async () => {
+            jest
+                .spyOn(resultDataProvider, 'fetchTestSuites')
+                .mockResolvedValueOnce([{ testSuiteId: '1', testGroupName: 'Group 1' }]);
+            jest.spyOn(resultDataProvider, 'fetchTestPoints').mockResolvedValueOnce([
+                {
+                    testCaseId: 1,
+                    testCaseName: 'TC 1',
+                    testCaseUrl: 'http://example.com/1',
+                    configurationName: 'Cfg',
+                    outcome: 'passed',
+                    lastRunId: 10,
+                    lastResultId: 20,
+                    lastResultDetails: { dateCompleted: '2023-01-01T00:00:00.000Z', runBy: { displayName: 'User 1' } },
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([]);
+            // runResults for appendix-a filtering
+            jest.spyOn(resultDataProvider, 'fetchAllResultData').mockResolvedValueOnce([
+                {
+                    comment: 'has comment',
+                    iteration: { attachments: [] },
+                    analysisAttachments: [],
+                    lastRunId: 1,
+                    lastResultId: 2,
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'alignStepsWithIterations').mockReturnValueOnce([]);
+            const openSpy = jest
+                .spyOn(resultDataProvider, 'fetchOpenPcrData')
+                .mockResolvedValueOnce(undefined);
+            // Ensure appendix-b mapping runs but doesn't require attachments
+            jest
+                .spyOn(resultDataProvider, 'mapStepResultsForExecutionAppendix')
+                .mockReturnValueOnce(new Map());
+            const res = await resultDataProvider.getCombinedResultsSummary(mockTestPlanId, mockProjectName, undefined, false, false, { openPcrMode: 'linked', openPcrLinkedQuery: { wiql: { href: 'x' }, columns: [] } }, true, { isEnabled: true, generateAttachments: { isEnabled: true, runAttachmentMode: 'planOnly' } }, { isEnabled: true, generateRunAttachments: { isEnabled: false } }, false);
+            expect(openSpy).toHaveBeenCalled();
+            const hasTestLog = res.combinedResults.some((x) => x.contentControl === 'test-execution-content-control');
+            expect(hasTestLog).toBe(true);
+            const hasAppendixA = res.combinedResults.some((x) => x.contentControl === 'appendix-a-content-control');
+            expect(hasAppendixA).toBe(true);
+            const hasAppendixB = res.combinedResults.some((x) => x.contentControl === 'appendix-b-content-control');
+            expect(hasAppendixB).toBe(true);
+        });
+    });
+    describe('appendLinkedRelations', () => {
+        it('should append requirement/bug/cr when enabled and skip closed items', async () => {
+            const relations = [
+                { rel: 'System.LinkTypes.Related', url: 'https://example.com/wi/1' },
+                { rel: 'System.LinkTypes.Related', url: 'https://example.com/wi/2' },
+                { rel: 'System.LinkTypes.Related', url: 'https://example.com/wi/3' },
+                { rel: 'System.LinkTypes.Related', url: 'https://example.com/wi/4' },
+            ];
+            const relatedRequirements = [];
+            const relatedBugs = [];
+            const relatedCRs = [];
+            const selected = new Set(['associatedRequirement', 'associatedBug', 'associatedCR']);
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce({
+                id: 1,
+                fields: {
+                    'System.WorkItemType': 'Requirement',
+                    'System.State': 'Active',
+                    'System.Title': 'Req 1',
+                    'Custom.CustomerRequirementId': 'CUST-1',
+                },
+                _links: { html: { href: 'http://example.com/1' } },
+            })
+                .mockResolvedValueOnce({
+                id: 2,
+                fields: {
+                    'System.WorkItemType': 'Bug',
+                    'System.State': 'Active',
+                    'System.Title': 'Bug 2',
+                },
+                _links: { html: { href: 'http://example.com/2' } },
+            })
+                .mockResolvedValueOnce({
+                id: 3,
+                fields: {
+                    'System.WorkItemType': 'Change Request',
+                    'System.State': 'Active',
+                    'System.Title': 'CR 3',
+                },
+                _links: { html: { href: 'http://example.com/3' } },
+            })
+                .mockResolvedValueOnce({
+                id: 4,
+                fields: {
+                    'System.WorkItemType': 'Bug',
+                    'System.State': 'Closed',
+                    'System.Title': 'Closed bug',
+                },
+                _links: { html: { href: 'http://example.com/4' } },
+            });
+            await resultDataProvider.appendLinkedRelations(relations, relatedRequirements, relatedBugs, relatedCRs, { id: 123 }, selected);
+            expect(relatedRequirements).toHaveLength(1);
+            expect(relatedRequirements[0]).toEqual(expect.objectContaining({ id: 1, customerId: 'CUST-1', workItemType: 'Requirement' }));
+            expect(relatedBugs).toHaveLength(1);
+            expect(relatedCRs).toHaveLength(1);
+        });
+        it('should log an error when fetching a related item fails', async () => {
+            const relations = [{ rel: 'System.LinkTypes.Related', url: 'https://example.com/wi/1' }];
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('network'));
+            await resultDataProvider.appendLinkedRelations(relations, [], [], [], { id: 999 }, new Set(['associatedBug']));
+            expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Could not append related work item to test case 999'));
+        });
+    });
+    describe('appendQueryRelations', () => {
+        it('should append query relations when map has items', () => {
+            // Arrange
+            const testCaseId = 1;
+            const relatedRequirements = [];
+            const relatedBugs = [];
+            const relatedCRs = [];
+            // Set up the map
+            resultDataProvider.testToAssociatedItemMap = new Map([
+                [
+                    1,
+                    [
+                        {
+                            id: 100,
+                            fields: { 'System.Title': 'Req 1', 'System.WorkItemType': 'Requirement' },
+                            _links: { html: { href: 'http://example.com/100' } },
+                        },
+                    ],
+                ],
+            ]);
+            resultDataProvider.querySelectedColumns = [];
+            // Act
+            resultDataProvider.appendQueryRelations(testCaseId, relatedRequirements, relatedBugs, relatedCRs);
+            // Assert
+            expect(relatedRequirements).toHaveLength(1);
+            expect(relatedRequirements[0].id).toBe(100);
+        });
+        it('should map Requirement/Bug/Change Request into correct buckets', () => {
+            const testCaseId = 1;
+            const relatedRequirements = [];
+            const relatedBugs = [];
+            const relatedCRs = [];
+            jest.spyOn(resultDataProvider, 'standardCustomField').mockReturnValue({});
+            resultDataProvider.testToAssociatedItemMap = new Map([
+                [
+                    1,
+                    [
+                        {
+                            id: 10,
+                            fields: { 'System.Title': 'R', 'System.WorkItemType': 'Requirement', X: '1' },
+                            _links: { html: { href: 'http://example.com/10' } },
+                        },
+                        {
+                            id: 11,
+                            fields: { 'System.Title': 'B', 'System.WorkItemType': 'Bug', Y: '2' },
+                            _links: { html: { href: 'http://example.com/11' } },
+                        },
+                        {
+                            id: 12,
+                            fields: { 'System.Title': 'C', 'System.WorkItemType': 'Change Request', Z: '3' },
+                            _links: { html: { href: 'http://example.com/12' } },
+                        },
+                    ],
+                ],
+            ]);
+            resultDataProvider.querySelectedColumns = [];
+            resultDataProvider.appendQueryRelations(testCaseId, relatedRequirements, relatedBugs, relatedCRs);
+            expect(relatedRequirements).toHaveLength(1);
+            expect(relatedBugs).toHaveLength(1);
+            expect(relatedCRs).toHaveLength(1);
+        });
+        it('should handle empty map', () => {
+            // Arrange
+            const testCaseId = 1;
+            const relatedRequirements = [];
+            const relatedBugs = [];
+            const relatedCRs = [];
+            resultDataProvider.testToAssociatedItemMap = new Map();
+            // Act
+            resultDataProvider.appendQueryRelations(testCaseId, relatedRequirements, relatedBugs, relatedCRs);
+            // Assert
+            expect(relatedRequirements).toHaveLength(0);
+        });
+    });
+    describe('convertUnspecifiedRunStatus', () => {
+        it('should return empty string for null actionResult', () => {
+            // Act
+            const result = resultDataProvider.convertUnspecifiedRunStatus(null);
+            // Assert
+            expect(result).toBe('');
+        });
+        it('should return empty string for Unspecified shared step title', () => {
+            // Arrange
+            const actionResult = { outcome: 'Unspecified', isSharedStepTitle: true };
+            // Act
+            const result = resultDataProvider.convertUnspecifiedRunStatus(actionResult);
+            // Assert
+            expect(result).toBe('');
+        });
+        it('should return Not Run for Unspecified non-shared step', () => {
+            // Arrange
+            const actionResult = { outcome: 'Unspecified', isSharedStepTitle: false };
+            // Act
+            const result = resultDataProvider.convertUnspecifiedRunStatus(actionResult);
+            // Assert
+            expect(result).toBe('Not Run');
+        });
+        it('should return original outcome for non-Unspecified status', () => {
+            // Arrange
+            const actionResult = { outcome: 'Passed', isSharedStepTitle: false };
+            // Act
+            const result = resultDataProvider.convertUnspecifiedRunStatus(actionResult);
+            // Assert
+            expect(result).toBe('Passed');
+        });
+    });
+    describe('fetchResultDataBasedOnWi', () => {
+        it('should call fetchResultDataBasedOnWiBase', async () => {
+            // Arrange
+            const mockResult = { id: 1, outcome: 'passed' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResult);
+            // Act - just verify it doesn't throw
+            const spy = jest.spyOn(resultDataProvider, 'fetchResultDataBasedOnWiBase');
+            try {
+                await resultDataProvider.fetchResultDataBasedOnWi(mockProjectName, '100', '200');
+            }
+            catch (_a) {
+                // Expected to fail due to missing mocks
+            }
+            // Assert
+            expect(spy).toHaveBeenCalledWith(mockProjectName, '100', '200');
+        });
+    });
+    describe('alignStepsWithIterationsBase', () => {
+        it('should return empty array when no iterations', () => {
+            // Arrange
+            const testData = [];
+            const iterations = [];
+            const options = {
+                createResultObject: jest.fn(),
+                shouldProcessStepLevel: jest.fn(),
+            };
+            // Act
+            const result = resultDataProvider.alignStepsWithIterationsBase(testData, iterations, false, false, false, options);
+            // Assert
+            expect(result).toEqual([]);
+        });
+        it('should return [null] when fetchedTestCase.iteration.actionResults is null (shouldProcessStepLevel=false)', () => {
+            const testData = [
+                {
+                    testGroupName: 'G',
+                    testPointsItems: [{ testCaseId: 1, testCaseName: 'TC', lastRunId: 10, lastResultId: 20 }],
+                    testCasesItems: [{ workItem: { id: 1, workItemFields: [{ key: 'Steps', value: '<steps />' }] } }],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 1,
+                    lastRunId: 10,
+                    lastResultId: 20,
+                    iteration: { actionResults: null },
+                    testCaseRevision: 1,
+                },
+            ];
+            const res = resultDataProvider.alignStepsWithIterations(testData, iterations);
+            expect(res).toEqual([null]);
+        });
+        it('should include a null row when actionResults contains an undefined element', () => {
+            const testData = [
+                {
+                    testGroupName: 'G',
+                    testPointsItems: [{ testCaseId: 1, testCaseName: 'TC', lastRunId: 10, lastResultId: 20 }],
+                    testCasesItems: [{ workItem: { id: 1, workItemFields: [{ key: 'Steps', value: '<steps />' }] } }],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 1,
+                    lastRunId: 10,
+                    lastResultId: 20,
+                    iteration: { actionResults: [undefined] },
+                    testCaseRevision: 1,
+                },
+            ];
+            const res = resultDataProvider.alignStepsWithIterations(testData, iterations);
+            expect(res).toEqual([null]);
+        });
+    });
+    describe('standardCustomField', () => {
+        it('should standardize custom fields with columns', () => {
+            // Arrange
+            const fields = { 'Custom.Field1': 'value1', 'Custom.Field2': 'value2' };
+            const columns = [
+                { referenceName: 'Custom.Field1', name: 'Field 1' },
+                { referenceName: 'Custom.Field2', name: 'Field 2' },
+            ];
+            // Act
+            const result = resultDataProvider.standardCustomField(fields, columns);
+            // Assert
+            expect(result).toBeDefined();
+            expect(result.field1).toBe('value1');
+        });
+        it('should handle uppercase field names', () => {
+            // Arrange
+            const fields = { 'Custom.ABC': 'value1' };
+            const columns = [{ referenceName: 'Custom.ABC', name: 'ABC' }];
+            // Act
+            const result = resultDataProvider.standardCustomField(fields, columns);
+            // Assert
+            expect(result.abc).toBe('value1');
+        });
+        it('should skip standard fields', () => {
+            // Arrange
+            const fields = { 'System.Id': 1, 'Custom.Field1': 'value1' };
+            const columns = [
+                { referenceName: 'System.Id', name: 'id' },
+                { referenceName: 'Custom.Field1', name: 'Field 1' },
+            ];
+            // Act
+            const result = resultDataProvider.standardCustomField(fields, columns);
+            // Assert
+            expect(result.id).toBeUndefined();
+            expect(result.field1).toBe('value1');
+        });
+        it('should handle null/undefined field values', () => {
+            // Arrange
+            const fields = { 'Custom.Field1': null };
+            const columns = [{ referenceName: 'Custom.Field1', name: 'Field 1' }];
+            // Act
+            const result = resultDataProvider.standardCustomField(fields, columns);
+            // Assert
+            expect(result.field1).toBeNull();
+        });
+        it('should handle fields without columns', () => {
+            // Arrange
+            const fields = { 'Custom.Field1': 'value1', 'System.Title': 'Title' };
+            // Act
+            const result = resultDataProvider.standardCustomField(fields);
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should handle displayName property', () => {
+            // Arrange
+            const fields = { 'Custom.Field1': { displayName: 'Display Value' } };
+            const columns = [{ referenceName: 'Custom.Field1', name: 'Field 1' }];
+            // Act
+            const result = resultDataProvider.standardCustomField(fields, columns);
+            // Assert
+            expect(result.field1).toBe('Display Value');
+        });
+    });
+    describe('getTestOutcome', () => {
+        it('should return outcome from last iteration', () => {
+            // Arrange
+            const resultData = {
+                iterationDetails: [{ outcome: 'Failed' }, { outcome: 'Passed' }],
+                outcome: 'Failed',
+            };
+            // Act
+            const result = resultDataProvider.getTestOutcome(resultData);
+            // Assert
+            expect(result).toBe('Passed');
+        });
+        it('should return result outcome when no iteration details', () => {
+            // Arrange
+            const resultData = { outcome: 'Passed' };
+            // Act
+            const result = resultDataProvider.getTestOutcome(resultData);
+            // Assert
+            expect(result).toBe('Passed');
+        });
+        it('should return default outcome when no data', () => {
+            // Arrange
+            const resultData = {};
+            // Act
+            const result = resultDataProvider.getTestOutcome(resultData);
+            // Assert
+            expect(result).toBe('NotApplicable');
+        });
+    });
+    describe('createIterationsMap', () => {
+        it('should create iterations map from results', () => {
+            // Arrange
+            const iterations = [{ lastRunId: 100, lastResultId: 200, testCase: { id: 1 } }];
+            // Act
+            const result = resultDataProvider.createIterationsMap(iterations, false, false);
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should create iterations map from results with iteration', () => {
+            // Arrange
+            const iterations = [{ lastRunId: 100, lastResultId: 200, testCaseId: 1, iteration: { id: 1 } }];
+            // Act
+            const result = resultDataProvider.createIterationsMap(iterations, false, false);
+            // Assert
+            expect(result).toBeDefined();
+            expect(result['100-200-1']).toBeDefined();
+        });
+        it('should create iterations map for test reporter mode', () => {
+            // Arrange
+            const iterations = [{ lastRunId: 100, lastResultId: 200, testCaseId: 1 }];
+            // Act
+            const result = resultDataProvider.createIterationsMap(iterations, true, false);
+            // Assert
+            expect(result['100-200-1']).toBeDefined();
+        });
+        it('should include not run test cases when flag is set', () => {
+            // Arrange
+            const iterations = [{ testCaseId: 1 }];
+            // Act
+            const result = resultDataProvider.createIterationsMap(iterations, false, true);
+            // Assert
+            expect(result['1']).toBeDefined();
+        });
+    });
+    describe('alignStepsWithIterationsBase', () => {
+        it('should return empty array when no iterations', () => {
+            // Arrange
+            const testData = [];
+            const iterations = [];
+            const options = {
+                createResultObject: jest.fn(),
+                shouldProcessStepLevel: jest.fn(),
+            };
+            // Act
+            const result = resultDataProvider.alignStepsWithIterationsBase(testData, iterations, false, false, false, options);
+            // Assert
+            expect(result).toEqual([]);
+        });
+    });
+    describe('alignStepsWithIterations', () => {
+        it('should return empty array when no iterations', () => {
+            // Arrange
+            const testData = [];
+            const iterations = [];
+            // Act
+            const result = resultDataProvider.alignStepsWithIterations(testData, iterations);
+            // Assert
+            expect(result).toEqual([]);
+        });
+    });
+    describe('fetchTestData', () => {
+        it('should fetch test data for suites', async () => {
+            // Arrange
+            const suites = [{ testSuiteId: 1, testGroupName: 'Suite 1' }];
+            const mockTestCases = { value: [{ workItem: { id: 1 } }] };
+            const mockTestPoints = { value: [{ testCaseReference: { id: 1 } }], count: 1 };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockTestCases)
+                .mockResolvedValueOnce(mockTestPoints);
+            // Act
+            const result = await resultDataProvider.fetchTestData(suites, mockProjectName, mockTestPlanId, false);
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0].testCasesItems).toBeDefined();
+        });
+        it('should handle errors gracefully', async () => {
+            // Arrange
+            const suites = [{ testSuiteId: 1, testGroupName: 'Suite 1' }];
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('API Error'));
+            // Act
+            const result = await resultDataProvider.fetchTestData(suites, mockProjectName, mockTestPlanId, false);
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('fetchAllResultData', () => {
+        it('should return empty array when no test data', async () => {
+            // Arrange
+            const testData = [];
+            // Act
+            const result = await resultDataProvider.fetchAllResultData(testData, mockProjectName);
+            // Assert
+            expect(result).toEqual([]);
+        });
+        it('should fetch result data for test points', async () => {
+            // Arrange
+            const testData = [
+                {
+                    testPointsItems: [{ testCaseId: 1, lastRunId: 100, lastResultId: 200 }],
+                },
+            ];
+            const mockResult = {
+                testCase: { id: 1 },
+                iteration: { actionResults: [] },
+            };
+            const mockAttachments = { value: [] };
+            const mockWi = { fields: {} };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockResult)
+                .mockResolvedValueOnce(mockAttachments)
+                .mockResolvedValueOnce(mockWi);
+            // Act
+            const result = await resultDataProvider.fetchAllResultData(testData, mockProjectName);
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should log response data and rethrow when an error with response is thrown', async () => {
+            const err = new Error('boom');
+            err.response = { data: { detail: 'bad' } };
+            jest.spyOn(resultDataProvider, 'fetchTestSuites').mockRejectedValueOnce(err);
+            await expect(resultDataProvider.getCombinedResultsSummary(mockTestPlanId, mockProjectName)).rejects.toThrow('boom');
+            expect(logger_1.default.error).toHaveBeenCalledWith('Error during getCombinedResultsSummary: boom');
+            expect(logger_1.default.error).toHaveBeenCalledWith('Response Data: {"detail":"bad"}');
+        });
+    });
+    describe('fetchAllResultDataTestReporter', () => {
+        it('should return empty array when no test data', async () => {
+            // Arrange
+            const testData = [];
+            // Act
+            const result = await resultDataProvider.fetchAllResultDataTestReporter(testData, mockProjectName, [], false);
+            // Assert
+            expect(result).toEqual([]);
+        });
+    });
+    describe('alignStepsWithIterationsTestReporter', () => {
+        it('should return empty array when no iterations', () => {
+            // Arrange
+            const testData = [];
+            const iterations = [];
+            // Act
+            const result = resultDataProvider.alignStepsWithIterationsTestReporter(testData, iterations, [], false);
+            // Assert
+            expect(result).toEqual([]);
+        });
+    });
+    describe('fetchAllResultDataBase', () => {
+        it('should return empty array when no test data', async () => {
+            // Arrange
+            const testData = [];
+            const fetchStrategy = jest.fn();
+            // Act
+            const result = await resultDataProvider.fetchAllResultDataBase(testData, mockProjectName, false, fetchStrategy);
+            // Assert
+            expect(result).toEqual([]);
+        });
+        it('should filter out points without run/result IDs when not test reporter', async () => {
+            // Arrange
+            const testData = [
+                {
+                    testSuiteId: 1,
+                    testPointsItems: [
+                        { testCaseId: 1 }, // No lastRunId/lastResultId
+                    ],
+                },
+            ];
+            const fetchStrategy = jest.fn();
+            // Act
+            const result = await resultDataProvider.fetchAllResultDataBase(testData, mockProjectName, false, fetchStrategy);
+            // Assert
+            expect(fetchStrategy).not.toHaveBeenCalled();
+            expect(result).toEqual([]);
+        });
+    });
+    describe('fetchResultDataBase', () => {
+        it('should fetch result data for a point', async () => {
+            // Arrange
+            const point = { lastRunId: 100, lastResultId: 200 };
+            const mockResultData = {
+                testCase: { id: 1 },
+                iterationDetails: [],
+            };
+            const fetchResultMethod = jest.fn().mockResolvedValue(mockResultData);
+            const createResponseObject = jest.fn().mockReturnValue({ id: 1 });
+            // Act
+            const result = await resultDataProvider.fetchResultDataBase(mockProjectName, '1', point, fetchResultMethod, createResponseObject);
+            // Assert
+            expect(fetchResultMethod).toHaveBeenCalled();
+            expect(result).toBeDefined();
+        });
+    });
+    describe('getCombinedResultsSummary', () => {
+        it('should return combined results summary with expected content controls', async () => {
+            const mockTestSuites = {
+                value: [
+                    {
+                        id: 1,
+                        name: 'Root Suite',
+                        children: [{ id: 2, name: 'Child Suite 1', parentSuite: { id: 1 } }],
+                    },
+                ],
+                count: 1,
+            };
+            const mockTestPoints = {
+                value: [
+                    {
+                        testCaseReference: { id: 1, name: 'Test Case 1' },
+                        configuration: { name: 'Config 1' },
+                        results: {
+                            outcome: 'passed',
+                            lastTestRunId: 100,
+                            lastResultId: 200,
+                            lastResultDetails: { dateCompleted: '2023-01-01', runBy: { displayName: 'Test User' } },
+                        },
+                    },
+                ],
+                count: 1,
+            };
+            const mockTestCases = {
+                value: [
+                    {
+                        workItem: {
+                            id: 1,
+                            workItemFields: [{ key: 'Steps', value: '<steps>...</steps>' }],
+                        },
+                    },
+                ],
+            };
+            const mockResult = {
+                testCase: { id: 1, name: 'Test Case 1' },
+                testSuite: { id: 2, name: 'Child Suite 1' },
+                iterationDetails: [
+                    {
+                        actionResults: [
+                            { stepIdentifier: '1', outcome: 'Passed', errorMessage: '', actionPath: 'path1' },
+                        ],
+                        attachments: [],
+                    },
+                ],
+                testCaseRevision: 1,
+                failureType: null,
+                resolutionState: null,
+                comment: null,
+            };
+            // Setup mocks for API calls
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockTestSuites) // fetchTestSuites
+                .mockResolvedValueOnce(mockTestPoints) // fetchTestPoints
+                .mockResolvedValueOnce(mockTestCases) // fetchTestCasesBySuiteId
+                .mockResolvedValueOnce(mockResult) // fetchResult
+                .mockResolvedValueOnce({ value: [] }) // fetchResult - attachments
+                .mockResolvedValueOnce({ fields: {} }); // fetchResult - wiByRevision
+            const mockTestStepParserHelper = resultDataProvider.testStepParserHelper;
+            mockTestStepParserHelper.parseTestSteps.mockResolvedValueOnce([
+                {
+                    stepId: 1,
+                    stepPosition: '1',
+                    action: 'Do something',
+                    expected: 'Something happens',
+                    isSharedStepTitle: false,
+                },
+            ]);
+            // Act
+            const result = await resultDataProvider.getCombinedResultsSummary(mockTestPlanId, mockProjectName, undefined, true);
+            // Assert
+            expect(result.combinedResults.length).toBeGreaterThan(0);
+            expect(result.combinedResults[0]).toHaveProperty('contentControl', 'test-group-summary-content-control');
+            expect(result.combinedResults[1]).toHaveProperty('contentControl', 'test-result-summary-content-control');
+            expect(result.combinedResults[2]).toHaveProperty('contentControl', 'detailed-test-result-content-control');
+        });
+    });
+    describe('fetchResultDataBase - shared step mapping', () => {
+        it('should map parsed steps into actionResults, filter missing stepPosition, and sort by stepPosition', async () => {
+            const point = { testCaseId: 1, lastRunId: 10, lastResultId: 20 };
+            const fetchResultMethod = jest.fn().mockResolvedValue({
+                testCase: { id: 1, name: 'TC' },
+                stepsResultXml: '<steps></steps>',
+                iterationDetails: [
+                    {
+                        actionResults: [
+                            { stepIdentifier: '2', actionPath: 'p2', sharedStepModel: { id: 5, revision: 7 } },
+                            { stepIdentifier: '999', actionPath: 'px' },
+                            { stepIdentifier: '1', actionPath: 'p1' },
+                        ],
+                    },
+                ],
+            });
+            const createResponseObject = (resultData) => ({ iteration: resultData.iterationDetails[0] });
+            const helper = resultDataProvider.testStepParserHelper;
+            helper.parseTestSteps.mockImplementationOnce(async (_xml, map) => {
+                // cover sharedStepIdToRevisionLookupMap population
+                expect(map.get(5)).toBe(7);
+                return [
+                    { stepId: 1, stepPosition: '1', action: 'A1', expected: 'E1', isSharedStepTitle: false },
+                    { stepId: 2, stepPosition: '2', action: 'A2', expected: 'E2', isSharedStepTitle: true },
+                ];
+            });
+            const res = await resultDataProvider.fetchResultDataBase(mockProjectName, 'suite1', point, fetchResultMethod, createResponseObject, []);
+            const actionResults = res.iteration.actionResults;
+            // 999 should be filtered out (no stepPosition)
+            expect(actionResults).toHaveLength(2);
+            // sorted by stepPosition numeric
+            expect(actionResults[0]).toEqual(expect.objectContaining({ stepIdentifier: '1', action: 'A1' }));
+            expect(actionResults[1]).toEqual(expect.objectContaining({ stepIdentifier: '2', action: 'A2', isSharedStepTitle: true }));
+        });
+    });
+    describe('getCombinedResultsSummary - appendix branches', () => {
+        it('should use mapAttachmentsUrl when stepAnalysis.generateRunAttachments is enabled and stepExecution.runAttachmentMode != planOnly', async () => {
+            jest
+                .spyOn(resultDataProvider, 'fetchTestSuites')
+                .mockResolvedValueOnce([{ testSuiteId: '1', testGroupName: 'Group 1' }]);
+            jest.spyOn(resultDataProvider, 'fetchTestPoints').mockResolvedValueOnce([
+                {
+                    testCaseId: 1,
+                    testCaseName: 'TC 1',
+                    testCaseUrl: 'http://example.com/1',
+                    configurationName: 'Cfg',
+                    outcome: 'passed',
+                    lastRunId: 10,
+                    lastResultId: 20,
+                    lastResultDetails: { dateCompleted: '2023-01-01T00:00:00.000Z', runBy: { displayName: 'User 1' } },
+                },
+            ]);
+            jest.spyOn(resultDataProvider, 'fetchTestData').mockResolvedValueOnce([]);
+            // ensure all predicates in stepAnalysis/filter can be true (comment false, attachments true, analysisAttachments true)
+            const runResults = [
+                {
+                    comment: '',
+                    iteration: { attachments: [{ actionPath: 'p', name: 'n', downloadUrl: 'd' }] },
+                    analysisAttachments: [{ id: 1 }],
+                },
+            ];
+            jest.spyOn(resultDataProvider, 'fetchAllResultData').mockResolvedValueOnce(runResults);
+            jest.spyOn(resultDataProvider, 'alignStepsWithIterations').mockReturnValueOnce([]);
+            const mapSpy = jest
+                .spyOn(resultDataProvider, 'mapAttachmentsUrl')
+                .mockReturnValueOnce(runResults)
+                .mockReturnValueOnce(runResults);
+            jest
+                .spyOn(resultDataProvider, 'mapStepResultsForExecutionAppendix')
+                .mockReturnValueOnce(new Map());
+            const res = await resultDataProvider.getCombinedResultsSummary(mockTestPlanId, mockProjectName, undefined, false, false, null, false, { isEnabled: true, generateAttachments: { isEnabled: true, runAttachmentMode: 'runOnly' } }, { isEnabled: true, generateRunAttachments: { isEnabled: true } }, false);
+            expect(mapSpy).toHaveBeenCalled();
+            expect(res.combinedResults.some((x) => x.contentControl === 'appendix-a-content-control')).toBe(true);
+            expect(res.combinedResults.some((x) => x.contentControl === 'appendix-b-content-control')).toBe(true);
+        });
+    });
+    describe('alignStepsWithIterationsTestReporter - step-level rows', () => {
+        it('should emit step-level fields when includeSteps/stepRunStatus/testStepComment are selected', () => {
+            const testData = [
+                {
+                    testGroupName: 'G',
+                    testPointsItems: [
+                        {
+                            testCaseId: 123,
+                            testCaseName: 'TC',
+                            testCaseUrl: 'u',
+                            lastRunId: 10,
+                            lastResultId: 20,
+                        },
+                    ],
+                    testCasesItems: [
+                        { workItem: { id: 123, workItemFields: [{ key: 'Steps', value: '<steps></steps>' }] } },
+                    ],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 123,
+                    lastRunId: 10,
+                    lastResultId: 20,
+                    iteration: {
+                        actionResults: [
+                            {
+                                stepIdentifier: '1',
+                                stepPosition: '1',
+                                action: 'A',
+                                expected: 'E',
+                                outcome: 'Unspecified',
+                                isSharedStepTitle: false,
+                                errorMessage: 'err',
+                            },
+                        ],
+                    },
+                    testCaseResult: 'Failed',
+                    comment: 'c',
+                    runBy: { displayName: 'u' },
+                    failureType: 'ft',
+                    executionDate: 'd',
+                    configurationName: 'cfg',
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                    customFields: {},
+                },
+            ];
+            const res = resultDataProvider.alignStepsWithIterationsTestReporter(testData, iterations, [
+                'includeSteps@stepsRunProperties',
+                'stepRunStatus@stepsRunProperties',
+                'testStepComment@stepsRunProperties',
+            ], true);
+            expect(res).toHaveLength(1);
+            expect(res[0]).toEqual(expect.objectContaining({
+                stepNo: '1',
+                stepAction: 'A',
+                stepExpected: 'E',
+                stepStatus: 'Not Run',
+                stepComments: 'err',
+            }));
+        });
+        it('should omit step fields when no @stepsRunProperties are selected', () => {
+            const testData = [
+                {
+                    testGroupName: 'G',
+                    testPointsItems: [
+                        { testCaseId: 123, testCaseName: 'TC', testCaseUrl: 'u', lastRunId: 10, lastResultId: 20 },
+                    ],
+                    testCasesItems: [
+                        { workItem: { id: 123, workItemFields: [{ key: 'Steps', value: '<steps></steps>' }] } },
+                    ],
+                },
+            ];
+            const iterations = [
+                {
+                    testCaseId: 123,
+                    lastRunId: 10,
+                    lastResultId: 20,
+                    iteration: {
+                        actionResults: [{ stepIdentifier: '1', stepPosition: '1', action: 'A', expected: 'E' }],
+                    },
+                    testCaseResult: 'Passed',
+                    comment: '',
+                    runBy: { displayName: 'u' },
+                    failureType: '',
+                    executionDate: 'd',
+                    configurationName: 'cfg',
+                    relatedRequirements: [],
+                    relatedBugs: [],
+                    relatedCRs: [],
+                    customFields: {},
+                },
+            ];
+            const res = resultDataProvider.alignStepsWithIterationsTestReporter(testData, iterations, [], true);
+            expect(res).toHaveLength(1);
+            expect(res[0].stepNo).toBeUndefined();
+        });
+    });
+    describe('fetchOpenPcrData', () => {
+        it('should populate both trace maps using linked work items', async () => {
+            const testItems = [
+                {
+                    testId: 1,
+                    testName: 'T1',
+                    testCaseUrl: 'u1',
+                    runStatus: 'Passed',
+                },
+            ];
+            const linked = [
+                {
+                    testId: 1,
+                    testName: 'T1',
+                    testCaseUrl: 'u1',
+                    runStatus: 'Passed',
+                    linkItems: [
+                        {
+                            pcrId: 10,
+                            workItemType: 'Bug',
+                            title: 'B10',
+                            severity: '2',
+                            pcrUrl: 'p10',
+                        },
+                    ],
+                },
+            ];
+            jest.spyOn(resultDataProvider, 'fetchLinkedWi').mockResolvedValueOnce(linked);
+            const openPcrToTestCaseTraceMap = new Map();
+            const testCaseToOpenPcrTraceMap = new Map();
+            await resultDataProvider.fetchOpenPcrData(testItems, mockProjectName, openPcrToTestCaseTraceMap, testCaseToOpenPcrTraceMap);
+            expect(openPcrToTestCaseTraceMap.size).toBe(1);
+            expect(testCaseToOpenPcrTraceMap.size).toBe(1);
+        });
+    });
+});
+//# sourceMappingURL=ResultDataProvider.test.js.map