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

package/src/modules/test/pipelineDataProvider.test.ts

@@ -1,292 +0,0 @@
-import { PipelineRun } from '../../models/tfs-data';
-import { TFSServices } from '../../helpers/tfs';
-import PipelinesDataProvider from '../PipelinesDataProvider';
-import GitDataProvider from '../GitDataProvider';
-import logger from '../../utils/logger';
-
-jest.mock('../../helpers/tfs');
-jest.mock('../../utils/logger');
-jest.mock('../GitDataProvider');
-
-describe('PipelinesDataProvider', () => {
-  let pipelinesDataProvider: PipelinesDataProvider;
-  const mockOrgUrl = 'https://dev.azure.com/orgname/';
-  const mockToken = 'mock-token';
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    pipelinesDataProvider = new PipelinesDataProvider(mockOrgUrl, mockToken);
-  });
-
-  describe('isMatchingPipeline', () => {
-    // Create test method to access private method
-    const invokeIsMatchingPipeline = (
-      fromPipeline: PipelineRun,
-      targetPipeline: PipelineRun,
-      searchPrevPipelineFromDifferentCommit: boolean
-    ): boolean => {
-      return (pipelinesDataProvider as any).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'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      const targetPipeline = {
-        resources: {
-          repositories: {
-            '0': {
-              self: {
-                repository: { id: 'repo2' },
-                version: 'v1',
-                refName: 'refs/heads/main'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      // 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'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      const targetPipeline = {
-        resources: {
-          repositories: {
-            '0': {
-              self: {
-                repository: { id: 'repo1' },
-                version: 'v1',
-                refName: 'refs/heads/main'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      // 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'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      const targetPipeline = {
-        resources: {
-          repositories: {
-            '0': {
-              self: {
-                repository: { id: 'repo1' },
-                version: 'v1',
-                refName: 'refs/heads/main'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      // 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'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      const targetPipeline = {
-        resources: {
-          repositories: {
-            '0': {
-              self: {
-                repository: { id: 'repo1' },
-                version: 'v2',
-                refName: 'refs/heads/main'
-              }
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      // 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'
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      const targetPipeline = {
-        resources: {
-          repositories: {
-            __designer_repo: {
-              repository: { id: 'repo1' },
-              version: 'v1',
-              refName: 'refs/heads/main'
-            }
-          }
-        }
-      } as unknown as PipelineRun;
-
-      // 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: {} };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockResponse);
-
-      // Act
-      const result = await pipelinesDataProvider.getPipelineRunDetails(projectName, pipelineId, runId);
-
-      // Assert
-      expect(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' }
-        ]
-      };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockResponse);
-
-      // Act
-      const result = await pipelinesDataProvider.GetPipelineRunHistory(projectName, pipelineId);
-
-      // Assert
-      expect(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');
-      (TFSServices.getItemContent as jest.Mock).mockRejectedValueOnce(expectedError);
-
-      // Act
-      const result = await pipelinesDataProvider.GetPipelineRunHistory(projectName, pipelineId);
-
-      // Assert
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs`,
-        mockToken,
-        'get',
-        null,
-        null
-      );
-      expect(logger.error).toHaveBeenCalledWith(`Could not fetch Pipeline Run History: ${expectedError.message}`);
-      expect(result).toBeUndefined();
-    });
-  });
-});

package/src/modules/test/testDataProvider.test.ts

@@ -1,318 +0,0 @@
-import { TFSServices } from '../../helpers/tfs';
-import { Helper, suiteData } from '../../helpers/helper';
-import TestDataProvider from '../TestDataProvider';
-import Utils from '../../utils/testStepParserHelper';
-import logger from '../../utils/logger';
-import { TestCase } from '../../models/tfs-data';
-
-jest.mock('../../helpers/tfs');
-jest.mock('../../utils/logger');
-jest.mock('../../helpers/helper');
-jest.mock('../../utils/testStepParserHelper');
-jest.mock('p-limit', () => jest.fn(() => (fn: Function) => fn()));
-
-describe('TestDataProvider', () => {
-  let testDataProvider: TestDataProvider;
-  const mockOrgUrl = 'https://dev.azure.com/orgname/';
-  const mockToken = 'mock-token';
-  const mockProject = 'project-123';
-  const mockPlanId = '456';
-  const mockSuiteId = '789';
-  const mockTestCaseId = '101112';
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    testDataProvider = new TestDataProvider(mockOrgUrl, mockToken);
-  });
-
-  // Helper to access private method for testing
-  const invokeFetchWithCache = async (instance: any, url: string, ttl = 60000) => {
-    return instance.fetchWithCache.call(instance, url, ttl);
-  };
-
-  describe('fetchWithCache', () => {
-    it('should return cached data when available and not expired', async () => {
-      // Arrange
-      const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
-      const mockData = { value: 'test data' };
-      const cache = new Map();
-      cache.set(mockUrl, {
-        data: mockData,
-        timestamp: Date.now(),
-      });
-      (testDataProvider as any).cache = cache;
-
-      // Act
-      const result = await invokeFetchWithCache(testDataProvider, mockUrl);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).not.toHaveBeenCalled();
-    });
-
-    it('should fetch new data when cache is expired', async () => {
-      // Arrange
-      const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
-      const mockData = { value: 'old data' };
-      const newData = { value: 'new data' };
-      const cache = new Map();
-      cache.set(mockUrl, {
-        data: mockData,
-        timestamp: Date.now() - 70000, // Expired (default TTL is 60000ms)
-      });
-      (testDataProvider as any).cache = cache;
-
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(newData);
-
-      // Act
-      const result = await invokeFetchWithCache(testDataProvider, mockUrl);
-
-      // Assert
-      expect(result).toEqual(newData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(mockUrl, mockToken);
-    });
-
-    it('should fetch and cache new data when not in cache', async () => {
-      // Arrange
-      const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
-      const mockData = { value: 'new data' };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
-
-      // Act
-      const result = await invokeFetchWithCache(testDataProvider, mockUrl);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(mockUrl, mockToken);
-      expect((testDataProvider as any).cache.has(mockUrl)).toBeTruthy();
-      expect((testDataProvider as any).cache.get(mockUrl).data).toEqual(mockData);
-    });
-
-    it('should throw and log error when fetch fails', async () => {
-      // Arrange
-      const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
-      const mockError = new Error('API call failed');
-      (TFSServices.getItemContent as jest.Mock).mockRejectedValueOnce(mockError);
-
-      // Act & Assert
-      await expect(invokeFetchWithCache(testDataProvider, mockUrl)).rejects.toThrow('API call failed');
-      expect(logger.error).toHaveBeenCalledWith(`Error fetching ${mockUrl}: API call failed`);
-    });
-  });
-
-  describe('GetTestSuiteByTestCase', () => {
-    it('should return test suites for a given test case ID', async () => {
-      // Arrange
-      const mockData = { value: [{ id: '123', name: 'Test Suite 1' }] };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
-
-      // Act
-      const result = await testDataProvider.GetTestSuiteByTestCase(mockTestCaseId);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}_apis/testplan/suites?testCaseId=${mockTestCaseId}`,
-        mockToken
-      );
-    });
-  });
-
-  describe('GetTestPlans', () => {
-    it('should return test plans for a given project', async () => {
-      // Arrange
-      const mockData = {
-        value: [
-          { id: '456', name: 'Test Plan 1' },
-          { id: '789', name: 'Test Plan 2' },
-        ],
-      };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
-
-      // Act
-      const result = await testDataProvider.GetTestPlans(mockProject);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}${mockProject}/_apis/test/plans`,
-        mockToken
-      );
-    });
-  });
-
-  describe('GetTestSuites', () => {
-    it('should return test suites for a given project and plan ID', async () => {
-      // Arrange
-      const mockData = {
-        value: [
-          { id: '123', name: 'Test Suite 1' },
-          { id: '456', name: 'Test Suite 2' },
-        ],
-      };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
-
-      // Act
-      const result = await testDataProvider.GetTestSuites(mockProject, mockPlanId);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}${mockProject}/_apis/test/Plans/${mockPlanId}/suites`,
-        mockToken
-      );
-    });
-
-    it('should return null and log error if fetching test suites fails', async () => {
-      // Arrange
-      const mockError = new Error('Failed to get test suites');
-      (TFSServices.getItemContent as jest.Mock).mockRejectedValueOnce(mockError);
-
-      // Act
-      const result = await testDataProvider.GetTestSuites(mockProject, mockPlanId);
-
-      // Assert
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('GetTestSuitesForPlan', () => {
-    it('should throw error when project is not provided', async () => {
-      // Act & Assert
-      await expect(testDataProvider.GetTestSuitesForPlan('', mockPlanId)).rejects.toThrow(
-        'Project not selected'
-      );
-    });
-
-    it('should throw error when plan ID is not provided', async () => {
-      // Act & Assert
-      await expect(testDataProvider.GetTestSuitesForPlan(mockProject, '')).rejects.toThrow(
-        'Plan not selected'
-      );
-    });
-
-    it('should return test suites for a plan', async () => {
-      // Arrange
-      const mockData = {
-        testSuites: [
-          { id: '123', name: 'Test Suite 1' },
-          { id: '456', name: 'Test Suite 2' },
-        ],
-      };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
-
-      // Act
-      const result = await testDataProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}/${mockProject}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${mockPlanId}`,
-        mockToken
-      );
-    });
-  });
-
-  describe('GetTestSuiteById', () => {
-    it('should call GetTestSuitesForPlan and Helper.findSuitesRecursive with correct params', async () => {
-      // Arrange
-      const mockTestSuites = { testSuites: [{ id: '123', name: 'Test Suite 1' }] };
-      const mockSuiteData = [new suiteData('Test Suite 1', '123', '456', 1)];
-
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockTestSuites);
-      (Helper.findSuitesRecursive as jest.Mock).mockReturnValueOnce(mockSuiteData);
-
-      // Act
-      const result = await testDataProvider.GetTestSuiteById(mockProject, mockPlanId, mockSuiteId, true);
-
-      // Assert
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}/${mockProject}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${mockPlanId}`,
-        mockToken
-      );
-      expect(Helper.findSuitesRecursive).toHaveBeenCalledWith(
-        mockPlanId,
-        mockOrgUrl,
-        mockProject,
-        mockTestSuites.testSuites,
-        mockSuiteId,
-        true
-      );
-      expect(result).toEqual(mockSuiteData);
-    });
-  });
-
-  describe('GetTestCases', () => {
-    it('should return test cases for a given project, plan ID, and suite ID', async () => {
-      // Arrange
-      const mockData = {
-        count: 2,
-        value: [
-          { testCase: { id: '101', name: 'Test Case 1', url: 'url1' } },
-          { testCase: { id: '102', name: 'Test Case 2', url: 'url2' } },
-        ],
-      };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
-
-      // Act
-      const result = await testDataProvider.GetTestCases(mockProject, mockPlanId, mockSuiteId);
-
-      // Assert
-      expect(result).toEqual(mockData);
-      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
-        `${mockOrgUrl}${mockProject}/_apis/test/Plans/${mockPlanId}/suites/${mockSuiteId}/testcases/`,
-        mockToken
-      );
-      expect(logger.debug).toHaveBeenCalledWith(
-        `test cases for plan ${mockPlanId} and ${mockSuiteId} were found`
-      );
-    });
-  });
-
-  describe('clearCache', () => {
-    it('should clear the cache', () => {
-      // Arrange
-      const mockUrl = `${mockOrgUrl}_apis/test/endpoint`;
-      const mockData = { value: 'test data' };
-      const cache = new Map();
-      cache.set(mockUrl, {
-        data: mockData,
-        timestamp: Date.now(),
-      });
-      (testDataProvider as any).cache = cache;
-
-      // Act
-      testDataProvider.clearCache();
-
-      // Assert
-      expect((testDataProvider as any).cache.size).toBe(0);
-      expect(logger.debug).toHaveBeenCalledWith('Cache cleared');
-    });
-  });
-
-  describe('UpdateTestRun', () => {
-    it('should update a test run with the correct state', async () => {
-      // Arrange
-      const mockRunId = '12345';
-      const mockState = 'Completed';
-      const mockResponse = { id: mockRunId, state: mockState };
-
-      (TFSServices.postRequest as jest.Mock).mockResolvedValueOnce(mockResponse);
-
-      // Act
-      const result = await testDataProvider.UpdateTestRun(mockProject, mockRunId, mockState);
-
-      // Assert
-      expect(result).toEqual(mockResponse);
-      expect(TFSServices.postRequest).toHaveBeenCalledWith(
-        `${mockOrgUrl}${mockProject}/_apis/test/Runs/${mockRunId}?api-version=5.0`,
-        mockToken,
-        'PATCH',
-        { state: mockState },
-        null
-      );
-      expect(logger.info).toHaveBeenCalledWith(`Update runId : ${mockRunId} to state : ${mockState}`);
-    });
-  });
-});