@elisra-devops/docgen-data-provider 1.21.0 → 1.23.0

package/src/modules/TestDataProvider.ts

@@ -44,21 +44,21 @@ export default class TestDataProvider {
   }
 
   async GetTestSuiteByTestCase(testCaseId: string): Promise<any> {
-    let url = `${this.orgUrl}/_apis/testplan/suites?testCaseId=${testCaseId}`;
-    return this.fetchWithCache(url);
+    let url = `${this.orgUrl.endsWith('/') ? this.orgUrl : `${this.orgUrl}/`}_apis/testplan/suites?testCaseId=${testCaseId}`;
+    return await this.fetchWithCache(url);
   }
 
   async GetTestPlans(project: string): Promise<string> {
     let testPlanUrl: string = `${this.orgUrl}${project}/_apis/test/plans`;
-    return this.fetchWithCache(testPlanUrl);
+    return await this.fetchWithCache(testPlanUrl);
   }
 
   async GetTestSuites(project: string, planId: string): Promise<any> {
     let testsuitesUrl: string = this.orgUrl + project + '/_apis/test/Plans/' + planId + '/suites';
     try {
-      return this.fetchWithCache(testsuitesUrl);
-    } catch (e) {
-      logger.error(`Failed to get test suites: ${e}`);
+      return await this.fetchWithCache(testsuitesUrl);
+    } catch (e: any) {
+      logger.error(`Failed to get test suites: ${e.message}`);
       return null;
     }
   }
@@ -72,7 +72,7 @@ export default class TestDataProvider {
     }
     let url =
       this.orgUrl + '/' + project + '/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=' + planid;
-    return this.fetchWithCache(url);
+    return await this.fetchWithCache(url);
   }
 
   async GetTestSuitesByPlan(project: string, planId: string, recursive: boolean): Promise<any> {
@@ -314,7 +314,7 @@ export default class TestDataProvider {
 
   async GetTestPoint(project: string, planId: string, suiteId: string, testCaseId: string): Promise<any> {
     let testPointUrl: string = `${this.orgUrl}${project}/_apis/test/Plans/${planId}/Suites/${suiteId}/points?testCaseId=${testCaseId}`;
-    return this.fetchWithCache(testPointUrl);
+    return await this.fetchWithCache(testPointUrl);
   }
 
   async CreateTestRun(

package/src/modules/TicketsDataProvider.ts

@@ -1,17 +1,13 @@
 import { TFSServices } from '../helpers/tfs';
 import { Workitem, QueryTree } from '../models/tfs-data';
-import { Helper, suiteData, Links, Trace, Relations } from '../helpers/helper';
-import { Query, TestSteps } from '../models/tfs-data';
+import { Helper, Links, Trace, Relations } from '../helpers/helper';
+import { Query } from '../models/tfs-data';
 import { QueryType } from '../models/tfs-data';
 import { QueryAllTypes } from '../models/tfs-data';
 import { Column } from '../models/tfs-data';
 import { value } from '../models/tfs-data';
-import { TestCase } from '../models/tfs-data';
-import * as xml2js from 'xml2js';
 
 import logger from '../utils/logger';
-import { log } from 'console';
-import { pid, title } from 'process';
 
 export default class TicketsDataProvider {
   orgUrl: string = '';
@@ -42,7 +38,7 @@ export default class TicketsDataProvider {
       let traceItem: Trace; //= new Trace();
       traceItem = await this.GetParentLink(project, wis[i]);
 
-      if (linksMap.get(wis[i].id).rels.length > 0) {
+      if (linksMap.get(wis[i].id)?.rels.length > 0) {
         relations = await this.PopulateWorkItemsByIds(linksMap.get(wis[i].id).rels, project);
         traceItem.links = await this.GetLinks(project, wis[i], relations);
       }
@@ -626,11 +622,11 @@ export default class TicketsDataProvider {
   } //CreateNewWorkItem
 
   async GetWorkitemAttachments(project: string, id: string) {
-    let attachmentList: Array<string> = [];
+    let attachmentList: Array<any> = [];
     let ticketsDataProvider = new TicketsDataProvider(this.orgUrl, this.token);
     try {
       let wi = await ticketsDataProvider.GetWorkItem(project, id);
-      if (!wi.relations) return [];
+      if (!wi?.relations) return [];
       await Promise.all(
         wi.relations.map(async (relation: any) => {
           if (relation.rel == 'AttachedFile') {

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

@@ -0,0 +1,171 @@
+import { TFSServices } from '../../helpers/tfs';
+import logger from '../../utils/logger';
+import JfrogDataProvider from '../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`
+            );
+        });
+    });
+});