@elisra-devops/docgen-data-provider 1.27.0 → 1.29.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,
@@ -114,7 +120,7 @@ export default class ResultDataProvider {
       });
 
       // 3. Calculate Detailed Results Summary
-      const testData = await this.fetchTestData(suites, projectName, testPlanId);
+      const testData = await this.fetchTestData(suites, projectName, testPlanId, false);
       const runResults = await this.fetchAllResultData(testData, projectName);
       const detailedStepResultsSummary = this.alignStepsWithIterations(testData, runResults)?.filter(
         (results) => results !== null
@@ -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)
@@ -164,7 +175,7 @@ export default class ResultDataProvider {
       if (stepExecution && stepExecution.isEnabled) {
         const mappedAnalysisData =
           stepExecution.generateAttachments.isEnabled &&
-          stepExecution.generateAttachments.runAttachmentMode !== 'planOnly'
+            stepExecution.generateAttachments.runAttachmentMode !== 'planOnly'
             ? runResults.filter((result) => result.iteration?.attachments?.length > 0)
             : [];
         const mappedAnalysisResultData =
@@ -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) {
@@ -209,6 +220,7 @@ export default class ResultDataProvider {
     projectName: string,
     selectedSuiteIds: number[],
     selectedFields: string[],
+    allowCrossTestPlan: boolean,
     enableRunTestCaseFilter: boolean,
     enableRunStepStatusFilter: boolean
   ) {
@@ -218,17 +230,21 @@ export default class ResultDataProvider {
     );
     logger.debug(`Selected suite IDs: ${selectedSuiteIds}`);
     try {
+      logger.debug(`Fetching Plan info for test plan ID: ${testPlanId}, project name: ${projectName}`);
       const plan = await this.fetchTestPlanName(testPlanId, projectName);
+      logger.debug(`Fetching Test suites for test plan ID: ${testPlanId}, project name: ${projectName}`);
       const suites = await this.fetchTestSuites(testPlanId, projectName, selectedSuiteIds, true);
-      const testData = await this.fetchTestData(suites, projectName, testPlanId);
+      logger.debug(`Fetching test data for test plan ID: ${testPlanId}, project name: ${projectName}`);
+      const testData = await this.fetchTestData(suites, projectName, testPlanId, allowCrossTestPlan);
+      logger.debug(`Fetching Run results for test data, project name: ${projectName}`);
       const runResults = await this.fetchAllResultDataTestReporter(testData, projectName, selectedFields);
+      logger.debug(`Aligning steps with iterations for test reporter results`);
       const testReporterData = this.alignStepsWithIterationsTestReporter(
         testData,
         runResults,
         selectedFields,
         !enableRunTestCaseFilter
       );
-
       // Apply filters sequentially based on enabled flags
       let filteredResults = testReporterData;
 
@@ -406,13 +422,85 @@ export default class ResultDataProvider {
       : `${parts[1]}/${parts[parts.length - 1]}`;
   }
 
+  private async fetchCrossTestPoints(projectName: string, testCaseIds: any[]): Promise<any[]> {
+    try {
+      const url = `${this.orgUrl}${projectName}/_apis/test/points?api-version=6.0`
+      if (testCaseIds.length === 0) {
+        return []
+      }
+
+      const requestBody: any = {
+        PointsFilter: {
+          TestcaseIds: testCaseIds,
+        },
+      };
+
+      const { data: value } = await TFSServices.postRequest(url, this.token, 'Post', requestBody, null)
+      if (!value || !value.points || !Array.isArray(value.points)) {
+        logger.warn("No test points found or invalid response format");
+        return [];
+      }
+
+      // Group test points by test case ID
+      const pointsByTestCase = new Map();
+      value.points.forEach((point: any) => {
+        const testCaseId = point.testCase.id;
+
+        if (!pointsByTestCase.has(testCaseId)) {
+          pointsByTestCase.set(testCaseId, []);
+        }
+
+        pointsByTestCase.get(testCaseId).push(point);
+      });
+
+      // For each test case, find the point with the most recent run
+      const latestPoints: any[] = [];
+
+      for (const [testCaseId, points] of pointsByTestCase.entries()) {
+        // Sort by lastTestRun.id (descending), then by lastResult.id (descending)
+        const sortedPoints = points.sort((a: any, b: any) => {
+          // Parse IDs as numbers for proper comparison
+          const aRunId = parseInt(a.lastTestRun?.id || '0');
+          const bRunId = parseInt(b.lastTestRun?.id || '0');
+
+          if (aRunId !== bRunId) {
+            return bRunId - aRunId; // Sort by run ID first (descending)
+          }
+
+          const aResultId = parseInt(a.lastResult?.id || '0');
+          const bResultId = parseInt(b.lastResult?.id || '0');
+          return bResultId - aResultId; // Then by result ID (descending)
+        });
+
+        // Take the first item (most recent)
+        latestPoints.push(sortedPoints[0]);
+      }
+
+      // Fetch detailed information for each test point and map to required format
+      const detailedPoints = await Promise.all(
+        latestPoints.map(async (point: any) => {
+          const url = `${point.url}?witFields=Microsoft.VSTS.TCM.Steps&includePointDetails=true`
+          const detailedPoint = await TFSServices.getItemContent(url, this.token);
+          return this.mapTestPointForCrossPlans(detailedPoint, projectName);
+          // return this.mapTestPointForCrossPlans(detailedPoint, projectName);
+        })
+      );
+      return detailedPoints
+    } catch (err: any) {
+      logger.error(`Error during fetching Cross Test Points: ${err.message}`);
+      logger.error(`Error stack: ${err.stack}`);
+      return [];
+    }
+
+  }
+
   /**
    * Fetches test points by suite ID.
    */
   private async fetchTestPoints(
     projectName: string,
     testPlanId: string,
-    testSuiteId: string
+    testSuiteId: string,
   ): Promise<any[]> {
     try {
       const url = `${this.orgUrl}${projectName}/_apis/testplan/Plans/${testPlanId}/Suites/${testSuiteId}/TestPoint?includePointDetails=true`;
@@ -441,6 +529,39 @@ export default class ResultDataProvider {
     };
   }
 
+
+  /**
+ * Maps raw test point data to a simplified object.
+ */
+  private mapTestPointForCrossPlans(testPoint: any, projectName: string): any {
+    return {
+      testCaseId: testPoint.testCase.id,
+      testCaseName: testPoint.testCase.name,
+      testCaseUrl: `${this.orgUrl}${projectName}/_workitems/edit/${testPoint.testCase.id}`,
+      configurationName: testPoint.configuration?.name,
+      outcome: testPoint.outcome || 'Not Run',
+      lastRunId: testPoint.lastTestRun?.id,
+      lastResultId: testPoint.lastResult?.id,
+      lastResultDetails: testPoint.lastResultDetails || {
+        "duration": 0,
+        "dateCompleted": "0000-00-00T00:00:00.000Z",
+        "runBy": { "displayName": "No tester", "id": "00000000-0000-0000-0000-000000000000" }
+      },
+    };
+  }
+
+  // Helper method to get all test points for a test case
+  async getTestPointsForTestCases(projectName: string, testCaseId: string[]): Promise<any> {
+    const url = `${this.orgUrl}${projectName}/_apis/test/points`;
+    const requestBody = {
+      PointsFilter: {
+        TestcaseIds: testCaseId,
+      },
+    };
+
+    return await TFSServices.postRequest(url, this.token, 'Post', requestBody, null);
+  }
+
   /**
    * Fetches test cases by suite ID.
    */
@@ -464,6 +585,10 @@ export default class ResultDataProvider {
     selectedFields?: string[]
   ): Promise<any> {
     try {
+      if (runId === '0' || resultId === '0') {
+        logger.warn(`Invalid runId or resultId: ${runId}, ${resultId}`);
+        return null;
+      }
       const url = `${this.orgUrl}${projectName}/_apis/test/runs/${runId}/results/${resultId}?detailsToInclude=Iterations`;
       const resultData = await TFSServices.getItemContent(url, this.token);
 
@@ -478,9 +603,6 @@ export default class ResultDataProvider {
       let relatedRequirements: any[] = [];
       let relatedBugs: any[] = [];
       let relatedCRs: 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
-
       // Process selected fields if provided
       if (selectedFields?.length && isTestReporter) {
         const filtered = selectedFields
@@ -610,8 +732,8 @@ export default class ResultDataProvider {
     return actionResult.outcome === 'Unspecified'
       ? 'Not Run'
       : actionResult.outcome !== 'Not Run'
-      ? actionResult.outcome
-      : '';
+        ? actionResult.outcome
+        : '';
   }
 
   /**
@@ -645,6 +767,7 @@ export default class ResultDataProvider {
     }
   ): any[] {
     const detailedResults: any[] = [];
+
     if (!iterations || iterations?.length === 0) {
       return detailedResults;
     }
@@ -658,7 +781,7 @@ export default class ResultDataProvider {
 
     for (const testItem of testData) {
       for (const point of testItem.testPointsItems) {
-        const testCase = testItem.testCasesItems.find((tc: any) => tc.workItem.id === point.testCaseId);
+        const testCase = testItem.testCasesItems.find((tc: any) => Number(tc.workItem.id) === Number(point.testCaseId));
         if (!testCase) continue;
 
         if (testCase.workItem.workItemFields.length === 0) {
@@ -747,13 +870,13 @@ export default class ResultDataProvider {
       resultObjectsToAdd.length > 0
         ? detailedResults.push(...resultObjectsToAdd)
         : detailedResults.push(
-            options.createResultObject({
-              testItem,
-              point,
-              fetchedTestCase,
-              filteredFields,
-            })
-          );
+          options.createResultObject({
+            testItem,
+            point,
+            fetchedTestCase,
+            filteredFields,
+          })
+        );
     }
   }
 
@@ -818,17 +941,25 @@ export default class ResultDataProvider {
   /**
    * Fetches test data for all suites, including test points and test cases.
    */
-  private async fetchTestData(suites: any[], projectName: string, testPlanId: string): Promise<any[]> {
+  private async fetchTestData(
+    suites: any[],
+    projectName: string,
+    testPlanId: string,
+    fetchCrossPlans: boolean = false
+  ): Promise<any[]> {
     return await Promise.all(
       suites.map((suite) =>
         this.limit(async () => {
           try {
-            const testPointsItems = await this.fetchTestPoints(projectName, testPlanId, suite.testSuiteId);
+
             const testCasesItems = await this.fetchTestCasesBySuiteId(
               projectName,
               testPlanId,
               suite.testSuiteId
             );
+            const testCaseIds = testCasesItems.map((testCase: any) => testCase.workItem.id);
+            const testPointsItems = !fetchCrossPlans ? await this.fetchTestPoints(projectName, testPlanId, suite.testSuiteId) : await this.fetchCrossTestPoints(projectName, testCaseIds);
+
             return { ...suite, testPointsItems, testCasesItems };
           } catch (error: any) {
             logger.error(`Error occurred for suite ${suite.testSuiteId}: ${error.message}`);
@@ -921,6 +1052,13 @@ export default class ResultDataProvider {
     additionalArgs: any[] = []
   ): Promise<any> {
     const { lastRunId, lastResultId } = point;
+    if (!lastRunId || !lastResultId) {
+      logger.warn(`Invalid lastRunId or lastResultId for point: ${JSON.stringify(point)}`);
+      return null;
+    } else if (lastRunId === '0' || lastResultId === '0') {
+      logger.warn(`Invalid lastRunId or lastResultId: ${lastRunId}, ${lastResultId}`);
+      return null;
+    }
     const resultData = await fetchResultMethod(
       projectName,
       lastRunId.toString(),
@@ -1099,21 +1237,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);
+      }
     }
   }
 
@@ -1323,6 +1472,7 @@ export default class ResultDataProvider {
       testGroupName: testPoint.testGroupName,
       testId: testPoint.testCaseId,
       testName: testPoint.testCaseName,
+      testCaseUrl: testPoint.testCaseUrl,
       runStatus: !includeHardCopyRun ? this.convertRunStatus(testPoint.outcome) : '',
     };
 

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