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

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

@@ -0,0 +1,1888 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tfs_1 = require("../../helpers/tfs");
+const GitDataProvider_1 = require("../../modules/GitDataProvider");
+const logger_1 = require("../../utils/logger");
+jest.mock('../../helpers/tfs');
+jest.mock('../../utils/logger');
+describe('GitDataProvider - GetCommitForPipeline', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockProjectId = 'project-123';
+    const mockBuildId = 456;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return the sourceVersion from build information', async () => {
+        // Arrange
+        const mockCommitSha = 'abc123def456';
+        const mockResponse = {
+            id: mockBuildId,
+            sourceVersion: mockCommitSha,
+            status: 'completed',
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitForPipeline(mockProjectId, mockBuildId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProjectId}/_apis/build/builds/${mockBuildId}`, mockToken, 'get');
+        expect(result).toBe(mockCommitSha);
+    });
+    it('should throw an error if the API call fails', async () => {
+        // Arrange
+        const expectedError = new Error('API call failed');
+        tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(expectedError);
+        // Act & Assert
+        await expect(gitDataProvider.GetCommitForPipeline(mockProjectId, mockBuildId)).rejects.toThrow('API call failed');
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProjectId}/_apis/build/builds/${mockBuildId}`, mockToken, 'get');
+    });
+    it('should return undefined if the response does not contain sourceVersion', async () => {
+        // Arrange
+        const mockResponse = {
+            id: mockBuildId,
+            status: 'completed',
+            // No sourceVersion property
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitForPipeline(mockProjectId, mockBuildId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProjectId}/_apis/build/builds/${mockBuildId}`, mockToken, 'get');
+        expect(result).toBeUndefined();
+    });
+    it('should correctly construct URL with given project ID and build ID', async () => {
+        // Arrange
+        const customProjectId = 'custom-project';
+        const customBuildId = 789;
+        const mockCommitSha = 'xyz789abc';
+        const mockResponse = { sourceVersion: mockCommitSha };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        await gitDataProvider.GetCommitForPipeline(customProjectId, customBuildId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${customProjectId}/_apis/build/builds/${customBuildId}`, mockToken, 'get');
+    });
+    it('should handle different organization URLs correctly', async () => {
+        // Arrange
+        const altOrgUrl = 'https://dev.azure.com/different-org/';
+        const altGitDataProvider = new GitDataProvider_1.default(altOrgUrl, mockToken);
+        const mockResponse = { sourceVersion: 'commit-sha' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        await altGitDataProvider.GetCommitForPipeline(mockProjectId, mockBuildId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${altOrgUrl}${mockProjectId}/_apis/build/builds/${mockBuildId}`, mockToken, 'get');
+    });
+});
+describe('GitDataProvider - GetTeamProjectGitReposList', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockTeamProject = 'project-123';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return sorted repositories when API call succeeds', async () => {
+        // Arrange
+        const mockRepos = {
+            value: [
+                { id: 'repo2', name: 'ZRepo' },
+                { id: 'repo1', name: 'ARepo' },
+                { id: 'repo3', name: 'MRepo' },
+            ],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockRepos);
+        // Act
+        const result = await gitDataProvider.GetTeamProjectGitReposList(mockTeamProject);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}/${mockTeamProject}/_apis/git/repositories`, mockToken, 'get');
+        expect(result).toHaveLength(3);
+        expect(result[0].name).toBe('ARepo');
+        expect(result[1].name).toBe('MRepo');
+        expect(result[2].name).toBe('ZRepo');
+        expect(logger_1.default.debug).toHaveBeenCalledWith(expect.stringContaining(`fetching repos list for team project - ${mockTeamProject}`));
+    });
+    it('should return empty array when no repositories exist', async () => {
+        // Arrange
+        const mockEmptyRepos = { value: [] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockEmptyRepos);
+        // Act
+        const result = await gitDataProvider.GetTeamProjectGitReposList(mockTeamProject);
+        // Assert
+        expect(result).toEqual([]);
+    });
+    it('should handle API errors appropriately', async () => {
+        // Arrange
+        const mockError = new Error('API Error');
+        tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+        // Act & Assert
+        await expect(gitDataProvider.GetTeamProjectGitReposList(mockTeamProject)).rejects.toThrow('API Error');
+    });
+});
+describe('GitDataProvider - GetGitRepoFromRepoId', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch repository by id', async () => {
+        const mockRepoId = 'repo-123';
+        const mockResponse = { id: mockRepoId, name: 'Repo' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        const result = await gitDataProvider.GetGitRepoFromRepoId(mockRepoId);
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}_apis/git/repositories/${mockRepoId}`, mockToken, 'get');
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetTag', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockGitRepoUrl = 'https://dev.azure.com/orgname/project/_apis/git/repositories/repo-id';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return tag info when tag exists', async () => {
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+            value: [
+                {
+                    name: 'refs/tags/v1.0.0',
+                    objectId: 'abc123',
+                    peeledObjectId: 'def456',
+                },
+            ],
+        });
+        const result = await gitDataProvider.GetTag(mockGitRepoUrl, 'v1.0.0');
+        expect(result).toEqual(expect.objectContaining({
+            name: 'v1.0.0',
+            objectId: 'abc123',
+            peeledObjectId: 'def456',
+        }));
+    });
+    it('should return null when no matching tag found', async () => {
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+            value: [{ name: 'refs/tags/other-tag', objectId: 'abc123' }],
+        });
+        const result = await gitDataProvider.GetTag(mockGitRepoUrl, 'v1.0.0');
+        expect(result).toBeNull();
+    });
+});
+describe('GitDataProvider - GetFileFromGitRepo', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockProjectName = 'project-123';
+    const mockRepoId = 'repo-456';
+    const mockFileName = 'README.md';
+    const mockVersion = { version: 'main', versionType: 'branch' };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return file content when file exists', async () => {
+        // Arrange
+        const mockContent = 'This is a test readme file';
+        const mockResponse = { content: mockContent };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetFileFromGitRepo(mockProjectName, mockRepoId, mockFileName, mockVersion);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`${mockOrgUrl}${mockProjectName}/_apis/git/repositories/${mockRepoId}/items`), mockToken, 'get', {}, {}, false);
+        expect(result).toBe(mockContent);
+    });
+    it('should handle special characters in version by encoding them', async () => {
+        // Arrange
+        const specialVersion = { version: 'feature/branch#123', versionType: 'branch' };
+        const mockResponse = { content: 'content' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        await gitDataProvider.GetFileFromGitRepo(mockProjectName, mockRepoId, mockFileName, specialVersion);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining('versionDescriptor.version=feature%2Fbranch%23123'), expect.anything(), expect.anything(), expect.anything(), expect.anything(), expect.anything());
+    });
+    it('should use custom gitRepoUrl if provided', async () => {
+        // Arrange
+        const mockCustomUrl = 'https://custom.git.url';
+        const mockResponse = { content: 'content' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        await gitDataProvider.GetFileFromGitRepo(mockProjectName, mockRepoId, mockFileName, mockVersion, mockCustomUrl);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(mockCustomUrl), expect.anything(), expect.anything(), expect.anything(), expect.anything(), expect.anything());
+    });
+    it('should return undefined when file does not exist', async () => {
+        // Arrange
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({});
+        // Act
+        const result = await gitDataProvider.GetFileFromGitRepo(mockProjectName, mockRepoId, mockFileName, mockVersion);
+        // Assert
+        expect(result).toBeUndefined();
+    });
+    it('should log warning and return undefined when error occurs', async () => {
+        // Arrange
+        const mockError = new Error('File not found');
+        tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+        // Act
+        const result = await gitDataProvider.GetFileFromGitRepo(mockProjectName, mockRepoId, mockFileName, mockVersion);
+        // Assert
+        expect(logger_1.default.warn).toHaveBeenCalledWith(expect.stringContaining(`File ${mockFileName} could not be read: ${mockError.message}`));
+        expect(result).toBeUndefined();
+    });
+});
+describe('GitDataProvider - CheckIfItemExist', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockGitApiUrl = 'https://dev.azure.com/orgname/project/_apis/git/repositories/repo-id';
+    const mockItemPath = 'path/to/file.txt';
+    const mockVersion = { version: 'main', versionType: 'branch' };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return true when item exists', async () => {
+        // Arrange
+        const mockResponse = { path: mockItemPath, content: 'content' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.CheckIfItemExist(mockGitApiUrl, mockItemPath, mockVersion);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`${mockGitApiUrl}/items?path=${mockItemPath}`), mockToken, 'get', {}, {}, false);
+        expect(result).toBe(true);
+    });
+    it('should return false when item does not exist', async () => {
+        // Arrange
+        tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('Not found'));
+        // Act
+        const result = await gitDataProvider.CheckIfItemExist(mockGitApiUrl, mockItemPath, mockVersion);
+        // Assert
+        expect(result).toBe(false);
+    });
+    it('should return false when API returns null', async () => {
+        // Arrange
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(null);
+        // Act
+        const result = await gitDataProvider.CheckIfItemExist(mockGitApiUrl, mockItemPath, mockVersion);
+        // Assert
+        expect(result).toBe(false);
+    });
+    it('should handle special characters in version', async () => {
+        // Arrange
+        const specialVersion = { version: 'feature/branch#123', versionType: 'branch' };
+        const mockResponse = { path: mockItemPath };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        await gitDataProvider.CheckIfItemExist(mockGitApiUrl, mockItemPath, specialVersion);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining('versionDescriptor.version=feature%2Fbranch%23123'), expect.anything(), expect.anything(), expect.anything(), expect.anything(), expect.anything());
+    });
+});
+describe('GitDataProvider - GetPullRequestsInCommitRangeWithoutLinkedItems', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockProjectId = 'project-123';
+    const mockRepoId = 'repo-456';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return filtered pull requests matching commit ids', async () => {
+        // Arrange
+        const mockCommits = {
+            value: [{ commitId: 'commit-1' }, { commitId: 'commit-2' }],
+        };
+        const mockPullRequests = {
+            count: 3,
+            value: [
+                {
+                    pullRequestId: 101,
+                    title: 'PR 1',
+                    createdBy: { displayName: 'User 1' },
+                    creationDate: '2023-01-01',
+                    closedDate: '2023-01-02',
+                    description: 'Description 1',
+                    lastMergeCommit: { commitId: 'commit-1' },
+                },
+                {
+                    pullRequestId: 102,
+                    title: 'PR 2',
+                    createdBy: { displayName: 'User 2' },
+                    creationDate: '2023-02-01',
+                    closedDate: '2023-02-02',
+                    description: 'Description 2',
+                    lastMergeCommit: { commitId: 'commit-3' }, // Not in our commit range
+                },
+                {
+                    pullRequestId: 103,
+                    title: 'PR 3',
+                    createdBy: { displayName: 'User 3' },
+                    creationDate: '2023-03-01',
+                    closedDate: '2023-03-02',
+                    description: 'Description 3',
+                    lastMergeCommit: { commitId: 'commit-2' },
+                },
+            ],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockPullRequests);
+        // Act
+        const result = await gitDataProvider.GetPullRequestsInCommitRangeWithoutLinkedItems(mockProjectId, mockRepoId, mockCommits);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`${mockOrgUrl}${mockProjectId}/_apis/git/repositories/${mockRepoId}/pullrequests`), mockToken, 'get');
+        expect(result).toHaveLength(2);
+        expect(result[0].pullRequestId).toBe(101);
+        expect(result[1].pullRequestId).toBe(103);
+        expect(logger_1.default.info).toHaveBeenCalledWith(expect.stringContaining('filtered in commit range 2 pullrequests'));
+    });
+    it('should return empty array when no matching pull requests', async () => {
+        // Arrange
+        const mockCommits = {
+            value: [
+                { commitId: 'commit-999' }, // Not matching any PRs
+            ],
+        };
+        const mockPullRequests = {
+            count: 2,
+            value: [
+                {
+                    pullRequestId: 101,
+                    lastMergeCommit: { commitId: 'commit-1' },
+                },
+                {
+                    pullRequestId: 102,
+                    lastMergeCommit: { commitId: 'commit-2' },
+                },
+            ],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockPullRequests);
+        // Act
+        const result = await gitDataProvider.GetPullRequestsInCommitRangeWithoutLinkedItems(mockProjectId, mockRepoId, mockCommits);
+        // Assert
+        expect(result).toHaveLength(0);
+    });
+    it('should handle API errors appropriately', async () => {
+        // Arrange
+        const mockCommits = { value: [{ commitId: 'commit-1' }] };
+        const mockError = new Error('API Error');
+        tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+        // Act & Assert
+        await expect(gitDataProvider.GetPullRequestsInCommitRangeWithoutLinkedItems(mockProjectId, mockRepoId, mockCommits)).rejects.toThrow('API Error');
+    });
+});
+describe('GitDataProvider - GetBranch', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    const mockGitRepoUrl = 'https://dev.azure.com/orgname/project/_apis/git/repositories/repo-id';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return branch info when branch exists', async () => {
+        // Arrange
+        const branchName = 'main';
+        const mockResponse = {
+            value: [{ name: 'refs/heads/main', objectId: 'abc123' }],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetBranch(mockGitRepoUrl, branchName);
+        // Assert
+        expect(result).toEqual({ name: 'refs/heads/main', objectId: 'abc123' });
+    });
+    it('should return null when branch does not exist', async () => {
+        // Arrange
+        const mockResponse = { value: [] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetBranch(mockGitRepoUrl, 'nonexistent');
+        // Assert
+        expect(result).toBeNull();
+    });
+    it('should return null when response is empty', async () => {
+        // Arrange
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(null);
+        // Act
+        const result = await gitDataProvider.GetBranch(mockGitRepoUrl, 'main');
+        // Assert
+        expect(result).toBeNull();
+    });
+});
+describe('GitDataProvider - GetGitRepoFromPrId', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch PR by ID', async () => {
+        // Arrange
+        const prId = 123;
+        const mockResponse = { pullRequestId: prId, title: 'Test PR' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetGitRepoFromPrId(prId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}_apis/git/pullrequests/${prId}`, mockToken, 'get');
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetPullRequestCommits', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch PR commits', async () => {
+        // Arrange
+        const repoId = 'repo-123';
+        const prId = 456;
+        const mockResponse = { value: [{ commitId: 'abc123' }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetPullRequestCommits(repoId, prId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}_apis/git/repositories/${repoId}/pullRequests/${prId}/commits`, mockToken, 'get');
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetCommitByCommitId', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch commit by SHA', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitSha = 'abc123def456';
+        const mockResponse = { commitId: commitSha, comment: 'Test commit' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitByCommitId(projectId, repoId, commitSha);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${projectId}/_apis/git/repositories/${repoId}/commits/${commitSha}`, mockToken, 'get');
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetItemsForPipelinesRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch items in pipeline range', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const fromBuildId = 100;
+        const toBuildId = 200;
+        const mockWorkItemsResponse = {
+            count: 1,
+            value: [{ id: 1 }],
+        };
+        const mockWorkItemResponse = { id: 1, fields: { 'System.Title': 'Test' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockWorkItemsResponse)
+            .mockResolvedValueOnce(mockWorkItemResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsForPipelinesRange(projectId, fromBuildId, toBuildId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`fromBuildId=${fromBuildId}&toBuildId=${toBuildId}`), mockToken, 'get');
+        expect(result).toHaveLength(1);
+    });
+});
+describe('GitDataProvider - GetCommitsInDateRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch commits in date range without branch', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const fromDate = '2023-01-01';
+        const toDate = '2023-12-31';
+        const mockResponse = { value: [{ commitId: 'abc123' }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsInDateRange(projectId, repoId, fromDate, toDate);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`fromDate=${fromDate}`), mockToken, 'get');
+        expect(result).toEqual(mockResponse);
+    });
+    it('should fetch commits in date range with branch', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const fromDate = '2023-01-01';
+        const toDate = '2023-12-31';
+        const branchName = 'main';
+        const mockResponse = { value: [{ commitId: 'abc123' }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsInDateRange(projectId, repoId, fromDate, toDate, branchName);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`itemVersion.version=${branchName}`), mockToken, 'get');
+    });
+});
+describe('GitDataProvider - GetCommitsInCommitRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch commits between two commit SHAs', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const fromSha = 'abc123';
+        const toSha = 'def456';
+        const mockResponse = { value: [{ commitId: 'xyz789' }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsInCommitRange(projectId, repoId, fromSha, toSha);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`fromCommitId=${fromSha}&searchCriteria.toCommitId=${toSha}`), mockToken, 'get');
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - CreatePullRequestComment', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should create a PR comment thread', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const prId = 789;
+        const threads = { comments: [{ content: 'Test comment' }] };
+        const mockResponse = { id: 1, comments: threads.comments };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.CreatePullRequestComment(projectName, repoId, prId, threads);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`pullRequests/${prId}/threads`), mockToken, 'post', threads, null);
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetPullRequestComments', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch PR comments', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const prId = 789;
+        const mockResponse = { value: [{ id: 1, comments: [] }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetPullRequestComments(projectName, repoId, prId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`pullRequests/${prId}/threads`), mockToken, 'get', null, null);
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetCommitsForRepo', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch commits for repo with version identifier', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const versionId = 'main';
+        const mockResponse = {
+            count: 2,
+            value: [
+                { commitId: 'abc123', comment: 'First commit', committer: { date: '2023-01-01' } },
+                { commitId: 'def456', comment: 'Second commit', author: { date: '2023-01-02' } },
+            ],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsForRepo(projectName, repoId, versionId);
+        // Assert
+        expect(result).toHaveLength(2);
+        expect(result[0].name).toContain('abc123');
+        expect(result[0].value).toBe('abc123');
+    });
+    it('should return empty array when no commits', async () => {
+        // Arrange
+        const mockResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsForRepo('project', 'repo');
+        // Assert
+        expect(result).toEqual([]);
+    });
+});
+describe('GitDataProvider - GetPullRequestsForRepo', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch PRs for repo', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const mockResponse = { count: 2, value: [{ pullRequestId: 1 }, { pullRequestId: 2 }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetPullRequestsForRepo(projectName, repoId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining('pullrequests?status=completed'), mockToken, 'get', null, null);
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetRepoBranches', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch repo branches', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const mockResponse = { value: [{ name: 'refs/heads/main' }, { name: 'refs/heads/develop' }] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetRepoBranches(projectName, repoId);
+        // Assert
+        expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining('refs?searchCriteria.$top=1000&filter=heads'), mockToken, 'get', null, null);
+        expect(result).toEqual(mockResponse);
+    });
+});
+describe('GitDataProvider - GetPullRequestsLinkedItemsInCommitRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch and filter PRs with linked work items', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = { value: [{ commitId: 'commit-1' }] };
+        const mockPRsResponse = {
+            count: 1,
+            value: [
+                {
+                    pullRequestId: 101,
+                    lastMergeCommit: { commitId: 'commit-1' },
+                    _links: { workItems: { href: 'https://example.com/workitems' } },
+                },
+            ],
+        };
+        const mockWorkItemsResponse = {
+            count: 1,
+            value: [{ id: 1 }],
+        };
+        const mockPopulatedWI = { id: 1, fields: { 'System.Title': 'Test WI' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPRsResponse)
+            .mockResolvedValueOnce(mockWorkItemsResponse)
+            .mockResolvedValueOnce(mockPopulatedWI);
+        // Act
+        const result = await gitDataProvider.GetPullRequestsLinkedItemsInCommitRange(projectId, repoId, commitRange);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].workItem.id).toBe(1);
+        expect(result[0].pullrequest.pullRequestId).toBe(101);
+    });
+    it('should handle PRs without linked work items', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = { value: [{ commitId: 'commit-1' }] };
+        const mockPRsResponse = {
+            count: 1,
+            value: [
+                {
+                    pullRequestId: 101,
+                    lastMergeCommit: { commitId: 'commit-1' },
+                    _links: {},
+                },
+            ],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetPullRequestsLinkedItemsInCommitRange(projectId, repoId, commitRange);
+        // Assert
+        expect(result).toHaveLength(0);
+    });
+});
+describe('GitDataProvider - GetItemsInCommitRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should process commits with work items', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                {
+                    commitId: 'commit-1',
+                    workItems: [{ id: 1 }],
+                },
+            ],
+        };
+        const mockPopulatedWI = { id: 1, fields: { 'System.Title': 'Test WI' } };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, null, false);
+        // Assert
+        expect(result.commitChangesArray).toHaveLength(1);
+        expect(result.commitsWithNoRelations).toHaveLength(0);
+    });
+    it('should include unlinked commits when flag is true', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                {
+                    commitId: 'commit-1',
+                    workItems: [],
+                    committer: { date: '2023-01-01', name: 'Test User' },
+                    comment: 'Test commit',
+                    remoteUrl: 'https://example.com/commit/1',
+                },
+            ],
+        };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, null, true);
+        // Assert
+        expect(result.commitChangesArray).toHaveLength(0);
+        expect(result.commitsWithNoRelations).toHaveLength(1);
+        expect(result.commitsWithNoRelations[0].commitId).toBe('commit-1');
+    });
+});
+describe('GitDataProvider - getItemsForPipelineRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should throw error when extended commits is empty', async () => {
+        // Arrange
+        const teamProject = 'project-123';
+        const extendedCommits = [];
+        const targetRepo = { url: 'https://example.com/repo' };
+        const addedWorkItemByIdSet = new Set();
+        // Act
+        const result = await gitDataProvider.getItemsForPipelineRange(teamProject, extendedCommits, targetRepo, addedWorkItemByIdSet);
+        // Assert - should log error and return empty arrays
+        expect(logger_1.default.error).toHaveBeenCalledWith('extended commits cannot be empty');
+        expect(result.commitChangesArray).toHaveLength(0);
+    });
+    it('should process commits with work items', async () => {
+        // Arrange
+        const teamProject = 'project-123';
+        const extendedCommits = [
+            {
+                commit: {
+                    commitId: 'commit-1',
+                    workItems: [{ id: 1 }],
+                    committer: { date: '2023-01-01', name: 'Test User' },
+                    comment: 'Test commit',
+                },
+            },
+        ];
+        const targetRepo = { url: 'https://example.com/repo' };
+        const addedWorkItemByIdSet = new Set();
+        const mockRepoData = {
+            _links: { web: { href: 'https://example.com/repo-web' } },
+            project: { id: 'project-id' },
+        };
+        const mockPopulatedWI = { id: 1, fields: { 'System.Title': 'Test WI' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockRepoData)
+            .mockResolvedValueOnce(mockPopulatedWI);
+        // Act
+        const result = await gitDataProvider.getItemsForPipelineRange(teamProject, extendedCommits, targetRepo, addedWorkItemByIdSet);
+        // Assert
+        expect(result.commitChangesArray).toHaveLength(1);
+        expect(result.commitChangesArray[0].workItem.id).toBe(1);
+    });
+    it('should include unlinked commits when flag is true', async () => {
+        // Arrange
+        const teamProject = 'project-123';
+        const extendedCommits = [
+            {
+                commit: {
+                    commitId: 'commit-1',
+                    workItems: [],
+                    committer: { date: '2023-01-01', name: 'Test User' },
+                    comment: 'Test commit',
+                    remoteUrl: 'https://example.com/commit/1',
+                },
+            },
+        ];
+        const targetRepo = { url: 'https://example.com/repo' };
+        const addedWorkItemByIdSet = new Set();
+        const mockRepoData = {
+            _links: { web: { href: 'https://example.com/repo-web' } },
+            project: { id: 'project-id' },
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockRepoData);
+        // Act
+        const result = await gitDataProvider.getItemsForPipelineRange(teamProject, extendedCommits, targetRepo, addedWorkItemByIdSet, undefined, true);
+        // Assert
+        expect(result.commitsWithNoRelations).toHaveLength(1);
+        expect(result.commitsWithNoRelations[0].commitId).toBe('commit-1');
+    });
+    it('should not add duplicate work items', async () => {
+        // Arrange
+        const teamProject = 'project-123';
+        const extendedCommits = [
+            { commit: { commitId: 'commit-1', workItems: [{ id: 1 }] } },
+            { commit: { commitId: 'commit-2', workItems: [{ id: 1 }] } }, // Same WI
+        ];
+        const targetRepo = { url: 'https://example.com/repo' };
+        const addedWorkItemByIdSet = new Set();
+        const mockRepoData = {
+            _links: { web: { href: 'https://example.com/repo-web' } },
+            project: { id: 'project-id' },
+        };
+        const mockPopulatedWI = { id: 1, fields: { 'System.Title': 'Test WI' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockRepoData)
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockPopulatedWI);
+        // Act
+        const result = await gitDataProvider.getItemsForPipelineRange(teamProject, extendedCommits, targetRepo, addedWorkItemByIdSet);
+        // Assert - should only have 1 work item (no duplicates)
+        expect(result.commitChangesArray).toHaveLength(1);
+    });
+});
+describe('GitDataProvider - GetItemsInPullRequestRange', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch items from PRs in range', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const prIds = [101];
+        const mockPRsResponse = {
+            count: 1,
+            value: [{ pullRequestId: 101, _links: { workItems: { href: 'https://example.com/wi1' } } }],
+        };
+        const mockWIResponse = { count: 1, value: [{ id: 1 }] };
+        const mockPopulatedWI = { id: 1, fields: { 'System.Title': 'WI 1' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPRsResponse)
+            .mockResolvedValueOnce(mockWIResponse)
+            .mockResolvedValueOnce(mockPopulatedWI);
+        // Act
+        const result = await gitDataProvider.GetItemsInPullRequestRange(projectId, repoId, prIds);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].workItem.id).toBe(1);
+    });
+});
+describe('GitDataProvider - GetRepoTagsWithCommits', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return empty array when response is null', async () => {
+        // Arrange
+        const repoApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(null);
+        // Act
+        const result = await gitDataProvider.GetRepoTagsWithCommits(repoApiUrl);
+        // Assert
+        expect(result).toEqual([]);
+    });
+    it('should return empty array when no tags exist', async () => {
+        // Arrange
+        const repoApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const mockTagsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockTagsResponse);
+        // Act
+        const result = await gitDataProvider.GetRepoTagsWithCommits(repoApiUrl);
+        // Assert
+        expect(result).toEqual([]);
+    });
+});
+describe('GitDataProvider - GetCommitBatch', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+        // Mock postRequest
+        tfs_1.TFSServices.postRequest = jest.fn();
+    });
+    it('should fetch commits in batches', async () => {
+        // Arrange
+        const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const itemVersion = { version: 'main', versionType: 'branch' };
+        const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const mockCommitsResponse = {
+            data: {
+                count: 1,
+                value: [
+                    {
+                        commitId: 'abc123',
+                        committer: { name: 'Test User', date: '2023-01-01T00:00:00Z' },
+                        comment: 'Test commit',
+                    },
+                ],
+            },
+        };
+        const mockEmptyResponse = { data: { count: 0, value: [] } };
+        tfs_1.TFSServices.postRequest
+            .mockResolvedValueOnce(mockCommitsResponse)
+            .mockResolvedValueOnce(mockEmptyResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].commit.commitId).toBe('abc123');
+        expect(result[0].committerName).toBe('Test User');
+    });
+    it('should handle empty commits response', async () => {
+        // Arrange
+        const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const itemVersion = { version: 'main', versionType: 'branch' };
+        const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const mockEmptyResponse = { data: { count: 0, value: [] } };
+        tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockEmptyResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion);
+        // Assert
+        expect(result).toHaveLength(0);
+    });
+    it('should include specificItemPath when provided', async () => {
+        // Arrange
+        const gitUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const itemVersion = { version: 'main', versionType: 'branch' };
+        const compareVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const specificItemPath = '/src/file.ts';
+        const mockEmptyResponse = { data: { count: 0, value: [] } };
+        tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockEmptyResponse);
+        // Act
+        await gitDataProvider.GetCommitBatch(gitUrl, itemVersion, compareVersion, specificItemPath);
+        // Assert
+        expect(tfs_1.TFSServices.postRequest).toHaveBeenCalledWith(expect.any(String), mockToken, undefined, expect.objectContaining({
+            itemPath: specificItemPath,
+            historyMode: 'fullHistory',
+        }));
+    });
+});
+describe('GitDataProvider - getSubmodulesData', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should return empty array when no .gitmodules file exists', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        // Mock GetFileFromGitRepo to return undefined (no .gitmodules)
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({});
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toEqual([]);
+    });
+});
+describe('GitDataProvider - GetRepoTagsWithCommits (extended)', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should fetch tags with commit dates', async () => {
+        // Arrange
+        const repoApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const mockTagsResponse = {
+            count: 1,
+            value: [{ name: 'refs/tags/v1.0.0', objectId: 'abc123', peeledObjectId: 'def456' }],
+        };
+        const mockCommitResponse = { committer: { date: '2023-01-01' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockResolvedValueOnce(mockCommitResponse);
+        // Act
+        const result = await gitDataProvider.GetRepoTagsWithCommits(repoApiUrl);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('v1.0.0');
+        expect(result[0].commitId).toBe('def456');
+        expect(result[0].date).toBe('2023-01-01');
+    });
+    it('should skip tags without commitId', async () => {
+        // Arrange
+        const repoApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const mockTagsResponse = {
+            count: 2,
+            value: [
+                { name: 'refs/tags/v1.0.0' }, // No objectId or peeledObjectId
+                { name: 'refs/tags/v2.0.0', objectId: 'abc123' },
+            ],
+        };
+        const mockCommitResponse = { committer: { date: '2023-01-01' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockResolvedValueOnce(mockCommitResponse);
+        // Act
+        const result = await gitDataProvider.GetRepoTagsWithCommits(repoApiUrl);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('v2.0.0');
+    });
+    it('should handle commit fetch failure gracefully', async () => {
+        // Arrange
+        const repoApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const mockTagsResponse = {
+            count: 1,
+            value: [{ name: 'refs/tags/v1.0.0', objectId: 'abc123' }],
+        };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockRejectedValueOnce(new Error('Commit not found'));
+        // Act
+        const result = await gitDataProvider.GetRepoTagsWithCommits(repoApiUrl);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].date).toBeUndefined();
+    });
+    it('should use author date when committer date is missing', async () => {
+        // Arrange
+        const repoApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const mockTagsResponse = {
+            count: 1,
+            value: [{ name: 'refs/tags/v1.0.0', objectId: 'abc123' }],
+        };
+        const mockCommitResponse = { author: { date: '2023-02-01' } }; // No committer
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockResolvedValueOnce(mockCommitResponse);
+        // Act
+        const result = await gitDataProvider.GetRepoTagsWithCommits(repoApiUrl);
+        // Assert
+        expect(result[0].date).toBe('2023-02-01');
+    });
+});
+describe('GitDataProvider - createLinkedRelatedItemsForSVD (via GetItemsInCommitRange)', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should create linked items for requirements with Affects relationship', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                {
+                    commitId: 'commit-1',
+                    workItems: [{ id: 1 }],
+                },
+            ],
+        };
+        const linkedWiOptions = {
+            isEnabled: true,
+            linkedWiTypes: 'reqOnly',
+            linkedWiRelationship: 'affectsOnly',
+        };
+        const mockPopulatedWI = {
+            id: 1,
+            fields: { 'System.Title': 'Test WI' },
+            relations: [
+                {
+                    url: 'https://example.com/workItems/2',
+                    rel: 'System.LinkTypes.Affects-Forward',
+                    attributes: { name: 'Affects' },
+                },
+            ],
+        };
+        const mockRelatedWI = {
+            id: 2,
+            fields: {
+                'System.WorkItemType': 'Requirement',
+                'System.Title': 'Related Requirement',
+            },
+            _links: { html: { href: 'https://example.com/wi/2' } },
+        };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockRelatedWI)
+            .mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, linkedWiOptions, false);
+        // Assert
+        expect(result.commitChangesArray).toHaveLength(1);
+        expect(result.commitChangesArray[0].linkedItems).toBeDefined();
+    });
+    it('should filter out non-workItem relations', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                {
+                    commitId: 'commit-1',
+                    workItems: [{ id: 1 }],
+                },
+            ],
+        };
+        const linkedWiOptions = {
+            isEnabled: true,
+            linkedWiTypes: 'both',
+            linkedWiRelationship: 'both',
+        };
+        const mockPopulatedWI = {
+            id: 1,
+            fields: { 'System.Title': 'Test WI' },
+            relations: [
+                {
+                    url: 'https://example.com/attachments/file.txt', // Not a workItem
+                    rel: 'AttachedFile',
+                    attributes: {},
+                },
+            ],
+        };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, linkedWiOptions, false);
+        // Assert
+        expect(result.commitChangesArray).toHaveLength(1);
+        expect(result.commitChangesArray[0].linkedItems).toEqual([]);
+    });
+    it('should handle linkedWiTypes=none', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                {
+                    commitId: 'commit-1',
+                    workItems: [{ id: 1 }],
+                },
+            ],
+        };
+        const linkedWiOptions = {
+            isEnabled: true,
+            linkedWiTypes: 'none',
+            linkedWiRelationship: 'both',
+        };
+        const mockPopulatedWI = {
+            id: 1,
+            fields: { 'System.Title': 'Test WI' },
+            relations: [
+                {
+                    url: 'https://example.com/workItems/2',
+                    rel: 'System.LinkTypes.Affects-Forward',
+                    attributes: { name: 'Affects' },
+                },
+            ],
+        };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, linkedWiOptions, false);
+        // Assert
+        expect(result.commitChangesArray[0].linkedItems).toEqual([]);
+    });
+    it('should handle Feature type with featureOnly option', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                {
+                    commitId: 'commit-1',
+                    workItems: [{ id: 1 }],
+                },
+            ],
+        };
+        const linkedWiOptions = {
+            isEnabled: true,
+            linkedWiTypes: 'featureOnly',
+            linkedWiRelationship: 'coversOnly',
+        };
+        const mockPopulatedWI = {
+            id: 1,
+            fields: { 'System.Title': 'Test WI' },
+            relations: [
+                {
+                    url: 'https://example.com/workItems/2',
+                    rel: 'System.LinkTypes.CoveredBy-Forward',
+                    attributes: { name: 'CoveredBy' },
+                },
+            ],
+        };
+        const mockRelatedWI = {
+            id: 2,
+            fields: {
+                'System.WorkItemType': 'Feature',
+                'System.Title': 'Related Feature',
+            },
+            _links: { html: { href: 'https://example.com/wi/2' } },
+        };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockRelatedWI)
+            .mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, linkedWiOptions, false);
+        // Assert
+        expect(result.commitChangesArray).toHaveLength(1);
+    });
+});
+describe('GitDataProvider - GetRepoReferences (extended)', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should sort tags by commit date (most recent first)', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const mockTagsResponse = {
+            count: 2,
+            value: [
+                { name: 'refs/tags/v1.0.0', objectId: 'abc123' },
+                { name: 'refs/tags/v2.0.0', objectId: 'def456', peeledObjectId: 'ghi789' },
+            ],
+        };
+        const mockCommit1 = { committer: { date: '2023-01-01' } };
+        const mockCommit2 = { committer: { date: '2023-06-01' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockResolvedValueOnce(mockCommit1)
+            .mockResolvedValueOnce(mockCommit2);
+        // Act
+        const result = await gitDataProvider.GetRepoReferences(projectId, repoId, 'tag');
+        // Assert
+        expect(result).toHaveLength(2);
+        // v2.0.0 should be first (more recent)
+        expect(result[0].name).toBe('v2.0.0');
+        expect(result[1].name).toBe('v1.0.0');
+    });
+    it('should sort branches by commit date', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const mockBranchesResponse = {
+            count: 2,
+            value: [
+                { name: 'refs/heads/main', objectId: 'abc123' },
+                { name: 'refs/heads/develop', objectId: 'def456' },
+            ],
+        };
+        const mockCommit1 = { committer: { date: '2023-01-01' } };
+        const mockCommit2 = { committer: { date: '2023-06-01' } };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockBranchesResponse)
+            .mockResolvedValueOnce(mockCommit1)
+            .mockResolvedValueOnce(mockCommit2);
+        // Act
+        const result = await gitDataProvider.GetRepoReferences(projectId, repoId, 'branch');
+        // Assert
+        expect(result).toHaveLength(2);
+        // develop should be first (more recent)
+        expect(result[0].name).toBe('develop');
+        expect(result[1].name).toBe('main');
+    });
+    it('should handle commit resolution failure in tag sorting', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const mockTagsResponse = {
+            count: 1,
+            value: [{ name: 'refs/tags/v1.0.0', objectId: 'abc123' }],
+        };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockRejectedValueOnce(new Error('Commit not found'));
+        // Act
+        const result = await gitDataProvider.GetRepoReferences(projectId, repoId, 'tag');
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].date).toBeUndefined();
+    });
+    it('should set date undefined when tag commit has no committer/author date', async () => {
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const mockTagsResponse = {
+            count: 1,
+            value: [{ name: 'refs/tags/v0.0.1', objectId: 'abc123' }],
+        };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockTagsResponse)
+            .mockResolvedValueOnce({});
+        const result = await gitDataProvider.GetRepoReferences(projectId, repoId, 'tag');
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(expect.objectContaining({ name: 'v0.0.1', date: undefined }));
+    });
+    it('should set date undefined when branch commit cannot be resolved to a date', async () => {
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const mockBranchesResponse = {
+            count: 1,
+            value: [{ name: 'refs/heads/feature', objectId: 'abc123' }],
+        };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockBranchesResponse)
+            .mockResolvedValueOnce(null);
+        const result = await gitDataProvider.GetRepoReferences(projectId, repoId, 'branch');
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual(expect.objectContaining({ name: 'feature', date: undefined }));
+    });
+});
+describe('GitDataProvider - duplicate work item removal', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should remove duplicate work items in GetItemsInCommitRange', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const commitRange = {
+            value: [
+                { commitId: 'commit-1', workItems: [{ id: 1 }] },
+                { commitId: 'commit-2', workItems: [{ id: 1 }] },
+            ],
+        };
+        const mockPopulatedWI = { id: 1, fields: { 'System.Title': 'Test WI' } };
+        const mockPRsResponse = { count: 0, value: [] };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockPopulatedWI)
+            .mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInCommitRange(projectId, repoId, commitRange, null, false);
+        // Assert
+        expect(result.commitChangesArray.length).toBeLessThanOrEqual(2);
+    });
+});
+describe('GitDataProvider - version encoding edge cases', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should handle version with null gracefully in GetFileFromGitRepo', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const fileName = 'test.txt';
+        const version = { version: null, versionType: 'branch' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({ content: 'file content' });
+        // Act
+        const result = await gitDataProvider.GetFileFromGitRepo(projectName, repoId, fileName, version);
+        // Assert
+        expect(result).toBe('file content');
+    });
+    it('should handle version with null gracefully in CheckIfItemExist', async () => {
+        // Arrange
+        const gitApiUrl = 'https://dev.azure.com/org/project/_apis/git/repositories/repo-id';
+        const itemPath = 'path/to/file.txt';
+        const version = { version: null, versionType: 'branch' };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({ path: itemPath });
+        // Act
+        const result = await gitDataProvider.CheckIfItemExist(gitApiUrl, itemPath, version);
+        // Assert
+        expect(result).toBe(true);
+    });
+});
+describe('GitDataProvider - GetCommitsForRepo edge cases', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should handle commits without committer date', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const mockResponse = {
+            count: 1,
+            value: [{ commitId: 'abc123', comment: 'Test commit' }],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsForRepo(projectName, repoId);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].date).toBeUndefined();
+    });
+    it('should fetch commits without version identifier', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const mockResponse = {
+            count: 1,
+            value: [{ commitId: 'abc123', comment: 'Test', committer: { date: '2023-01-01' } }],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+        // Act
+        const result = await gitDataProvider.GetCommitsForRepo(projectName, repoId, '');
+        // Assert
+        expect(result).toHaveLength(1);
+    });
+});
+describe('GitDataProvider - GetItemsInPullRequestRange edge cases', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should handle PR without workItems link', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const prIds = [101];
+        const mockPRsResponse = {
+            count: 1,
+            value: [{ pullRequestId: 101, _links: {} }],
+        };
+        tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockPRsResponse);
+        // Act
+        const result = await gitDataProvider.GetItemsInPullRequestRange(projectId, repoId, prIds);
+        // Assert
+        expect(result).toHaveLength(0);
+    });
+    it('should handle errors when fetching work items', async () => {
+        // Arrange
+        const projectId = 'project-123';
+        const repoId = 'repo-456';
+        const prIds = [101];
+        const mockPRsResponse = {
+            count: 1,
+            value: [{ pullRequestId: 101, _links: { workItems: { href: 'https://example.com/wi' } } }],
+        };
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce(mockPRsResponse)
+            .mockRejectedValueOnce(new Error('Failed to fetch'));
+        // Act
+        const result = await gitDataProvider.GetItemsInPullRequestRange(projectId, repoId, prIds);
+        // Assert
+        expect(result).toHaveLength(0);
+        expect(logger_1.default.error).toHaveBeenCalled();
+    });
+});
+describe('GitDataProvider - getSubmodulesData', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should parse .gitmodules file and return submodule data', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://dev.azure.com/org/project/_git/common-lib`;
+        // Mock GetFileFromGitRepo calls
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent }) // .gitmodules file
+            .mockResolvedValueOnce({ content: 'target-sha-123' }) // target SHA
+            .mockResolvedValueOnce({ content: 'source-sha-456' }); // source SHA
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].gitSubModuleName).toBe('libs_common');
+        expect(result[0].targetSha1).toBe('target-sha-123');
+        expect(result[0].sourceSha1).toBe('source-sha-456');
+    });
+    it('should handle .gitmodules with CRLF line endings', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]\r\n\tpath = libs/common\r\n\turl = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha' })
+            .mockResolvedValueOnce({ content: 'source-sha' });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(1);
+    });
+    it('should handle relative URL paths in submodules', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = ../common-lib`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha' })
+            .mockResolvedValueOnce({ content: 'source-sha' });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].gitSubRepoUrl).toContain('common-lib');
+    });
+    it('should skip submodule when source SHA not found', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha' })
+            .mockResolvedValueOnce({ content: undefined }); // source not found
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(0);
+        expect(logger_1.default.warn).toHaveBeenCalled();
+    });
+    it('should skip submodule when target SHA not found', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: undefined }) // target not found
+            .mockResolvedValueOnce({ content: 'source-sha' });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(0);
+        expect(logger_1.default.warn).toHaveBeenCalled();
+    });
+    it('should skip submodule when source and target SHA are the same', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'same-sha' })
+            .mockResolvedValueOnce({ content: 'same-sha' });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(0);
+        expect(logger_1.default.warn).toHaveBeenCalled();
+    });
+    it('should search commits for source SHA when not found initially', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [{ commit: { commitId: 'commit-1' } }, { commit: { commitId: 'commit-2' } }];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha' })
+            .mockResolvedValueOnce({ content: undefined }) // source not found initially
+            .mockResolvedValueOnce({ content: 'source-sha-from-commit' }); // found in commit search
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(1);
+        expect(result[0].sourceSha1).toBe('source-sha-from-commit');
+    });
+    it('should handle commits with direct commitId property', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [{ commitId: 'direct-commit-1' }, { commitId: 'direct-commit-2' }];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha' })
+            .mockResolvedValueOnce({ content: undefined })
+            .mockResolvedValueOnce({ content: 'source-sha' });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(1);
+    });
+    it('should warn when commit not found in extended commits', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [
+            { noCommitId: true }, // No commitId or commit property
+            { noCommitId: true },
+        ];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/repo`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha' })
+            .mockResolvedValueOnce({ content: undefined });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(0);
+        expect(logger_1.default.warn).toHaveBeenCalled();
+    });
+    it('should handle errors gracefully', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('API error'));
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert - returns empty array when .gitmodules fetch fails
+        expect(result).toEqual([]);
+    });
+    it('should handle multiple submodules', async () => {
+        // Arrange
+        const projectName = 'project-123';
+        const repoId = 'repo-456';
+        const targetVersion = { version: 'main', versionType: 'branch' };
+        const sourceVersion = { version: 'v1.0.0', versionType: 'tag' };
+        const allCommitsExtended = [];
+        const gitModulesContent = `[submodule "libs/common"]
+	path = libs/common
+	url = https://example.com/common
+[submodule "libs/utils"]
+	path = libs/utils
+	url = https://example.com/utils`;
+        tfs_1.TFSServices.getItemContent
+            .mockResolvedValueOnce({ content: gitModulesContent })
+            .mockResolvedValueOnce({ content: 'target-sha-1' })
+            .mockResolvedValueOnce({ content: 'source-sha-1' })
+            .mockResolvedValueOnce({ content: 'target-sha-2' })
+            .mockResolvedValueOnce({ content: 'source-sha-2' });
+        // Act
+        const result = await gitDataProvider.getSubmodulesData(projectName, repoId, targetVersion, sourceVersion, allCommitsExtended);
+        // Assert
+        expect(result).toHaveLength(2);
+        expect(result[0].gitSubModuleName).toBe('libs_common');
+        expect(result[1].gitSubModuleName).toBe('libs_utils');
+    });
+});
+describe('GitDataProvider - createLinkedRelatedItemsForSVD', () => {
+    let gitDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        gitDataProvider = new GitDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    it('should add Requirement when linkedWiTypes=reqOnly and linkedWiRelationship=affectsOnly', async () => {
+        jest.spyOn(gitDataProvider.ticketsDataProvider, 'GetWorkItemByUrl').mockResolvedValueOnce({
+            id: 10,
+            fields: { 'System.WorkItemType': 'Requirement', 'System.Title': 'Req' },
+            _links: { html: { href: 'http://example.com/10' } },
+        });
+        const res = await gitDataProvider.createLinkedRelatedItemsForSVD({ isEnabled: true, linkedWiTypes: 'reqOnly', linkedWiRelationship: 'affectsOnly' }, {
+            id: 1,
+            relations: [
+                {
+                    url: 'https://example.com/_apis/wit/workItems/10',
+                    rel: 'Affects',
+                    attributes: { name: 'Affects' },
+                },
+            ],
+        });
+        expect(res).toHaveLength(1);
+        expect(res[0]).toEqual(expect.objectContaining({
+            id: 10,
+            wiType: 'Requirement',
+            relationType: 'Affects',
+            title: 'Req',
+            url: 'http://example.com/10',
+        }));
+    });
+    it('should add Feature when linkedWiTypes=featureOnly and linkedWiRelationship=coversOnly', async () => {
+        jest.spyOn(gitDataProvider.ticketsDataProvider, 'GetWorkItemByUrl').mockResolvedValueOnce({
+            id: 11,
+            fields: { 'System.WorkItemType': 'Feature', 'System.Title': 'Feat' },
+            _links: { html: { href: 'http://example.com/11' } },
+        });
+        const res = await gitDataProvider.createLinkedRelatedItemsForSVD({ isEnabled: true, linkedWiTypes: 'featureOnly', linkedWiRelationship: 'coversOnly' }, {
+            id: 2,
+            relations: [
+                {
+                    url: 'https://example.com/_apis/wit/workItems/11',
+                    rel: 'CoveredBy',
+                    attributes: { name: 'CoveredBy' },
+                },
+            ],
+        });
+        expect(res).toHaveLength(1);
+        expect(res[0]).toEqual(expect.objectContaining({
+            id: 11,
+            wiType: 'Feature',
+            relationType: 'CoveredBy',
+            title: 'Feat',
+            url: 'http://example.com/11',
+        }));
+    });
+    it('should add items when linkedWiTypes=both and linkedWiRelationship=both', async () => {
+        jest.spyOn(gitDataProvider.ticketsDataProvider, 'GetWorkItemByUrl').mockResolvedValueOnce({
+            id: 12,
+            fields: { 'System.WorkItemType': 'Requirement', 'System.Title': 'Req 12' },
+            _links: { html: { href: 'http://example.com/12' } },
+        });
+        const res = await gitDataProvider.createLinkedRelatedItemsForSVD({ isEnabled: true, linkedWiTypes: 'both', linkedWiRelationship: 'both' }, {
+            id: 3,
+            relations: [
+                {
+                    url: 'https://example.com/_apis/wit/workItems/12',
+                    rel: 'Affects',
+                    attributes: { name: 'Affects' },
+                },
+            ],
+        });
+        expect(res).toHaveLength(1);
+    });
+    it('should skip when linkedWiTypes is enabled but item type does not match', async () => {
+        jest.spyOn(gitDataProvider.ticketsDataProvider, 'GetWorkItemByUrl').mockResolvedValueOnce({
+            id: 13,
+            fields: { 'System.WorkItemType': 'Task', 'System.Title': 'Task 13' },
+            _links: { html: { href: 'http://example.com/13' } },
+        });
+        const res = await gitDataProvider.createLinkedRelatedItemsForSVD({ isEnabled: true, linkedWiTypes: 'reqOnly', linkedWiRelationship: 'both' }, {
+            id: 4,
+            relations: [
+                {
+                    url: 'https://example.com/_apis/wit/workItems/13',
+                    rel: 'Affects',
+                    attributes: { name: 'Affects' },
+                },
+            ],
+        });
+        expect(res).toEqual([]);
+    });
+});
+//# sourceMappingURL=gitDataProvider.test.js.map