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

package/src/tests/index.test.ts

@@ -0,0 +1,28 @@
+import logger from '../utils/logger';
+
+jest.mock('../utils/logger');
+
+describe('src/index.ts', () => {
+  it('should construct providers and create module providers', async () => {
+    const { default: DgDataProviderAzureDevOps } = await import('../index');
+    const provider = new DgDataProviderAzureDevOps('https://dev.azure.com/org/', 'token', '5.1', 'jfrog');
+
+    expect(logger.info).toHaveBeenCalled();
+
+    await expect(provider.getMangementDataProvider()).resolves.toBeDefined();
+    await expect(provider.getTicketsDataProvider()).resolves.toBeDefined();
+    await expect(provider.getGitDataProvider()).resolves.toBeDefined();
+    await expect(provider.getPipelinesDataProvider()).resolves.toBeDefined();
+    await expect(provider.getTestDataProvider()).resolves.toBeDefined();
+    await expect(provider.getResultDataProvider()).resolves.toBeDefined();
+    await expect(provider.getJfrogDataProvider()).resolves.toBeDefined();
+  });
+
+  it('should default jfrogToken to empty string when undefined', async () => {
+    const { default: DgDataProviderAzureDevOps } = await import('../index');
+    const provider = new DgDataProviderAzureDevOps('https://dev.azure.com/org/', 'token', '5.1');
+
+    const jfrog = await provider.getJfrogDataProvider();
+    expect(jfrog).toBeDefined();
+  });
+});

package/src/tests/models/tfs-data.test.ts

@@ -0,0 +1,203 @@
+import {
+  Query,
+  QueryTree,
+  Column,
+  Workitem,
+  value,
+  QueryType,
+  TestCase,
+  TestSteps,
+  createLinkedRelation,
+  createRequirementRelation,
+  createMomRelation,
+  createBugRelation,
+  LinkedRelation,
+} from '../../models/tfs-data';
+
+describe('tfs-data models', () => {
+  describe('Query class', () => {
+    it('should create Query with default arrays', () => {
+      const query = new Query();
+      expect(query.columns).toEqual([]);
+      expect(query.workItems).toEqual([]);
+    });
+  });
+
+  describe('Column class', () => {
+    it('should create Column with properties', () => {
+      const column = new Column();
+      column.referenceName = 'System.Title';
+      column.name = 'Title';
+      column.url = 'https://example.com';
+
+      expect(column.referenceName).toBe('System.Title');
+      expect(column.name).toBe('Title');
+      expect(column.url).toBe('https://example.com');
+    });
+  });
+
+  describe('Workitem class', () => {
+    it('should create Workitem with default Source of 0', () => {
+      const workitem = new Workitem();
+      expect(workitem.Source).toBe(0);
+    });
+
+    it('should allow setting all properties', () => {
+      const workitem = new Workitem();
+      workitem.id = 123;
+      workitem.url = 'https://example.com/workitem/123';
+      workitem.parentId = 100;
+      workitem.fields = [];
+      workitem.attachments = [];
+      workitem.level = 1;
+
+      expect(workitem.id).toBe(123);
+      expect(workitem.url).toBe('https://example.com/workitem/123');
+      expect(workitem.parentId).toBe(100);
+      expect(workitem.level).toBe(1);
+    });
+  });
+
+  describe('value class', () => {
+    it('should create value with name and value', () => {
+      const v = new value();
+      v.name = 'Title';
+      v.value = 'Test Value';
+
+      expect(v.name).toBe('Title');
+      expect(v.value).toBe('Test Value');
+    });
+  });
+
+  describe('TestCase class', () => {
+    it('should create TestCase with empty relations array', () => {
+      const testCase = new TestCase();
+      expect(testCase.relations).toEqual([]);
+      expect(testCase.caseEvidenceAttachments).toEqual([]);
+    });
+
+    it('should allow setting all properties', () => {
+      const testCase = new TestCase();
+      testCase.id = '123';
+      testCase.title = 'Test Case Title';
+      testCase.description = 'Test Description';
+      testCase.area = 'Area\\Path';
+      testCase.steps = [];
+      testCase.suit = 'Suite 1';
+      testCase.url = 'https://example.com/testcase/123';
+
+      expect(testCase.id).toBe('123');
+      expect(testCase.title).toBe('Test Case Title');
+      expect(testCase.description).toBe('Test Description');
+      expect(testCase.area).toBe('Area\\Path');
+      expect(testCase.suit).toBe('Suite 1');
+    });
+  });
+
+  describe('TestSteps class', () => {
+    it('should create TestSteps with all properties', () => {
+      const step = new TestSteps();
+      step.stepId = '1';
+      step.stepPosition = '1';
+      step.action = 'Click button';
+      step.expected = 'Button clicked';
+      step.isSharedStepTitle = false;
+
+      expect(step.stepId).toBe('1');
+      expect(step.stepPosition).toBe('1');
+      expect(step.action).toBe('Click button');
+      expect(step.expected).toBe('Button clicked');
+      expect(step.isSharedStepTitle).toBe(false);
+    });
+  });
+
+  describe('createLinkedRelation', () => {
+    it('should create a LinkedRelation object', () => {
+      const result = createLinkedRelation(
+        '123',
+        'Requirement',
+        'Test Requirement',
+        'https://example.com/wi/123',
+        'Parent'
+      );
+
+      expect(result).toEqual({
+        id: '123',
+        wiType: 'Requirement',
+        title: 'Test Requirement',
+        url: 'https://example.com/wi/123',
+        relationType: 'Parent',
+      });
+    });
+  });
+
+  describe('createRequirementRelation', () => {
+    it('should create a RequirementRelation with customerId', () => {
+      const result = createRequirementRelation('123', 'Requirement Title', 'CUST-001');
+
+      expect(result).toEqual({
+        type: 'requirement',
+        id: '123',
+        title: 'Requirement Title',
+        customerId: 'CUST-001',
+      });
+    });
+
+    it('should create a RequirementRelation without customerId', () => {
+      const result = createRequirementRelation('123', 'Requirement Title');
+
+      expect(result).toEqual({
+        type: 'requirement',
+        id: '123',
+        title: 'Requirement Title',
+        customerId: undefined,
+      });
+    });
+  });
+
+  describe('createMomRelation', () => {
+    it('should create a MomRelation object', () => {
+      const result = createMomRelation('123', 'Bug', 'Bug Title', 'https://example.com/wi/123', 'Active');
+
+      expect(result).toEqual({
+        type: 'Bug',
+        id: '123',
+        title: 'Bug Title',
+        url: 'https://example.com/wi/123',
+        status: 'Active',
+      });
+    });
+  });
+
+  describe('createBugRelation', () => {
+    it('should create a BugRelation with severity', () => {
+      const result = createBugRelation('123', 'Bug Title', '1 - Critical');
+
+      expect(result).toEqual({
+        type: 'bug',
+        id: '123',
+        title: 'Bug Title',
+        severity: '1 - Critical',
+      });
+    });
+
+    it('should create a BugRelation without severity', () => {
+      const result = createBugRelation('123', 'Bug Title');
+
+      expect(result).toEqual({
+        type: 'bug',
+        id: '123',
+        title: 'Bug Title',
+        severity: undefined,
+      });
+    });
+  });
+
+  describe('QueryType enum', () => {
+    it('should have correct enum values', () => {
+      expect(QueryType.Flat).toBe('flat');
+      expect(QueryType.Tree).toBe('tree');
+      expect(QueryType.OneHop).toBe('oneHop');
+    });
+  });
+});

package/src/tests/modules/JfrogDataProvider.test.ts

@@ -0,0 +1,167 @@
+import { TFSServices } from '../../helpers/tfs';
+import logger from '../../utils/logger';
+import JfrogDataProvider from '../../modules/JfrogDataProvider';
+
+jest.mock('../../helpers/tfs');
+jest.mock('../../utils/logger');
+
+describe('JfrogDataProvider', () => {
+  let jfrogDataProvider: JfrogDataProvider;
+  const mockOrgUrl = 'https://dev.azure.com/organization/';
+  const mockTfsToken = 'mock-tfs-token';
+  const mockJfrogToken = 'mock-jfrog-token';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jfrogDataProvider = new JfrogDataProvider(mockOrgUrl, mockTfsToken, mockJfrogToken);
+  });
+
+  describe('getServiceConnectionUrlByConnectionId', () => {
+    it('should fetch service connection URL with correct parameters', async () => {
+      // Arrange
+      const mockTeamProject = 'test-project';
+      const mockConnectionId = 'connection-123';
+      const mockResponse = { url: 'https://jfrog.example.com' };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      // Act
+      const result = await jfrogDataProvider.getServiceConnectionUrlByConnectionId(
+        mockTeamProject,
+        mockConnectionId
+      );
+
+      // Assert
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        `${mockOrgUrl}${mockTeamProject}/_apis/serviceendpoint/endpoints/${mockConnectionId}?api-version=6`,
+        mockTfsToken
+      );
+      expect(logger.debug).toHaveBeenCalledWith(`service connection url "${mockResponse.url}"`);
+      expect(result).toBe(mockResponse.url);
+    });
+
+    it('should propagate errors when API call fails', async () => {
+      // Arrange
+      const mockTeamProject = 'test-project';
+      const mockConnectionId = 'connection-123';
+      const mockError = new Error('API error');
+
+      (TFSServices.getItemContent as jest.Mock).mockRejectedValueOnce(mockError);
+
+      // Act & Assert
+      await expect(
+        jfrogDataProvider.getServiceConnectionUrlByConnectionId(mockTeamProject, mockConnectionId)
+      ).rejects.toThrow('API error');
+    });
+  });
+
+  describe('getCiDataFromJfrog', () => {
+    it('should fetch JFrog data with token and format URLs correctly', async () => {
+      // Arrange
+      const mockJfrogUrl = 'https://jfrog.example.com';
+      const mockBuildName = 'build-name';
+      const mockBuildVersion = 'version-1.0';
+      const mockResponse = {
+        buildInfo: {
+          url: 'https://ci.example.com/build/123',
+        },
+      };
+
+      (TFSServices.getJfrogRequest as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      // Act
+      const result = await jfrogDataProvider.getCiDataFromJfrog(
+        mockJfrogUrl,
+        mockBuildName,
+        mockBuildVersion
+      );
+
+      // Assert
+      expect(TFSServices.getJfrogRequest).toHaveBeenCalledWith(
+        `${mockJfrogUrl}/api/build/${mockBuildName}/${mockBuildVersion}`,
+        { Authorization: `Bearer ${mockJfrogToken}` }
+      );
+      expect(logger.info).toHaveBeenCalledWith(
+        `Querying Jfrog using url ${mockJfrogUrl}/api/build/${mockBuildName}/${mockBuildVersion}`
+      );
+      expect(logger.debug).toHaveBeenCalledWith(`CI Url from JFROG: ${mockResponse.buildInfo.url}`);
+      expect(result).toBe(mockResponse.buildInfo.url);
+    });
+
+    it('should handle build names and versions that already start with /', async () => {
+      // Arrange
+      const mockJfrogUrl = 'https://jfrog.example.com';
+      const mockBuildName = '/build-name';
+      const mockBuildVersion = '/version-1.0';
+      const mockResponse = {
+        buildInfo: {
+          url: 'https://ci.example.com/build/123',
+        },
+      };
+
+      (TFSServices.getJfrogRequest as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      // Act
+      const result = await jfrogDataProvider.getCiDataFromJfrog(
+        mockJfrogUrl,
+        mockBuildName,
+        mockBuildVersion
+      );
+
+      // Assert
+      expect(TFSServices.getJfrogRequest).toHaveBeenCalledWith(
+        `${mockJfrogUrl}/api/build${mockBuildName}${mockBuildVersion}`,
+        { Authorization: `Bearer ${mockJfrogToken}` }
+      );
+      expect(result).toBe(mockResponse.buildInfo.url);
+    });
+
+    it('should make request without token when jfrogToken is empty', async () => {
+      // Arrange
+      const mockJfrogUrl = 'https://jfrog.example.com';
+      const mockBuildName = 'build-name';
+      const mockBuildVersion = 'version-1.0';
+      const mockResponse = {
+        buildInfo: {
+          url: 'https://ci.example.com/build/123',
+        },
+      };
+
+      // Create provider with empty jfrog token
+      const jfrogDataProviderNoToken = new JfrogDataProvider(mockOrgUrl, mockTfsToken, '');
+      (TFSServices.getJfrogRequest as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      // Act
+      const result = await jfrogDataProviderNoToken.getCiDataFromJfrog(
+        mockJfrogUrl,
+        mockBuildName,
+        mockBuildVersion
+      );
+
+      // Assert
+      expect(TFSServices.getJfrogRequest).toHaveBeenCalledWith(
+        `${mockJfrogUrl}/api/build/${mockBuildName}/${mockBuildVersion}`
+      );
+      expect(result).toBe(mockResponse.buildInfo.url);
+    });
+
+    it('should log and rethrow errors from JFrog API', async () => {
+      // Arrange
+      const mockJfrogUrl = 'https://jfrog.example.com';
+      const mockBuildName = 'build-name';
+      const mockBuildVersion = 'version-1.0';
+      const mockError = new Error('JFrog API error');
+
+      (TFSServices.getJfrogRequest as jest.Mock).mockRejectedValueOnce(mockError);
+
+      // Act & Assert
+      await expect(
+        jfrogDataProvider.getCiDataFromJfrog(mockJfrogUrl, mockBuildName, mockBuildVersion)
+      ).rejects.toThrow('JFrog API error');
+
+      expect(logger.error).toHaveBeenCalledWith(
+        `Error occurred during querying JFrog using: JFrog API error`
+      );
+    });
+  });
+});