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

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

@@ -0,0 +1,783 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tfs_1 = require("../../helpers/tfs");
+const PipelinesDataProvider_1 = require("../../modules/PipelinesDataProvider");
+const logger_1 = require("../../utils/logger");
+jest.mock('../../helpers/tfs');
+jest.mock('../../utils/logger');
+jest.mock('../../modules/GitDataProvider');
+describe('PipelinesDataProvider', () => {
+    let pipelinesDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/orgname/';
+    const mockToken = 'mock-token';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        pipelinesDataProvider = new PipelinesDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    describe('isMatchingPipeline', () => {
+        // Create test method to access private method
+        const invokeIsMatchingPipeline = (fromPipeline, targetPipeline, searchPrevPipelineFromDifferentCommit) => {
+            return pipelinesDataProvider.isMatchingPipeline(fromPipeline, targetPipeline, searchPrevPipelineFromDifferentCommit);
+        };
+        it('should return false when repository IDs are different', () => {
+            // Arrange
+            const fromPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            const targetPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo2' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            // Act
+            const result = invokeIsMatchingPipeline(fromPipeline, targetPipeline, false);
+            // Assert
+            expect(result).toBe(false);
+        });
+        it('should return true when versions are the same and searchPrevPipelineFromDifferentCommit is false', () => {
+            // Arrange
+            const fromPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            const targetPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            // Act
+            const result = invokeIsMatchingPipeline(fromPipeline, targetPipeline, false);
+            // Assert
+            expect(result).toBe(true);
+        });
+        it('should return false when versions are the same and searchPrevPipelineFromDifferentCommit is true', () => {
+            // Arrange
+            const fromPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            const targetPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            // Act
+            const result = invokeIsMatchingPipeline(fromPipeline, targetPipeline, true);
+            // Assert
+            expect(result).toBe(false);
+        });
+        it('should return true when refNames match but versions differ', () => {
+            // Arrange
+            const fromPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            const targetPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v2',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            // Act
+            const result = invokeIsMatchingPipeline(fromPipeline, targetPipeline, true);
+            // Assert
+            expect(result).toBe(true);
+        });
+        it('should use __designer_repo when self is not available', () => {
+            // Arrange
+            const fromPipeline = {
+                resources: {
+                    repositories: {
+                        __designer_repo: {
+                            repository: { id: 'repo1' },
+                            version: 'v1',
+                            refName: 'refs/heads/main',
+                        },
+                    },
+                },
+            };
+            const targetPipeline = {
+                resources: {
+                    repositories: {
+                        __designer_repo: {
+                            repository: { id: 'repo1' },
+                            version: 'v1',
+                            refName: 'refs/heads/main',
+                        },
+                    },
+                },
+            };
+            // Act
+            const result = invokeIsMatchingPipeline(fromPipeline, targetPipeline, false);
+            // Assert
+            expect(result).toBe(true);
+        });
+    });
+    describe('getPipelineRunDetails', () => {
+        it('should call TFSServices.getItemContent with correct parameters', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const pipelineId = 123;
+            const runId = 456;
+            const mockResponse = { id: runId, resources: {} };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.getPipelineRunDetails(projectName, pipelineId, runId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs/${runId}`, mockToken);
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('GetPipelineRunHistory', () => {
+        it('should return filtered pipeline run history', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const pipelineId = '123';
+            const mockResponse = {
+                value: [
+                    { id: 1, result: 'succeeded' },
+                    { id: 2, result: 'failed' },
+                    { id: 3, result: 'canceled' },
+                    { id: 4, result: 'succeeded' },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetPipelineRunHistory(projectName, pipelineId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs`, mockToken, 'get', null, null);
+            expect(result).toEqual({
+                count: 4, // Note: Current filter logic keeps all runs where result is not 'failed' AND not 'canceled'
+                value: mockResponse.value,
+            });
+        });
+        it('should handle API errors gracefully', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const pipelineId = '123';
+            const expectedError = new Error('API error');
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(expectedError);
+            // Act
+            const result = await pipelinesDataProvider.GetPipelineRunHistory(projectName, pipelineId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs`, mockToken, 'get', null, null);
+            expect(logger_1.default.error).toHaveBeenCalledWith(`Could not fetch Pipeline Run History: ${expectedError.message}`);
+            expect(result).toBeUndefined();
+        });
+        it('should return response when value is undefined', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const pipelineId = '123';
+            const mockResponse = { count: 0 };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetPipelineRunHistory(projectName, pipelineId);
+            // Assert
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('getPipelineBuildByBuildId', () => {
+        it('should fetch pipeline build by build ID', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const buildId = 123;
+            const mockResponse = { id: buildId, buildNumber: '20231201.1' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.getPipelineBuildByBuildId(projectName, buildId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${projectName}/_apis/build/builds/${buildId}`, mockToken, 'get');
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('TriggerBuildById', () => {
+        it('should trigger a build with parameters', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const buildDefId = '456';
+            const parameters = '{"Test":"123"}';
+            const mockResponse = { id: 789, status: 'queued' };
+            tfs_1.TFSServices.postRequest.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.TriggerBuildById(projectName, buildDefId, parameters);
+            // Assert
+            expect(tfs_1.TFSServices.postRequest).toHaveBeenCalledWith(`${mockOrgUrl}${projectName}/_apis/build/builds?api-version=5.0`, mockToken, 'post', {
+                definition: { id: buildDefId },
+                parameters: parameters,
+            }, null);
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('GetArtifactByBuildId', () => {
+        it('should return empty response when no artifacts exist', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const buildId = '123';
+            const artifactName = 'drop';
+            const mockResponse = { count: 0 };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetArtifactByBuildId(projectName, buildId, artifactName);
+            // Assert
+            expect(result).toEqual(mockResponse);
+        });
+        it('should download artifact when it exists', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const buildId = '123';
+            const artifactName = 'drop';
+            const mockArtifactsResponse = { count: 1 };
+            const mockArtifactResponse = {
+                resource: { downloadUrl: 'https://example.com/download' },
+            };
+            const mockDownloadResult = { data: Buffer.from('zip content') };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockArtifactsResponse)
+                .mockResolvedValueOnce(mockArtifactResponse);
+            tfs_1.TFSServices.downloadZipFile.mockResolvedValueOnce(mockDownloadResult);
+            // Act
+            const result = await pipelinesDataProvider.GetArtifactByBuildId(projectName, buildId, artifactName);
+            // Assert
+            expect(tfs_1.TFSServices.downloadZipFile).toHaveBeenCalledWith('https://example.com/download', mockToken);
+            expect(result).toEqual(mockDownloadResult);
+        });
+        it('should throw error when artifact fetch fails', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const buildId = '123';
+            const artifactName = 'drop';
+            const mockError = new Error('Artifact not found');
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+            // Act & Assert
+            await expect(pipelinesDataProvider.GetArtifactByBuildId(projectName, buildId, artifactName)).rejects.toThrow();
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('getPipelineStageName', () => {
+        it('should return the matching Stage record', async () => {
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                records: [
+                    { type: 'Stage', name: 'Deploy', state: 'completed', result: 'succeeded' },
+                    { type: 'Job', name: 'Job1' },
+                ],
+            });
+            const record = await pipelinesDataProvider.getPipelineStageName(123, 'project1', 'Deploy');
+            expect(record).toEqual(expect.objectContaining({ type: 'Stage', name: 'Deploy' }));
+        });
+        it('should return undefined when no matching stage exists', async () => {
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                records: [{ type: 'Stage', name: 'Build', state: 'completed', result: 'succeeded' }],
+            });
+            const record = await pipelinesDataProvider.getPipelineStageName(123, 'project1', 'Deploy');
+            expect(record).toBeUndefined();
+        });
+        it('should return undefined on fetch error and log', async () => {
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('boom'));
+            const record = await pipelinesDataProvider.getPipelineStageName(123, 'project1', 'Deploy');
+            expect(record).toBeUndefined();
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('isStageSuccessful', () => {
+        it('should return false when stage is missing', async () => {
+            jest.spyOn(pipelinesDataProvider, 'getPipelineStageName').mockResolvedValueOnce(undefined);
+            await expect(pipelinesDataProvider.isStageSuccessful({ id: 1 }, 'project1', 'Deploy')).resolves.toBeUndefined();
+        });
+        it('should return false when stage is not completed', async () => {
+            jest
+                .spyOn(pipelinesDataProvider, 'getPipelineStageName')
+                .mockResolvedValueOnce({ state: 'inProgress', result: 'succeeded' });
+            await expect(pipelinesDataProvider.isStageSuccessful({ id: 1 }, 'project1', 'Deploy')).resolves.toBe(false);
+        });
+        it('should return false when stage result is not succeeded', async () => {
+            jest
+                .spyOn(pipelinesDataProvider, 'getPipelineStageName')
+                .mockResolvedValueOnce({ state: 'completed', result: 'failed' });
+            await expect(pipelinesDataProvider.isStageSuccessful({ id: 1 }, 'project1', 'Deploy')).resolves.toBe(false);
+        });
+        it('should return true when stage is completed and succeeded', async () => {
+            jest
+                .spyOn(pipelinesDataProvider, 'getPipelineStageName')
+                .mockResolvedValueOnce({ state: 'completed', result: 'succeeded' });
+            await expect(pipelinesDataProvider.isStageSuccessful({ id: 1 }, 'project1', 'Deploy')).resolves.toBe(true);
+        });
+    });
+    describe('GetReleaseByReleaseId', () => {
+        it('should fetch release by ID', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const releaseId = 123;
+            const mockResponse = { id: releaseId, name: 'Release-1' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetReleaseByReleaseId(projectName, releaseId);
+            // Assert
+            expect(result).toEqual(mockResponse);
+        });
+        it('should replace dev.azure.com with vsrm.dev.azure.com for release URL', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const releaseId = 123;
+            const mockResponse = { id: releaseId };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            await pipelinesDataProvider.GetReleaseByReleaseId(projectName, releaseId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining('vsrm.dev.azure.com'), mockToken, 'get', null, null);
+        });
+    });
+    describe('GetReleaseHistory', () => {
+        it('should fetch release history for a definition', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const definitionId = '456';
+            const mockResponse = { value: [{ id: 1 }, { id: 2 }] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetReleaseHistory(projectName, definitionId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(`definitionId=${definitionId}`), mockToken, 'get', null, null);
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('GetAllReleaseHistory', () => {
+        it('should fetch all releases with pagination', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const definitionId = '456';
+            const mockResponse1 = {
+                data: { value: [{ id: 1 }, { id: 2 }] },
+                headers: { 'x-ms-continuationtoken': 'token123' },
+            };
+            const mockResponse2 = {
+                data: { value: [{ id: 3 }] },
+                headers: {},
+            };
+            tfs_1.TFSServices.getItemContentWithHeaders
+                .mockResolvedValueOnce(mockResponse1)
+                .mockResolvedValueOnce(mockResponse2);
+            // Act
+            const result = await pipelinesDataProvider.GetAllReleaseHistory(projectName, definitionId);
+            // Assert
+            expect(result.count).toBe(3);
+            expect(result.value).toHaveLength(3);
+        });
+        it('should support x-ms-continuation-token header and default value when data is missing', async () => {
+            const projectName = 'project1';
+            const definitionId = '456';
+            tfs_1.TFSServices.getItemContentWithHeaders
+                .mockResolvedValueOnce({
+                data: undefined,
+                headers: { 'x-ms-continuation-token': 'token123' },
+            })
+                .mockResolvedValueOnce({
+                data: { value: [{ id: 1 }] },
+                headers: {},
+            });
+            const result = await pipelinesDataProvider.GetAllReleaseHistory(projectName, definitionId);
+            expect(result.count).toBe(1);
+            expect(result.value).toEqual([{ id: 1 }]);
+        });
+        it('should handle errors during pagination', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const definitionId = '456';
+            tfs_1.TFSServices.getItemContentWithHeaders.mockRejectedValueOnce(new Error('API Error'));
+            // Act
+            const result = await pipelinesDataProvider.GetAllReleaseHistory(projectName, definitionId);
+            // Assert
+            expect(result).toEqual({ count: 0, value: [] });
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('GetAllPipelines', () => {
+        it('should fetch all pipelines for a project', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const mockResponse = { value: [{ id: 1 }, { id: 2 }], count: 2 };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetAllPipelines(projectName);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${projectName}/_apis/pipelines?$top=2000`, mockToken, 'get', null, null);
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('GetAllReleaseDefenitions', () => {
+        it('should fetch all release definitions', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const mockResponse = { value: [{ id: 1 }, { id: 2 }] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetAllReleaseDefenitions(projectName);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining('vsrm.dev.azure.com'), mockToken, 'get', null, null);
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('GetRecentReleaseArtifactInfo', () => {
+        it('should return empty array when no releases exist', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const mockResponse = { value: [] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName);
+            // Assert
+            expect(result).toEqual([]);
+        });
+        it('should return artifact info from most recent release', async () => {
+            // Arrange
+            const projectName = 'project1';
+            const mockReleasesResponse = { value: [{ id: 123 }] };
+            const mockReleaseResponse = {
+                artifacts: [
+                    {
+                        definitionReference: {
+                            definition: { name: 'artifact1' },
+                            version: { name: '1.0.0' },
+                        },
+                    },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockReleasesResponse)
+                .mockResolvedValueOnce(mockReleaseResponse);
+            // Act
+            const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName);
+            // Assert
+            expect(result).toEqual([{ artifactName: 'artifact1', artifactVersion: '1.0.0' }]);
+        });
+    });
+    describe('getPipelineResourcePipelinesFromObject', () => {
+        it('should return empty set when no pipeline resources exist', async () => {
+            // Arrange
+            const inPipeline = {
+                resources: {},
+            };
+            // Act
+            const result = await pipelinesDataProvider.getPipelineResourcePipelinesFromObject(inPipeline);
+            // Assert
+            expect(result).toEqual(new Set());
+        });
+        it('should extract pipeline resources from pipeline object', async () => {
+            // Arrange
+            const inPipeline = {
+                resources: {
+                    pipelines: {
+                        myPipeline: {
+                            pipeline: {
+                                id: 123,
+                                url: 'https://dev.azure.com/org/project/_apis/pipelines/123?revision=1',
+                            },
+                        },
+                    },
+                },
+            };
+            const mockBuildResponse = {
+                definition: { id: 456, type: 'build' },
+                buildNumber: '20231201.1',
+                project: { name: 'project1' },
+                repository: { type: 'TfsGit' },
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockBuildResponse);
+            // Act
+            const result = await pipelinesDataProvider.getPipelineResourcePipelinesFromObject(inPipeline);
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                name: 'myPipeline',
+                buildId: 123,
+                definitionId: 456,
+                buildNumber: '20231201.1',
+                teamProject: 'project1',
+                provider: 'TfsGit',
+            });
+        });
+        it('should handle errors when fetching pipeline resources', async () => {
+            // Arrange
+            const inPipeline = {
+                resources: {
+                    pipelines: {
+                        myPipeline: {
+                            pipeline: {
+                                id: 123,
+                                url: 'https://dev.azure.com/org/project/_apis/pipelines/123?revision=1',
+                            },
+                        },
+                    },
+                },
+            };
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('API Error'));
+            // Act
+            const result = await pipelinesDataProvider.getPipelineResourcePipelinesFromObject(inPipeline);
+            // Assert
+            expect(result).toEqual([]);
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('getPipelineResourceRepositoriesFromObject', () => {
+        it('should return empty map when no repository resources exist', async () => {
+            // Arrange
+            const inPipeline = {
+                resources: {},
+            };
+            const mockGitDataProvider = {};
+            // Act
+            const result = await pipelinesDataProvider.getPipelineResourceRepositoriesFromObject(inPipeline, mockGitDataProvider);
+            // Assert
+            expect(result).toEqual(new Map());
+        });
+        it('should extract repository resources from pipeline object', async () => {
+            // Arrange
+            const inPipeline = {
+                resources: {
+                    repositories: {
+                        self: {
+                            repository: { id: 'repo-123', type: 'azureReposGit' },
+                            version: 'abc123',
+                        },
+                    },
+                },
+            };
+            const mockRepo = {
+                name: 'MyRepo',
+                url: 'https://dev.azure.com/org/project/_git/MyRepo',
+            };
+            const mockGitDataProvider = {
+                GetGitRepoFromRepoId: jest.fn().mockResolvedValue(mockRepo),
+            };
+            // Act
+            const result = await pipelinesDataProvider.getPipelineResourceRepositoriesFromObject(inPipeline, mockGitDataProvider);
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                repoName: 'MyRepo',
+                repoSha1: 'abc123',
+                url: 'https://dev.azure.com/org/project/_git/MyRepo',
+            });
+        });
+        it('should skip non-azureReposGit repositories', async () => {
+            // Arrange
+            const inPipeline = {
+                resources: {
+                    repositories: {
+                        external: {
+                            repository: { id: 'repo-123', type: 'GitHub' },
+                            version: 'abc123',
+                        },
+                    },
+                },
+            };
+            const mockGitDataProvider = {
+                GetGitRepoFromRepoId: jest.fn(),
+            };
+            // Act
+            const result = await pipelinesDataProvider.getPipelineResourceRepositoriesFromObject(inPipeline, mockGitDataProvider);
+            // Assert
+            expect(result).toHaveLength(0);
+            expect(mockGitDataProvider.GetGitRepoFromRepoId).not.toHaveBeenCalled();
+        });
+    });
+    describe('findPreviousPipeline', () => {
+        it('should return undefined when no pipeline runs exist', async () => {
+            // Arrange
+            const teamProject = 'project1';
+            const pipelineId = '123';
+            const toPipelineRunId = 100;
+            const targetPipeline = {};
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({});
+            // Act
+            const result = await pipelinesDataProvider.findPreviousPipeline(teamProject, pipelineId, toPipelineRunId, targetPipeline, false);
+            // Assert
+            expect(result).toBeUndefined();
+        });
+        it('should skip invalid runs and return first matching previous pipeline', async () => {
+            const teamProject = 'project1';
+            const pipelineId = '123';
+            const toPipelineRunId = 100;
+            const targetPipeline = {
+                resources: {
+                    repositories: { '0': { self: { repository: { id: 'r' }, version: 'v2', refName: 'main' } } },
+                },
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                value: [
+                    { id: 100, result: 'succeeded' },
+                    { id: 99, result: 'succeeded' },
+                ],
+            });
+            jest.spyOn(pipelinesDataProvider, 'getPipelineRunDetails').mockResolvedValueOnce({
+                resources: {
+                    repositories: { '0': { self: { repository: { id: 'r' }, version: 'v1', refName: 'main' } } },
+                },
+            });
+            jest.spyOn(pipelinesDataProvider, 'isMatchingPipeline').mockReturnValueOnce(true);
+            const res = await pipelinesDataProvider.findPreviousPipeline(teamProject, pipelineId, toPipelineRunId, targetPipeline, true);
+            expect(res).toBe(99);
+        });
+        it('should skip when fromStage provided but stage is not successful', async () => {
+            const teamProject = 'project1';
+            const pipelineId = '123';
+            const toPipelineRunId = 100;
+            const targetPipeline = {};
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                value: [{ id: 99, result: 'succeeded' }],
+            });
+            jest.spyOn(pipelinesDataProvider, 'isStageSuccessful').mockResolvedValueOnce(false);
+            const detailsSpy = jest.spyOn(pipelinesDataProvider, 'getPipelineRunDetails');
+            const res = await pipelinesDataProvider.findPreviousPipeline(teamProject, pipelineId, toPipelineRunId, targetPipeline, false, 'Deploy');
+            expect(res).toBeUndefined();
+            expect(detailsSpy).not.toHaveBeenCalled();
+        });
+        it('should skip when pipeline details do not include repositories', async () => {
+            const teamProject = 'project1';
+            const pipelineId = '123';
+            const toPipelineRunId = 100;
+            const targetPipeline = {};
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                value: [{ id: 99, result: 'succeeded' }],
+            });
+            jest
+                .spyOn(pipelinesDataProvider, 'getPipelineRunDetails')
+                .mockResolvedValueOnce({ resources: {} });
+            const res = await pipelinesDataProvider.findPreviousPipeline(teamProject, pipelineId, toPipelineRunId, targetPipeline, false);
+            expect(res).toBeUndefined();
+        });
+        it('should find matching previous pipeline', async () => {
+            // Arrange
+            const teamProject = 'project1';
+            const pipelineId = '123';
+            const toPipelineRunId = 100;
+            const targetPipeline = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v2',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            const mockRunHistory = {
+                value: [{ id: 99, result: 'succeeded' }],
+            };
+            const mockPipelineDetails = {
+                resources: {
+                    repositories: {
+                        '0': {
+                            self: {
+                                repository: { id: 'repo1' },
+                                version: 'v1',
+                                refName: 'refs/heads/main',
+                            },
+                        },
+                    },
+                },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockRunHistory)
+                .mockResolvedValueOnce(mockPipelineDetails);
+            // Act
+            const result = await pipelinesDataProvider.findPreviousPipeline(teamProject, pipelineId, toPipelineRunId, targetPipeline, true);
+            // Assert
+            expect(result).toBe(99);
+        });
+    });
+    describe('isInvalidPipelineRun', () => {
+        const invokeIsInvalidPipelineRun = (pipelineRun, toPipelineRunId, fromStage) => {
+            return pipelinesDataProvider.isInvalidPipelineRun(pipelineRun, toPipelineRunId, fromStage);
+        };
+        it('should return true when pipeline run id >= toPipelineRunId', () => {
+            expect(invokeIsInvalidPipelineRun({ id: 100, result: 'succeeded' }, 100, '')).toBe(true);
+            expect(invokeIsInvalidPipelineRun({ id: 101, result: 'succeeded' }, 100, '')).toBe(true);
+        });
+        it('should return true for canceled/failed/canceling results', () => {
+            expect(invokeIsInvalidPipelineRun({ id: 99, result: 'canceled' }, 100, '')).toBe(true);
+            expect(invokeIsInvalidPipelineRun({ id: 99, result: 'failed' }, 100, '')).toBe(true);
+            expect(invokeIsInvalidPipelineRun({ id: 99, result: 'canceling' }, 100, '')).toBe(true);
+        });
+        it('should return true for unknown result without fromStage', () => {
+            expect(invokeIsInvalidPipelineRun({ id: 99, result: 'unknown' }, 100, '')).toBe(true);
+        });
+        it('should return false for valid pipeline run with fromStage', () => {
+            expect(invokeIsInvalidPipelineRun({ id: 99, result: 'unknown' }, 100, 'Deploy')).toBe(false);
+        });
+        it('should return false for succeeded result', () => {
+            expect(invokeIsInvalidPipelineRun({ id: 99, result: 'succeeded' }, 100, '')).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=pipelineDataProvider.test.js.map