@elisra-devops/docgen-data-provider 1.18.0 → 1.20.0

package/src/modules/TestDataProvider.ts

@@ -1,21 +1,18 @@
 import { TFSServices } from '../helpers/tfs';
-import { Workitem } from '../models/tfs-data';
-import { Helper, suiteData, Links, Trace, Relations } from '../helpers/helper';
-import { Query, TestSteps, createBugRelation, createRequirementRelation } 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 { Helper, suiteData } from '../helpers/helper';
+import { TestSteps, createRequirementRelation } from '../models/tfs-data';
 import { TestCase } from '../models/tfs-data';
 import * as xml2js from 'xml2js';
-
 import logger from '../utils/logger';
 import TestStepParserHelper from '../utils/testStepParserHelper';
+const pLimit = require('p-limit');
 
 export default class TestDataProvider {
   orgUrl: string = '';
   token: string = '';
   private testStepParserHelper: TestStepParserHelper;
+  private cache = new Map<string, any>(); // Cache for API responses
+  private limit = pLimit(10);
 
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
@@ -23,26 +20,47 @@ export default class TestDataProvider {
     this.testStepParserHelper = new TestStepParserHelper(orgUrl, token);
   }
 
+  private async fetchWithCache(url: string, ttlMs = 60000): Promise<any> {
+    if (this.cache.has(url)) {
+      const cached = this.cache.get(url);
+      if (cached.timestamp + ttlMs > Date.now()) {
+        return cached.data;
+      }
+    }
+
+    try {
+      const result = await TFSServices.getItemContent(url, this.token);
+
+      this.cache.set(url, {
+        data: result,
+        timestamp: Date.now(),
+      });
+
+      return result;
+    } catch (error: any) {
+      logger.error(`Error fetching ${url}: ${error.message}`);
+      throw error;
+    }
+  }
+
   async GetTestSuiteByTestCase(testCaseId: string): Promise<any> {
     let url = `${this.orgUrl}/_apis/testplan/suites?testCaseId=${testCaseId}`;
-    let testCaseData = await TFSServices.getItemContent(url, this.token);
-    return testCaseData;
+    return this.fetchWithCache(url);
   }
 
-  //get all test plans in the project
   async GetTestPlans(project: string): Promise<string> {
     let testPlanUrl: string = `${this.orgUrl}${project}/_apis/test/plans`;
-    return TFSServices.getItemContent(testPlanUrl, this.token);
+    return this.fetchWithCache(testPlanUrl);
   }
-  //async get data test
 
-  // get all test suits in projct test plan
   async GetTestSuites(project: string, planId: string): Promise<any> {
     let testsuitesUrl: string = this.orgUrl + project + '/_apis/test/Plans/' + planId + '/suites';
     try {
-      let testSuites = await TFSServices.getItemContent(testsuitesUrl, this.token);
-      return testSuites;
-    } catch (e) {}
+      return this.fetchWithCache(testsuitesUrl);
+    } catch (e) {
+      logger.error(`Failed to get test suites: ${e}`);
+      return null;
+    }
   }
 
   async GetTestSuitesForPlan(project: string, planid: string): Promise<any> {
@@ -54,20 +72,16 @@ export default class TestDataProvider {
     }
     let url =
       this.orgUrl + '/' + project + '/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=' + planid;
-    let suites = await TFSServices.getItemContent(url, this.token);
-    return suites;
+    return this.fetchWithCache(url);
   }
 
   async GetTestSuitesByPlan(project: string, planId: string, recursive: boolean): Promise<any> {
     let suiteId = Number(planId) + 1;
-    let suites = await this.GetTestSuiteById(project, planId, suiteId.toString(), recursive);
-    return suites;
+    return this.GetTestSuiteById(project, planId, suiteId.toString(), recursive);
   }
-  //gets all testsuits recorsivly under test suite
 
   async GetTestSuiteById(project: string, planId: string, suiteId: string, recursive: boolean): Promise<any> {
     let testSuites = await this.GetTestSuitesForPlan(project, planId);
-    // GetTestSuites(project, planId);
     Helper.suitList = [];
     let dataSuites: any = Helper.findSuitesRecursive(
       planId,
@@ -78,17 +92,14 @@ export default class TestDataProvider {
       recursive
     );
     Helper.first = true;
-    // let levledSuites: any = Helper.buildSuiteslevel(dataSuites);
-
     return dataSuites;
   }
-  //gets all testcase under test suite acording to recursive flag
 
   async GetTestCasesBySuites(
     project: string,
     planId: string,
     suiteId: string,
-    recursiv: boolean,
+    recursive: boolean,
     includeRequirements: boolean,
     CustomerRequirementId: boolean,
     stepResultDetailsMap?: Map<string, any>
@@ -96,28 +107,48 @@ export default class TestDataProvider {
     let testCasesList: Array<any> = new Array<any>();
     const requirementToTestCaseTraceMap: Map<string, string[]> = new Map();
     const testCaseToRequirementsTraceMap: Map<string, string[]> = new Map();
+    // const startTime = performance.now();
+
     let suitesTestCasesList: Array<suiteData> = await this.GetTestSuiteById(
       project,
       planId,
       suiteId,
-      recursiv
+      recursive
+    );
+
+    // Create array of promises that each return their test cases
+    const testCaseListPromises = suitesTestCasesList.map((suite) =>
+      this.limit(async () => {
+        try {
+          const testCases = await this.GetTestCases(project, planId, suite.id);
+          // const structureStartTime = performance.now();
+          const testCasesWithSteps = await this.StructureTestCase(
+            project,
+            testCases,
+            suite,
+            includeRequirements,
+            CustomerRequirementId,
+            requirementToTestCaseTraceMap,
+            testCaseToRequirementsTraceMap,
+            stepResultDetailsMap
+          );
+          // logger.debug(
+          //   `Performance: structured suite ${suite.id} in ${performance.now() - structureStartTime}ms`
+          // );
+
+          // Return the results instead of modifying shared array
+          return testCasesWithSteps || [];
+        } catch (error) {
+          logger.error(`Error processing suite ${suite.id}: ${error}`);
+          return []; // Return empty array on error
+        }
+      })
     );
-    for (let i = 0; i < suitesTestCasesList.length; i++) {
-      let testCases: any = await this.GetTestCases(project, planId, suitesTestCasesList[i].id);
-      let testCseseWithSteps: any = await this.StructureTestCase(
-        project,
-        testCases,
-        suitesTestCasesList[i],
-        includeRequirements,
-        CustomerRequirementId,
-        requirementToTestCaseTraceMap,
-        testCaseToRequirementsTraceMap,
-        stepResultDetailsMap
-      );
-
-      if (testCseseWithSteps.length > 0) testCasesList = [...testCasesList, ...testCseseWithSteps];
-    }
 
+    // Wait for all promises and only then combine the results
+    const results = await Promise.all(testCaseListPromises);
+    testCasesList = results.flat(); // Combine all results into a single array
+    // logger.debug(`Performance: GetTestCasesBySuites completed in ${performance.now() - startTime}ms`);
     return { testCasesList, requirementToTestCaseTraceMap, testCaseToRequirementsTraceMap };
   }
 
@@ -130,13 +161,14 @@ export default class TestDataProvider {
     requirementToTestCaseTraceMap: Map<string, string[]>,
     testCaseToRequirementsTraceMap: Map<string, string[]>,
     stepResultDetailsMap?: Map<string, any>
-  ): Promise<Array<any>> {
+  ): Promise<any[]> {
     let url = this.orgUrl + project + '/_workitems/edit/';
-    let testCasesUrlList: Array<any> = new Array<any>();
+    let testCasesUrlList: any[] = [];
     logger.debug(`Trying to structure Test case for ${project} suite: ${suite.id}:${suite.name}`);
     try {
-      if (!testCases) {
-        throw new Error('test cases were not found');
+      if (!testCases || !testCases.value || testCases.count === 0) {
+        logger.warn(`No test cases found for suite: ${suite.id}`);
+        return [];
       }
 
       for (let i = 0; i < testCases.count; i++) {
@@ -147,7 +179,7 @@ export default class TestDataProvider {
           let newurl = !stepDetailObject?.testCaseRevision
             ? testCases.value[i].testCase.url + '?$expand=All'
             : `${testCases.value[i].testCase.url}/revisions/${stepDetailObject.testCaseRevision}?$expand=All`;
-          let test: any = await TFSServices.getItemContent(newurl, this.token);
+          let test: any = await this.fetchWithCache(newurl);
           let testCase: TestCase = new TestCase();
 
           testCase.title = test.fields['System.Title'];
@@ -174,7 +206,7 @@ export default class TestDataProvider {
               // Only proceed if the URL contains 'workItems'
               if (relation.url.includes('/workItems/')) {
                 try {
-                  let relatedItemContent: any = await TFSServices.getItemContent(relation.url, this.token);
+                  let relatedItemContent: any = await this.fetchWithCache(relation.url);
                   // Check if the WorkItemType is "Requirement" before adding to relations
                   if (relatedItemContent.fields['System.WorkItemType'] === 'Requirement') {
                     const newRequirementRelation = this.createNewRequirement(
@@ -212,8 +244,8 @@ export default class TestDataProvider {
           }
           testCasesUrlList.push(testCase);
         } catch {
-          const errorMsg = `ran into an issue while retriving testCase ${testCases.value[i].testCase.id}`;
-          logger.error(`errorMsg`);
+          const errorMsg = `ran into an issue while retrieving testCase ${testCases.value[i].testCase.id}`;
+          logger.error(`Error: ${errorMsg}`);
           throw new Error(errorMsg);
         }
       }
@@ -275,16 +307,14 @@ export default class TestDataProvider {
   async GetTestCases(project: string, planId: string, suiteId: string): Promise<any> {
     let testCaseUrl: string =
       this.orgUrl + project + '/_apis/test/Plans/' + planId + '/suites/' + suiteId + '/testcases/';
-    let testCases: any = await TFSServices.getItemContent(testCaseUrl, this.token);
+    let testCases: any = await this.fetchWithCache(testCaseUrl);
     logger.debug(`test cases for plan ${planId} and ${suiteId} were ${testCases ? 'found' : 'not found'}`);
     return testCases;
   }
 
-  //gets all test point in a test case
   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}`;
-    let testPoints: any = await TFSServices.getItemContent(testPointUrl, this.token);
-    return testPoints;
+    return this.fetchWithCache(testPointUrl);
   }
 
   async CreateTestRun(
@@ -415,4 +445,12 @@ export default class TestDataProvider {
     }
     map.get(key)?.push(value);
   };
+
+  /**
+   * Clears the cache to free memory
+   */
+  public clearCache(): void {
+    this.cache.clear();
+    logger.debug('Cache cleared');
+  }
 }