@elisra-devops/docgen-data-provider 1.21.0 → 1.23.0

package/bin/modules/ResultDataProvider.js

@@ -15,6 +15,28 @@ const tfs_1 = require("../helpers/tfs");
 const logger_1 = require("../utils/logger");
 const testStepParserHelper_1 = require("../utils/testStepParserHelper");
 const pLimit = require('p-limit');
+/**
+ * Provides methods to fetch, process, and summarize test data from Azure DevOps.
+ *
+ * This class includes functionalities for:
+ * - Fetching test suites, test points, and test cases.
+ * - Aligning test steps with iterations and generating detailed results.
+ * - Fetching result data based on work items and test runs.
+ * - Summarizing test group results, test results, and detailed results.
+ * - Fetching linked work items and open PCRs (Problem Change Requests).
+ * - Generating test logs and mapping attachments for download.
+ * - Supporting test reporter functionalities with customizable field selection and filtering.
+ *
+ * Key Features:
+ * - Hierarchical and flat test suite processing.
+ * - Step-level and test-level result alignment.
+ * - Customizable result summaries and detailed reports.
+ * - Integration with Azure DevOps APIs for fetching and processing test data.
+ * - Support for additional configurations like open PCRs, test logs, and step execution analysis.
+ *
+ * Usage:
+ * Instantiate the class with the organization URL and token, and use the provided methods to fetch and process test data.
+ */
 class ResultDataProvider {
     constructor(orgUrl, token) {
         this.orgUrl = '';
@@ -41,7 +63,200 @@ class ResultDataProvider {
         this.testStepParserHelper = new testStepParserHelper_1.default(orgUrl, token);
     }
     /**
-     * Retrieves test suites by test plan ID and processes them into a flat structure with hierarchy names.
+     * Combines the results of test group result summary, test results summary, and detailed results summary into a single key-value pair array.
+     */
+    async getCombinedResultsSummary(testPlanId, projectName, selectedSuiteIds, addConfiguration = false, isHierarchyGroupName = false, includeOpenPCRs = false, includeTestLog = false, stepExecution, stepAnalysis, includeHardCopyRun = false) {
+        const combinedResults = [];
+        try {
+            // Fetch test suites
+            const suites = await this.fetchTestSuites(testPlanId, projectName, selectedSuiteIds, isHierarchyGroupName);
+            // Prepare test data for summaries
+            const testPointsPromises = suites.map((suite) => this.limit(() => this.fetchTestPoints(projectName, testPlanId, suite.testSuiteId)
+                .then((testPointsItems) => (Object.assign(Object.assign({}, suite), { testPointsItems })))
+                .catch((error) => {
+                logger_1.default.error(`Error occurred for suite ${suite.testSuiteId}: ${error.message}`);
+                return Object.assign(Object.assign({}, suite), { testPointsItems: [] });
+            })));
+            const testPoints = await Promise.all(testPointsPromises);
+            // 1. Calculate Test Group Result Summary
+            const summarizedResults = testPoints
+                .filter((testPoint) => testPoint.testPointsItems && testPoint.testPointsItems.length > 0)
+                .map((testPoint) => {
+                const groupResultSummary = this.calculateGroupResultSummary(testPoint.testPointsItems || [], includeHardCopyRun);
+                return Object.assign(Object.assign({}, testPoint), { groupResultSummary });
+            });
+            const totalSummary = this.calculateTotalSummary(summarizedResults, includeHardCopyRun);
+            const testGroupArray = summarizedResults.map((item) => (Object.assign({ testGroupName: item.testGroupName }, item.groupResultSummary)));
+            testGroupArray.push(Object.assign({ testGroupName: 'Total' }, totalSummary));
+            // Add test group result summary to combined results
+            combinedResults.push({
+                contentControl: 'test-group-summary-content-control',
+                data: testGroupArray,
+                skin: 'test-result-test-group-summary-table',
+            });
+            // 2. Calculate Test Results Summary
+            const flattenedTestPoints = this.flattenTestPoints(testPoints);
+            const testResultsSummary = flattenedTestPoints.map((testPoint) => this.formatTestResult(testPoint, addConfiguration, includeHardCopyRun));
+            // Add test results summary to combined results
+            combinedResults.push({
+                contentControl: 'test-result-summary-content-control',
+                data: testResultsSummary,
+                skin: 'test-result-table',
+            });
+            // 3. Calculate Detailed Results Summary
+            const testData = await this.fetchTestData(suites, projectName, testPlanId);
+            const runResults = await this.fetchAllResultData(testData, projectName);
+            const detailedStepResultsSummary = this.alignStepsWithIterations(testData, runResults);
+            //Filter out all the results with no comment
+            const filteredDetailedResults = detailedStepResultsSummary.filter((result) => result && (result.stepComments !== '' || result.stepStatus === 'Failed'));
+            // Add detailed results summary to combined results
+            combinedResults.push({
+                contentControl: 'detailed-test-result-content-control',
+                data: !includeHardCopyRun ? filteredDetailedResults : [],
+                skin: 'detailed-test-result-table',
+            });
+            if (includeOpenPCRs) {
+                //5. Open PCRs data (only if enabled)
+                await this.fetchOpenPcrData(testResultsSummary, projectName, combinedResults);
+            }
+            //6. Test Log (only if enabled)
+            if (includeTestLog) {
+                this.fetchTestLogData(flattenedTestPoints, combinedResults);
+            }
+            if (stepAnalysis && stepAnalysis.isEnabled) {
+                const mappedAnalysisData = runResults.filter((result) => {
+                    var _a, _b, _c;
+                    return result.comment ||
+                        ((_b = (_a = result.iteration) === null || _a === void 0 ? void 0 : _a.attachments) === null || _b === void 0 ? void 0 : _b.length) > 0 ||
+                        ((_c = result.analysisAttachments) === null || _c === void 0 ? void 0 : _c.length) > 0;
+                });
+                const mappedAnalysisResultData = stepAnalysis.generateRunAttachments.isEnabled
+                    ? this.mapAttachmentsUrl(mappedAnalysisData, projectName)
+                    : mappedAnalysisData;
+                if ((mappedAnalysisResultData === null || mappedAnalysisResultData === void 0 ? void 0 : mappedAnalysisResultData.length) > 0) {
+                    combinedResults.push({
+                        contentControl: 'appendix-a-content-control',
+                        data: mappedAnalysisResultData,
+                        skin: 'step-analysis-appendix-skin',
+                    });
+                }
+            }
+            if (stepExecution && stepExecution.isEnabled) {
+                const mappedAnalysisData = stepExecution.generateAttachments.isEnabled &&
+                    stepExecution.generateAttachments.runAttachmentMode !== 'planOnly'
+                    ? runResults.filter((result) => { var _a, _b; return ((_b = (_a = result.iteration) === null || _a === void 0 ? void 0 : _a.attachments) === null || _b === void 0 ? void 0 : _b.length) > 0; })
+                    : [];
+                const mappedAnalysisResultData = mappedAnalysisData.length > 0 ? this.mapAttachmentsUrl(mappedAnalysisData, projectName) : [];
+                const mappedDetailedResults = this.mapStepResultsForExecutionAppendix(detailedStepResultsSummary, mappedAnalysisResultData);
+                combinedResults.push({
+                    contentControl: 'appendix-b-content-control',
+                    data: mappedDetailedResults,
+                    skin: 'step-execution-appendix-skin',
+                });
+            }
+            return combinedResults;
+        }
+        catch (error) {
+            logger_1.default.error(`Error during getCombinedResultsSummary: ${error.message}`);
+            if (error.response) {
+                logger_1.default.error(`Response Data: ${JSON.stringify(error.response.data)}`);
+            }
+            // Ensure the error is rethrown to propagate it correctly
+            throw new Error(error.message || 'Unknown error occurred during getCombinedResultsSummary');
+        }
+    }
+    /**
+     * Fetches and processes test reporter results for a given test plan and project.
+     *
+     * @param testPlanId - The ID of the test plan to fetch results for.
+     * @param projectName - The name of the project associated with the test plan.
+     * @param selectedSuiteIds - An array of suite IDs to filter the test results.
+     * @param selectedFields - An array of field names to include in the results.
+     * @param enableRunStepStatusFilter - A flag to enable filtering out test steps with a "Not Run" status.
+     * @returns A promise that resolves to an array of test reporter results, formatted for use in a test-reporter-table.
+     *
+     * @throws Will log an error if any step in the process fails.
+     */
+    async getTestReporterResults(testPlanId, projectName, selectedSuiteIds, selectedFields, enableRunStepStatusFilter) {
+        const fetchedTestResults = [];
+        logger_1.default.debug(`Fetching test reporter results for test plan ID: ${testPlanId}, project name: ${projectName}`);
+        logger_1.default.debug(`Selected suite IDs: ${selectedSuiteIds}`);
+        try {
+            const plan = await this.fetchTestPlanName(testPlanId, projectName);
+            const suites = await this.fetchTestSuites(testPlanId, projectName, selectedSuiteIds, true);
+            const testData = await this.fetchTestData(suites, projectName, testPlanId);
+            const runResults = await this.fetchAllResultDataTestReporter(testData, projectName, selectedFields);
+            const testReporterData = this.alignStepsWithIterationsTestReporter(testData, runResults, selectedFields);
+            const isNotRunStep = (result) => {
+                return result && result.stepStatus === 'Not Run';
+            };
+            // Apply filters sequentially based on enabled flags
+            let filteredResults = testReporterData;
+            // filter: Test step run status
+            if (enableRunStepStatusFilter) {
+                filteredResults = filteredResults.filter((result) => !isNotRunStep(result));
+            }
+            // Use the final filtered results
+            fetchedTestResults.push({
+                contentControl: 'test-reporter-table',
+                customName: `Test Results for ${plan}`,
+                data: filteredResults || [],
+                skin: 'test-reporter-table',
+            });
+            return fetchedTestResults;
+        }
+        catch (error) {
+            logger_1.default.error(`Error during getTestReporterResults: ${error.message}`);
+        }
+    }
+    /**
+     * Mapping each attachment to a proper URL for downloading it
+     * @param runResults Array of run results
+     */
+    mapAttachmentsUrl(runResults, project) {
+        return runResults.map((result) => {
+            var _a;
+            if (!result.iteration) {
+                return result;
+            }
+            const { iteration, analysisAttachments } = result, restResult = __rest(result, ["iteration", "analysisAttachments"]);
+            //add downloadUri field for each attachment
+            const baseDownloadUrl = `${this.orgUrl}${project}/_apis/test/runs/${result.lastRunId}/results/${result.lastResultId}/attachments`;
+            if (iteration && ((_a = iteration.attachments) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                const { attachments, actionResults } = iteration, restOfIteration = __rest(iteration, ["attachments", "actionResults"]);
+                const attachmentPathToIndexMap = this.CreateAttachmentPathIndexMap(actionResults);
+                const mappedAttachments = attachments.map((attachment) => (Object.assign(Object.assign({}, attachment), { stepNo: attachmentPathToIndexMap.has(attachment.actionPath)
+                        ? attachmentPathToIndexMap.get(attachment.actionPath)
+                        : undefined, downloadUrl: `${baseDownloadUrl}/${attachment.id}/${attachment.name}` })));
+                restResult.iteration = Object.assign(Object.assign({}, restOfIteration), { attachments: mappedAttachments });
+            }
+            if (analysisAttachments && analysisAttachments.length > 0) {
+                restResult.analysisAttachments = analysisAttachments.map((attachment) => (Object.assign(Object.assign({}, attachment), { downloadUrl: `${baseDownloadUrl}/${attachment.id}/${attachment.fileName}` })));
+            }
+            return Object.assign({}, restResult);
+        });
+    }
+    async fetchTestPlanName(testPlanId, teamProject) {
+        try {
+            const url = `${this.orgUrl}${teamProject}/_apis/testplan/Plans/${testPlanId}?api-version=5.1`;
+            const testPlan = await tfs_1.TFSServices.getItemContent(url, this.token);
+            return testPlan.name;
+        }
+        catch (error) {
+            logger_1.default.error(`Error during fetching Test Plan Name: ${error.message}`);
+            return '';
+        }
+    }
+    /**
+     * Fetches test suites for a given test plan and project, optionally filtering by selected suite IDs.
+     *
+     * @param testPlanId - The ID of the test plan to fetch suites for.
+     * @param projectName - The name of the project containing the test plan.
+     * @param selectedSuiteIds - An optional array of suite IDs to filter the results by.
+     * @param isHierarchyGroupName - A flag indicating whether to build the test group name hierarchically. Defaults to `true`.
+     * @returns A promise that resolves to an array of objects containing `testSuiteId` and `testGroupName`.
+     *          Returns an empty array if no test suites are found or an error occurs.
+     * @throws Will log an error message if fetching test suites fails.
      */
     async fetchTestSuites(testPlanId, projectName, selectedSuiteIds, isHierarchyGroupName = true) {
         try {
@@ -117,6 +332,8 @@ class ResultDataProvider {
             currentSuite = parentSuite;
         }
         const parts = path.split('/');
+        if (parts.length - 1 === 1)
+            return parts[1];
         return parts.length > 3
             ? `${parts[1]}/.../${parts[parts.length - 1]}`
             : `${parts[1]}/${parts[parts.length - 1]}`;
@@ -128,7 +345,7 @@ class ResultDataProvider {
         try {
             const url = `${this.orgUrl}${projectName}/_apis/testplan/Plans/${testPlanId}/Suites/${testSuiteId}/TestPoint?includePointDetails=true`;
             const { value: testPoints, count } = await tfs_1.TFSServices.getItemContent(url, this.token);
-            return count !== 0 ? testPoints.map(this.mapTestPoint) : [];
+            return count !== 0 ? testPoints.map((testPoint) => this.mapTestPoint(testPoint, projectName)) : [];
         }
         catch (error) {
             logger_1.default.error(`Error during fetching Test Points: ${error.message}`);
@@ -138,11 +355,12 @@ class ResultDataProvider {
     /**
      * Maps raw test point data to a simplified object.
      */
-    mapTestPoint(testPoint) {
+    mapTestPoint(testPoint, projectName) {
         var _a, _b, _c, _d, _e;
         return {
             testCaseId: testPoint.testCaseReference.id,
             testCaseName: testPoint.testCaseReference.name,
+            testCaseUrl: `${this.orgUrl}${projectName}/_workitems/edit/${testPoint.testCaseReference.id}`,
             configurationName: (_a = testPoint.configuration) === null || _a === void 0 ? void 0 : _a.name,
             outcome: ((_b = testPoint.results) === null || _b === void 0 ? void 0 : _b.outcome) || 'Not Run',
             lastRunId: (_c = testPoint.results) === null || _c === void 0 ? void 0 : _c.lastTestRunId,
@@ -159,25 +377,103 @@ class ResultDataProvider {
         return testCases;
     }
     /**
-     * Fetches iterations data by run and result IDs.
+     * 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.
+     * If an error occurs, logs the error and returns `null`.
+     *
+     * @throws Logs an error message if the data retrieval fails.
      */
-    async fetchResult(projectName, runId, resultId) {
+    async fetchResultDataBasedOnWiBase(projectName, runId, resultId, options = {}) {
+        var _a, _b, _c, _d;
         try {
             const url = `${this.orgUrl}${projectName}/_apis/test/runs/${runId}/results/${resultId}?detailsToInclude=Iterations`;
             const resultData = await tfs_1.TFSServices.getItemContent(url, this.token);
             const attachmentsUrl = `${this.orgUrl}${projectName}/_apis/test/runs/${runId}/results/${resultId}/attachments`;
             const { value: analysisAttachments } = await tfs_1.TFSServices.getItemContent(attachmentsUrl, this.token);
-            const wiUrl = `${this.orgUrl}${projectName}/_apis/wit/workItems/${resultData.testCase.id}/revisions/${resultData.testCaseRevision}`;
+            // Build workItem URL with optional expand parameter
+            const expandParam = options.expandWorkItem ? '?$expand=all' : '';
+            const wiUrl = `${this.orgUrl}${projectName}/_apis/wit/workItems/${resultData.testCase.id}/revisions/${resultData.testCaseRevision}${expandParam}`;
             const wiByRevision = await tfs_1.TFSServices.getItemContent(wiUrl, this.token);
-            return Object.assign(Object.assign({}, resultData), { stepsResultXml: wiByRevision.fields['Microsoft.VSTS.TCM.Steps'] || undefined, analysisAttachments, testCaseRevision: resultData.testCaseRevision });
+            let filteredFields = {};
+            let relatedRequirements = [];
+            // Process selected fields if provided
+            if (((_a = options.selectedFields) === null || _a === void 0 ? void 0 : _a.length) && options.processRelatedRequirements) {
+                const filtered = (_c = (_b = options.selectedFields) === null || _b === void 0 ? void 0 : _b.filter((field) => field.includes('@testCaseWorkItemField'))) === null || _c === void 0 ? void 0 : _c.map((field) => field.split('@')[0]);
+                const selectedFieldSet = new Set(filtered);
+                if (selectedFieldSet.size !== 0) {
+                    // Process related requirements if needed
+                    const { relations } = wiByRevision;
+                    if (relations) {
+                        for (const relation of relations) {
+                            if ((_d = relation.rel) === null || _d === void 0 ? void 0 : _d.includes('System.LinkTypes.Hierarchy')) {
+                                const relatedUrl = relation.url;
+                                const wi = await tfs_1.TFSServices.getItemContent(relatedUrl, this.token);
+                                if (wi.fields['System.WorkItemType'] === 'Requirement') {
+                                    const { id, fields, _links } = wi;
+                                    const requirementTitle = fields['System.Title'];
+                                    const customerFieldKey = Object.keys(fields).find((key) => key.toLowerCase().includes('customer'));
+                                    const customerId = customerFieldKey ? fields[customerFieldKey] : undefined;
+                                    const url = _links.html.href;
+                                    relatedRequirements.push({ id, requirementTitle, customerId, url });
+                                }
+                            }
+                        }
+                    }
+                    // Filter fields based on selected field set
+                    filteredFields = Object.keys(wiByRevision.fields)
+                        .filter((key) => selectedFieldSet.has(key))
+                        .reduce((obj, key) => {
+                        var _a, _b;
+                        obj[key] = (_b = (_a = wiByRevision.fields[key]) === null || _a === void 0 ? void 0 : _a.displayName) !== null && _b !== void 0 ? _b : wiByRevision.fields[key];
+                        return obj;
+                    }, {});
+                }
+            }
+            return Object.assign(Object.assign({}, resultData), { stepsResultXml: wiByRevision.fields['Microsoft.VSTS.TCM.Steps'] || undefined, analysisAttachments, testCaseRevision: resultData.testCaseRevision, filteredFields,
+                relatedRequirements });
         }
         catch (error) {
             logger_1.default.error(`Error while fetching run result: ${error.message}`);
+            if (options.includeFullErrorStack) {
+                logger_1.default.error(`Error stack: ${error.stack}`);
+            }
             return null;
         }
     }
     /**
-     * Converts run status from API format to a more readable format.
+     * Fetches result data based on the specified work item (WI) details.
+     *
+     * @param projectName - The name of the project associated with the work item.
+     * @param runId - The unique identifier of the test run.
+     * @param resultId - The unique identifier of the test result.
+     * @returns A promise that resolves to the result data.
+     */
+    async fetchResultDataBasedOnWi(projectName, runId, resultId) {
+        return this.fetchResultDataBasedOnWiBase(projectName, runId, resultId);
+    }
+    /**
+     * Converts a run status string into a human-readable format.
+     *
+     * @param status - The status string to convert. Expected values are:
+     *   - `'passed'`: Indicates the run was successful.
+     *   - `'failed'`: Indicates the run was unsuccessful.
+     *   - `'notApplicable'`: Indicates the run is not applicable.
+     *   - Any other value will default to `'Not Run'`.
+     * @returns A human-readable string representing the run status.
      */
     convertRunStatus(status) {
         switch (status) {
@@ -191,7 +487,19 @@ class ResultDataProvider {
                 return 'Not Run';
         }
     }
-    setRunStatus(actionResult) {
+    /**
+     * Converts the outcome of an action result based on specific conditions.
+     *
+     * - If the outcome is 'Unspecified' and the action result is a shared step title,
+     *   it returns an empty string.
+     * - If the outcome is 'Unspecified' but not a shared step title, it returns 'Not Run'.
+     * - If the outcome is not 'Not Run', it returns the original outcome.
+     * - Otherwise, it returns an empty string.
+     *
+     * @param actionResult - The action result object containing the outcome and other properties.
+     * @returns A string representing the converted outcome.
+     */
+    convertUnspecifiedRunStatus(actionResult) {
         if (actionResult.outcome === 'Unspecified' && actionResult.isSharedStepTitle) {
             return '';
         }
@@ -202,13 +510,24 @@ class ResultDataProvider {
                 : '';
     }
     /**
-     * Aligns test steps with their corresponding iterations.
+     * Aligns test steps with iterations and generates detailed results based on the provided options.
+     *
+     * @param testData - An array of test data objects containing test points and test cases.
+     * @param iterations - An array of iteration data used to map test cases to their respective iterations.
+     * @param options - Configuration options for processing the test data.
+     * @param options.selectedFields - An optional array of selected fields to filter step-level properties.
+     * @param options.createResultObject - A callback function to create a result object for each test or step.
+     * @param options.shouldProcessStepLevel - A callback function to determine whether to process at the step level.
+     * @returns An array of detailed result objects, either at the test level or step level, depending on the options.
      */
-    alignStepsWithIterations(testData, iterations) {
+    alignStepsWithIterationsBase(testData, iterations, options) {
+        var _a, _b;
         const detailedResults = [];
         if (!iterations || (iterations === null || iterations === void 0 ? void 0 : iterations.length) === 0) {
             return detailedResults;
         }
+        // Process filtered fields if available
+        const filteredFields = new Set(((_b = (_a = options.selectedFields) === null || _a === void 0 ? void 0 : _a.filter((field) => field.includes('@stepsRunProperties'))) === null || _b === void 0 ? void 0 : _b.map((field) => field.split('@')[0])) || []);
         for (const testItem of testData) {
             for (const point of testItem.testPointsItems) {
                 const testCase = testItem.testCasesItems.find((tc) => tc.workItem.id === point.testCaseId);
@@ -221,32 +540,77 @@ class ResultDataProvider {
                 }
                 if (point.lastRunId && point.lastResultId) {
                     const iterationKey = `${point.lastRunId}-${point.lastResultId}-${testCase.workItem.id}`;
-                    const testCastObj = iterationsMap[iterationKey];
-                    if (!testCastObj || !testCastObj.iteration || !testCastObj.iteration.actionResults)
+                    const fetchedTestCase = iterationsMap[iterationKey];
+                    if (!fetchedTestCase || !fetchedTestCase.iteration)
                         continue;
-                    const { actionResults } = testCastObj === null || testCastObj === void 0 ? void 0 : testCastObj.iteration;
-                    for (let i = 0; i < (actionResults === null || actionResults === void 0 ? void 0 : actionResults.length); i++) {
-                        const stepIdentifier = parseInt(actionResults[i].stepIdentifier, 10);
-                        const resultObj = {
-                            testId: point.testCaseId,
-                            testCaseRevision: testCastObj.testCaseRevision,
-                            testName: point.testCaseName,
-                            stepIdentifier: stepIdentifier,
-                            actionPath: actionResults[i].actionPath,
-                            stepNo: actionResults[i].stepPosition,
-                            stepAction: actionResults[i].action,
-                            stepExpected: actionResults[i].expected,
-                            isSharedStepTitle: actionResults[i].isSharedStepTitle,
-                            stepStatus: this.setRunStatus(actionResults[i]),
-                            stepComments: actionResults[i].errorMessage || '',
-                        };
+                    // Determine if we should process at step level
+                    const shouldProcessSteps = options.shouldProcessStepLevel(fetchedTestCase, filteredFields);
+                    if (!shouldProcessSteps) {
+                        // Create a test-level result object
+                        const resultObj = options.createResultObject({
+                            testItem,
+                            point,
+                            fetchedTestCase,
+                            filteredFields,
+                        });
                         detailedResults.push(resultObj);
                     }
+                    else {
+                        // Create step-level result objects
+                        const { actionResults } = fetchedTestCase === null || fetchedTestCase === void 0 ? void 0 : fetchedTestCase.iteration;
+                        for (let i = 0; i < (actionResults === null || actionResults === void 0 ? void 0 : actionResults.length); i++) {
+                            const resultObj = options.createResultObject({
+                                testItem,
+                                point,
+                                fetchedTestCase,
+                                actionResult: actionResults[i],
+                                filteredFields,
+                            });
+                            detailedResults.push(resultObj);
+                        }
+                    }
                 }
             }
         }
         return detailedResults;
     }
+    /**
+     * Aligns test steps with their corresponding iterations by processing the provided test data and iterations.
+     * This method utilizes a base alignment function with custom logic for processing step-level data and creating result objects.
+     *
+     * @param testData - An array of test data objects containing information about test cases and their steps.
+     * @param iterations - An array of iteration objects containing action results for each test case.
+     * @returns An array of aligned step data objects, each containing detailed information about a test step and its status.
+     *
+     * The alignment process includes:
+     * - Filtering and processing step-level data based on the presence of iteration and action results.
+     * - Creating result objects for each step, including details such as test ID, step identifier, action path, step status, and comments.
+     */
+    alignStepsWithIterations(testData, iterations) {
+        return this.alignStepsWithIterationsBase(testData, iterations, {
+            shouldProcessStepLevel: (fetchedTestCase) => fetchedTestCase != null &&
+                fetchedTestCase.iteration != null &&
+                fetchedTestCase.iteration.actionResults != null,
+            createResultObject: ({ point, fetchedTestCase, actionResult }) => {
+                if (!actionResult)
+                    return null;
+                const stepIdentifier = parseInt(actionResult.stepIdentifier, 10);
+                return {
+                    testId: point.testCaseId,
+                    testCaseRevision: fetchedTestCase.testCaseRevision,
+                    testName: point.testCaseName,
+                    stepIdentifier: stepIdentifier,
+                    actionPath: actionResult.actionPath,
+                    stepNo: actionResult.stepPosition,
+                    stepAction: actionResult.action,
+                    stepExpected: actionResult.expected,
+                    isSharedStepTitle: actionResult.isSharedStepTitle,
+                    stepStatus: this.convertUnspecifiedRunStatus(actionResult),
+                    stepComments: actionResult.errorMessage || '',
+                };
+            },
+        });
+    }
     /**
      * Creates a mapping of iterations by their unique keys.
      */
@@ -276,12 +640,19 @@ class ResultDataProvider {
         })));
     }
     /**
-     * Fetches result data for all test points within the given test data.
+     * Fetches all result data based on the provided test data, project name, and fetch strategy.
+     * This method processes the test data, filters valid test points, and sequentially fetches
+     * result data for each valid point using the provided fetch strategy.
+     *
+     * @param testData - An array of test data objects containing test suite and test points information.
+     * @param projectName - The name of the project for which the result data is being fetched.
+     * @param fetchStrategy - A function that defines the strategy for fetching result data. It takes
+     *                        the project name, test suite ID, a test point, and additional arguments,
+     *                        and returns a Promise resolving to the fetched result data.
+     * @param additionalArgs - An optional array of additional arguments to be passed to the fetch strategy.
+     * @returns A Promise that resolves to an array of fetched result data.
      */
-    /**
-     * Fetches result data for all test points within the given test data, sequentially to avoid context-related errors.
-     */
-    async fetchAllResultData(testData, projectName) {
+    async fetchAllResultDataBase(testData, projectName, fetchStrategy, additionalArgs = []) {
         const results = [];
         for (const item of testData) {
             if (item.testPointsItems && item.testPointsItems.length > 0) {
@@ -290,7 +661,7 @@ class ResultDataProvider {
                 const validPoints = testPointsItems.filter((point) => point && point.lastRunId && point.lastResultId);
                 // Fetch results for each point sequentially
                 for (const point of validPoints) {
-                    const resultData = await this.fetchResultData(projectName, testSuiteId, point);
+                    const resultData = await fetchStrategy(projectName, testSuiteId, point, ...additionalArgs);
                     if (resultData !== null) {
                         results.push(resultData);
                     }
@@ -300,11 +671,17 @@ class ResultDataProvider {
         return results;
     }
     /**
-     * Fetches result Data data for a specific test point.
+     * Fetches result data for all test points within the given test data, sequentially to avoid context-related errors.
      */
-    async fetchResultData(projectName, testSuiteId, point) {
+    async fetchAllResultData(testData, projectName) {
+        return this.fetchAllResultDataBase(testData, projectName, (projectName, testSuiteId, point) => this.fetchResultData(projectName, testSuiteId, point));
+    }
+    /**
+     * Base method for fetching result data for test points
+     */
+    async fetchResultDataBase(projectName, testSuiteId, point, fetchResultMethod, createResponseObject, additionalArgs = []) {
         const { lastRunId, lastResultId } = point;
-        const resultData = await this.fetchResult(projectName, lastRunId.toString(), lastResultId.toString());
+        const resultData = await fetchResultMethod(projectName, lastRunId.toString(), lastResultId.toString(), ...additionalArgs);
         const iteration = resultData.iterationDetails.length > 0
             ? resultData.iterationDetails[resultData.iterationDetails.length - 1]
             : undefined;
@@ -338,22 +715,30 @@ class ResultDataProvider {
                 .sort((a, b) => this.compareActionResults(a.stepPosition, b.stepPosition));
         }
         return (resultData === null || resultData === void 0 ? void 0 : resultData.testCase)
-            ? {
-                testCaseName: `${resultData.testCase.name} - ${resultData.testCase.id}`,
-                testCaseId: resultData.testCase.id,
-                testSuiteName: `${resultData.testSuite.name}`,
-                testSuiteId,
-                lastRunId,
-                lastResultId,
-                iteration,
-                testCaseRevision: resultData.testCaseRevision,
-                failureType: resultData.failureType,
-                resolution: resultData.resolutionState,
-                comment: resultData.comment,
-                analysisAttachments: resultData.analysisAttachments,
-            }
+            ? createResponseObject(resultData, testSuiteId, point, ...additionalArgs)
             : null;
     }
+    /**
+     * Fetches result Data for a specific test point
+     */
+    async fetchResultData(projectName, testSuiteId, point) {
+        return this.fetchResultDataBase(projectName, testSuiteId, point, (project, runId, resultId) => this.fetchResultDataBasedOnWi(project, runId, resultId), (resultData, testSuiteId, point) => ({
+            testCaseName: `${resultData.testCase.name} - ${resultData.testCase.id}`,
+            testCaseId: resultData.testCase.id,
+            testSuiteName: `${resultData.testSuite.name}`,
+            testSuiteId,
+            lastRunId: point.lastRunId,
+            lastResultId: point.lastResultId,
+            iteration: resultData.iterationDetails.length > 0
+                ? resultData.iterationDetails[resultData.iterationDetails.length - 1]
+                : undefined,
+            testCaseRevision: resultData.testCaseRevision,
+            failureType: resultData.failureType,
+            resolution: resultData.resolutionState,
+            comment: resultData.comment,
+            analysisAttachments: resultData.analysisAttachments,
+        }));
+    }
     /**
      * Fetches all the linked work items (WI) for the given test case.
      * @param project Project name
@@ -476,33 +861,6 @@ class ResultDataProvider {
             });
         }
     }
-    /**
-     * Mapping each attachment to a proper URL for downloading it
-     * @param runResults Array of run results
-     */
-    mapAttachmentsUrl(runResults, project) {
-        return runResults.map((result) => {
-            var _a;
-            if (!result.iteration) {
-                return result;
-            }
-            const { iteration, analysisAttachments } = result, restResult = __rest(result, ["iteration", "analysisAttachments"]);
-            //add downloadUri field for each attachment
-            const baseDownloadUrl = `${this.orgUrl}${project}/_apis/test/runs/${result.lastRunId}/results/${result.lastResultId}/attachments`;
-            if (iteration && ((_a = iteration.attachments) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                const { attachments, actionResults } = iteration, restOfIteration = __rest(iteration, ["attachments", "actionResults"]);
-                const attachmentPathToIndexMap = this.CreateAttachmentPathIndexMap(actionResults);
-                const mappedAttachments = attachments.map((attachment) => (Object.assign(Object.assign({}, attachment), { stepNo: attachmentPathToIndexMap.has(attachment.actionPath)
-                        ? attachmentPathToIndexMap.get(attachment.actionPath)
-                        : undefined, downloadUrl: `${baseDownloadUrl}/${attachment.id}/${attachment.name}` })));
-                restResult.iteration = Object.assign(Object.assign({}, restOfIteration), { attachments: mappedAttachments });
-            }
-            if (analysisAttachments && analysisAttachments.length > 0) {
-                restResult.analysisAttachments = analysisAttachments.map((attachment) => (Object.assign(Object.assign({}, attachment), { downloadUrl: `${baseDownloadUrl}/${attachment.id}/${attachment.fileName}` })));
-            }
-            return Object.assign({}, restResult);
-        });
-    }
     CreateAttachmentPathIndexMap(actionResults) {
         const attachmentPathToIndexMap = new Map();
         for (let i = 0; i < actionResults.length; i++) {
@@ -511,122 +869,6 @@ class ResultDataProvider {
         }
         return attachmentPathToIndexMap;
     }
-    /**
-     * Combines the results of test group result summary, test results summary, and detailed results summary into a single key-value pair array.
-     */
-    async getCombinedResultsSummary(testPlanId, projectName, selectedSuiteIds, addConfiguration = false, isHierarchyGroupName = false, includeOpenPCRs = false, includeTestLog = false, stepExecution, stepAnalysis, includeHardCopyRun = false) {
-        const combinedResults = [];
-        try {
-            // Fetch test suites
-            const suites = await this.fetchTestSuites(testPlanId, projectName, selectedSuiteIds, isHierarchyGroupName);
-            // Prepare test data for summaries
-            const testPointsPromises = suites.map((suite) => this.limit(() => this.fetchTestPoints(projectName, testPlanId, suite.testSuiteId)
-                .then((testPointsItems) => (Object.assign(Object.assign({}, suite), { testPointsItems })))
-                .catch((error) => {
-                logger_1.default.error(`Error occurred for suite ${suite.testSuiteId}: ${error.message}`);
-                return Object.assign(Object.assign({}, suite), { testPointsItems: [] });
-            })));
-            const testPoints = await Promise.all(testPointsPromises);
-            // 1. Calculate Test Group Result Summary
-            const summarizedResults = testPoints
-                .filter((testPoint) => testPoint.testPointsItems && testPoint.testPointsItems.length > 0)
-                .map((testPoint) => {
-                const groupResultSummary = this.calculateGroupResultSummary(testPoint.testPointsItems || [], includeHardCopyRun);
-                return Object.assign(Object.assign({}, testPoint), { groupResultSummary });
-            });
-            const totalSummary = this.calculateTotalSummary(summarizedResults, includeHardCopyRun);
-            const testGroupArray = summarizedResults.map((item) => (Object.assign({ testGroupName: item.testGroupName }, item.groupResultSummary)));
-            testGroupArray.push(Object.assign({ testGroupName: 'Total' }, totalSummary));
-            // Add test group result summary to combined results
-            combinedResults.push({
-                contentControl: 'test-group-summary-content-control',
-                data: testGroupArray,
-                skin: 'test-result-test-group-summary-table',
-            });
-            // 2. Calculate Test Results Summary
-            const flattenedTestPoints = this.flattenTestPoints(testPoints);
-            const testResultsSummary = flattenedTestPoints.map((testPoint) => this.formatTestResult(testPoint, addConfiguration, includeHardCopyRun));
-            // Add test results summary to combined results
-            combinedResults.push({
-                contentControl: 'test-result-summary-content-control',
-                data: testResultsSummary,
-                skin: 'test-result-table',
-            });
-            // 3. Calculate Detailed Results Summary
-            const testData = await this.fetchTestData(suites, projectName, testPlanId);
-            const runResults = await this.fetchAllResultData(testData, projectName);
-            const detailedStepResultsSummary = this.alignStepsWithIterations(testData, runResults);
-            //Filter out all the results with no comment
-            const filteredDetailedResults = detailedStepResultsSummary.filter((result) => result && (result.stepComments !== '' || result.stepStatus === 'Failed'));
-            // Add detailed results summary to combined results
-            combinedResults.push({
-                contentControl: 'detailed-test-result-content-control',
-                data: !includeHardCopyRun ? filteredDetailedResults : [],
-                skin: 'detailed-test-result-table',
-            });
-            if (includeOpenPCRs) {
-                //5. Open PCRs data (only if enabled)
-                await this.fetchOpenPcrData(testResultsSummary, projectName, combinedResults);
-            }
-            //6. Test Log (only if enabled)
-            if (includeTestLog) {
-                this.fetchTestLogData(flattenedTestPoints, combinedResults);
-            }
-            if (stepAnalysis && stepAnalysis.isEnabled) {
-                const mappedAnalysisData = runResults.filter((result) => {
-                    var _a, _b, _c;
-                    return result.comment ||
-                        ((_b = (_a = result.iteration) === null || _a === void 0 ? void 0 : _a.attachments) === null || _b === void 0 ? void 0 : _b.length) > 0 ||
-                        ((_c = result.analysisAttachments) === null || _c === void 0 ? void 0 : _c.length) > 0;
-                });
-                const mappedAnalysisResultData = stepAnalysis.generateRunAttachments.isEnabled
-                    ? this.mapAttachmentsUrl(mappedAnalysisData, projectName)
-                    : mappedAnalysisData;
-                if ((mappedAnalysisResultData === null || mappedAnalysisResultData === void 0 ? void 0 : mappedAnalysisResultData.length) > 0) {
-                    combinedResults.push({
-                        contentControl: 'appendix-a-content-control',
-                        data: mappedAnalysisResultData,
-                        skin: 'step-analysis-appendix-skin',
-                    });
-                }
-            }
-            if (stepExecution && stepExecution.isEnabled) {
-                const mappedAnalysisData = stepExecution.generateAttachments.isEnabled &&
-                    stepExecution.generateAttachments.runAttachmentMode !== 'planOnly'
-                    ? runResults.filter((result) => { var _a, _b; return ((_b = (_a = result.iteration) === null || _a === void 0 ? void 0 : _a.attachments) === null || _b === void 0 ? void 0 : _b.length) > 0; })
-                    : [];
-                const mappedAnalysisResultData = mappedAnalysisData.length > 0 ? this.mapAttachmentsUrl(mappedAnalysisData, projectName) : [];
-                const mappedDetailedResults = this.mapStepResultsForExecutionAppendix(detailedStepResultsSummary, mappedAnalysisResultData);
-                combinedResults.push({
-                    contentControl: 'appendix-b-content-control',
-                    data: mappedDetailedResults,
-                    skin: 'step-execution-appendix-skin',
-                });
-            }
-            return combinedResults;
-        }
-        catch (error) {
-            logger_1.default.error(`Error during getCombinedResultsSummary: ${error.message}`);
-            if (error.response) {
-                logger_1.default.error(`Response Data: ${JSON.stringify(error.response.data)}`);
-            }
-            throw error;
-        }
-    }
-    // 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,
-    //         };
-    //       })
-    //     : [];
-    // }
     mapStepResultsForExecutionAppendix(detailedResults, runResultData) {
         // Create maps first to avoid repeated lookups
         const testCaseIdToStepsMap = new Map();
@@ -778,6 +1020,180 @@ class ResultDataProvider {
         }
         return formattedResult;
     }
+    /**
+     * Fetches result data based on the Work Item Test Reporter.
+     *
+     * This method retrieves detailed result data for a specific test run and result ID,
+     * including related work items, selected fields, and additional processing options.
+     *
+     * @param projectName - The name of the project containing the test run.
+     * @param runId - The unique identifier of the test run.
+     * @param resultId - The unique identifier of the test result.
+     * @param selectedFields - (Optional) An array of field names to include in the result data.
+     * @returns A promise that resolves to the fetched result data.
+     */
+    async fetchResultDataBasedOnWiTestReporter(projectName, runId, resultId, selectedFields) {
+        return this.fetchResultDataBasedOnWiBase(projectName, runId, resultId, {
+            expandWorkItem: true,
+            selectedFields,
+            processRelatedRequirements: true,
+            includeFullErrorStack: true,
+        });
+    }
+    /**
+     * Fetches all result data for the test reporter by processing the provided test data.
+     *
+     * This method utilizes the `fetchAllResultDataBase` function to retrieve and process
+     * result data for a specific project and test reporter. It applies a callback to fetch
+     * result data for individual test points.
+     *
+     * @param testData - An array of test data objects to process.
+     * @param projectName - The name of the project for which result data is being fetched.
+     * @param selectedFields - An optional array of field names to include in the result data.
+     * @returns A promise that resolves to an array of processed result data.
+     */
+    async fetchAllResultDataTestReporter(testData, projectName, selectedFields) {
+        return this.fetchAllResultDataBase(testData, projectName, (projectName, testSuiteId, point, selectedFields) => this.fetchResultDataForTestReporter(projectName, testSuiteId, point, selectedFields), [selectedFields]);
+    }
+    /**
+     * Aligns test steps with iterations for the test reporter by processing test data and iterations
+     * and generating a structured result object based on the provided selected fields.
+     *
+     * @param testData - An array of test data objects to be processed.
+     * @param iterations - An array of iteration objects to align with the test data.
+     * @param selectedFields - An array of selected fields to determine which properties to include in the result.
+     * @returns An array of structured result objects containing aligned test steps and iterations.
+     *
+     * The method uses a base alignment function and provides custom logic for:
+     * - Determining whether step-level processing should occur based on the fetched test case and filtered fields.
+     * - Creating a result object with properties such as suite name, test case details, priority, run information,
+     *   failure type, automation status, execution date, configuration name, state, error message, and related requirements.
+     * - Including step-specific properties (e.g., step number, action, expected result, status, and comments) if action results are available
+     *   and the corresponding fields are selected.
+     */
+    alignStepsWithIterationsTestReporter(testData, iterations, selectedFields) {
+        return this.alignStepsWithIterationsBase(testData, iterations, {
+            selectedFields,
+            shouldProcessStepLevel: (fetchedTestCase, filteredFields) => fetchedTestCase != null &&
+                fetchedTestCase.iteration != null &&
+                fetchedTestCase.iteration.actionResults != null &&
+                filteredFields.size > 0,
+            createResultObject: ({ testItem, point, fetchedTestCase, actionResult, filteredFields = new Set(), }) => {
+                var _a;
+                const baseObj = {
+                    suiteName: testItem.testGroupName,
+                    testCase: {
+                        id: point.testCaseId,
+                        title: point.testCaseName,
+                        url: point.testCaseUrl,
+                        result: fetchedTestCase.testCaseResult,
+                        comment: (_a = fetchedTestCase.iteration) === null || _a === void 0 ? void 0 : _a.comment,
+                    },
+                    priority: fetchedTestCase.priority,
+                    runBy: fetchedTestCase.runBy,
+                    activatedBy: fetchedTestCase.activatedBy,
+                    assignedTo: fetchedTestCase.assignedTo,
+                    failureType: fetchedTestCase.failureType,
+                    automationStatus: fetchedTestCase.automationStatus,
+                    executionDate: fetchedTestCase.executionDate,
+                    configurationName: fetchedTestCase.configurationName,
+                    errorMessage: fetchedTestCase.errorMessage,
+                    relatedRequirements: fetchedTestCase.relatedRequirements,
+                };
+                // If we have action results, add step-specific properties
+                if (actionResult) {
+                    return Object.assign(Object.assign({}, baseObj), { stepNo: actionResult.stepPosition, stepAction: filteredFields.has('includeSteps') ? actionResult.action : undefined, stepExpected: filteredFields.has('includeSteps') ? actionResult.expected : undefined, stepStatus: filteredFields.has('stepRunStatus')
+                            ? this.convertUnspecifiedRunStatus(actionResult)
+                            : undefined, stepComments: filteredFields.has('testStepComment') ? actionResult.errorMessage : undefined });
+                }
+                return baseObj;
+            },
+        });
+    }
+    /**
+     * Fetches result data for a test reporter based on the provided project, test suite, and point information.
+     * This method processes the result data and formats it according to the selected fields.
+     *
+     * @param projectName - The name of the project.
+     * @param testSuiteId - The ID of the test suite.
+     * @param point - The test point containing details such as last run ID, result ID, and configuration name.
+     * @param selectedFields - An optional array of field names to filter and include in the response.
+     *
+     * @returns A promise that resolves to the formatted result data object containing details about the test case,
+     *          test suite, last run, iteration, and other selected fields.
+     */
+    async fetchResultDataForTestReporter(projectName, testSuiteId, point, selectedFields) {
+        return this.fetchResultDataBase(projectName, testSuiteId, point, (project, runId, resultId, fields) => this.fetchResultDataBasedOnWiTestReporter(project, runId, resultId, fields), (resultData, testSuiteId, point, selectedFields) => {
+            var _a, _b;
+            const { lastRunId, lastResultId, configurationName, lastResultDetails } = point;
+            const iteration = resultData.iterationDetails.length > 0
+                ? resultData.iterationDetails[resultData.iterationDetails.length - 1]
+                : undefined;
+            const resultDataResponse = {
+                testCaseName: `${resultData.testCase.name} - ${resultData.testCase.id}`,
+                testCaseId: resultData.testCase.id,
+                testSuiteName: `${resultData.testSuite.name}`,
+                testSuiteId,
+                lastRunId,
+                lastResultId,
+                iteration,
+                testCaseRevision: resultData.testCaseRevision,
+                resolution: resultData.resolutionState,
+                automationStatus: resultData.filteredFields['Microsoft.VSTS.TCM.AutomationStatus'] || undefined,
+                analysisAttachments: resultData.analysisAttachments,
+                failureType: undefined,
+                comment: undefined,
+                priority: undefined,
+                runBy: undefined,
+                executionDate: undefined,
+                testCaseResult: undefined,
+                errorMessage: undefined,
+                configurationName: undefined,
+                relatedRequirements: undefined,
+                lastRunResult: undefined,
+            };
+            const filteredFields = (_a = selectedFields === null || selectedFields === void 0 ? void 0 : selectedFields.filter((field) => field.includes('@runResultField') || field.includes('@linked'))) === null || _a === void 0 ? void 0 : _a.map((field) => field.split('@')[0]);
+            if (filteredFields && filteredFields.length > 0) {
+                for (const field of filteredFields) {
+                    switch (field) {
+                        case 'priority':
+                            resultDataResponse.priority = resultData.priority;
+                            break;
+                        case 'testCaseResult':
+                            const outcome = (_b = resultData.iterationDetails[resultData.iterationDetails.length - 1]) === null || _b === void 0 ? void 0 : _b.outcome;
+                            resultDataResponse.testCaseResult = {
+                                resultMessage: `${outcome} in Run ${lastRunId}`,
+                                url: `${this.orgUrl}${projectName}/_testManagement/runs?runId=${lastRunId}&_a=resultSummary&resultId=${lastResultId}`,
+                            };
+                            break;
+                        case 'failureType':
+                            resultDataResponse.failureType = resultData.failureType;
+                            break;
+                        case 'testCaseComment':
+                            resultDataResponse.comment = resultData.comment || undefined;
+                            break;
+                        case 'runBy':
+                            const runBy = lastResultDetails.runBy.displayName;
+                            resultDataResponse.runBy = runBy;
+                            break;
+                        case 'executionDate':
+                            resultDataResponse.executionDate = lastResultDetails.dateCompleted;
+                            break;
+                        case 'configurationName':
+                            resultDataResponse.configurationName = configurationName;
+                            break;
+                        case 'associatedRequirement':
+                            resultDataResponse.relatedRequirements = resultData.relatedRequirements;
+                            break;
+                        default:
+                            logger_1.default.debug(`Field ${field} not handled`);
+                            break;
+                    }
+                }
+            }
+            return resultDataResponse;
+        }, [selectedFields]);
+    }
 }
 exports.default = ResultDataProvider;
 //# sourceMappingURL=ResultDataProvider.js.map