@elisra-devops/docgen-data-provider 0.4.16 → 0.6.0

package/src/modules/TestDataProvider.ts

@@ -1,93 +1,63 @@
-import { TFSServices } from "../helpers/tfs";
-import { Workitem } from "../models/tfs-data";
-import { Helper, suiteData, Links, Trace, Relations } from "../helpers/helper";
-import { Query, TestSteps, Relation } 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 { 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 { TestCase } from '../models/tfs-data';
+import * as xml2js from 'xml2js';
 
-import logger from "../utils/logger";
+import logger from '../utils/logger';
+import { log } from 'winston';
 
 export default class TestDataProvider {
-  orgUrl: string = "";
-  token: string = "";
-  
+  orgUrl: string = '';
+  token: string = '';
+
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
     this.token = token;
   }
 
-  async GetTestSuiteByTestCase(
-    testCaseId: string
-  ): Promise<any> {
+  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;
   }
 
   //get all test plans in the project
-  async GetTestPlans(
-    project: string
-  ): Promise<string> {
+  async GetTestPlans(project: string): Promise<string> {
     let testPlanUrl: string = `${this.orgUrl}${project}/_apis/test/plans`;
-    return TFSServices.getItemContent(testPlanUrl,this.token);
+    return TFSServices.getItemContent(testPlanUrl, this.token);
   }
+  //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";
+  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
-      );
+      let testSuites = await TFSServices.getItemContent(testsuitesUrl, this.token);
       return testSuites;
     } catch (e) {}
   }
 
-  async GetTestSuitesForPlan(
-    project: string,
-    planid: string
-  ): Promise<any> {
+  async GetTestSuitesForPlan(project: string, planid: string): Promise<any> {
     let url =
-      this.orgUrl +
-      "/" +
-      project +
-      "/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=" +
-      planid;
+      this.orgUrl + '/' + project + '/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=' + planid;
     let suites = await TFSServices.getItemContent(url, this.token);
     return suites;
   }
 
-  async GetTestSuitesByPlan(
-    project: string,
-    planId: string,
-    recursive: boolean
-  ): Promise<any> {
+  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
-    );
+    let suites = await this.GetTestSuiteById(project, planId, suiteId.toString(), recursive);
     return suites;
   }
   //gets all testsuits recorsivly under test suite
 
-  async GetTestSuiteById(
-    project: string,
-    planId: string,
-    suiteId: string,
-    recursive: boolean
-  ): Promise<any> {
+  async GetTestSuiteById(project: string, planId: string, suiteId: string, recursive: boolean): Promise<any> {
     let testSuites = await this.GetTestSuitesForPlan(project, planId);
     // GetTestSuites(project, planId);
     Helper.suitList = [];
@@ -111,8 +81,10 @@ export default class TestDataProvider {
     planId: string,
     suiteId: string,
     recursiv: boolean,
-    relations: boolean,
-    CustomerRequirementId: boolean
+    includeRequirements: boolean,
+    CustomerRequirementId: boolean,
+    includeBugs: boolean,
+    includeSeverity: boolean
   ): Promise<Array<any>> {
     let testCasesList: Array<any> = new Array<any>();
     let suitesTestCasesList: Array<suiteData> = await this.GetTestSuiteById(
@@ -122,20 +94,17 @@ export default class TestDataProvider {
       recursiv
     );
     for (let i = 0; i < suitesTestCasesList.length; i++) {
-      let testCases: any = await this.GetTestCases(
-        project,
-        planId,
-        suitesTestCasesList[i].id
-      );
+      let testCases: any = await this.GetTestCases(project, planId, suitesTestCasesList[i].id);
       let testCseseWithSteps: any = await this.StructureTestCase(
         project,
         testCases,
         suitesTestCasesList[i],
-        relations,
-        CustomerRequirementId
+        includeRequirements,
+        CustomerRequirementId,
+        includeBugs,
+        includeSeverity
       );
-      if (testCseseWithSteps.length > 0)
-        testCasesList = [...testCasesList, ...testCseseWithSteps];
+      if (testCseseWithSteps.length > 0) testCasesList = [...testCasesList, ...testCseseWithSteps];
     }
     return testCasesList;
   }
@@ -144,84 +113,109 @@ export default class TestDataProvider {
     project: string,
     testCases: any,
     suite: suiteData,
-    relations: boolean,
-    CustomerRequirementId: boolean
+    includeRequirements: boolean,
+    CustomerRequirementId: boolean,
+    includeBugs: boolean,
+    includeSeverity: boolean
   ): Promise<Array<any>> {
-
-    let url = this.orgUrl + project + "/_workitems/edit/";
+    let url = this.orgUrl + project + '/_workitems/edit/';
     let testCasesUrlList: Array<any> = new Array<any>();
     //let tesrCase:TestCase;
     for (let i = 0; i < testCases.count; i++) {
-      try{
-      let newurl = testCases.value[i].testCase.url + "?$expand=All"
-      let test: any = await TFSServices.getItemContent(
-        newurl,
-        this.token
-      );
-      let testCase: TestCase = new TestCase();
+      try {
+        let newurl = testCases.value[i].testCase.url + '?$expand=All';
+        let test: any = await TFSServices.getItemContent(newurl, this.token);
+        let testCase: TestCase = new TestCase();
 
-      testCase.title = test.fields["System.Title"];
-      testCase.area = test.fields["System.AreaPath"];
-      testCase.description = test.fields["System.Description"];
-      testCase.url = url + test.id;
-      //testCase.steps = test.fields["Microsoft.VSTS.TCM.Steps"];
-      testCase.id = test.id;
-      testCase.suit = suite.id;
-      if (test.fields["Microsoft.VSTS.TCM.Steps"] != null) {
-        let steps: Array<TestSteps> = this.ParseSteps(
-          test.fields["Microsoft.VSTS.TCM.Steps"]
-        );
-        testCase.steps = steps;
-      }      
-      if (relations && test.relations) {
-        for (const relation of test.relations) {
+        testCase.title = test.fields['System.Title'];
+        testCase.area = test.fields['System.AreaPath'];
+        testCase.description = test.fields['System.Description'];
+        testCase.url = url + test.id;
+        //testCase.steps = test.fields["Microsoft.VSTS.TCM.Steps"];
+        testCase.id = test.id;
+        testCase.suit = suite.id;
+        if (test.fields['Microsoft.VSTS.TCM.Steps'] != null) {
+          let steps: Array<TestSteps> = this.ParseSteps(test.fields['Microsoft.VSTS.TCM.Steps']);
+          testCase.steps = steps;
+        }
+        if ((includeBugs || includeRequirements) && test.relations) {
+          for (const relation of test.relations) {
             // Only proceed if the URL contains 'workItems'
             if (relation.url.includes('/workItems/')) {
-                try {
-                    let relatedItemContent: any = await TFSServices.getItemContent(relation.url, this.token);
-                    
-                    // Check if the WorkItemType is "Requirement" before adding to relations
-                    if (relatedItemContent.fields["System.WorkItemType"] === "Requirement") {
-                        let customerId = undefined;
-                        // Check if CustomerRequirementId is true and set customerId
-                        if (CustomerRequirementId) {
-                            // Here we check for either of the two potential fields for customer ID
-                            customerId = relatedItemContent.fields["Custom.CustomerRequirementID"] || relatedItemContent.fields["Custom.CustomerID"] || relatedItemContent.fields["Elisra.CustomerRequirementId"] || " ";
-                        }
-                        
-                        let relatedItem: Relation = {
-                            id: relatedItemContent.id,
-                            title: relatedItemContent.fields["System.Title"],
-                            customerId: customerId  // Add this field conditionally
-                        };
-                        testCase.relations.push(relatedItem);
-                    }
-                } catch (fetchError) {
-                    // Log error silently or handle as needed
-                    console.error("Failed to fetch relation content", fetchError);
-                    logger.error(`Failed to fetch relation content for URL ${relation.url}: ${fetchError}`);
+              try {
+                let relatedItemContent: any = await TFSServices.getItemContent(relation.url, this.token);
+                // Check if the WorkItemType is "Requirement" before adding to relations
+                if (
+                  includeRequirements &&
+                  relatedItemContent.fields['System.WorkItemType'] === 'Requirement'
+                ) {
+                  const newRequirementRelation = this.createNewRequirement(
+                    CustomerRequirementId,
+                    relatedItemContent
+                  );
+                  testCase.relations.push(newRequirementRelation);
+                }
+
+                // Check if the WorkItemType is "Requirement" before adding to relations
+                if (includeBugs && relatedItemContent.fields['System.WorkItemType'] === 'Bug') {
+                  const newBugRelation = this.createBugRelation(includeSeverity, relatedItemContent);
+                  testCase.relations.push(newBugRelation);
                 }
+              } catch (fetchError) {
+                // Log error silently or handle as needed
+                console.error('Failed to fetch relation content', fetchError);
+                logger.error(`Failed to fetch relation content for URL ${relation.url}: ${fetchError}`);
+              }
             }
+          }
         }
-    }    
-      testCasesUrlList.push(testCase);
+        testCasesUrlList.push(testCase);
+      } catch {
+        logger.error(`ran into an issue while retriving testCase ${testCases.value[i].testCase.id}`);
+      }
     }
-    
-    catch{
-      logger.error(`ran into an issue while retriving testCase ${testCases.value[i].testCase.id}`);
+
+    return testCasesUrlList;
+  }
+
+  private createBugRelation(includeSeverity: boolean, relatedItemContent: any) {
+    let severity = undefined;
+    // Check if CustomerRequirementId is true and set customerId
+    if (includeSeverity) {
+      // Add severity here
+      severity = relatedItemContent.fields['Microsoft.VSTS.Common.Severity'];
     }
-    
+    const newBugRelation = createBugRelation(
+      relatedItemContent.id,
+      relatedItemContent.fields['System.Title'],
+      severity
+    );
+    return newBugRelation;
   }
 
-    return testCasesUrlList;
+  private createNewRequirement(CustomerRequirementId: boolean, relatedItemContent: any) {
+    let customerId = undefined;
+    // Check if CustomerRequirementId is true and set customerId
+    if (CustomerRequirementId) {
+      // Here we check for either of the two potential fields for customer ID
+      customerId =
+        relatedItemContent.fields['Custom.CustomerRequirementID'] ||
+        relatedItemContent.fields['Custom.CustomerID'] ||
+        relatedItemContent.fields['Elisra.CustomerRequirementId'] ||
+        ' ';
+    }
+    const newRequirementRelation = createRequirementRelation(
+      relatedItemContent.id,
+      relatedItemContent.fields['System.Title'],
+      customerId
+    );
+    return newRequirementRelation;
   }
 
-  ParseSteps(
-    steps: string
-  ) {
+  ParseSteps(steps: string) {
     let stepsLsist: Array<TestSteps> = new Array<TestSteps>();
-    const start: string = ";P&gt;";
-    const end: string = "&lt;/P";
+    const start: string = ';P&gt;';
+    const end: string = '&lt;/P';
     let totalString: String = steps;
     xml2js.parseString(steps, function (err, result) {
       if (err) console.log(err);
@@ -230,17 +224,13 @@ export default class TestDataProvider {
           let step: TestSteps = new TestSteps();
           try {
             if (result.steps.step[i].parameterizedString[0]._ != null)
-              step.action = result.steps.step[
-                i
-              ].parameterizedString[0]._
+              step.action = result.steps.step[i].parameterizedString[0]._;
           } catch (e) {
             logger.warn(`No test step action data to parse for testcase `);
           }
           try {
             if (result.steps.step[i].parameterizedString[1]._ != null)
-              step.expected = result.steps.step[
-                i
-              ].parameterizedString[1]._
+              step.expected = result.steps.step[i].parameterizedString[1]._;
           } catch (e) {
             logger.warn(`No test step expected data to parse for testcase `);
           }
@@ -251,39 +241,17 @@ export default class TestDataProvider {
     return stepsLsist;
   }
 
-  async GetTestCases(
-    project: string,
-    planId: string,
-    suiteId: string
-  ): Promise<any> {
+  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
-    );
+      this.orgUrl + project + '/_apis/test/Plans/' + planId + '/suites/' + suiteId + '/testcases/';
+    let testCases: any = await TFSServices.getItemContent(testCaseUrl, this.token);
     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
-    );
+  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;
   }
 
@@ -294,9 +262,7 @@ export default class TestDataProvider {
     testPointId: string
   ): Promise<any> {
     try {
-      logger.info(
-        `Create test run op test point  ${testPointId} ,test planId : ${testPlanId}`
-      );
+      logger.info(`Create test run op test point  ${testPointId} ,test planId : ${testPlanId}`);
       let Url = `${this.orgUrl}${projectName}/_apis/test/runs`;
       let data = {
         name: testRunName,
@@ -305,13 +271,7 @@ export default class TestDataProvider {
         },
         pointIds: [testPointId],
       };
-      let res = await TFSServices.postRequest(
-        Url,
-        this.token,
-        "Post",
-        data,
-        null
-      );
+      let res = await TFSServices.postRequest(Url, this.token, 'Post', data, null);
       return res;
     } catch (err) {
       logger.error(`Error : ${err}`);
@@ -319,31 +279,17 @@ export default class TestDataProvider {
     }
   }
 
-  async UpdateTestRun(
-    projectName: string,
-    runId: string,
-    state: string
-  ): Promise<any> {
+  async UpdateTestRun(projectName: string, runId: string, state: string): Promise<any> {
     logger.info(`Update runId : ${runId} to state : ${state}`);
     let Url = `${this.orgUrl}${projectName}/_apis/test/Runs/${runId}?api-version=5.0`;
     let data = {
       state: state,
     };
-    let res = await TFSServices.postRequest(
-      Url,
-      this.token,
-      "PATCH",
-      data,
-      null
-    );
+    let res = await TFSServices.postRequest(Url, this.token, 'PATCH', data, null);
     return res;
   }
 
-  async UpdateTestCase(
-    projectName: string,
-    runId: string,
-    state: number
-  ): Promise<any> {
+  async UpdateTestCase(projectName: string, runId: string, state: number): Promise<any> {
     let data: any;
     logger.info(`Update test case, runId : ${runId} to state : ${state}`);
     let Url = `${this.orgUrl}${projectName}/_apis/test/Runs/${runId}/results?api-version=5.0`;
@@ -353,7 +299,7 @@ export default class TestDataProvider {
         data = [
           {
             id: 100000,
-            outcome: "0",
+            outcome: '0',
           },
         ];
         break;
@@ -362,8 +308,8 @@ export default class TestDataProvider {
         data = [
           {
             id: 100000,
-            state: "Completed",
-            outcome: "1",
+            state: 'Completed',
+            outcome: '1',
           },
         ];
         break;
@@ -372,8 +318,8 @@ export default class TestDataProvider {
         data = [
           {
             id: 100000,
-            state: "Completed",
-            outcome: "2",
+            state: 'Completed',
+            outcome: '2',
           },
         ];
         break;
@@ -382,19 +328,13 @@ export default class TestDataProvider {
         data = [
           {
             id: 100000,
-            state: "Completed",
-            outcome: "3",
+            state: 'Completed',
+            outcome: '3',
           },
         ];
         break;
     }
-    let res = await TFSServices.postRequest(
-      Url,
-      this.token,
-      "PATCH",
-      data,
-      null
-    );
+    let res = await TFSServices.postRequest(Url, this.token, 'PATCH', data, null);
     return res;
   }
 
@@ -414,51 +354,26 @@ export default class TestDataProvider {
       comment: comment,
       attachmentType: attachmentType,
     };
-    let res = await TFSServices.postRequest(
-      Url,
-      this.token,
-      "Post",
-      data,
-      null
-    );
+    let res = await TFSServices.postRequest(Url, this.token, 'Post', data, null);
     return res;
   }
 
-  async GetTestRunById(
-    projectName: string, runId: string
-  ): Promise<any> {
+  async GetTestRunById(projectName: string, runId: string): Promise<any> {
     logger.info(`getting test run id: ${runId}`);
     let url = `${this.orgUrl}${projectName}/_apis/test/Runs/${runId}`;
-    let res = await TFSServices.getItemContent(
-      url,
-      this.token,
-      "get",
-      null,
-      null
-    );
+    let res = await TFSServices.getItemContent(url, this.token, 'get', null, null);
     return res;
   }
 
-  async GetTestPointByTestCaseId(
-    projectName: string,
-    testCaseId: string
-  ): Promise<any> {
-    logger.info(
-      `get test points at project ${projectName} , of testCaseId : ${testCaseId}`
-    );
+  async GetTestPointByTestCaseId(projectName: string, testCaseId: string): Promise<any> {
+    logger.info(`get test points at project ${projectName} , of testCaseId : ${testCaseId}`);
     let url = `${this.orgUrl}${projectName}/_apis/test/points`;
     let data = {
       PointsFilter: {
         TestcaseIds: [testCaseId],
       },
     };
-    let res = await TFSServices.postRequest(
-      url,
-      this.token,
-      "Post",
-      data,
-      null
-    );
+    let res = await TFSServices.postRequest(url, this.token, 'Post', data, null);
     return res;
   }
 }