@elisra-devops/docgen-data-provider 1.26.6 → 1.28.0

package/src/modules/ResultDataProvider.ts

@@ -1,8 +1,8 @@
-import { log } from 'winston';
+import DataProviderUtils from '../utils/DataProviderUtils';
 import { TFSServices } from '../helpers/tfs';
-import { TestSteps } from '../models/tfs-data';
+import { OpenPcrRequest, TestSteps } from '../models/tfs-data';
 import logger from '../utils/logger';
-import TestStepParserHelper from '../utils/testStepParserHelper';
+import Utils from '../utils/testStepParserHelper';
 const pLimit = require('p-limit');
 /**
  * Provides methods to fetch, process, and summarize test data from Azure DevOps.
@@ -30,11 +30,11 @@ export default class ResultDataProvider {
   orgUrl: string = '';
   token: string = '';
   private limit = pLimit(10);
-  private testStepParserHelper: TestStepParserHelper;
+  private testStepParserHelper: Utils;
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
     this.token = token;
-    this.testStepParserHelper = new TestStepParserHelper(orgUrl, token);
+    this.testStepParserHelper = new Utils(orgUrl, token);
   }
 
   /**
@@ -46,14 +46,20 @@ export default class ResultDataProvider {
     selectedSuiteIds?: number[],
     addConfiguration: boolean = false,
     isHierarchyGroupName: boolean = false,
-    includeOpenPCRs: boolean = false,
+    openPcrRequest: OpenPcrRequest | null = null,
     includeTestLog: boolean = false,
     stepExecution?: any,
     stepAnalysis?: any,
     includeHardCopyRun: boolean = false
-  ): Promise<any[]> {
+  ): Promise<{
+    combinedResults: any[];
+    openPcrToTestCaseTraceMap: Map<string, string[]>;
+    testCaseToOpenPcrTraceMap: Map<string, string[]>;
+  }> {
     const combinedResults: any[] = [];
     try {
+      const openPcrToTestCaseTraceMap = new Map<string, string[]>();
+      const testCaseToOpenPcrTraceMap = new Map<string, string[]>();
       // Fetch test suites
       const suites = await this.fetchTestSuites(
         testPlanId,
@@ -131,9 +137,14 @@ export default class ResultDataProvider {
         skin: 'detailed-test-result-table',
       });
 
-      if (includeOpenPCRs) {
+      if (openPcrRequest?.openPcrMode === 'linked') {
         //5. Open PCRs data (only if enabled)
-        await this.fetchOpenPcrData(testResultsSummary, projectName, combinedResults);
+        await this.fetchOpenPcrData(
+          testResultsSummary,
+          projectName,
+          openPcrToTestCaseTraceMap,
+          testCaseToOpenPcrTraceMap
+        );
       }
 
       //6. Test Log (only if enabled)
@@ -181,7 +192,7 @@ export default class ResultDataProvider {
         });
       }
 
-      return combinedResults;
+      return { combinedResults, openPcrToTestCaseTraceMap, testCaseToOpenPcrTraceMap };
     } catch (error: any) {
       logger.error(`Error during getCombinedResultsSummary: ${error.message}`);
       if (error.response) {
@@ -456,39 +467,12 @@ export default class ResultDataProvider {
     return testCases;
   }
 
-  /**
-   * Fetches result data based on a work item base (WiBase) for a specific test run and result.
-   *
-   * @param projectName - The name of the project in Azure DevOps.
-   * @param runId - The ID of the test run.
-   * @param resultId - The ID of the test result.
-   * @param options - Optional parameters for customizing the data retrieval.
-   * @param options.expandWorkItem - If true, expands all fields of the work item.
-   * @param options.selectedFields - An array of field names to filter the work item fields.
-   * @param options.processRelatedRequirements - If true, processes related requirements linked to the work item.
-   * @param options.includeFullErrorStack - If true, includes the full error stack in the logs when an error occurs.
-   * @returns A promise that resolves to an object containing the fetched result data, including:
-   * - `stepsResultXml`: The test steps result in XML format.
-   * - `analysisAttachments`: Attachments related to the test result analysis.
-   * - `testCaseRevision`: The revision number of the test case.
-   * - `filteredFields`: The filtered fields from the work item based on the selected fields.
-   * - `relatedRequirements`: An array of related requirements with details such as ID, title, customer ID, and URL.
-   * - `relatedBugs`: An array of related bugs with details such as ID, title, and URL.
-   * If an error occurs, logs the error and returns `null`.
-   *
-   * @throws Logs an error message if the data retrieval fails.
-   */
   private async fetchResultDataBasedOnWiBase(
     projectName: string,
     runId: string,
     resultId: string,
-    options: {
-      expandWorkItem?: boolean;
-      selectedFields?: string[];
-      processRelatedRequirements?: boolean;
-      processRelatedBugs?: boolean;
-      includeFullErrorStack?: boolean;
-    } = {}
+    isTestReporter: boolean = false,
+    selectedFields?: string[]
   ): Promise<any> {
     try {
       const url = `${this.orgUrl}${projectName}/_apis/test/runs/${runId}/results/${resultId}?detailsToInclude=Iterations`;
@@ -498,21 +482,16 @@ export default class ResultDataProvider {
       const { value: analysisAttachments } = await TFSServices.getItemContent(attachmentsUrl, this.token);
 
       // Build workItem URL with optional expand parameter
-      const expandParam = options.expandWorkItem ? '?$expand=all' : '';
+      const expandParam = isTestReporter ? '?$expand=all' : '';
       const wiUrl = `${this.orgUrl}${projectName}/_apis/wit/workItems/${resultData.testCase.id}/revisions/${resultData.testCaseRevision}${expandParam}`;
       const wiByRevision = await TFSServices.getItemContent(wiUrl, this.token);
       let filteredFields: any = {};
       let relatedRequirements: any[] = [];
       let relatedBugs: any[] = [];
-      //TODO: Add CR support as well, and also add the logic to fetch the CR details
-      // TODO: Add logic for grabbing the relations from cross projects
-
+      let relatedCRs: any[] = [];
       // Process selected fields if provided
-      if (
-        options.selectedFields?.length &&
-        (options.processRelatedRequirements || options.processRelatedBugs)
-      ) {
-        const filtered = options.selectedFields
+      if (selectedFields?.length && isTestReporter) {
+        const filtered = selectedFields
           ?.filter((field: string) => field.includes('@testCaseWorkItemField'))
           ?.map((field: string) => field.split('@')[0]);
         const selectedFieldSet = new Set(filtered);
@@ -523,7 +502,7 @@ export default class ResultDataProvider {
           if (relations) {
             for (const relation of relations) {
               if (
-                relation.rel?.includes('System.LinkTypes.Hierarchy') ||
+                relation.rel?.includes('System.LinkTypes') ||
                 relation.rel?.includes('Microsoft.VSTS.Common.TestedBy')
               ) {
                 const relatedUrl = relation.url;
@@ -542,6 +521,11 @@ export default class ResultDataProvider {
                   const bugTitle = fields['System.Title'];
                   const url = _links.html.href;
                   relatedBugs.push({ id, bugTitle, url });
+                } else if (wi.fields['System.WorkItemType'] === 'Change Request') {
+                  const { id, fields, _links } = wi;
+                  const crTitle = fields['System.Title'];
+                  const url = _links.html.href;
+                  relatedCRs.push({ id, crTitle, url });
                 }
               }
             }
@@ -564,10 +548,11 @@ export default class ResultDataProvider {
         filteredFields,
         relatedRequirements,
         relatedBugs,
+        relatedCRs,
       };
     } catch (error: any) {
       logger.error(`Error while fetching run result: ${error.message}`);
-      if (options.includeFullErrorStack) {
+      if (isTestReporter) {
         logger.error(`Error stack: ${error.stack}`);
       }
       return null;
@@ -1122,21 +1107,32 @@ export default class ResultDataProvider {
    * Fetching Open PCRs data
    */
 
-  private async fetchOpenPcrData(testItems: any[], projectName: string, combinedResults: any[]) {
+  private async fetchOpenPcrData(
+    testItems: any[],
+    projectName: string,
+    openPcrToTestCaseTraceMap: Map<string, string[]>,
+    testCaseToOpenPcrTraceMap: Map<string, string[]>
+  ) {
     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({
-        contentControl: 'open-pcr-content-control',
-        data: flatOpenPcrsItems,
-        skin: 'open-pcr-table',
+    for (const wi of linkedWorkItems) {
+      const { linkItems, ...restItem } = wi;
+      const stringifiedTestCase = JSON.stringify({
+        id: restItem.testId,
+        title: restItem.testName,
+        testCaseUrl: restItem.testCaseUrl,
+        runStatus: restItem.runStatus,
       });
+      for (const linkedItem of linkItems) {
+        const stringifiedPcr = JSON.stringify({
+          pcrId: linkedItem.pcrId,
+          workItemType: linkedItem.workItemType,
+          title: linkedItem.title,
+          severity: linkedItem.severity,
+          pcrUrl: linkedItem.pcrUrl,
+        });
+        DataProviderUtils.addToTraceMap(openPcrToTestCaseTraceMap, stringifiedPcr, stringifiedTestCase);
+        DataProviderUtils.addToTraceMap(testCaseToOpenPcrTraceMap, stringifiedTestCase, stringifiedPcr);
+      }
     }
   }
 
@@ -1346,6 +1342,7 @@ export default class ResultDataProvider {
       testGroupName: testPoint.testGroupName,
       testId: testPoint.testCaseId,
       testName: testPoint.testCaseName,
+      testCaseUrl: testPoint.testCaseUrl,
       runStatus: !includeHardCopyRun ? this.convertRunStatus(testPoint.outcome) : '',
     };
 
@@ -1374,13 +1371,7 @@ export default class ResultDataProvider {
     resultId: string,
     selectedFields?: string[]
   ): Promise<any> {
-    return this.fetchResultDataBasedOnWiBase(projectName, runId, resultId, {
-      expandWorkItem: true,
-      selectedFields,
-      processRelatedRequirements: true,
-      processRelatedBugs: true,
-      includeFullErrorStack: true,
-    });
+    return this.fetchResultDataBasedOnWiBase(projectName, runId, resultId, true, selectedFields);
   }
 
   /**
@@ -1459,6 +1450,7 @@ export default class ResultDataProvider {
           runBy: fetchedTestCase.runBy,
           activatedBy: fetchedTestCase.activatedBy,
           assignedTo: fetchedTestCase.assignedTo,
+          subSystem: fetchedTestCase.subSystem,
           failureType: fetchedTestCase.failureType,
           automationStatus: fetchedTestCase.automationStatus,
           executionDate: fetchedTestCase.executionDate,
@@ -1466,6 +1458,7 @@ export default class ResultDataProvider {
           errorMessage: fetchedTestCase.errorMessage,
           relatedRequirements: fetchedTestCase.relatedRequirements,
           relatedBugs: fetchedTestCase.relatedBugs,
+          relatedCRs: fetchedTestCase.relatedCRs,
         };
 
         // If we have action results, add step-specific properties
@@ -1518,7 +1511,6 @@ export default class ResultDataProvider {
             resultData.iterationDetails.length > 0
               ? resultData.iterationDetails[resultData.iterationDetails.length - 1]
               : undefined;
-
           const resultDataResponse = {
             testCaseName: `${resultData.testCase.name} - ${resultData.testCase.id}`,
             testCaseId: resultData.testCase.id,
@@ -1534,6 +1526,8 @@ export default class ResultDataProvider {
             failureType: undefined as string | undefined,
             comment: undefined as string | undefined,
             priority: undefined,
+            assignedTo: resultData.filteredFields['System.AssignedTo'],
+            subSystem: resultData.filteredFields['Custom.SubSystem'],
             runBy: undefined as string | undefined,
             executionDate: undefined as string | undefined,
             testCaseResult: undefined as any | undefined,
@@ -1541,6 +1535,7 @@ export default class ResultDataProvider {
             configurationName: undefined as string | undefined,
             relatedRequirements: undefined,
             relatedBugs: undefined,
+            relatedCRs: undefined,
             lastRunResult: undefined as any,
           };
 
@@ -1582,6 +1577,7 @@ export default class ResultDataProvider {
                   const runBy = lastResultDetails.runBy.displayName;
                   resultDataResponse.runBy = runBy;
                   break;
+
                 case 'executionDate':
                   resultDataResponse.executionDate = lastResultDetails.dateCompleted;
                   break;
@@ -1594,6 +1590,9 @@ export default class ResultDataProvider {
                 case 'associatedBug':
                   resultDataResponse.relatedBugs = resultData.relatedBugs;
                   break;
+                case 'associatedCR':
+                  resultDataResponse.relatedCRs = resultData.relatedCRs;
+                  break;
                 default:
                   logger.debug(`Field ${field} not handled`);
                   break;

package/src/modules/TestDataProvider.ts

@@ -4,20 +4,21 @@ import { TestSteps, createMomRelation, createRequirementRelation } from '../mode
 import { TestCase } from '../models/tfs-data';
 import * as xml2js from 'xml2js';
 import logger from '../utils/logger';
-import TestStepParserHelper from '../utils/testStepParserHelper';
+import Utils from '../utils/testStepParserHelper';
+import DataProviderUtils from '../utils/DataProviderUtils';
 const pLimit = require('p-limit');
 
 export default class TestDataProvider {
   orgUrl: string = '';
   token: string = '';
-  private testStepParserHelper: TestStepParserHelper;
+  private testStepParserHelper: Utils;
   private cache = new Map<string, any>(); // Cache for API responses
   private limit = pLimit(10);
 
   constructor(orgUrl: string, token: string) {
     this.orgUrl = orgUrl;
     this.token = token;
-    this.testStepParserHelper = new TestStepParserHelper(orgUrl, token);
+    this.testStepParserHelper = new Utils(orgUrl, token);
   }
 
   private async fetchWithCache(url: string, ttlMs = 60000): Promise<any> {
@@ -226,10 +227,14 @@ export default class TestDataProvider {
                     const stringifiedRequirement = JSON.stringify(newRequirementRelation);
 
                     // Add the test case to the requirement-to-test-case trace map
-                    this.addToMap(requirementToTestCaseTraceMap, stringifiedRequirement, stringifiedTestCase);
+                    DataProviderUtils.addToTraceMap(
+                      requirementToTestCaseTraceMap,
+                      stringifiedRequirement,
+                      stringifiedTestCase
+                    );
 
                     // Add the requirement to the test-case-to-requirements trace map
-                    this.addToMap(
+                    DataProviderUtils.addToTraceMap(
                       testCaseToRequirementsTraceMap,
                       stringifiedTestCase,
                       stringifiedRequirement

package/src/modules/TicketsDataProvider.ts

@@ -120,9 +120,11 @@ export default class TicketsDataProvider {
       logger.debug(`doctype: ${docType}`);
       switch (docType) {
         case 'STD':
-          return await this.fetchLinkedQueries(queries, false);
+          return await this.fetchLinkedReqTestQueries(queries, false);
         case 'STR':
-          return await this.fetchLinkedQueries(queries, true);
+          const reqTestTrees = await this.fetchLinkedReqTestQueries(queries, false);
+          const openPcrTestTrees = await this.fetchLinkedOpenPcrTestQueries(queries, false);
+          return { reqTestTrees, openPcrTestTrees };
         case 'SVD':
           return await this.fetchAnyQueries(queries);
         default:
@@ -140,13 +142,41 @@ export default class TicketsDataProvider {
    * @param onlyTestReq get only test req
    * @returns ReqTestTree and TestReqTree
    */
-  private async fetchLinkedQueries(queries: any, onlyTestReq: boolean = false) {
-    const { tree1: reqTestTree, tree2: testReqTree } = await this.structureReqTestQueries(
+  private async fetchLinkedReqTestQueries(queries: any, onlyTestReq: boolean = false) {
+    const { tree1: reqTestTree, tree2: testReqTree } = await this.structureFetchedQueries(
       queries,
-      onlyTestReq
+      onlyTestReq,
+      null,
+      ['Requirement'],
+      ['Test Case']
     );
     return { reqTestTree, testReqTree };
   }
+
+  /**
+   * Fetches and structures linked queries related to open PCR (Problem Change Request) tests.
+   *
+   * This method retrieves and organizes the relationships between "Test Case" and
+   * other entities such as "Bug" and "Change Request" into two tree structures.
+   *
+   * @param queries - The input queries to be processed and structured.
+   * @param onlySourceSide - A flag indicating whether to process only the source side of the queries.
+   *                          Defaults to `false`.
+   * @returns An object containing two tree structures:
+   *          - `OpenPcrToTestTree`: The tree representing the relationship from Open PCR to Test Case.
+   *          - `TestToOpenPcrTree`: The tree representing the relationship from Test Case to Open PCR.
+   */
+  private async fetchLinkedOpenPcrTestQueries(queries: any, onlySourceSide: boolean = false) {
+    const { tree1: OpenPcrToTestTree, tree2: TestToOpenPcrTree } = await this.structureFetchedQueries(
+      queries,
+      onlySourceSide,
+      null,
+      ['Bug', 'Change Request'],
+      ['Test Case']
+    );
+    return { OpenPcrToTestTree, TestToOpenPcrTree };
+  }
+
   private async fetchAnyQueries(queries: any) {
     const { tree1: systemOverviewQueryTree, tree2: knownBugsQueryTree } = await this.structureAllQueryPath(
       queries
@@ -756,12 +786,25 @@ export default class TicketsDataProvider {
   }
 
   /**
-   * Recursively structures the query list for the requirement to test case and test case to requirement queries
+   * Recursively structures fetched queries into two hierarchical trees (tree1 and tree2)
+   * based on specific conditions. It processes both leaf and non-leaf nodes, fetching
+   * children if necessary, and builds the trees by matching source and target conditions.
+   *
+   * @param rootQuery - The root query object to process. It may contain children or be a leaf node.
+   * @param onlyTestReq - A boolean flag indicating whether to exclude requirement-to-test-case queries.
+   * @param parentId - The ID of the parent node, used to maintain the hierarchy. Defaults to `null`.
+   * @param sources - An array of source strings used to match queries.
+   * @param targets - An array of target strings used to match queries.
+   * @returns A promise that resolves to an object containing two trees (`tree1` and `tree2`),
+   *          or `null` for each tree if no valid nodes are found.
+   * @throws Logs an error if an exception occurs during processing.
    */
-  private async structureReqTestQueries(
+  private async structureFetchedQueries(
     rootQuery: any,
     onlyTestReq: boolean,
-    parentId: any = null
+    parentId: any = null,
+    sources: string[],
+    targets: string[]
   ): Promise<any> {
     try {
       if (!rootQuery.hasChildren) {
@@ -770,7 +813,7 @@ export default class TicketsDataProvider {
           let tree1Node = null;
           let tree2Node = null;
           // Check if the query is a requirement to test case query
-          if (!onlyTestReq && this.matchesReqTestCondition(wiql)) {
+          if (!onlyTestReq && this.matchesSourceTargetCondition(wiql, sources, targets)) {
             tree1Node = {
               id: rootQuery.id,
               pId: parentId,
@@ -781,7 +824,7 @@ export default class TicketsDataProvider {
               isValidQuery: true,
             };
           }
-          if (this.matchesTestReqCondition(wiql)) {
+          if (this.matchesSourceTargetCondition(wiql, targets, sources)) {
             tree2Node = {
               id: rootQuery.id,
               pId: parentId,
@@ -802,13 +845,15 @@ export default class TicketsDataProvider {
         const queryUrl = `${rootQuery.url}?$depth=2&$expand=all`;
         const currentQuery = await TFSServices.getItemContent(queryUrl, this.token);
         return currentQuery
-          ? await this.structureReqTestQueries(currentQuery, onlyTestReq, currentQuery.id)
+          ? await this.structureFetchedQueries(currentQuery, onlyTestReq, currentQuery.id, sources, targets)
           : { tree1: null, tree2: null };
       }
 
       // Process children recursively
       const childResults = await Promise.all(
-        rootQuery.children.map((child: any) => this.structureReqTestQueries(child, onlyTestReq, rootQuery.id))
+        rootQuery.children.map((child: any) =>
+          this.structureFetchedQueries(child, onlyTestReq, rootQuery.id, sources, targets)
+        )
       );
 
       // Build tree1
@@ -848,20 +893,36 @@ export default class TicketsDataProvider {
     }
   }
 
-  // check if the query is a requirement to test case query
-  private matchesReqTestCondition(wiql: string): boolean {
-    return (
-      wiql.includes("Source.[System.WorkItemType] = 'Requirement'") &&
-      wiql.includes("Target.[System.WorkItemType] = 'Test Case'")
-    );
-  }
+  /**
+   * Determines whether the given WIQL (Work Item Query Language) string matches the specified
+   * source and target conditions. It checks if the WIQL contains references to the specified
+   * source and target work item types.
+   *
+   * @param wiql - The WIQL string to evaluate.
+   * @param source - An array of source work item types to check for in the WIQL.
+   * @param target - An array of target work item types to check for in the WIQL.
+   * @returns A boolean indicating whether the WIQL includes at least one source work item type
+   *          and at least one target work item type.
+   */
+  private matchesSourceTargetCondition(wiql: string, source: string[], target: string[]): boolean {
+    let isSourceIncluded = false;
+    let isTargetIncluded = false;
+
+    for (const src of source) {
+      if (wiql.includes(`Source.[System.WorkItemType] = '${src}'`)) {
+        isSourceIncluded = true;
+        break;
+      }
+    }
 
-  // check if the query is a test case to requirement query
-  private matchesTestReqCondition(wiql: string): boolean {
-    return (
-      wiql.includes("Source.[System.WorkItemType] = 'Test Case'") &&
-      wiql.includes("Target.[System.WorkItemType] = 'Requirement'")
-    );
+    for (const tgt of target) {
+      if (wiql.includes(`Target.[System.WorkItemType] = '${tgt}'`)) {
+        isTargetIncluded = true;
+        break;
+      }
+    }
+
+    return isSourceIncluded && isTargetIncluded;
   }
 
   // check if the query is a bug query