@salesforce/apex-node 2.1.3 → 2.1.5

package/lib/src/streaming/types.d.ts

@@ -1,15 +1,15 @@
-export declare type StreamingEvent = {
+export type StreamingEvent = {
     createdDate: string;
     replayId?: number;
     type: string;
 };
-export declare type TestResultMessage = {
+export type TestResultMessage = {
     event: StreamingEvent;
     sobject: {
         Id: string;
     };
 };
-export declare type StreamMessage = {
+export type StreamMessage = {
     channel: string;
     clientId: string;
     successful?: boolean;
@@ -26,4 +26,4 @@ export declare const enum StreamingErrors {
     ERROR_AUTH_INVALID = "401::Authentication invalid",
     ERROR_UNKNOWN_CLIENT_ID = "403::Unknown client"
 }
-export declare const RetreiveResultsInterval: number;
+export declare const RetrieveResultsInterval: number;

package/lib/src/streaming/types.js

@@ -6,11 +6,11 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetreiveResultsInterval = exports.StreamingErrors = void 0;
+exports.RetrieveResultsInterval = exports.StreamingErrors = void 0;
 var StreamingErrors;
 (function (StreamingErrors) {
     StreamingErrors["ERROR_AUTH_INVALID"] = "401::Authentication invalid";
     StreamingErrors["ERROR_UNKNOWN_CLIENT_ID"] = "403::Unknown client";
-})(StreamingErrors = exports.StreamingErrors || (exports.StreamingErrors = {}));
-exports.RetreiveResultsInterval = 60 * 1000;
+})(StreamingErrors || (exports.StreamingErrors = StreamingErrors = {}));
+exports.RetrieveResultsInterval = 60 * 1000;
 //# sourceMappingURL=types.js.map

package/lib/src/streaming/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/streaming/types.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AA6BH,IAAkB,eAGjB;AAHD,WAAkB,eAAe;IAC/B,qEAAkD,CAAA;IAClD,kEAA+C,CAAA;AACjD,CAAC,EAHiB,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAGhC;AAEY,QAAA,uBAAuB,GAAG,EAAE,GAAG,IAAI,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/streaming/types.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AA6BH,IAAkB,eAGjB;AAHD,WAAkB,eAAe;IAC/B,qEAAkD,CAAA;IAClD,kEAA+C,CAAA;AACjD,CAAC,EAHiB,eAAe,+BAAf,eAAe,QAGhC;AAEY,QAAA,uBAAuB,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/lib/src/tests/asyncTests.js

@@ -5,15 +5,6 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncTests = void 0;
 const i18n_1 = require("../i18n");
@@ -37,33 +28,31 @@ class AsyncTests {
      * @param progress progress reporter
      * @param token cancellation token
      */
-    runTests(options, codeCoverage = false, exitOnTestRunId = false, progress, token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const sClient = new streaming_1.StreamingClient(this.connection, progress);
-                yield sClient.init();
-                yield sClient.handshake();
-                token &&
-                    token.onCancellationRequested(() => __awaiter(this, void 0, void 0, function* () {
-                        const testRunId = yield sClient.subscribedTestRunIdPromise;
-                        yield this.abortTestRun(testRunId, progress);
-                        sClient.disconnect();
-                    }));
-                const testRunId = yield this.getTestRunRequestAction(options)();
-                if (exitOnTestRunId) {
-                    return { testRunId };
-                }
-                if (token && token.isCancellationRequested) {
-                    return null;
-                }
-                const asyncRunResult = yield sClient.subscribe(undefined, testRunId);
-                const testRunSummary = yield this.checkRunStatus(asyncRunResult.runId);
-                return yield this.formatAsyncResults(asyncRunResult, (0, utils_1.getCurrentTime)(), codeCoverage, testRunSummary, progress);
+    async runTests(options, codeCoverage = false, exitOnTestRunId = false, progress, token) {
+        try {
+            const sClient = new streaming_1.StreamingClient(this.connection, progress);
+            await sClient.init();
+            await sClient.handshake();
+            token &&
+                token.onCancellationRequested(async () => {
+                    const testRunId = await sClient.subscribedTestRunIdPromise;
+                    await this.abortTestRun(testRunId, progress);
+                    sClient.disconnect();
+                });
+            const testRunId = await this.getTestRunRequestAction(options)();
+            if (exitOnTestRunId) {
+                return { testRunId };
             }
-            catch (e) {
-                throw (0, diagnosticUtil_1.formatTestErrors)(e);
+            if (token && token.isCancellationRequested) {
+                return null;
             }
-        });
+            const asyncRunResult = await sClient.subscribe(undefined, testRunId);
+            const testRunSummary = await this.checkRunStatus(asyncRunResult.runId);
+            return await this.formatAsyncResults(asyncRunResult, (0, utils_1.getCurrentTime)(), codeCoverage, testRunSummary, progress);
+        }
+        catch (e) {
+            throw (0, diagnosticUtil_1.formatTestErrors)(e);
+        }
     }
     /**
      * Report Asynchronous Test Run Results
@@ -71,69 +60,65 @@ class AsyncTests {
      * @param codeCoverage should report code coverages
      * @param token cancellation token
      */
-    reportAsyncResults(testRunId, codeCoverage = false, token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const sClient = new streaming_1.StreamingClient(this.connection);
-                yield sClient.init();
-                yield sClient.handshake();
-                let queueItem;
-                let testRunSummary = yield this.checkRunStatus(testRunId);
-                if (testRunSummary !== undefined) {
-                    queueItem = yield sClient.handler(undefined, testRunId);
-                }
-                else {
-                    queueItem = (yield sClient.subscribe(undefined, testRunId)).queueItem;
-                    testRunSummary = yield this.checkRunStatus(testRunId);
-                }
-                token &&
-                    token.onCancellationRequested(() => __awaiter(this, void 0, void 0, function* () {
-                        sClient.disconnect();
-                    }));
-                if (token && token.isCancellationRequested) {
-                    return null;
-                }
-                return yield this.formatAsyncResults({ queueItem, runId: testRunId }, (0, utils_1.getCurrentTime)(), codeCoverage, testRunSummary);
-            }
-            catch (e) {
-                throw (0, diagnosticUtil_1.formatTestErrors)(e);
-            }
-        });
-    }
-    checkRunStatus(testRunId, progress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(0, utils_2.isValidTestRunID)(testRunId)) {
-                throw new Error(i18n_1.nls.localize('invalidTestRunIdErr', testRunId));
+    async reportAsyncResults(testRunId, codeCoverage = false, token) {
+        try {
+            const sClient = new streaming_1.StreamingClient(this.connection);
+            await sClient.init();
+            await sClient.handshake();
+            let queueItem;
+            let testRunSummary = await this.checkRunStatus(testRunId);
+            if (testRunSummary !== undefined) {
+                queueItem = await sClient.handler(undefined, testRunId);
             }
-            let testRunSummaryQuery = 'SELECT AsyncApexJobId, Status, ClassesCompleted, ClassesEnqueued, ';
-            testRunSummaryQuery +=
-                'MethodsEnqueued, StartTime, EndTime, TestTime, UserId ';
-            testRunSummaryQuery += `FROM ApexTestRunResult WHERE AsyncApexJobId = '${testRunId}'`;
-            progress === null || progress === void 0 ? void 0 : progress.report({
-                type: 'FormatTestResultProgress',
-                value: 'retrievingTestRunSummary',
-                message: i18n_1.nls.localize('retrievingTestRunSummary')
-            });
-            const testRunSummaryResults = (yield this.connection.tooling.query(testRunSummaryQuery, {
-                autoFetch: true
-            }));
-            if (testRunSummaryResults.records.length === 0) {
-                throw new Error(i18n_1.nls.localize('noTestResultSummary', testRunId));
+            else {
+                queueItem = (await sClient.subscribe(undefined, testRunId)).queueItem;
+                testRunSummary = await this.checkRunStatus(testRunId);
             }
-            if (testRunSummaryResults.records[0].Status ===
-                "Aborted" /* Aborted */ ||
-                testRunSummaryResults.records[0].Status ===
-                    "Failed" /* Failed */ ||
-                testRunSummaryResults.records[0].Status ===
-                    "Completed" /* Completed */ ||
-                testRunSummaryResults.records[0].Status ===
-                    "Passed" /* Passed */ ||
-                testRunSummaryResults.records[0].Status ===
-                    "Skipped" /* Skipped */) {
-                return testRunSummaryResults.records[0];
+            token &&
+                token.onCancellationRequested(async () => {
+                    sClient.disconnect();
+                });
+            if (token && token.isCancellationRequested) {
+                return null;
             }
-            return undefined;
+            return await this.formatAsyncResults({ queueItem, runId: testRunId }, (0, utils_1.getCurrentTime)(), codeCoverage, testRunSummary);
+        }
+        catch (e) {
+            throw (0, diagnosticUtil_1.formatTestErrors)(e);
+        }
+    }
+    async checkRunStatus(testRunId, progress) {
+        if (!(0, utils_2.isValidTestRunID)(testRunId)) {
+            throw new Error(i18n_1.nls.localize('invalidTestRunIdErr', testRunId));
+        }
+        let testRunSummaryQuery = 'SELECT AsyncApexJobId, Status, ClassesCompleted, ClassesEnqueued, ';
+        testRunSummaryQuery +=
+            'MethodsEnqueued, StartTime, EndTime, TestTime, UserId ';
+        testRunSummaryQuery += `FROM ApexTestRunResult WHERE AsyncApexJobId = '${testRunId}'`;
+        progress?.report({
+            type: 'FormatTestResultProgress',
+            value: 'retrievingTestRunSummary',
+            message: i18n_1.nls.localize('retrievingTestRunSummary')
         });
+        const testRunSummaryResults = (await this.connection.tooling.query(testRunSummaryQuery, {
+            autoFetch: true
+        }));
+        if (testRunSummaryResults.records.length === 0) {
+            throw new Error(i18n_1.nls.localize('noTestResultSummary', testRunId));
+        }
+        if (testRunSummaryResults.records[0].Status ===
+            "Aborted" /* ApexTestRunResultStatus.Aborted */ ||
+            testRunSummaryResults.records[0].Status ===
+                "Failed" /* ApexTestRunResultStatus.Failed */ ||
+            testRunSummaryResults.records[0].Status ===
+                "Completed" /* ApexTestRunResultStatus.Completed */ ||
+            testRunSummaryResults.records[0].Status ===
+                "Passed" /* ApexTestRunResultStatus.Passed */ ||
+            testRunSummaryResults.records[0].Status ===
+                "Skipped" /* ApexTestRunResultStatus.Skipped */) {
+            return testRunSummaryResults.records[0];
+        }
+        return undefined;
     }
     /**
      * Format the results of a completed asynchronous test run
@@ -144,169 +129,172 @@ class AsyncTests {
      * @param progress progress reporter
      * @returns
      */
-    formatAsyncResults(asyncRunResult, commandStartTime, codeCoverage = false, testRunSummary, progress) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const coveredApexClassIdSet = new Set();
-            const apexTestResults = yield this.getAsyncTestResults(asyncRunResult.queueItem);
-            const { apexTestClassIdSet, testResults, globalTests } = yield this.buildAsyncTestResults(apexTestResults);
-            let outcome = testRunSummary.Status;
-            if (globalTests.failed > 0) {
-                outcome = "Failed" /* Failed */;
-            }
-            else if (globalTests.passed === 0) {
-                outcome = "Skipped" /* Skipped */;
-            }
-            else if (testRunSummary.Status === "Completed" /* Completed */) {
-                outcome = "Passed" /* Passed */;
-            }
-            // TODO: deprecate testTotalTime
-            const result = {
-                summary: {
-                    outcome,
-                    testsRan: testResults.length,
-                    passing: globalTests.passed,
-                    failing: globalTests.failed,
-                    skipped: globalTests.skipped,
-                    passRate: (0, utils_2.calculatePercentage)(globalTests.passed, testResults.length),
-                    failRate: (0, utils_2.calculatePercentage)(globalTests.failed, testResults.length),
-                    skipRate: (0, utils_2.calculatePercentage)(globalTests.skipped, testResults.length),
-                    testStartTime: (0, utils_1.formatStartTime)(testRunSummary.StartTime, 'ISO'),
-                    testExecutionTimeInMs: (_a = testRunSummary.TestTime) !== null && _a !== void 0 ? _a : 0,
-                    testTotalTimeInMs: (_b = testRunSummary.TestTime) !== null && _b !== void 0 ? _b : 0,
-                    commandTimeInMs: (0, utils_1.getCurrentTime)() - commandStartTime,
-                    hostname: this.connection.instanceUrl,
-                    orgId: this.connection.getAuthInfoFields().orgId,
-                    username: this.connection.getUsername(),
-                    testRunId: asyncRunResult.runId,
-                    userId: testRunSummary.UserId
-                },
-                tests: testResults
-            };
-            if (codeCoverage) {
-                const perClassCovMap = yield this.codecoverage.getPerClassCodeCoverage(apexTestClassIdSet);
-                result.tests.forEach(item => {
-                    const keyCodeCov = `${item.apexClass.id}-${item.methodName}`;
-                    const perClassCov = perClassCovMap.get(keyCodeCov);
-                    // Skipped test is not in coverage map, check to see if perClassCov exists first
-                    if (perClassCov) {
-                        perClassCov.forEach(classCov => coveredApexClassIdSet.add(classCov.apexClassOrTriggerId));
-                        item.perClassCoverage = perClassCov;
-                    }
-                });
-                progress === null || progress === void 0 ? void 0 : progress.report({
-                    type: 'FormatTestResultProgress',
-                    value: 'queryingForAggregateCodeCoverage',
-                    message: i18n_1.nls.localize('queryingForAggregateCodeCoverage')
-                });
-                const { codeCoverageResults, totalLines, coveredLines } = yield this.codecoverage.getAggregateCodeCoverage(coveredApexClassIdSet);
-                result.codecoverage = codeCoverageResults;
-                result.summary.totalLines = totalLines;
-                result.summary.coveredLines = coveredLines;
-                result.summary.testRunCoverage = (0, utils_2.calculatePercentage)(coveredLines, totalLines);
-                result.summary.orgWideCoverage = yield this.codecoverage.getOrgWideCoverage();
-            }
-            return result;
-        });
-    }
-    getAsyncTestResults(testQueueResult) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let apexTestResultQuery = 'SELECT Id, QueueItemId, StackTrace, Message, ';
-            apexTestResultQuery +=
-                'RunTime, TestTimestamp, AsyncApexJobId, MethodName, Outcome, ApexLogId, ';
-            apexTestResultQuery +=
-                'ApexClass.Id, ApexClass.Name, ApexClass.NamespacePrefix ';
-            apexTestResultQuery += 'FROM ApexTestResult WHERE QueueItemId IN (%s)';
-            const apexResultIds = testQueueResult.records.map(record => record.Id);
-            // iterate thru ids, create query with id, & compare query length to char limit
-            const queries = [];
-            for (let i = 0; i < apexResultIds.length; i += constants_1.QUERY_RECORD_LIMIT) {
-                const recordSet = apexResultIds
-                    .slice(i, i + constants_1.QUERY_RECORD_LIMIT)
-                    .map(id => `'${id}'`);
-                const query = util.format(apexTestResultQuery, recordSet.join(','));
-                queries.push(query);
-            }
-            const queryPromises = queries.map(query => {
-                return this.connection.tooling.query(query, {
-                    autoFetch: true
-                });
+    async formatAsyncResults(asyncRunResult, commandStartTime, codeCoverage = false, testRunSummary, progress) {
+        const coveredApexClassIdSet = new Set();
+        const apexTestResults = await this.getAsyncTestResults(asyncRunResult.queueItem);
+        const { apexTestClassIdSet, testResults, globalTests } = await this.buildAsyncTestResults(apexTestResults);
+        let outcome = testRunSummary.Status;
+        if (globalTests.failed > 0) {
+            outcome = "Failed" /* ApexTestRunResultStatus.Failed */;
+        }
+        else if (globalTests.passed === 0) {
+            outcome = "Skipped" /* ApexTestRunResultStatus.Skipped */;
+        }
+        else if (testRunSummary.Status === "Completed" /* ApexTestRunResultStatus.Completed */) {
+            outcome = "Passed" /* ApexTestRunResultStatus.Passed */;
+        }
+        // TODO: deprecate testTotalTime
+        const result = {
+            summary: {
+                outcome,
+                testsRan: testResults.length,
+                passing: globalTests.passed,
+                failing: globalTests.failed,
+                skipped: globalTests.skipped,
+                passRate: (0, utils_2.calculatePercentage)(globalTests.passed, testResults.length),
+                failRate: (0, utils_2.calculatePercentage)(globalTests.failed, testResults.length),
+                skipRate: (0, utils_2.calculatePercentage)(globalTests.skipped, testResults.length),
+                testStartTime: (0, utils_1.formatStartTime)(testRunSummary.StartTime, 'ISO'),
+                testExecutionTimeInMs: testRunSummary.TestTime ?? 0,
+                testTotalTimeInMs: testRunSummary.TestTime ?? 0,
+                commandTimeInMs: (0, utils_1.getCurrentTime)() - commandStartTime,
+                hostname: this.connection.instanceUrl,
+                orgId: this.connection.getAuthInfoFields().orgId,
+                username: this.connection.getUsername(),
+                testRunId: asyncRunResult.runId,
+                userId: testRunSummary.UserId
+            },
+            tests: testResults
+        };
+        if (codeCoverage) {
+            const perClassCovMap = await this.codecoverage.getPerClassCodeCoverage(apexTestClassIdSet);
+            result.tests.forEach((item) => {
+                const keyCodeCov = `${item.apexClass.id}-${item.methodName}`;
+                const perClassCov = perClassCovMap.get(keyCodeCov);
+                // Skipped test is not in coverage map, check to see if perClassCov exists first
+                if (perClassCov) {
+                    perClassCov.forEach((classCov) => coveredApexClassIdSet.add(classCov.apexClassOrTriggerId));
+                    item.perClassCoverage = perClassCov;
+                }
+            });
+            progress?.report({
+                type: 'FormatTestResultProgress',
+                value: 'queryingForAggregateCodeCoverage',
+                message: i18n_1.nls.localize('queryingForAggregateCodeCoverage')
             });
-            const apexTestResults = yield Promise.all(queryPromises);
-            return apexTestResults;
+            const { codeCoverageResults, totalLines, coveredLines } = await this.codecoverage.getAggregateCodeCoverage(coveredApexClassIdSet);
+            result.codecoverage = codeCoverageResults;
+            result.summary.totalLines = totalLines;
+            result.summary.coveredLines = coveredLines;
+            result.summary.testRunCoverage = (0, utils_2.calculatePercentage)(coveredLines, totalLines);
+            result.summary.orgWideCoverage =
+                await this.codecoverage.getOrgWideCoverage();
+        }
+        return result;
+    }
+    async getAsyncTestResults(testQueueResult) {
+        let apexTestResultQuery = 'SELECT Id, QueueItemId, StackTrace, Message, ';
+        apexTestResultQuery +=
+            'RunTime, TestTimestamp, AsyncApexJobId, MethodName, Outcome, ApexLogId, ';
+        apexTestResultQuery +=
+            'ApexClass.Id, ApexClass.Name, ApexClass.NamespacePrefix ';
+        apexTestResultQuery += 'FROM ApexTestResult WHERE QueueItemId IN (%s)';
+        const apexResultIds = testQueueResult.records.map((record) => record.Id);
+        // iterate thru ids, create query with id, & compare query length to char limit
+        const queries = [];
+        for (let i = 0; i < apexResultIds.length; i += constants_1.QUERY_RECORD_LIMIT) {
+            const recordSet = apexResultIds
+                .slice(i, i + constants_1.QUERY_RECORD_LIMIT)
+                .map((id) => `'${id}'`);
+            const query = util.format(apexTestResultQuery, recordSet.join(','));
+            queries.push(query);
+        }
+        const queryPromises = queries.map((query) => {
+            return (0, utils_2.queryAll)(this.connection, query, true);
         });
+        const apexTestResults = await Promise.all(queryPromises);
+        return apexTestResults;
     }
-    buildAsyncTestResults(apexTestResults) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const apexTestClassIdSet = new Set();
-            let passed = 0;
-            let failed = 0;
-            let skipped = 0;
-            // Iterate over test results, format and add them as results.tests
-            const testResults = [];
-            for (const result of apexTestResults) {
-                result.records.forEach(item => {
-                    var _a;
-                    switch (item.Outcome) {
-                        case "Pass" /* Pass */:
-                            passed++;
-                            break;
-                        case "Fail" /* Fail */:
-                        case "CompileFail" /* CompileFail */:
-                            failed++;
-                            break;
-                        case "Skip" /* Skip */:
-                            skipped++;
-                            break;
-                    }
-                    apexTestClassIdSet.add(item.ApexClass.Id);
-                    // Can only query the FullName field if a single record is returned, so manually build the field
-                    item.ApexClass.FullName = item.ApexClass.NamespacePrefix
-                        ? `${item.ApexClass.NamespacePrefix}.${item.ApexClass.Name}`
-                        : item.ApexClass.Name;
-                    const diagnostic = item.Message || item.StackTrace ? (0, diagnosticUtil_1.getAsyncDiagnostic)(item) : null;
-                    testResults.push(Object.assign({ id: item.Id, queueItemId: item.QueueItemId, stackTrace: item.StackTrace, message: item.Message, asyncApexJobId: item.AsyncApexJobId, methodName: item.MethodName, outcome: item.Outcome, apexLogId: item.ApexLogId, apexClass: {
-                            id: item.ApexClass.Id,
-                            name: item.ApexClass.Name,
-                            namespacePrefix: item.ApexClass.NamespacePrefix,
-                            fullName: item.ApexClass.FullName
-                        }, runTime: (_a = item.RunTime) !== null && _a !== void 0 ? _a : 0, testTimestamp: item.TestTimestamp, fullName: `${item.ApexClass.FullName}.${item.MethodName}` }, (diagnostic ? { diagnostic } : {})));
+    async buildAsyncTestResults(apexTestResults) {
+        const apexTestClassIdSet = new Set();
+        let passed = 0;
+        let failed = 0;
+        let skipped = 0;
+        // Iterate over test results, format and add them as results.tests
+        const testResults = [];
+        for (const result of apexTestResults) {
+            result.records.forEach((item) => {
+                switch (item.Outcome) {
+                    case "Pass" /* ApexTestResultOutcome.Pass */:
+                        passed++;
+                        break;
+                    case "Fail" /* ApexTestResultOutcome.Fail */:
+                    case "CompileFail" /* ApexTestResultOutcome.CompileFail */:
+                        failed++;
+                        break;
+                    case "Skip" /* ApexTestResultOutcome.Skip */:
+                        skipped++;
+                        break;
+                }
+                apexTestClassIdSet.add(item.ApexClass.Id);
+                // Can only query the FullName field if a single record is returned, so manually build the field
+                item.ApexClass.FullName = item.ApexClass.NamespacePrefix
+                    ? `${item.ApexClass.NamespacePrefix}.${item.ApexClass.Name}`
+                    : item.ApexClass.Name;
+                const diagnostic = item.Message || item.StackTrace ? (0, diagnosticUtil_1.getAsyncDiagnostic)(item) : null;
+                testResults.push({
+                    id: item.Id,
+                    queueItemId: item.QueueItemId,
+                    stackTrace: item.StackTrace,
+                    message: item.Message,
+                    asyncApexJobId: item.AsyncApexJobId,
+                    methodName: item.MethodName,
+                    outcome: item.Outcome,
+                    apexLogId: item.ApexLogId,
+                    apexClass: {
+                        id: item.ApexClass.Id,
+                        name: item.ApexClass.Name,
+                        namespacePrefix: item.ApexClass.NamespacePrefix,
+                        fullName: item.ApexClass.FullName
+                    },
+                    runTime: item.RunTime ?? 0,
+                    testTimestamp: item.TestTimestamp, // TODO: convert timestamp
+                    fullName: `${item.ApexClass.FullName}.${item.MethodName}`,
+                    ...(diagnostic ? { diagnostic } : {})
                 });
-            }
-            return {
-                apexTestClassIdSet,
-                testResults,
-                globalTests: { passed, failed, skipped }
-            };
-        });
+            });
+        }
+        return {
+            apexTestClassIdSet,
+            testResults,
+            globalTests: { passed, failed, skipped }
+        };
     }
     /**
      * Abort test run with test run id
      * @param testRunId
      */
-    abortTestRun(testRunId, progress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            progress === null || progress === void 0 ? void 0 : progress.report({
-                type: 'AbortTestRunProgress',
-                value: 'abortingTestRun',
-                message: i18n_1.nls.localize('abortingTestRun', testRunId),
-                testRunId
-            });
-            const testQueueItems = yield this.connection.tooling.query(`SELECT Id, Status FROM ApexTestQueueItem WHERE ParentJobId = '${testRunId}'`);
-            for (const record of testQueueItems.records) {
-                record.Status = "Aborted" /* Aborted */;
-            }
-            yield this.connection.tooling.update('ApexTestQueueItem', testQueueItems.records);
-            progress === null || progress === void 0 ? void 0 : progress.report({
-                type: 'AbortTestRunProgress',
-                value: 'abortingTestRunRequested',
-                message: i18n_1.nls.localize('abortingTestRunRequested', testRunId),
-                testRunId
-            });
+    async abortTestRun(testRunId, progress) {
+        progress?.report({
+            type: 'AbortTestRunProgress',
+            value: 'abortingTestRun',
+            message: i18n_1.nls.localize('abortingTestRun', testRunId),
+            testRunId
+        });
+        const testQueueItems = await this.connection.tooling.query(`SELECT Id, Status FROM ApexTestQueueItem WHERE ParentJobId = '${testRunId}'`);
+        for (const record of testQueueItems.records) {
+            record.Status = "Aborted" /* ApexTestQueueItemStatus.Aborted */;
+        }
+        await this.connection.tooling.update('ApexTestQueueItem', testQueueItems.records);
+        progress?.report({
+            type: 'AbortTestRunProgress',
+            value: 'abortingTestRunRequested',
+            message: i18n_1.nls.localize('abortingTestRunRequested', testRunId),
+            testRunId
         });
     }
     getTestRunRequestAction(options) {
-        const requestTestRun = () => __awaiter(this, void 0, void 0, function* () {
+        const requestTestRun = async () => {
             const url = `${this.connection.tooling._baseUrl()}/runTestsAsynchronous`;
             const request = {
                 method: 'POST',
@@ -315,13 +303,13 @@ class AsyncTests {
                 headers: { 'content-type': 'application/json' }
             };
             try {
-                const testRunId = (yield this.connection.tooling.request(request));
+                const testRunId = (await this.connection.tooling.request(request));
                 return Promise.resolve(testRunId);
             }
             catch (e) {
                 return Promise.reject(e);
             }
-        });
+        };
         return requestTestRun;
     }
 }