@elisra-devops/docgen-data-provider 1.63.12 → 1.67.0

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

@@ -0,0 +1,717 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tfs_1 = require("../../helpers/tfs");
+const helper_1 = require("../../helpers/helper");
+const TestDataProvider_1 = require("../../modules/TestDataProvider");
+const logger_1 = require("../../utils/logger");
+jest.mock('../../helpers/tfs');
+jest.mock('../../utils/logger');
+jest.mock('../../helpers/helper');
+jest.mock('../../utils/testStepParserHelper', () => {
+    return {
+        __esModule: true,
+        default: jest.fn().mockImplementation(() => ({
+            parseTestSteps: jest.fn(),
+        })),
+    };
+});
+jest.mock('p-limit', () => jest.fn(() => (fn) => fn()));
+describe('TestDataProvider', () => {
+    let testDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockProject = 'project-123';
+    const mockPlanId = '456';
+    const mockSuiteId = '789';
+    const mockTestCaseId = '101112';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        testDataProvider = new TestDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    // Helper to access private method for testing
+    const invokeFetchWithCache = async (instance, url, ttl = 60000) => {
+        return instance.fetchWithCache.call(instance, url, ttl);
+    };
+    describe('fetchWithCache', () => {
+        it('should return cached data when available and not expired', async () => {
+            // Arrange
+            const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
+            const mockData = { value: 'test data' };
+            const cache = new Map();
+            cache.set(mockUrl, {
+                data: mockData,
+                timestamp: Date.now(),
+            });
+            testDataProvider.cache = cache;
+            // Act
+            const result = await invokeFetchWithCache(testDataProvider, mockUrl);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).not.toHaveBeenCalled();
+        });
+        it('should fetch new data when cache is expired', async () => {
+            // Arrange
+            const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
+            const mockData = { value: 'old data' };
+            const newData = { value: 'new data' };
+            const cache = new Map();
+            cache.set(mockUrl, {
+                data: mockData,
+                timestamp: Date.now() - 70000, // Expired (default TTL is 60000ms)
+            });
+            testDataProvider.cache = cache;
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(newData);
+            // Act
+            const result = await invokeFetchWithCache(testDataProvider, mockUrl);
+            // Assert
+            expect(result).toEqual(newData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(mockUrl, mockToken);
+        });
+        it('should fetch and cache new data when not in cache', async () => {
+            // Arrange
+            const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
+            const mockData = { value: 'new data' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockData);
+            // Act
+            const result = await invokeFetchWithCache(testDataProvider, mockUrl);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(mockUrl, mockToken);
+            expect(testDataProvider.cache.has(mockUrl)).toBeTruthy();
+            expect(testDataProvider.cache.get(mockUrl).data).toEqual(mockData);
+        });
+        it('should throw and log error when fetch fails', async () => {
+            // Arrange
+            const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
+            const mockError = new Error('API call failed');
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+            // Act & Assert
+            await expect(invokeFetchWithCache(testDataProvider, mockUrl)).rejects.toThrow('API call failed');
+            expect(logger_1.default.error).toHaveBeenCalledWith(`Error fetching ${mockUrl}: API call failed`);
+        });
+    });
+    describe('GetTestSuiteByTestCase', () => {
+        it('should return test suites for a given test case ID', async () => {
+            // Arrange
+            const mockData = { value: [{ id: '123', name: 'Test Suite 1' }] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockData);
+            // Act
+            const result = await testDataProvider.GetTestSuiteByTestCase(mockTestCaseId);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}_apis/testplan/suites?testCaseId=${mockTestCaseId}`, mockToken);
+        });
+    });
+    describe('GetTestPlans', () => {
+        it('should return test plans for a given project', async () => {
+            // Arrange
+            const mockData = {
+                value: [
+                    { id: '456', name: 'Test Plan 1' },
+                    { id: '789', name: 'Test Plan 2' },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockData);
+            // Act
+            const result = await testDataProvider.GetTestPlans(mockProject);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/plans`, mockToken);
+        });
+    });
+    describe('GetTestSuites', () => {
+        it('should return test suites for a given project and plan ID', async () => {
+            // Arrange
+            const mockData = {
+                value: [
+                    { id: '123', name: 'Test Suite 1' },
+                    { id: '456', name: 'Test Suite 2' },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockData);
+            // Act
+            const result = await testDataProvider.GetTestSuites(mockProject, mockPlanId);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/Plans/${mockPlanId}/suites`, mockToken);
+        });
+        it('should return null and log error if fetching test suites fails', async () => {
+            // Arrange
+            const mockError = new Error('Failed to get test suites');
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+            // Act
+            const result = await testDataProvider.GetTestSuites(mockProject, mockPlanId);
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+    describe('GetTestSuitesForPlan', () => {
+        it('should throw error when project is not provided', async () => {
+            // Act & Assert
+            await expect(testDataProvider.GetTestSuitesForPlan('', mockPlanId)).rejects.toThrow('Project not selected');
+        });
+        it('should throw error when plan ID is not provided', async () => {
+            // Act & Assert
+            await expect(testDataProvider.GetTestSuitesForPlan(mockProject, '')).rejects.toThrow('Plan not selected');
+        });
+        it('should return test suites for a plan', async () => {
+            // Arrange
+            const mockData = {
+                testSuites: [
+                    { id: '123', name: 'Test Suite 1' },
+                    { id: '456', name: 'Test Suite 2' },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockData);
+            // Act
+            const result = await testDataProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}/${mockProject}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${mockPlanId}`, mockToken);
+        });
+    });
+    describe('GetTestSuiteById', () => {
+        it('should call GetTestSuitesForPlan and Helper.findSuitesRecursive with correct params', async () => {
+            // Arrange
+            const mockTestSuites = { testSuites: [{ id: '123', name: 'Test Suite 1' }] };
+            const mockSuiteData = [new helper_1.suiteData('Test Suite 1', '123', '456', 1)];
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockTestSuites);
+            helper_1.Helper.findSuitesRecursive.mockReturnValueOnce(mockSuiteData);
+            // Act
+            const result = await testDataProvider.GetTestSuiteById(mockProject, mockPlanId, mockSuiteId, true);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}/${mockProject}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${mockPlanId}`, mockToken);
+            expect(helper_1.Helper.findSuitesRecursive).toHaveBeenCalledWith(mockPlanId, mockOrgUrl, mockProject, mockTestSuites.testSuites, mockSuiteId, true);
+            expect(result).toEqual(mockSuiteData);
+        });
+    });
+    describe('GetTestCases', () => {
+        it('should return test cases for a given project, plan ID, and suite ID', async () => {
+            // Arrange
+            const mockData = {
+                count: 2,
+                value: [
+                    { testCase: { id: '101', name: 'Test Case 1', url: 'url1' } },
+                    { testCase: { id: '102', name: 'Test Case 2', url: 'url2' } },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockData);
+            // Act
+            const result = await testDataProvider.GetTestCases(mockProject, mockPlanId, mockSuiteId);
+            // Assert
+            expect(result).toEqual(mockData);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/Plans/${mockPlanId}/suites/${mockSuiteId}/testcases/`, mockToken);
+            expect(logger_1.default.debug).toHaveBeenCalledWith(`test cases for plan ${mockPlanId} and ${mockSuiteId} were found`);
+        });
+    });
+    describe('clearCache', () => {
+        it('should clear the cache', () => {
+            // Arrange
+            const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
+            const mockData = { value: 'test data' };
+            const cache = new Map();
+            cache.set(mockUrl, {
+                data: mockData,
+                timestamp: Date.now(),
+            });
+            testDataProvider.cache = cache;
+            // Act
+            testDataProvider.clearCache();
+            // Assert
+            expect(testDataProvider.cache.size).toBe(0);
+            expect(logger_1.default.debug).toHaveBeenCalledWith('Cache cleared');
+        });
+    });
+    describe('UpdateTestRun', () => {
+        it('should update a test run with the correct state', async () => {
+            // Arrange
+            const mockRunId = '12345';
+            const mockState = 'Completed';
+            const mockResponse = { id: mockRunId, state: mockState };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.UpdateTestRun(mockProject, mockRunId, mockState);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(tfs_1.TFSServices.postRequest).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/Runs/${mockRunId}?api-version=5.0`, mockToken, 'PATCH', { state: mockState }, null);
+            expect(logger_1.default.info).toHaveBeenCalledWith(`Update runId : ${mockRunId} to state : ${mockState}`);
+        });
+    });
+    describe('GetTestSuitesByPlan', () => {
+        it('should return suites without filter using default suiteId', async () => {
+            // Arrange
+            const mockTestSuites = { testSuites: [{ id: 457, name: 'Suite 1', parentSuiteId: 0 }] };
+            const mockSuiteData = [new helper_1.suiteData('Suite 1', '457', '456', 1)];
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockTestSuites);
+            helper_1.Helper.findSuitesRecursive.mockReturnValue(mockSuiteData);
+            // Act
+            const result = await testDataProvider.GetTestSuitesByPlan(mockProject, mockPlanId, true);
+            // Assert
+            expect(helper_1.Helper.findSuitesRecursive).toHaveBeenCalled();
+        });
+        it('should process multiple top-level suite hierarchies and combine results', async () => {
+            jest.spyOn(testDataProvider, 'GetTestSuitesForPlan').mockResolvedValueOnce({
+                testSuites: [
+                    { id: 1, parentSuiteId: 0 },
+                    { id: 2, parentSuiteId: 0 },
+                    { id: 10, parentSuiteId: 1 },
+                    { id: 11, parentSuiteId: 2 },
+                ],
+            });
+            const suiteIdsFilter = [10, 11];
+            const getByIdSpy = jest
+                .spyOn(testDataProvider, 'GetTestSuiteById')
+                .mockResolvedValueOnce([{ id: '10' }])
+                .mockResolvedValueOnce([{ id: '11' }]);
+            const res = await testDataProvider.GetTestSuitesByPlan(mockProject, mockPlanId, true, suiteIdsFilter);
+            expect(getByIdSpy).toHaveBeenCalledTimes(2);
+            expect(res).toEqual([{ id: '10' }, { id: '11' }]);
+        });
+        it('should fallback to first suite when no top-level suites can be determined', async () => {
+            jest.spyOn(testDataProvider, 'GetTestSuitesForPlan').mockResolvedValueOnce({
+                testSuites: [{ id: 1, parentSuiteId: 0 }],
+            });
+            const getByIdSpy = jest
+                .spyOn(testDataProvider, 'GetTestSuiteById')
+                .mockResolvedValueOnce([{ id: '1' }]);
+            const res = await testDataProvider.GetTestSuitesByPlan(mockProject, mockPlanId, true, [1]);
+            expect(getByIdSpy).toHaveBeenCalledWith(mockProject, mockPlanId, '1', true, [1]);
+            expect(res).toEqual([{ id: '1' }]);
+        });
+    });
+    describe('createNewRequirement', () => {
+        it('should pick customer id from any supported customer fields when enabled', () => {
+            const rel = testDataProvider.createNewRequirement(true, {
+                id: '123',
+                fields: {
+                    'System.Title': 'Req title',
+                    'Custom.CustomerID': 'CID-1',
+                },
+            });
+            expect(rel).toEqual({ type: 'requirement', id: '123', title: 'Req title', customerId: 'CID-1' });
+        });
+        it('should default customerId to a single space when enabled and no field exists', () => {
+            const rel = testDataProvider.createNewRequirement(true, {
+                id: '123',
+                fields: {
+                    'System.Title': 'Req title',
+                },
+            });
+            expect(rel).toEqual({ type: 'requirement', id: '123', title: 'Req title', customerId: ' ' });
+        });
+    });
+    describe('addToMap', () => {
+        it('should create array for missing key and append values', () => {
+            const map = new Map();
+            testDataProvider.addToMap(map, 'k', 'v1');
+            testDataProvider.addToMap(map, 'k', 'v2');
+            expect(map.get('k')).toEqual(['v1', 'v2']);
+        });
+    });
+    describe('GetTestSuiteById with filtering', () => {
+        it('should filter suites when suiteIdsFilter is provided', async () => {
+            // Arrange
+            const suiteIdsFilter = [123, 456];
+            const mockTestSuites = {
+                testSuites: [
+                    { id: 123, name: 'Suite 1', parentSuiteId: 100 },
+                    { id: 456, name: 'Suite 2', parentSuiteId: 100 },
+                ],
+            };
+            const mockSuiteData = [new helper_1.suiteData('Suite 1', '123', '100', 1)];
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockTestSuites);
+            helper_1.Helper.findSuitesRecursive.mockReturnValue(mockSuiteData);
+            // Act
+            const result = await testDataProvider.GetTestSuiteById(mockProject, mockPlanId, '123', true, suiteIdsFilter);
+            // Assert
+            expect(helper_1.Helper.findSuitesRecursive).toHaveBeenCalled();
+        });
+    });
+    describe('GetTestPoint', () => {
+        it('should return test points for a test case', async () => {
+            // Arrange
+            const mockResponse = { value: [{ id: 1, testCaseId: mockTestCaseId }] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockResponse);
+            // Act
+            const result = await testDataProvider.GetTestPoint(mockProject, mockPlanId, mockSuiteId, mockTestCaseId);
+            // Assert
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('CreateTestRun', () => {
+        it('should create a test run successfully', async () => {
+            // Arrange
+            const testRunName = 'Test Run 1';
+            const testPointId = '12345';
+            const mockResponse = { data: { id: 1, name: testRunName } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.CreateTestRun(mockProject, testRunName, mockPlanId, testPointId);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(tfs_1.TFSServices.postRequest).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/runs`, mockToken, 'Post', {
+                name: testRunName,
+                plan: { id: mockPlanId },
+                pointIds: [testPointId],
+            }, null);
+        });
+        it('should throw error when creation fails', async () => {
+            // Arrange
+            const testRunName = 'Test Run 1';
+            const testPointId = '12345';
+            const mockError = new Error('Creation failed');
+            tfs_1.TFSServices.postRequest.mockRejectedValueOnce(mockError);
+            // Act & Assert
+            await expect(testDataProvider.CreateTestRun(mockProject, testRunName, mockPlanId, testPointId)).rejects.toThrow('Error: Creation failed');
+        });
+    });
+    describe('UpdateTestCase', () => {
+        it('should update test case to Active state (0)', async () => {
+            // Arrange
+            const mockRunId = '12345';
+            const mockResponse = { data: { outcome: '0' } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.UpdateTestCase(mockProject, mockRunId, 0);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(logger_1.default.info).toHaveBeenCalledWith('Reset test case to Active state ');
+        });
+        it('should update test case to Completed state (1)', async () => {
+            // Arrange
+            const mockRunId = '12345';
+            const mockResponse = { data: { state: 'Completed', outcome: '1' } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.UpdateTestCase(mockProject, mockRunId, 1);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(logger_1.default.info).toHaveBeenCalledWith('Update test case to complite state ');
+        });
+        it('should update test case to Passed state (2)', async () => {
+            // Arrange
+            const mockRunId = '12345';
+            const mockResponse = { data: { state: 'Completed', outcome: '2' } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.UpdateTestCase(mockProject, mockRunId, 2);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(logger_1.default.info).toHaveBeenCalledWith('Update test case to passed state ');
+        });
+        it('should update test case to Failed state (3)', async () => {
+            // Arrange
+            const mockRunId = '12345';
+            const mockResponse = { data: { state: 'Completed', outcome: '3' } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.UpdateTestCase(mockProject, mockRunId, 3);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(logger_1.default.info).toHaveBeenCalledWith('Update test case to failed state ');
+        });
+    });
+    describe('UploadTestAttachment', () => {
+        it('should upload attachment to test run', async () => {
+            // Arrange
+            const runId = '12345';
+            const stream = 'base64encodeddata';
+            const fileName = 'test.png';
+            const comment = 'Test attachment';
+            const attachmentType = 'GeneralAttachment';
+            const mockResponse = { data: { id: 1 } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.UploadTestAttachment(runId, mockProject, stream, fileName, comment, attachmentType);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(tfs_1.TFSServices.postRequest).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/Runs/${runId}/attachments?api-version=5.0-preview.1`, mockToken, 'Post', { stream, fileName, comment, attachmentType }, null);
+        });
+    });
+    describe('GetTestRunById', () => {
+        it('should return test run by ID', async () => {
+            // Arrange
+            const runId = '12345';
+            const mockResponse = { id: runId, name: 'Test Run 1' };
+            // Act
+            const result = await testDataProvider.GetTestRunById(mockProject, runId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalled();
+        });
+    });
+    describe('GetTestPointByTestCaseId', () => {
+        it('should return test points for a test case ID', async () => {
+            // Arrange
+            const mockResponse = { data: { value: [{ id: 1 }] } };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await testDataProvider.GetTestPointByTestCaseId(mockProject, mockTestCaseId);
+            // Assert
+            expect(result).toEqual(mockResponse);
+            expect(tfs_1.TFSServices.postRequest).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/test/points`, mockToken, 'Post', { PointsFilter: { TestcaseIds: [mockTestCaseId] } }, null);
+        });
+    });
+    describe('GetTestCasesBySuites', () => {
+        it('should return test cases for suites', async () => {
+            // Arrange
+            const mockSuiteData = [new helper_1.suiteData('Suite 1', '123', '456', 1)];
+            const mockTestCases = {
+                count: 1,
+                value: [{ testCase: { id: '101', url: 'http://test.com/101' } }],
+            };
+            const mockTestCaseDetails = {
+                id: 101,
+                fields: {
+                    'System.Title': 'Test Case 1',
+                    'System.AreaPath': 'Area/Path',
+                    'System.Description': 'Description',
+                    'Microsoft.VSTS.TCM.Steps': null,
+                },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce({ testSuites: mockSuiteData })
+                .mockResolvedValueOnce(mockTestCases)
+                .mockResolvedValueOnce(mockTestCaseDetails);
+            helper_1.Helper.findSuitesRecursive.mockReturnValueOnce(mockSuiteData);
+            // Act
+            const result = await testDataProvider.GetTestCasesBySuites(mockProject, mockPlanId, mockSuiteId, false, false, false, false);
+            // Assert
+            expect(result.testCasesList).toBeDefined();
+            expect(result.requirementToTestCaseTraceMap).toBeDefined();
+            expect(result.testCaseToRequirementsTraceMap).toBeDefined();
+        });
+        it('should use pre-filtered suites when provided', async () => {
+            // Arrange
+            const preFilteredSuites = [new helper_1.suiteData('Suite 1', '123', '456', 1)];
+            const mockTestCases = {
+                count: 1,
+                value: [{ testCase: { id: '101', url: 'http://test.com/101' } }],
+            };
+            const mockTestCaseDetails = {
+                id: 101,
+                fields: {
+                    'System.Title': 'Test Case 1',
+                    'System.AreaPath': 'Area/Path',
+                    'System.Description': 'Description',
+                    'Microsoft.VSTS.TCM.Steps': null,
+                },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockTestCases)
+                .mockResolvedValueOnce(mockTestCaseDetails);
+            // Act
+            const result = await testDataProvider.GetTestCasesBySuites(mockProject, mockPlanId, mockSuiteId, false, false, false, false, undefined, undefined, preFilteredSuites);
+            // Assert
+            expect(result.testCasesList).toBeDefined();
+        });
+        it('should handle errors in suite processing', async () => {
+            // Arrange
+            const preFilteredSuites = [new helper_1.suiteData('Suite 1', '123', '456', 1)];
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('API Error'));
+            // Act
+            const result = await testDataProvider.GetTestCasesBySuites(mockProject, mockPlanId, mockSuiteId, false, false, false, false, undefined, undefined, preFilteredSuites);
+            // Assert
+            expect(result.testCasesList).toEqual([]);
+        });
+    });
+    describe('StructureTestCase', () => {
+        it('should return empty array when no test cases', async () => {
+            // Arrange
+            const suite = new helper_1.suiteData('Suite 1', '123', '456', 1);
+            const testCases = { count: 0, value: [] };
+            // Act
+            const result = await testDataProvider.StructureTestCase(mockProject, testCases, suite, false, false, false, new Map(), new Map());
+            // Assert
+            expect(result).toEqual([]);
+            expect(logger_1.default.warn).toHaveBeenCalled();
+        });
+        it('should warn and return [] when no testCases are provided', async () => {
+            const res = await testDataProvider.StructureTestCase(mockProject, { value: [], count: 0 }, { id: '1', name: 'Suite 1' }, true, true, false, new Map(), new Map());
+            expect(res).toEqual([]);
+            expect(logger_1.default.warn).toHaveBeenCalledWith('No test cases found for suite: 1');
+        });
+        it('should parse steps, add requirement relation when enabled, and add mom relation when enabled', async () => {
+            const UtilsMock = require('../../utils/testStepParserHelper').default;
+            const parserInstance = UtilsMock.mock.results[0].value;
+            parserInstance.parseTestSteps.mockResolvedValueOnce([{ stepId: '1' }]);
+            const suite = { id: '1', name: 'Suite 1' };
+            const testCases = {
+                count: 1,
+                value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+            };
+            jest.spyOn(testDataProvider, 'fetchWithCache').mockImplementation(async (...args) => {
+                const url = String(args[0] || '');
+                if (url.includes('testcase/123') && url.includes('?$expand=All')) {
+                    return {
+                        id: 123,
+                        fields: {
+                            'System.Title': 'TC 123',
+                            'System.AreaPath': 'A',
+                            'System.Description': 'D',
+                            'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+                        },
+                        relations: [
+                            { url: 'https://example.com/_apis/wit/workItems/200' },
+                            { url: 'https://example.com/not-work-items/ignore' },
+                            { url: 'https://example.com/_apis/wit/workItems/201' },
+                        ],
+                    };
+                }
+                if (url.includes('/workItems/200')) {
+                    return {
+                        id: 200,
+                        fields: {
+                            'System.WorkItemType': 'Requirement',
+                            'System.Title': 'REQ 200',
+                            'Custom.CustomerRequirementId': 'C-200',
+                        },
+                        _links: { html: { href: 'http://example.com/200' } },
+                    };
+                }
+                if (url.includes('/workItems/201')) {
+                    return {
+                        id: 201,
+                        fields: {
+                            'System.WorkItemType': 'Bug',
+                            'System.Title': 'BUG 201',
+                            'System.State': 'Active',
+                        },
+                        _links: { html: { href: 'http://example.com/201' } },
+                    };
+                }
+                throw new Error(`unexpected url ${url}`);
+            });
+            const requirementToTestCaseTraceMap = new Map();
+            const testCaseToRequirementsTraceMap = new Map();
+            const res = await testDataProvider.StructureTestCase(mockProject, testCases, suite, true, true, true, requirementToTestCaseTraceMap, testCaseToRequirementsTraceMap);
+            expect(res).toHaveLength(1);
+            expect(res[0].steps).toEqual([{ stepId: '1' }]);
+            expect(res[0].relations).toEqual(expect.arrayContaining([
+                expect.objectContaining({ type: 'requirement', id: 200, customerId: 'C-200' }),
+            ]));
+            expect(res[0].relations).toEqual(expect.arrayContaining([expect.objectContaining({ type: 'Bug', id: 201 })]));
+            expect(requirementToTestCaseTraceMap.size).toBe(1);
+            expect(testCaseToRequirementsTraceMap.size).toBe(1);
+        });
+        it('should use stepResultDetailsMap when provided and skip parseTestSteps', async () => {
+            const UtilsMock = require('../../utils/testStepParserHelper').default;
+            const parserInstance = UtilsMock.mock.results[0].value;
+            parserInstance.parseTestSteps.mockClear();
+            const suite = { id: '1', name: 'Suite 1' };
+            const testCases = {
+                count: 1,
+                value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+            };
+            const stepResultDetailsMap = new Map();
+            stepResultDetailsMap.set('123', {
+                testCaseRevision: 7,
+                stepList: [{ stepId: 'from-cache' }],
+                caseEvidenceAttachments: [{ id: 1 }],
+            });
+            jest.spyOn(testDataProvider, 'fetchWithCache').mockResolvedValueOnce({
+                id: 123,
+                fields: {
+                    'System.Title': 'TC 123',
+                    'System.AreaPath': 'A',
+                    'System.Description': 'D',
+                    'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+                },
+                relations: [],
+            });
+            const res = await testDataProvider.StructureTestCase(mockProject, testCases, suite, true, false, false, new Map(), new Map(), stepResultDetailsMap);
+            expect(res).toHaveLength(1);
+            expect(res[0].steps).toEqual([{ stepId: 'from-cache' }]);
+            expect(res[0].caseEvidenceAttachments).toEqual([{ id: 1 }]);
+            expect(parserInstance.parseTestSteps).not.toHaveBeenCalled();
+        });
+        it('should log error and continue when fetching relation content fails', async () => {
+            const suite = { id: '1', name: 'Suite 1' };
+            const testCases = {
+                count: 1,
+                value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+            };
+            jest.spyOn(testDataProvider, 'fetchWithCache').mockImplementation(async (...args) => {
+                const url = String(args[0] || '');
+                if (url.includes('testcase/123') && url.includes('?$expand=All')) {
+                    return {
+                        id: 123,
+                        fields: {
+                            'System.Title': 'TC 123',
+                            'System.AreaPath': 'A',
+                            'System.Description': 'D',
+                            'Microsoft.VSTS.TCM.Steps': null,
+                        },
+                        relations: [{ url: 'https://example.com/_apis/wit/workItems/200' }],
+                    };
+                }
+                if (url.includes('/workItems/200')) {
+                    throw new Error('boom');
+                }
+                return null;
+            });
+            const res = await testDataProvider.StructureTestCase(mockProject, testCases, suite, true, true, false, new Map(), new Map());
+            expect(res).toHaveLength(1);
+            expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Failed to fetch relation content for URL https://example.com/_apis/wit/workItems/200'));
+        });
+        it('should append linked MOMs from testCaseToLinkedMomLookup when provided', async () => {
+            const suite = { id: '1', name: 'Suite 1' };
+            const testCases = {
+                count: 1,
+                value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+            };
+            jest.spyOn(testDataProvider, 'fetchWithCache').mockResolvedValueOnce({
+                id: 123,
+                fields: {
+                    'System.Title': 'TC 123',
+                    'System.AreaPath': 'A',
+                    'System.Description': 'D',
+                    'Microsoft.VSTS.TCM.Steps': null,
+                },
+                relations: [],
+            });
+            const testCaseToLinkedMomLookup = new Map();
+            testCaseToLinkedMomLookup.set(123, new Set([
+                {
+                    id: 900,
+                    fields: {
+                        'System.WorkItemType': 'Task',
+                        'System.Title': 'Task 900',
+                        'System.State': 'Active',
+                    },
+                    _links: { html: { href: 'http://example.com/900' } },
+                },
+            ]));
+            const res = await testDataProvider.StructureTestCase(mockProject, testCases, suite, false, false, false, new Map(), new Map(), undefined, testCaseToLinkedMomLookup);
+            expect(res).toHaveLength(1);
+            expect(res[0].relations).toEqual(expect.arrayContaining([expect.objectContaining({ type: 'Task', id: 900 })]));
+        });
+        it('should return empty list when test case fetch fails', async () => {
+            const suite = { id: '1', name: 'Suite 1' };
+            const testCases = {
+                count: 1,
+                value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+            };
+            jest.spyOn(testDataProvider, 'fetchWithCache').mockRejectedValueOnce(new Error('boom'));
+            const res = await testDataProvider.StructureTestCase(mockProject, testCases, suite, false, false, false, new Map(), new Map());
+            expect(res).toEqual([]);
+            expect(logger_1.default.error).toHaveBeenCalledWith('Error: ran into an issue while retrieving testCase 123');
+        });
+    });
+    describe('ParseSteps', () => {
+        it('should parse XML steps correctly', () => {
+            // Arrange
+            const stepsXml = `<steps>
+        <step>
+          <parameterizedString>Action 1</parameterizedString>
+          <parameterizedString>Expected 1</parameterizedString>
+        </step>
+      </steps>`;
+            // Act
+            const result = testDataProvider.ParseSteps(stepsXml);
+            // Assert - ParseSteps uses xml2js.parseString which is synchronous callback-based
+            // The result may be empty if parsing fails or steps format doesn't match
+            expect(Array.isArray(result)).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=testDataProvider.test.js.map