@elisra-devops/docgen-data-provider 1.3.0 → 1.3.2

package/src/modules/ResultDataProvider.ts

@@ -1,16 +1,17 @@
 import { TFSServices } from '../helpers/tfs';
-import { TestSteps } from '../models/tfs-data';
+import { TestSteps, Workitem } from '../models/tfs-data';
 import * as xml2js from 'xml2js';
 import logger from '../utils/logger';
-import { error, log } from 'console';
-
+import TestStepParserHelper from '../utils/testStepParserHelper';
 export default class ResultDataProvider {
   orgUrl: string = '';
   token: string = '';
 
+  private testStepParserHelper: TestStepParserHelper;
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
     this.token = token;
+    this.testStepParserHelper = new TestStepParserHelper(orgUrl, token);
   }
 
   /**
@@ -198,34 +199,6 @@ export default class ResultDataProvider {
     }
   }
 
-  /**
-   * Parses test steps from XML format into a structured array.
-   */
-  private parseTestSteps(xmlSteps: string): { stepsList: TestSteps[] } {
-    const stepsList: TestSteps[] = [];
-
-    xml2js.parseString(xmlSteps, { explicitArray: false }, (err, result) => {
-      if (err) {
-        logger.warn('Failed to parse XML test steps.');
-        return;
-      }
-
-      if (result.steps === undefined || parseInt(result.steps.$.last) === 0) {
-        return;
-      }
-      const stepsArray = Array.isArray(result.steps?.step) ? result.steps.step : [result.steps?.step];
-      for (let i = 0; i < stepsArray.length; i++) {
-        const stepObj = stepsArray[i];
-        const step = new TestSteps();
-        step.stepId = Number(stepObj.$.id);
-        step.action = stepObj.parameterizedString?.[0]?._ || '';
-        step.expected = stepObj.parameterizedString?.[1]?._ || '';
-        stepsList.push(step);
-      }
-    });
-    return { stepsList };
-  }
-
   /**
    * Aligns test steps with their corresponding iterations.
    */
@@ -240,9 +213,6 @@ export default class ResultDataProvider {
         const testCase = testItem.testCasesItems.find((tc: any) => tc.workItem.id === point.testCaseId);
         if (!testCase) continue;
         const iterationsMap = this.createIterationsMap(iterations, testCase.workItem.id);
-
-        logger.debug(`parsing data for test case Id ${point.testCaseId}`);
-
         if (testCase.workItem.workItemFields.length === 0) {
           logger.warn(`Could not fetch the steps from WI ${JSON.stringify(testCase.workItem.id)}`);
           continue;
@@ -263,7 +233,7 @@ export default class ResultDataProvider {
               testCaseRevision: testCastObj.testCaseRevision,
               testName: point.testCaseName,
               stepIdentifier: stepIdentifier,
-              stepNo: i + 1,
+              stepNo: actionResults[i].stepPosition,
               stepAction: actionResults[i].action,
               stepExpected: actionResults[i].expected,
               stepStatus:
@@ -275,31 +245,6 @@ export default class ResultDataProvider {
               stepComments: actionResults[i].errorMessage || '',
             };
 
-            detailedResults.push(resultObj);
-          }
-        } else {
-          const { stepsList: steps } = this.parseTestSteps(
-            testCase.workItem.workItemFields[0]['Microsoft.VSTS.TCM.Steps']
-          );
-
-          if (steps.length === 0) {
-            logger.warn(`No steps were found for WI ${testCase.workItem?.id}`);
-            continue;
-          }
-          //In case of not tested
-          logger.debug(`Test case ${point.testCaseId} does not have a test result`);
-          for (let i = 0; i < steps.length; i++) {
-            const resultObj = {
-              testId: point.testCaseId,
-              testName: point.testCaseName,
-              stepIdentifier: steps[i].stepId,
-              testCaseRevision: undefined,
-              stepNo: i + 1,
-              stepAction: steps[i].action,
-              stepExpected: steps[i].expected,
-              stepStatus: 'Not Run',
-              stepComments: 'No Result',
-            };
             detailedResults.push(resultObj);
           }
         }
@@ -374,22 +319,57 @@ export default class ResultDataProvider {
     return results;
   }
 
+  //Sorting step positions
+  private compareActionResults = (a: string, b: string) => {
+    const aParts = a.split('.').map(Number);
+    const bParts = b.split('.').map(Number);
+    const maxLength = Math.max(aParts.length, bParts.length);
+
+    for (let i = 0; i < maxLength; i++) {
+      const aNum = aParts[i] || 0; // Default to 0 if undefined
+      const bNum = bParts[i] || 0;
+
+      if (aNum > bNum) return 1;
+      if (aNum < bNum) return -1;
+      // If equal, continue to next segment
+    }
+
+    return 0; // Versions are equal
+  };
+
   /**
    * Fetches result Data data for a specific test point.
    */
   private async fetchResultData(projectName: string, testSuiteId: string, point: any) {
     const { lastRunId, lastResultId } = point;
     const resultData = await this.fetchResult(projectName, lastRunId.toString(), lastResultId.toString());
-    logger.debug(
-      `resultData is ${resultData ? 'available' : 'unavailable'} for run ${lastRunId} result ${lastResultId} `
-    );
+
     const iteration =
       resultData.iterationDetails.length > 0
         ? resultData.iterationDetails[resultData.iterationDetails.length - 1]
         : undefined;
 
     if (resultData.stepsResultXml && iteration) {
-      const { stepsList } = this.parseTestSteps(resultData.stepsResultXml);
+      const actionResultsWithSharedModels = iteration.actionResults.filter(
+        (result: any) => result.sharedStepModel
+      );
+      const actionResultsWithNoSharedModels = iteration.actionResults.filter(
+        (result: any) => !result.sharedStepModel
+      );
+      const sharedStepIdToRevisionLookupMap: Map<number, number> = new Map();
+
+      if (actionResultsWithSharedModels?.length > 0) {
+        actionResultsWithSharedModels.forEach((actionResult: any) => {
+          const { sharedStepModel } = actionResult;
+          sharedStepIdToRevisionLookupMap.set(Number(sharedStepModel.id), Number(sharedStepModel.revision));
+        });
+      }
+      const stepsList = await this.testStepParserHelper.parseTestSteps(
+        resultData.stepsResultXml,
+        sharedStepIdToRevisionLookupMap
+      );
+
+      sharedStepIdToRevisionLookupMap.clear();
 
       const stepMap = new Map<string, any>();
       for (const step of stepsList) {
@@ -397,12 +377,22 @@ export default class ResultDataProvider {
       }
 
       for (const actionResult of iteration.actionResults) {
+        //If the actions results holds a sharedStepModel then ignore it and continue
+        if (actionResult.sharedStepModel) {
+          continue;
+        }
+
         const step = stepMap.get(actionResult.stepIdentifier);
         if (step) {
+          actionResult.stepPosition = step.stepPosition;
           actionResult.action = step.action;
           actionResult.expected = step.expected;
         }
       }
+      //Sort by step position
+      iteration.actionResults = actionResultsWithNoSharedModels
+        .filter((result: any) => result.stepPosition)
+        .sort((a: any, b: any) => this.compareActionResults(a.stepPosition, b.stepPosition));
     }
     return resultData?.testCase
       ? {
@@ -425,56 +415,77 @@ export default class ResultDataProvider {
   /**
    * Fetches all the linked work items (WI) for the given test case.
    * @param project Project name
-   * @param testCaseId Test case ID number
+   * @param testItems Test cases
    * @returns Array of linked Work Items
    */
-  private async fetchLinkedWi(project: string, testCaseId: string): Promise<any[]> {
+  private async fetchLinkedWi(project: string, testItems: any[]): Promise<any[]> {
     try {
+      const summarizedItemMap: Map<number, any> = new Map();
+      const testIds = testItems.map((summeryItem) => {
+        summarizedItemMap.set(summeryItem.testId, { ...summeryItem, linkItems: [] });
+        return `${summeryItem.testId}`;
+      });
+      const testIdsString = testIds.join(',');
       // Construct URL to fetch linked work items
-      const getLinkedWiUrl = `${this.orgUrl}${project}/_apis/wit/workItems/${testCaseId}?$expand=relations`;
+      const getLinkedWisUrl = `${this.orgUrl}${project}/_apis/wit/workItems?ids=${testIdsString}&$expand=relations`;
 
       // Fetch linked work items
-      const { relations } = await TFSServices.getItemContent(getLinkedWiUrl, this.token);
+      const { value: workItems } = await TFSServices.getItemContent(getLinkedWisUrl, this.token);
+
+      if (workItems.length > 0) {
+        for (const wi of workItems) {
+          const { relations } = wi;
+          // Ensure relations is an array
+          const item = summarizedItemMap.get(wi.id);
+          if (!item) {
+            continue;
+          }
+          if (!Array.isArray(relations) || relations.length === 0) {
+            continue;
+          }
 
-      // Ensure relations is an array
-      if (!Array.isArray(relations) || relations.length === 0) {
-        return [];
-      }
+          const relationWorkItemsIds = relations
+            .filter((relation) => relation?.attributes?.name === 'Tests')
+            .map((relation) => relation.url.split('/').pop());
+
+          if (relationWorkItemsIds.length === 0) {
+            continue;
+          }
 
-      // Filter relations by 'Tests' attribute and extract work item IDs
-      const workItemIds = relations
-        .filter((relation) => relation?.attributes?.name === 'Tests')
-        .map((relation) => relation.url.split('/').pop());
+          // Construct URL to fetch work item details
+          const relatedWIIdsString = relationWorkItemsIds.join(',');
+          const getRelatedWiDataUrl = `${this.orgUrl}${project}/_apis/wit/workItems?ids=${relatedWIIdsString}&$expand=1`;
 
-      if (workItemIds.length === 0) {
-        return [];
-      }
+          // Fetch work item details
+          const { value: relatedWorkItems } = await TFSServices.getItemContent(
+            getRelatedWiDataUrl,
+            this.token
+          );
 
-      // Construct URL to fetch work item details
-      const idsString = workItemIds.join(',');
-      const getWiDataUrl = `${this.orgUrl}${project}/_apis/wit/workItems?ids=${idsString}&$expand=1`;
+          // Ensure workItems is an array
+          if (!Array.isArray(relatedWorkItems)) {
+            throw new Error('Unexpected format for work items data');
+          }
 
-      // Fetch work item details
-      const { value: workItems } = await TFSServices.getItemContent(getWiDataUrl, this.token);
+          // Filter work items based on type and state
+          const filteredWi = relatedWorkItems.filter(({ fields }) => {
+            const workItemType = fields?.['System.WorkItemType'];
+            const state = fields?.['System.State'];
+            return (
+              (workItemType === 'Change Request' || workItemType === 'Bug') &&
+              state !== 'Closed' &&
+              state !== 'Resolved'
+            );
+          });
 
-      // Ensure workItems is an array
-      if (!Array.isArray(workItems)) {
-        throw new Error('Unexpected format for work items data');
+          const mappedFilteredWi = filteredWi.length > 0 ? this.MapLinkedWorkItem(filteredWi, project) : [];
+          summarizedItemMap.set(item.id, { ...item, linkItems: mappedFilteredWi });
+        }
       }
 
-      // Filter work items based on type and state
-      const filteredWi = workItems.filter(({ fields }) => {
-        const workItemType = fields?.['System.WorkItemType'];
-        const state = fields?.['System.State'];
-        return (
-          (workItemType === 'Change Request' || workItemType === 'Bug') &&
-          state !== 'Closed' &&
-          state !== 'Resolved'
-        );
-      });
+      return [...summarizedItemMap.values()];
 
       // Return mapped work items if any exist
-      return filteredWi.length > 0 ? this.MapLinkedWorkItem(filteredWi, project) : [];
     } catch (error) {
       logger.error('Error fetching linked work items:', error);
       return []; // Return an empty array or handle it as needed
@@ -506,27 +517,13 @@ export default class ResultDataProvider {
    */
 
   private async fetchOpenPcrData(testItems: any[], projectName: string, combinedResults: any[]) {
-    const linkedWorkItemsPromises = testItems.map((summaryItem) =>
-      this.fetchLinkedWi(projectName, summaryItem.testId)
-        .then((linkItems) => ({
-          ...summaryItem,
-          linkItems,
-        }))
-        .catch((error: any) => {
-          logger.error(`Error occurred for testCase ${summaryItem.testId}: ${error.message}`);
-          return { ...summaryItem, linkItems: [] };
-        })
-    );
-
-    const linkedWorkItems = await Promise.all(linkedWorkItemsPromises);
-
+    const linkedWorkItems = await this.fetchLinkedWi(projectName, testItems);
     const flatOpenPcrsItems = linkedWorkItems
       .filter((item) => item.linkItems.length > 0)
       .flatMap((item) => {
         const { linkItems, ...restItem } = item;
         return linkItems.map((linkedItem: any) => ({ ...restItem, ...linkedItem }));
       });
-
     if (flatOpenPcrsItems?.length > 0) {
       // Add openPCR to combined results
       combinedResults.push({
@@ -749,19 +746,42 @@ export default class ResultDataProvider {
     }
   }
 
-  private mapStepResultsForExecutionAppendix(detailedResults: any[]): any {
-    return detailedResults?.length > 0
-      ? detailedResults.map((result) => {
-          return {
-            testId: result.testId,
-            testCaseRevision: result.testCaseRevision || undefined,
-            stepNo: result.stepNo,
-            stepIdentifier: result.stepIdentifier,
-            stepStatus: result.stepStatus,
-            stepComments: result.stepComments,
-          };
-        })
-      : [];
+  // private mapStepResultsForExecutionAppendix(detailedResults: any[]): any {
+  //   return detailedResults?.length > 0
+  //     ? detailedResults.map((result) => {
+  //         return {
+  //           testId: result.testId,
+  //           testCaseRevision: result.testCaseRevision || undefined,
+  //           stepNo: result.stepNo,
+  //           stepIdentifier: result.stepIdentifier,
+  //           stepStatus: result.stepStatus,
+  //           stepComments: result.stepComments,
+  //         };
+  //       })
+  //     : [];
+  // }
+
+  private mapStepResultsForExecutionAppendix(detailedResults: any[]): Map<string, any> {
+    let testCaseIdToStepsMap: Map<string, any> = new Map();
+    detailedResults.forEach((result) => {
+      const testCaseRevision = result.testCaseRevision;
+      if (!testCaseIdToStepsMap.has(result.testId.toString())) {
+        testCaseIdToStepsMap.set(result.testId.toString(), { testCaseRevision, stepList: [] });
+      }
+      const value = testCaseIdToStepsMap.get(result.testId.toString());
+      const { stepList } = value;
+      stepList.push({
+        stepPosition: result.stepNo,
+        stepIdentifier: result.stepIdentifier,
+        action: result.stepAction,
+        expected: result.stepExpected,
+        stepStatus: result.stepStatus,
+        stepComments: result.stepComments,
+      });
+      testCaseIdToStepsMap.set(result.testId.toString(), { ...testCaseRevision, stepList: stepList });
+    });
+
+    return testCaseIdToStepsMap;
   }
 
   /**

package/src/modules/TestDataProvider.ts

@@ -10,14 +10,17 @@ import { TestCase } from '../models/tfs-data';
 import * as xml2js from 'xml2js';
 
 import logger from '../utils/logger';
+import TestStepParserHelper from '../utils/testStepParserHelper';
 
 export default class TestDataProvider {
   orgUrl: string = '';
   token: string = '';
+  private testStepParserHelper: TestStepParserHelper;
 
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
     this.token = token;
+    this.testStepParserHelper = new TestStepParserHelper(orgUrl, token);
   }
 
   async GetTestSuiteByTestCase(testCaseId: string): Promise<any> {
@@ -90,7 +93,7 @@ export default class TestDataProvider {
     CustomerRequirementId: boolean,
     includeBugs: boolean,
     includeSeverity: boolean,
-    stepResultDetails?: any[]
+    stepResultDetailsMap?: Map<string, any>
   ): Promise<any> {
     let testCasesList: Array<any> = new Array<any>();
     const requirementToTestCaseTraceMap: Map<string, string[]> = new Map();
@@ -113,7 +116,7 @@ export default class TestDataProvider {
         includeSeverity,
         requirementToTestCaseTraceMap,
         testCaseToRequirementsTraceMap,
-        stepResultDetails
+        stepResultDetailsMap
       );
 
       if (testCseseWithSteps.length > 0) testCasesList = [...testCasesList, ...testCseseWithSteps];
@@ -132,7 +135,7 @@ export default class TestDataProvider {
     includeSeverity: boolean,
     requirementToTestCaseTraceMap: Map<string, string[]>,
     testCaseToRequirementsTraceMap: Map<string, string[]>,
-    stepResultDetails?: any[]
+    stepResultDetailsMap?: Map<string, any>
   ): Promise<Array<any>> {
     let url = this.orgUrl + project + '/_workitems/edit/';
     let testCasesUrlList: Array<any> = new Array<any>();
@@ -145,8 +148,7 @@ export default class TestDataProvider {
       for (let i = 0; i < testCases.count; i++) {
         try {
           let stepDetailObject =
-            stepResultDetails?.find((result) => result.testId === Number(testCases.value[i].testCase.id)) ||
-            undefined;
+            stepResultDetailsMap?.get(testCases.value[i].testCase.id.toString()) || undefined;
 
           let newurl = !stepDetailObject?.testCaseRevision
             ? testCases.value[i].testCase.url + '?$expand=All'
@@ -161,9 +163,16 @@ export default class TestDataProvider {
           //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']);
+
+          if (!stepDetailObject && test.fields['Microsoft.VSTS.TCM.Steps'] != null) {
+            let steps = await this.testStepParserHelper.parseTestSteps(
+              test.fields['Microsoft.VSTS.TCM.Steps'],
+              new Map<number, number>()
+            );
             testCase.steps = steps;
+            //In case its already parsed during the STR
+          } else if (stepDetailObject) {
+            testCase.steps = stepDetailObject.stepList;
           }
           if (test.relations) {
             for (const relation of test.relations) {

package/src/modules/TicketsDataProvider.ts

@@ -104,7 +104,9 @@ export default class TicketsDataProvider {
       if (path == '')
         url = `${this.orgUrl}${project}/_apis/wit/queries/Shared%20Queries?$depth=2&$expand=all`;
       else url = `${this.orgUrl}${project}/_apis/wit/queries/${path}?$depth=2&$expand=all`;
+      logger.debug(`share query URL ${url}`);
       let queries: any = await TFSServices.getItemContent(url, this.token);
+      logger.debug(`share queries ${JSON.stringify(queries)}`);
 
       const { tree1: reqTestTree, tree2: testReqTree } = this.structureQueries(queries);
       return { reqTestTree, testReqTree };

package/src/utils/testStepParserHelper.ts

@@ -0,0 +1,165 @@
+import { TFSServices } from '../helpers/tfs';
+import { TestSteps, Workitem } from '../models/tfs-data';
+import * as xml2js from 'xml2js';
+import logger from './logger';
+
+export default class TestStepParserHelper {
+  private orgUrl: string;
+  private token: string;
+
+  constructor(orgUrl: string, token: string) {
+    this.orgUrl = orgUrl;
+    this.token = token;
+  }
+
+  private extractStepData(stepNode: any, stepPosition: string, parentStepId: string = ''): TestSteps {
+    const step = new TestSteps();
+    step.stepId = parentStepId === '' ? stepNode.$.id : `${parentStepId};${stepNode.$.id}`;
+    step.stepPosition = stepPosition;
+    step.action = stepNode.parameterizedString?.[0]?._ || '';
+    step.expected = stepNode.parameterizedString?.[1]?._ || '';
+    return step;
+  }
+
+  private async fetchSharedSteps(
+    sharedStepId: string,
+    sharedStepIdToRevisionLookupMap: Map<number, number>,
+    parentStepPosition: string,
+    parentStepId: string = ''
+  ): Promise<TestSteps[]> {
+    try {
+      let sharedStepsList: TestSteps[] = [];
+      const revision = sharedStepIdToRevisionLookupMap.get(Number(sharedStepId));
+
+      const wiUrl = revision
+        ? `${this.orgUrl}/_apis/wit/workitems/${sharedStepId}/revisions/${revision}`
+        : `${this.orgUrl}/_apis/wit/workitems/${sharedStepId}`;
+      const sharedStepWI = await TFSServices.getItemContent(wiUrl, this.token);
+
+      const stepsXML = sharedStepWI?.fields['Microsoft.VSTS.TCM.Steps'] || null;
+      if (stepsXML) {
+        const stepsList = await this.parseTestSteps(
+          stepsXML,
+          sharedStepIdToRevisionLookupMap,
+          `${parentStepPosition}.`,
+          parentStepId
+        );
+        sharedStepsList = stepsList;
+      }
+      return sharedStepsList;
+    } catch (err: any) {
+      const errorMsg = `failed to fetch shared step WI: ${err.message}`;
+      logger.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+  }
+
+  private async processCompref(
+    comprefNode: any,
+    sharedStepIdToRevisionLookupMap: Map<number, number>,
+    stepPosition: string,
+    parentStepId: string = ''
+  ): Promise<TestSteps[]> {
+    const stepList: TestSteps[] = [];
+    if (comprefNode.$ && comprefNode.$.ref) {
+      //Nested Steps
+      const sharedStepId = comprefNode.$.ref;
+      const comprefStepId = comprefNode.$.id;
+      //Fetch the shared step data using the ID
+      const sharedSteps = await this.fetchSharedSteps(
+        sharedStepId,
+        sharedStepIdToRevisionLookupMap,
+        stepPosition,
+        comprefStepId
+      );
+      stepList.push(...sharedSteps);
+    }
+    // If 'compref' contains nested steps
+    if (comprefNode.children) {
+      for (const child of comprefNode.children) {
+        const nodeName = child['#name'];
+        const currentPosition = comprefNode.children.indexOf(child) + 1;
+        let currentPositionStr = '';
+        if (stepPosition.includes('.')) {
+          const positions = stepPosition.split('.');
+          const lastPosition = Number(positions.pop());
+          positions.push(`${currentPosition + lastPosition}`);
+          currentPositionStr = positions.join('.');
+        } else {
+          currentPositionStr = `${currentPosition + Number(stepPosition)}`;
+        }
+        if (nodeName === 'step') {
+          stepList.push(this.extractStepData(child, currentPositionStr, parentStepId));
+        } else if (nodeName === 'compref') {
+          // Handle nested 'compref' elements recursively
+          const nestedSteps = await this.processCompref(
+            child,
+            sharedStepIdToRevisionLookupMap,
+            currentPositionStr,
+            parentStepId
+          );
+          stepList.push(...nestedSteps);
+        }
+      }
+    }
+    return stepList;
+  }
+
+  private async processSteps(
+    parsedResultStepsXml: any,
+    sharedStepIdToRevisionLookupMap: Map<number, number>,
+    parentStepPosition: string,
+    parentStepId: string = ''
+  ): Promise<TestSteps[]> {
+    const stepsList: TestSteps[] = [];
+    const root = parsedResultStepsXml;
+
+    const children: any[] = root.children || [];
+    for (const child of children) {
+      const nodeName = child['#name'];
+      const currentStepPosition = children.indexOf(child) + 1;
+      if (nodeName === 'step') {
+        //Process a regular step
+        stepsList.push(
+          this.extractStepData(child, `${parentStepPosition}${currentStepPosition}`, parentStepId)
+        );
+      } else if (nodeName === 'compref') {
+        // Process shared steps
+        const sharedSteps = await this.processCompref(
+          child,
+          sharedStepIdToRevisionLookupMap,
+          `${parentStepPosition}${currentStepPosition}`,
+          parentStepId
+        );
+        stepsList.push(...sharedSteps);
+      }
+    }
+    return stepsList;
+  }
+
+  public async parseTestSteps(
+    xmlSteps: string,
+    sharedStepIdToRevisionLookupMap: Map<number, number>,
+    level: string = '',
+    parentStepId: string = ''
+  ): Promise<TestSteps[]> {
+    try {
+      const result = await xml2js.parseStringPromise(xmlSteps, {
+        explicitChildren: true,
+        preserveChildrenOrder: true,
+        explicitArray: false, // Prevents unnecessary arrays
+        childkey: 'children', // Key to store child elements
+      });
+      const stepsList = await this.processSteps(
+        result.steps,
+        sharedStepIdToRevisionLookupMap,
+        level,
+        parentStepId
+      );
+      return stepsList;
+    } catch (err) {
+      logger.error('Failed to parse XML test steps.', err);
+      return [];
+    }
+  }
+}