@elisra-devops/docgen-data-provider 1.11.0 → 1.12.1

package/src/modules/PipelinesDataProvider.ts

@@ -14,65 +14,182 @@ export default class PipelinesDataProvider {
   }
 
   public async findPreviousPipeline(
-    projectName: string,
-    pipeLineId: string,
+    teamProject: string,
+    pipelineId: string,
     toPipelineRunId: number,
-    toPipeline: any,
-    searchPrevPipelineFromDifferentCommit: boolean
+    targetPipeline: any,
+    searchPrevPipelineFromDifferentCommit: boolean,
+    fromStage: string = ''
   ) {
-    // get pipeline runs:
-    const pipelineRuns = await this.GetPipelineRunHistory(projectName, pipeLineId);
+    const pipelineRuns = await this.GetPipelineRunHistory(teamProject, pipelineId);
+    if (!pipelineRuns.value) {
+      return undefined;
+    }
 
     for (const pipelineRun of pipelineRuns.value) {
-      if (pipelineRun.id >= toPipelineRunId) {
+      if (this.isInvalidPipelineRun(pipelineRun, toPipelineRunId, fromStage)) {
         continue;
       }
-      if (pipelineRun.result !== 'succeeded') {
+
+      if (fromStage && !(await this.isStageSuccessful(pipelineRun, teamProject, fromStage))) {
         continue;
       }
 
-      const fromPipeline = await this.getPipelineFromPipelineId(projectName, Number(pipeLineId));
+      const fromPipeline = await this.getPipelineRunDetails(teamProject, Number(pipelineId), pipelineRun.id);
       if (!fromPipeline.resources.repositories) {
         continue;
       }
-      const fromPipelineRepositories = fromPipeline.resources.repositories;
-      logger.debug(`from pipeline repositories ${JSON.stringify(fromPipelineRepositories)}`);
-      const toPipelineRepositories = toPipeline.resources.repositories;
-      logger.debug(`to pipeline repositories ${JSON.stringify(toPipelineRepositories)}`);
-
-      const fromPipeLineSelfRepo =
-        '__designer_repo' in fromPipelineRepositories
-          ? fromPipelineRepositories['__designer_repo']
-          : 'self' in fromPipelineRepositories
-          ? fromPipelineRepositories['self']
-          : undefined;
-      const toPipeLineSelfRepo =
-        '__designer_repo' in toPipelineRepositories
-          ? toPipelineRepositories['__designer_repo']
-          : 'self' in toPipelineRepositories
-          ? toPipelineRepositories['self']
-          : undefined;
-      if (
-        fromPipeLineSelfRepo.repository.id === toPipeLineSelfRepo.repository.id &&
-        fromPipeLineSelfRepo.version === toPipeLineSelfRepo.version
-      ) {
-        if (searchPrevPipelineFromDifferentCommit) {
-          continue;
-        }
-      }
 
-      if (
-        fromPipeLineSelfRepo.repository.id === toPipeLineSelfRepo.repository.id &&
-        fromPipeLineSelfRepo.refName !== toPipeLineSelfRepo.refName
-      ) {
-        continue;
+      if (this.isMatchingPipeline(fromPipeline, targetPipeline, searchPrevPipelineFromDifferentCommit)) {
+        return pipelineRun.id;
       }
-
-      return pipelineRun.id;
     }
     return undefined;
   }
 
+  /**
+   * Determines if a pipeline run is invalid based on various conditions.
+   *
+   * @param pipelineRun - The pipeline run object to evaluate.
+   * @param toPipelineRunId - The pipeline run ID to compare against.
+   * @param fromStage - The stage from which the pipeline run originated.
+   * @returns `true` if the pipeline run is considered invalid, `false` otherwise.
+   */
+  private isInvalidPipelineRun(pipelineRun: any, toPipelineRunId: number, fromStage: string): boolean {
+    return (
+      pipelineRun.id >= toPipelineRunId ||
+      ['canceled', 'failed', 'canceling'].includes(pipelineRun.result) ||
+      (pipelineRun.result === 'unknown' && !fromStage) ||
+      (pipelineRun.result !== 'succeeded' && !fromStage)
+    );
+  }
+
+  /**
+   * Checks if a specific stage in a pipeline run was successful.
+   *
+   * @param pipelineRun - The pipeline run object containing details of the run.
+   * @param teamProject - The name of the team project.
+   * @param fromStage - The name of the stage to check.
+   * @returns A promise that resolves to a boolean indicating whether the stage was successful.
+   */
+  private async isStageSuccessful(
+    pipelineRun: any,
+    teamProject: string,
+    fromStage: string
+  ): Promise<boolean> {
+    const fromPipelineStage = await this.getPipelineStageName(pipelineRun, teamProject, fromStage);
+    return (
+      fromPipelineStage && fromPipelineStage.state === 'completed' && fromPipelineStage.result === 'succeeded'
+    );
+  }
+
+  /**
+   * Determines if two pipelines match based on their repository and version information.
+   *
+   * @param fromPipeline - The source pipeline to compare.
+   * @param targetPipeline - The target pipeline to compare against.
+   * @param searchPrevPipelineFromDifferentCommit - A flag indicating whether to search for a previous pipeline from a different commit.
+   * @returns `true` if the pipelines match based on the repository and version criteria; otherwise, `false`.
+   */
+  private isMatchingPipeline(
+    fromPipeline: PipelineRun,
+    targetPipeline: PipelineRun,
+    searchPrevPipelineFromDifferentCommit: boolean
+  ): boolean {
+    const fromRepo =
+      fromPipeline.resources.repositories[0].self || fromPipeline.resources.repositories.__designer_repo;
+    const targetRepo =
+      targetPipeline.resources.repositories[0].self || targetPipeline.resources.repositories.__designer_repo;
+
+    if (fromRepo.repository.id !== targetRepo.repository.id) {
+      return false;
+    }
+
+    if (fromRepo.version === targetRepo.version) {
+      return !searchPrevPipelineFromDifferentCommit;
+    }
+
+    return fromRepo.refName === targetRepo.refName;
+  }
+
+  /**
+   * Retrieves a set of pipeline resources from a given pipeline run object.
+   *
+   * @param inPipeline - The pipeline run object containing resources.
+   * @returns A promise that resolves to an array of unique pipeline resource objects.
+   *
+   * The function performs the following steps:
+   * 1. Initializes an empty set to store unique pipeline resources.
+   * 2. Checks if the input pipeline has any resources of type pipelines.
+   * 3. Iterates over each pipeline resource and processes it.
+   * 4. Fixes the URL of the pipeline resource to match the build API format.
+   * 5. Fetches the build details using the fixed URL.
+   * 6. If the build response is valid and matches the criteria, adds the pipeline resource to the set.
+   * 7. Returns an array of unique pipeline resources.
+   *
+   * The returned pipeline resource object contains the following properties:
+   * - name: The alias name of the resource pipeline.
+   * - buildId: The ID of the resource pipeline.
+   * - definitionId: The ID of the build definition.
+   * - buildNumber: The build number.
+   * - teamProject: The name of the team project.
+   * - provider: The type of repository provider.
+   *
+   * @throws Will log an error message if there is an issue fetching the pipeline resource.
+   */
+  public async getPipelineResourcePipelinesFromObject(inPipeline: PipelineRun) {
+    const resourcePipelines: Set<any> = new Set();
+
+    if (!inPipeline.resources.pipelines) {
+      return resourcePipelines;
+    }
+    const pipelines = inPipeline.resources.pipelines;
+
+    const pipelineEntries = Object.entries(pipelines);
+
+    await Promise.all(
+      pipelineEntries.map(async ([resourcePipelineAlias, resource]) => {
+        const resourcePipelineObj = (resource as any).pipeline;
+        const resourcePipelineName = resourcePipelineAlias;
+        let urlBeforeFix = resourcePipelineObj.url;
+        urlBeforeFix = urlBeforeFix.substring(0, urlBeforeFix.indexOf('?revision'));
+        const fixedUrl = urlBeforeFix.replace('/_apis/pipelines/', '/_apis/build/builds/');
+        let buildResponse: any;
+        try {
+          buildResponse = await TFSServices.getItemContent(fixedUrl, this.token, 'get');
+        } catch (err: any) {
+          logger.error(`Error fetching pipeline ${resourcePipelineName} : ${err.message}`);
+        }
+        if (
+          buildResponse &&
+          buildResponse.definition.type === 'build' &&
+          buildResponse.repository.type === 'TfsGit'
+        ) {
+          let resourcePipelineToAdd = {
+            name: resourcePipelineName,
+            buildId: resourcePipelineObj.id,
+            definitionId: buildResponse.definition.id,
+            buildNumber: buildResponse.buildNumber,
+            teamProject: buildResponse.project.name,
+            provider: buildResponse.repository.type,
+          };
+          if (!resourcePipelines.has(resourcePipelineToAdd)) {
+            resourcePipelines.add(resourcePipelineToAdd);
+          }
+        }
+      })
+    );
+
+    return [...resourcePipelines];
+  }
+
+  /**
+   * Retrieves a set of resource repositories from a given pipeline object.
+   *
+   * @param inPipeline - The pipeline run object containing resource information.
+   * @param gitDataProviderInstance - An instance of GitDataProvider to fetch repository details.
+   * @returns A promise that resolves to an array of unique resource repositories.
+   */
   public async getPipelineResourceRepositoriesFromObject(
     inPipeline: PipelineRun,
     gitDataProviderInstance: GitDataProvider
@@ -103,12 +220,27 @@ export default class PipelinesDataProvider {
     return [...resourceRepositories];
   }
 
-  async getPipelineFromPipelineId(projectName: string, buildId: number) {
+  /**
+   * Retrieves the details of a specific pipeline build by its build ID.
+   *
+   * @param projectName - The name of the project that contains the pipeline.
+   * @param buildId - The unique identifier of the build to retrieve.
+   * @returns A promise that resolves to the content of the build details.
+   */
+  async getPipelineBuildByBuildId(projectName: string, buildId: number) {
     let url = `${this.orgUrl}${projectName}/_apis/build/builds/${buildId}`;
     return TFSServices.getItemContent(url, this.token, 'get');
   } //GetCommitForPipeline
 
-  async getPipelineRunBuildById(projectName: string, pipelineId: number, runId: number) {
+  /**
+   * Retrieves the details of a specific pipeline run.
+   *
+   * @param projectName - The name of the project containing the pipeline.
+   * @param pipelineId - The ID of the pipeline.
+   * @param runId - The ID of the pipeline run.
+   * @returns A promise that resolves to the content of the pipeline run.
+   */
+  async getPipelineRunDetails(projectName: string, pipelineId: number, runId: number): Promise<PipelineRun> {
     let url = `${this.orgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs/${runId}`;
     return TFSServices.getItemContent(url, this.token);
   }
@@ -126,6 +258,19 @@ export default class PipelinesDataProvider {
     return res;
   }
 
+  /**
+   * Retrieves an artifact by build ID from a specified project.
+   *
+   * @param {string} projectName - The name of the project.
+   * @param {string} buildId - The ID of the build.
+   * @param {string} artifactName - The name of the artifact to retrieve.
+   * @returns {Promise<any>} A promise that resolves to the artifact data.
+   * @throws Will throw an error if the retrieval process fails.
+   *
+   * @example
+   * const artifact = await GetArtifactByBuildId('MyProject', '12345', 'MyArtifact');
+   * console.log(artifact);
+   */
   async GetArtifactByBuildId(projectName: string, buildId: string, artifactName: string): Promise<any> {
     try {
       logger.info(
@@ -149,6 +294,13 @@ export default class PipelinesDataProvider {
     }
   }
 
+  /**
+   * Retrieves a release by its release ID for a given project.
+   *
+   * @param projectName - The name of the project.
+   * @param releaseId - The ID of the release to retrieve.
+   * @returns A promise that resolves to the release data.
+   */
   async GetReleaseByReleaseId(projectName: string, releaseId: number): Promise<any> {
     let url = `${this.orgUrl}${projectName}/_apis/release/releases/${releaseId}`;
     if (url.startsWith('https://dev.azure.com')) {
@@ -157,18 +309,30 @@ export default class PipelinesDataProvider {
     return TFSServices.getItemContent(url, this.token, 'get', null, null);
   }
 
+  /**
+   * Retrieves the run history of a specified pipeline within a project.
+   *
+   * @param projectName - The name of the project containing the pipeline.
+   * @param pipelineId - The ID of the pipeline to retrieve the run history for.
+   * @returns An object containing the count of successful runs and an array of successful run details.
+   * @throws Will log an error message if the pipeline run history could not be fetched.
+   */
   async GetPipelineRunHistory(projectName: string, pipelineId: string) {
-    let url: string = `${this.orgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs`;
-    let res: any = await TFSServices.getItemContent(url, this.token, 'get', null, null);
-    //Filter successful builds only
-    let { value } = res;
-    if (value) {
-      const successfulRunHistory = value.filter(
-        (run: any) => run.result !== 'failed' || run.result !== 'canceled'
-      );
-      return { count: successfulRunHistory.length, value: successfulRunHistory };
+    try {
+      let url: string = `${this.orgUrl}${projectName}/_apis/pipelines/${pipelineId}/runs`;
+      let res: any = await TFSServices.getItemContent(url, this.token, 'get', null, null);
+      //Filter successful builds only
+      let { value } = res;
+      if (value) {
+        const successfulRunHistory = value.filter(
+          (run: any) => run.result !== 'failed' || run.result !== 'canceled'
+        );
+        return { count: successfulRunHistory.length, value: successfulRunHistory };
+      }
+      return res;
+    } catch (err: any) {
+      logger.error(`Could not fetch Pipeline Run History: ${err.message}`);
     }
-    return res;
   }
 
   async GetReleaseHistory(projectName: string, definitionId: string) {
@@ -217,4 +381,28 @@ export default class PipelinesDataProvider {
     }
     return artifactInfo;
   }
+
+  /**
+   * Get stage name
+   * @param pipelineRunId requested pipeline run id
+   * @param teamProject requested team project
+   * @param stageName stage name to search for in the pipeline
+   * @returns
+   */
+  private async getPipelineStageName(pipelineRunId: number, teamProject: string, stageName: string) {
+    let url = `${this.orgUrl}${teamProject}/_apis/build/builds/${pipelineRunId}/timeline?api-version=6.0`;
+    try {
+      const getPipelineLogsResponse = await TFSServices.getItemContent(url, this.token, 'get');
+
+      const { records } = getPipelineLogsResponse;
+      for (const record of records) {
+        if (record.type === 'Stage' && record.name === stageName) {
+          return record;
+        }
+      }
+    } catch (err: any) {
+      logger.error(`Error fetching pipeline ${pipelineRunId} with url ${url} : ${err.message}`);
+      return undefined;
+    }
+  }
 }

package/src/modules/TicketsDataProvider.ts

@@ -97,7 +97,13 @@ export default class TicketsDataProvider {
     }
     return linkList;
   }
-  // gets queries recursiv
+  /**
+   * Getting shared queries
+   * @param project project name
+   * @param path query path
+   * @param docType document type
+   * @returns
+   */
   async GetSharedQueries(project: string, path: string, docType: string = ''): Promise<any> {
     let url;
     try {
@@ -108,7 +114,9 @@ export default class TicketsDataProvider {
       logger.debug(`doctype: ${docType}`);
       switch (docType) {
         case 'STD':
-          return await this.fetchOneHopQueriesForStr(queries);
+          return await this.fetchLinkedQueries(queries, false);
+        case 'STR':
+          return await this.fetchLinkedQueries(queries, true);
         case 'SVD':
           return await this.fetchAnyQueries(queries);
         default:
@@ -120,8 +128,17 @@ export default class TicketsDataProvider {
     }
   }
 
-  private async fetchOneHopQueriesForStr(queries: any) {
-    const { tree1: reqTestTree, tree2: testReqTree } = await this.structureReqTestQueries(queries);
+  /**
+   * fetches linked queries
+   * @param queries fetched queries
+   * @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(
+      queries,
+      onlyTestReq
+    );
     return { reqTestTree, testReqTree };
   }
   private async fetchAnyQueries(queries: any) {
@@ -131,7 +148,11 @@ export default class TicketsDataProvider {
     return { systemOverviewQueryTree, knownBugsQueryTree };
   }
 
-  async GetQueryResultsFromWiql(wiqlHref: string = '', displayAsTable: boolean = false): Promise<any> {
+  async GetQueryResultsFromWiql(
+    wiqlHref: string = '',
+    displayAsTable: boolean = false,
+    testCaseToRequirementMap: Map<number, Set<any>>
+  ): Promise<any> {
     try {
       if (!wiqlHref) {
         throw new Error('Incorrect WIQL Link');
@@ -145,7 +166,7 @@ export default class TicketsDataProvider {
       switch (queryResult.queryType) {
         case QueryType.OneHop:
           return displayAsTable
-            ? await this.parseDirectLinkedQueryResultForTableFormat(queryResult)
+            ? await this.parseDirectLinkedQueryResultForTableFormat(queryResult, testCaseToRequirementMap)
             : await this.parseTreeQueryResult(queryResult);
         case QueryType.Tree:
           return await this.parseTreeQueryResult(queryResult);
@@ -161,7 +182,10 @@ export default class TicketsDataProvider {
     }
   }
 
-  private async parseDirectLinkedQueryResultForTableFormat(queryResult: QueryTree) {
+  private async parseDirectLinkedQueryResultForTableFormat(
+    queryResult: QueryTree,
+    testCaseToRequirementMap: Map<number, Set<any>>
+  ) {
     const { columns, workItemRelations } = queryResult;
 
     if (workItemRelations?.length === 0) {
@@ -205,8 +229,8 @@ export default class TicketsDataProvider {
         }
 
         // Get relation source from lookup
-        const sourceRelation = lookupMap.get(relation.source.id);
-        if (!sourceRelation) {
+        const sourceWorkItem = lookupMap.get(relation.source.id);
+        if (!sourceWorkItem) {
           throw new Error('Source relation has no mapping');
         }
 
@@ -216,9 +240,14 @@ export default class TicketsDataProvider {
           columnTargetsMap,
           true
         );
-        const targets: any = sourceTargetsMap.get(sourceRelation) || [];
+        //In case if source is a test case
+        this.mapTestCaseToRequirement(sourceWorkItem, testCaseToRequirementMap, targetWi);
+
+        //In case of target is a test case
+        this.mapTestCaseToRequirement(targetWi, testCaseToRequirementMap, sourceWorkItem);
+        const targets: any = sourceTargetsMap.get(sourceWorkItem) || [];
         targets.push(targetWi);
-        sourceTargetsMap.set(sourceRelation, targets);
+        sourceTargetsMap.set(sourceWorkItem, targets);
       }
     }
 
@@ -230,6 +259,27 @@ export default class TicketsDataProvider {
     };
   }
 
+  private mapTestCaseToRequirement(
+    testCaseItem: any,
+    testCaseToRequirementMap: Map<number, Set<any>>,
+    RequirementWi: any
+  ) {
+    if (testCaseItem.fields['System.WorkItemType'] == 'Test Case') {
+      if (!testCaseToRequirementMap.has(testCaseItem.id)) {
+        testCaseToRequirementMap.set(testCaseItem.id, new Set());
+      }
+      const requirementSet = testCaseToRequirementMap.get(testCaseItem.id);
+      if (requirementSet) {
+        // Check if there's already an item with the same ID
+        const alreadyExists = [...requirementSet].some((reqItem) => reqItem.id === RequirementWi.id);
+
+        if (!alreadyExists) {
+          requirementSet.add(RequirementWi);
+        }
+      }
+    }
+  }
+
   private async parseFlatQueryResultForTableFormat(queryResult: QueryTree) {
     const { columns, workItems } = queryResult;
 
@@ -539,6 +589,7 @@ export default class TicketsDataProvider {
     return queryResult;
   }
 
+  //Build columns
   BuildColumns(results: any, queryResult: Query) {
     for (var i = 0; i < results.columns.length; i++) {
       queryResult.columns[i] = new Column();
@@ -592,12 +643,14 @@ export default class TicketsDataProvider {
     }
   }
 
+  //Get work item attachments
   async GetWorkitemAttachmentsJSONData(project: string, attachmentId: string) {
     let wiuRL = `${this.orgUrl}${project}/_apis/wit/attachments/${attachmentId}`;
     let attachment = await TFSServices.getItemContent(wiuRL, this.token);
     return attachment;
   }
 
+  //Update work item
   async UpdateWorkItem(projectName: string, wiBody: any, workItemId: number, byPass: boolean) {
     let res: any;
     let url: string = `${this.orgUrl}${projectName}/_apis/wit/workitems/${workItemId}?bypassRules=${String(
@@ -696,15 +749,22 @@ export default class TicketsDataProvider {
     }
   }
 
-  private async structureReqTestQueries(rootQuery: any, parentId: any = null): Promise<any> {
+  /**
+   * Recursively structures the query list for the requirement to test case and test case to requirement queries
+   */
+  private async structureReqTestQueries(
+    rootQuery: any,
+    onlyTestReq: boolean,
+    parentId: any = null
+  ): Promise<any> {
     try {
       if (!rootQuery.hasChildren) {
         if (!rootQuery.isFolder && rootQuery.queryType === 'oneHop') {
           const wiql = rootQuery.wiql;
           let tree1Node = null;
           let tree2Node = null;
-
-          if (this.matchesReqTestCondition(wiql)) {
+          // Check if the query is a requirement to test case query
+          if (!onlyTestReq && this.matchesReqTestCondition(wiql)) {
             tree1Node = {
               id: rootQuery.id,
               pId: parentId,
@@ -731,18 +791,18 @@ export default class TicketsDataProvider {
           return { tree1: null, tree2: null };
         }
       }
-
+      // If the query has children, but they are not loaded, fetch them
       if (!rootQuery.children) {
         const queryUrl = `${rootQuery.url}?$depth=2&$expand=all`;
         const currentQuery = await TFSServices.getItemContent(queryUrl, this.token);
         return currentQuery
-          ? await this.structureReqTestQueries(currentQuery, currentQuery.id)
+          ? await this.structureReqTestQueries(currentQuery, onlyTestReq, currentQuery.id)
           : { tree1: null, tree2: null };
       }
 
       // Process children recursively
       const childResults = await Promise.all(
-        rootQuery.children.map((child: any) => this.structureReqTestQueries(child, rootQuery.id))
+        rootQuery.children.map((child: any) => this.structureReqTestQueries(child, onlyTestReq, rootQuery.id))
       );
 
       // Build tree1
@@ -782,6 +842,7 @@ 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'") &&
@@ -789,6 +850,7 @@ export default class TicketsDataProvider {
     );
   }
 
+  // check if the query is a test case to requirement query
   private matchesTestReqCondition(wiql: string): boolean {
     return (
       wiql.includes("Source.[System.WorkItemType] = 'Test Case'") &&
@@ -796,10 +858,12 @@ export default class TicketsDataProvider {
     );
   }
 
+  // check if the query is a bug query
   private matchesBugCondition(wiql: string): boolean {
     return wiql.includes(`[System.WorkItemType] = 'Bug'`);
   }
 
+  // Filter the fields based on the columns to filter map
   private filterFieldsByColumns(
     item: any,
     columnsToFilterMap: Map<string, string>,