hardhat 3.1.10 → 3.1.11

package/src/internal/builtin-plugins/solidity/build-system/solc-config-selection.ts

@@ -18,19 +18,17 @@ export class SolcConfigSelector {
 
   /**
    * Creates a new SolcConfigSelector that can be used to select the best solc
-   * configuration for subgraphs of the given dependency graph.
+   * configuration for single-root subgraphs to create their respective
+   * individual compilation jobs.
    *
-   * All the queries are done in the context of the given dependency graph, and
-   * using the same build profile.
+   * All the queries use the same build profile.
    *
    * @param buildProfileName The name of the build profile to use.
    * @param buildProfile  The build profile config.
-   * @param _dependencyGraph The entire dependency graph of the project.
    */
   constructor(
     buildProfileName: string,
     buildProfile: SolidityBuildProfileConfig,
-    _dependencyGraph: DependencyGraph,
   ) {
     this.#buildProfileName = buildProfileName;
     this.#buildProfile = buildProfile;
@@ -46,7 +44,7 @@ export class SolcConfigSelector {
    */
   public selectBestSolcConfigForSingleRootGraph(
     subgraph: DependencyGraph,
-  ): SolcConfig | CompilationJobCreationError {
+  ): { success: true; config: SolcConfig } | CompilationJobCreationError {
     const roots = subgraph.getRoots();
 
     assertHardhatInvariant(
@@ -56,11 +54,11 @@ export class SolcConfigSelector {
 
     const [userSourceName, root] = [...roots.entries()][0];
 
-    const allVersionPragamas = [...subgraph.getAllFiles()]
+    const allVersionPragmas = [...subgraph.getAllFiles()]
       .map(({ content }) => content.versionPragmas)
       .flat(1);
 
-    const versionRange = Array.from(new Set(allVersionPragamas)).join(" ");
+    const versionRange = Array.from(new Set(allVersionPragmas)).join(" ");
 
     const overriddenCompiler = this.#buildProfile.overrides[userSourceName];
 
@@ -75,7 +73,7 @@ export class SolcConfigSelector {
         );
       }
 
-      return overriddenCompiler;
+      return { success: true, config: overriddenCompiler };
     }
 
     // if there's no override, we find a compiler that matches the version range
@@ -100,9 +98,21 @@ export class SolcConfigSelector {
       `Matching config not found for version '${matchingVersion.toString()}'`,
     );
 
-    return matchingConfig;
+    return { success: true, config: matchingConfig };
   }
 
+  /**
+   * Returns a description of why we couldn't get a compiler configuration for
+   * the given root file and dependency subgraph.
+   *
+   * @param root The root file that created the single-root dependency subgraph
+   * @param dependencyGraph The dependency subgraph we couldn't get a compiler
+   *   configuration for
+   * @param compilerVersions The compiler versions that are configured for the
+   *   selected build profile. For overridden roots, it's a single one.
+   * @param overridden True if the root has an overridden config.
+   * @returns The error why we couldn't get a compiler configuration.
+   */
   #getCompilationJobCreationError(
     root: ResolvedFile,
     dependencyGraph: DependencyGraph,
@@ -110,27 +120,70 @@ export class SolcConfigSelector {
     overridden: boolean,
   ): CompilationJobCreationError {
     const rootVersionRange = root.content.versionPragmas.join(" ");
-    if (maxSatisfying(compilerVersions, rootVersionRange) === null) {
-      let reason: CompilationJobCreationErrorReason;
-      let formattedReason: string;
-      if (overridden) {
-        reason =
-          CompilationJobCreationErrorReason.INCOMPATIBLE_OVERRIDDEN_SOLC_VERSION;
-        formattedReason = `An override with incompatible solc version was found for this file.`;
-      } else {
-        reason =
-          CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_WITH_ROOT;
-        formattedReason = `No solc version enabled in this profile is compatible with this file.`;
+
+    // This logic is pretty different depending if we are dealing with a config
+    // override or not. If we are, we have a single compiler option, so things
+    // are simpler.
+
+    if (overridden) {
+      // The root may not be compatible with the override version
+      if (maxSatisfying(compilerVersions, rootVersionRange) === null) {
+        return {
+          success: false,
+          reason:
+            CompilationJobCreationErrorReason.INCOMPATIBLE_OVERRIDDEN_SOLC_VERSION,
+          rootFilePath: root.fsPath,
+          buildProfile: this.#buildProfileName,
+          formattedReason: `An override with incompatible solc version was found for this file.`,
+        };
       }
 
+      // A transitive dependency can have a pragma that's incompatible with
+      // the overridden version.
+      for (const transitiveDependency of this.#getTransitiveDependencies(
+        root,
+        dependencyGraph,
+      )) {
+        const depOwnRange =
+          transitiveDependency.dependency.content.versionPragmas.join(" ");
+
+        if (maxSatisfying(compilerVersions, depOwnRange) === null) {
+          return {
+            success: false,
+            reason:
+              CompilationJobCreationErrorReason.OVERRIDDEN_SOLC_VERSION_INCOMPATIBLE_WITH_DEPENDENCY,
+            rootFilePath: root.fsPath,
+            buildProfile: this.#buildProfileName,
+            incompatibleImportPath: transitiveDependency.fsPath,
+            formattedReason: `The compiler version override is incompatible with a dependency of this file:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
+          };
+        }
+      }
+
+      // There's no other case. If the root and all the dependencies are
+      // compatible, and we still can choose a version, we have a bug.
+      /* c8 ignore next 5 */
+      assertHardhatInvariant(
+        false,
+        "Trying to get the error for an overridden solidity file that has no compatible config, but failed to detect it, as the root and all the dependencies are compatible with the overridden compiler config.",
+      );
+    }
+
+    // Non-overridden case: we first check if the root is compatible with any
+    // configured compiler
+    if (maxSatisfying(compilerVersions, rootVersionRange) === null) {
       return {
-        reason,
+        success: false,
+        reason:
+          CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_WITH_ROOT,
         rootFilePath: root.fsPath,
         buildProfile: this.#buildProfileName,
-        formattedReason,
+        formattedReason: `No solc version enabled in this profile is compatible with this file.`,
       };
     }
 
+    // We check all the transitive dependencies of the root to try to return
+    // the most specific error that we can.
     for (const transitiveDependency of this.#getTransitiveDependencies(
       root,
       dependencyGraph,
@@ -140,21 +193,59 @@ export class SolcConfigSelector {
           .map((pragmas) => pragmas.join(" "))
           .join(" ");
 
+      const depOwnRange =
+        transitiveDependency.dependency.content.versionPragmas.join(" ");
+
+      // A transitive dependency can have a pragma that's incompatible with
+      // all the configured compilers
+      if (maxSatisfying(compilerVersions, depOwnRange) === null) {
+        return {
+          success: false,
+          reason:
+            CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_WITH_DEPENDENCY,
+          rootFilePath: root.fsPath,
+          buildProfile: this.#buildProfileName,
+          incompatibleImportPath: transitiveDependency.fsPath,
+          formattedReason: `No solc version enabled in this profile is compatible with a dependency of this file:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
+        };
+      }
+
+      // The root and the version ranges to get to this transitive dependency
+      // may be contradictory, so no version ever can satisfy them.
       if (!intersects(rootVersionRange, transitiveDependencyVersionRange)) {
         return {
+          success: false,
           reason: CompilationJobCreationErrorReason.IMPORT_OF_INCOMPATIBLE_FILE,
           rootFilePath: root.fsPath,
           buildProfile: this.#buildProfileName,
           incompatibleImportPath: transitiveDependency.fsPath,
-          formattedReason: `Following these imports leads to an incompatible solc version pragma that no version can satisfy:
-  * ${shortenPath(root.fsPath)}
-  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}
-`,
+          formattedReason: `Following these imports leads to an incompatible solc version pragma that no version can satisfy:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
+        };
+      }
+
+      // The root and the version ranges to get to this transitive dependency
+      // may not be compatible with any configured compiler.
+      const combinedRange = `${rootVersionRange} ${transitiveDependencyVersionRange}`;
+      if (maxSatisfying(compilerVersions, combinedRange) === null) {
+        return {
+          success: false,
+          reason:
+            CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_FOR_TRANSITIVE_IMPORT_PATH,
+          rootFilePath: root.fsPath,
+          buildProfile: this.#buildProfileName,
+          incompatibleImportPath: transitiveDependency.fsPath,
+          formattedReason: `No solc version enabled in this profile is compatible with this file and this import path:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
         };
       }
     }
 
+    // This is a generic case that can happen when the incompatibilities exist
+    // but we can't detect them with the above algorithm. For example, if a
+    // root imports two compatible dependencies that are incompatible with each
+    // other. We could try and improve this error message, but it's
+    // computationally expensive and hard to express to the users.
     return {
+      success: false,
       reason:
         CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_FOUND,
       rootFilePath: root.fsPath,
@@ -163,6 +254,12 @@ export class SolcConfigSelector {
     };
   }
 
+  /**
+   * Returns a generator of all the transitive dependencies of a root file. For each
+   * dependency, it yields the sequence of fsPaths from the root to that dependency,
+   * along with the corresponding version pragma paths for each file in the import chain.
+   * The paths don't include the root itself.
+   */
   *#getTransitiveDependencies(
     root: ResolvedFile,
     dependencyGraph: DependencyGraph,
@@ -179,7 +276,7 @@ export class SolcConfigSelector {
         continue;
       }
 
-      visited.add(file);
+      visited = new Set([...visited, file]);
 
       yield {
         fsPath: [file.fsPath],

package/src/internal/builtin-plugins/solidity/config.ts

@@ -124,7 +124,7 @@ const buildProfilesSolidityUserConfigType = commonSolidityUserConfigType.extend(
   },
 );
 
-const soldityUserConfigType = conditionalUnionType(
+const solidityUserConfigType = conditionalUnionType(
   [
     [(data) => typeof data === "string", z.string()],
     [(data) => Array.isArray(data), z.array(z.string()).nonempty()],
@@ -159,7 +159,7 @@ const userConfigType = z.object({
       ).optional(),
     })
     .optional(),
-  solidity: soldityUserConfigType.optional(),
+  solidity: solidityUserConfigType.optional(),
 });
 
 export function validateSolidityUserConfig(

package/src/internal/builtin-plugins/solidity/hook-handlers/hre.ts

@@ -46,6 +46,14 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     return buildSystem.getScope(fsPath);
   }
 
+  public isSuccessfulBuildResult(
+    buildResult: CompilationJobCreationError | Map<string, FileBuildResult>,
+  ): buildResult is Map<string, FileBuildResult> {
+    // Note: This duplicates the logic of the actual implementation because it's
+    // a synchronous method, so we can't import the implementation.
+    return buildResult instanceof Map;
+  }
+
   public async build(
     rootFiles: string[],
     options?: BuildOptions,

package/src/internal/builtin-plugins/solidity/tasks/build.ts

@@ -110,7 +110,7 @@ async function buildForScope(
     scope,
   });
 
-  throwIfSolidityBuildFailed(results);
+  throwIfSolidityBuildFailed(solidity, results);
 
   // If we recompiled the entire project we cleanup the artifacts
   if (isFullCompilation) {

package/src/internal/builtin-plugins/solidity-test/edr-artifacts.ts

@@ -60,7 +60,7 @@ export async function getBuildInfos(
  */
 export async function getEdrArtifacts(
   artifactManager: ArtifactManager,
-): Promise<Array<{ edrAtifact: EdrArtifact; userSourceName: string }>> {
+): Promise<Array<{ edrArtifact: EdrArtifact; userSourceName: string }>> {
   const fullyQualifiedNames = await artifactManager.getAllFullyQualifiedNames();
 
   const artifacts = await Promise.all(
@@ -140,7 +140,7 @@ export async function getEdrArtifacts(
     // from an artifact id between the `run` call and the events emitted by the
     // test runner.
     return {
-      edrAtifact: {
+      edrArtifact: {
         id,
         contract,
       },

package/src/internal/builtin-plugins/solidity-test/runner.ts

@@ -38,7 +38,7 @@ export interface RunOptions {
  * Despite the changes, the signature of the function should still be considered
  * a draft that may change in the future.
  *
- * TODO: Once the signature is finalised, give feedback to the EDR team.
+ * TODO: Once the signature is finalized, give feedback to the EDR team.
  */
 export function run(
   chainType: ChainType,

package/src/internal/builtin-plugins/solidity-test/task-action.ts

@@ -1,6 +1,8 @@
 import type { RunOptions } from "./runner.js";
 import type { TestEvent } from "./types.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
+import type { TestSummary } from "../../../types/test.js";
+import type { Result } from "../../../types/utils.js";
 import type {
   Artifact as EdrArtifact,
   BuildInfoAndOutput,
@@ -19,19 +21,10 @@ import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import { createNonClosingWriter } from "@nomicfoundation/hardhat-utils/stream";
 
 import { getFullyQualifiedName } from "../../../utils/contract-names.js";
+import { errorResult, successfulResult } from "../../../utils/result.js";
 import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
 import { ArtifactManagerImplementation } from "../artifacts/artifact-manager.js";
-import {
-  markTestRunStart as initCoverage,
-  markTestWorkerDone as saveCoverageData,
-  markTestRunDone as reportCoverage,
-} from "../coverage/helpers.js";
-import {
-  markTestRunStart as initGasStats,
-  markTestWorkerDone as saveGasStatsData,
-  markTestRunDone as reportGasStats,
-} from "../gas-analytics/helpers.js";
 import { edrGasReportToHardhatGasMeasurements } from "../network-manager/edr/utils/convert-to-edr.js";
 
 import { getEdrArtifacts, getBuildInfos } from "./edr-artifacts.js";
@@ -56,7 +49,7 @@ interface TestActionArguments {
 const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   { testFiles, chainType, grep, noCompile, verbosity, testSummaryIndex },
   hre,
-) => {
+): Promise<Result<TestSummary, TestSummary>> => {
   assertHardhatInvariant(
     hre instanceof HardhatRuntimeEnvironmentImplementation,
     "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
@@ -98,7 +91,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
 
   // EDR needs all artifacts (contracts + tests)
   const edrArtifacts: Array<{
-    edrAtifact: EdrArtifact;
+    edrArtifact: EdrArtifact;
     userSourceName: string;
   }> = [];
   const buildInfos: BuildInfoAndOutput[] = [];
@@ -110,20 +103,20 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   }
 
   const sourceNameToUserSourceName = new Map(
-    edrArtifacts.map(({ userSourceName, edrAtifact }) => [
-      edrAtifact.id.source,
+    edrArtifacts.map(({ userSourceName, edrArtifact }) => [
+      edrArtifact.id.source,
       userSourceName,
     ]),
   );
 
-  edrArtifacts.forEach(({ userSourceName, edrAtifact }) => {
+  edrArtifacts.forEach(({ userSourceName, edrArtifact }) => {
     if (
       testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ) &&
-      isTestSuiteArtifact(edrAtifact)
+      isTestSuiteArtifact(edrArtifact)
     ) {
-      warnDeprecatedTestFail(edrAtifact, sourceNameToUserSourceName);
+      warnDeprecatedTestFail(edrArtifact, sourceNameToUserSourceName);
     }
   });
 
@@ -133,8 +126,8 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ),
     )
-    .filter(({ edrAtifact }) => isTestSuiteArtifact(edrAtifact))
-    .map(({ edrAtifact }) => edrAtifact.id);
+    .filter(({ edrArtifact }) => isTestSuiteArtifact(edrArtifact))
+    .map(({ edrArtifact }) => edrArtifact.id);
 
   console.log("Running Solidity tests");
   console.log();
@@ -186,12 +179,16 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   const options: RunOptions =
     solidityTestConfigToRunOptions(solidityTestConfig);
 
-  await initCoverage("solidity");
-  await initGasStats("solidity");
+  await hre.hooks.runHandlerChain(
+    "test",
+    "onTestRunStart",
+    ["solidity"],
+    async () => {},
+  );
 
   const runStream = run(
     chainType,
-    edrArtifacts.map(({ edrAtifact }) => edrAtifact),
+    edrArtifacts.map(({ edrArtifact }) => edrArtifact),
     testSuiteIds,
     config,
     tracingConfig,
@@ -271,26 +268,27 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     includesErrors = true;
   }
 
-  await saveCoverageData("solidity");
-  await saveGasStatsData("solidity");
-
-  // this may print coverage and gas statistics reports
-  await reportCoverage("solidity");
-  await reportGasStats("solidity");
+  await hre.hooks.runHandlerChain(
+    "test",
+    "onTestWorkerDone",
+    ["solidity"],
+    async () => {},
+  );
 
-  if (includesFailures || includesErrors) {
-    process.exitCode = 1;
-  }
+  await hre.hooks.runHandlerChain(
+    "test",
+    "onTestRunDone",
+    ["solidity"],
+    async () => {},
+  );
 
   console.log();
 
-  return {
-    failed,
-    passed,
-    skipped,
-    todo: 0,
-    failureOutput,
-  };
+  const summary = { failed, passed, skipped, todo: 0, failureOutput };
+
+  return includesFailures || includesErrors
+    ? errorResult(summary)
+    : successfulResult(summary);
 };
 
 export default runSolidityTests;

package/src/internal/builtin-plugins/telemetry/task-action.ts

@@ -1,5 +1,6 @@
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 
+import { errorResult, successfulResult } from "../../../utils/result.js";
 import {
   isTelemetryAllowed,
   setTelemetryEnabled,
@@ -15,8 +16,7 @@ const configureTelemetry: NewTaskActionFunction<
 > = async ({ enable, disable }) => {
   if (enable && disable) {
     console.error("Cannot enable and disable telemetry at the same time");
-    process.exitCode = 1;
-    return;
+    return errorResult();
   }
 
   if (enable) {
@@ -40,6 +40,8 @@ const configureTelemetry: NewTaskActionFunction<
       "Telemetry is disabled, to enable it run `npx hardhat telemetry --enable`",
     );
   }
+
+  return successfulResult();
 };
 
 export default configureTelemetry;

package/src/internal/builtin-plugins/test/task-action.ts

@@ -4,13 +4,21 @@ import type {
   Task,
   TaskArguments,
 } from "../../../types/tasks.js";
+import type { TestSummary } from "../../../types/test.js";
+import type { Result } from "../../../types/utils.js";
 
 import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import chalk, { type ChalkInstance } from "chalk";
 
+import {
+  errorResult,
+  isResult,
+  successfulResult,
+} from "../../../utils/result.js";
 import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
 
 interface TestActionArguments {
@@ -21,10 +29,27 @@ interface TestActionArguments {
   verbosity: number;
 }
 
+// Old plugins may only return { failed, passed } without skipped/todo,
+// so we accept a partial shape and fill defaults in the coordinator.
+interface PartialTestSummary extends Omit<TestSummary, "skipped" | "todo"> {
+  skipped?: number;
+  todo?: number;
+}
+
+function isTestSummary(value: unknown): value is PartialTestSummary {
+  return (
+    isObject(value) &&
+    typeof value.failed === "number" &&
+    typeof value.passed === "number" &&
+    (value.skipped === undefined || typeof value.skipped === "number") &&
+    (value.todo === undefined || typeof value.todo === "number")
+  );
+}
+
 const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
   { testFiles, chainType, grep, noCompile, verbosity },
   hre,
-) => {
+): Promise<Result<void, void>> => {
   // If this code is executed, it means the user has not specified a test runner.
   // If file paths are specified, we need to determine which test runner applies to each test file.
   // If no file paths are specified, each test runner will execute all tests located under its configured path in the Hardhat configuration.
@@ -49,18 +74,10 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
     hre._coverage.disableReport();
   }
 
-  const testSummaries: Record<
-    string,
-    {
-      failed?: number;
-      passed?: number;
-      skipped?: number;
-      todo?: number;
-      failureOutput?: string;
-    }
-  > = {};
+  const testSummaries: Record<string, TestSummary> = {};
 
   let failureIndex = 1;
+  let hasFailures = false;
   for (const subtask of thisTask.subtasks.values()) {
     const files = getTestFilesForSubtask(subtask, testFiles, subtasksToFiles);
 
@@ -84,18 +101,45 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
       args.verbosity = verbosity;
     }
 
-    const summaryId = subtask.id[subtask.id.length - 1];
-
     if (subtask.options.has("testSummaryIndex")) {
       args.testSummaryIndex = failureIndex;
+    }
+
+    const subtaskResult = await subtask.run(args);
 
-      testSummaries[summaryId] = await subtask.run(args);
-      failureIndex += testSummaries[summaryId].failed ?? 0;
-    } else if (summaryId === "mocha") {
-      // mocha doesn't use the testSummaryIndex, but it does return failure & success counts
-      testSummaries[summaryId] = await subtask.run(args);
-    } else {
-      await subtask.run(args);
+    const isSubtaskResult = isResult(
+      subtaskResult,
+      isTestSummary,
+      isTestSummary,
+    );
+    const summary = isSubtaskResult
+      ? subtaskResult.success
+        ? subtaskResult.value
+        : subtaskResult.error
+      : isTestSummary(subtaskResult)
+        ? subtaskResult
+        : undefined;
+
+    if (summary !== undefined) {
+      const summaryId = subtask.id[subtask.id.length - 1];
+      testSummaries[summaryId] = {
+        skipped: 0,
+        todo: 0,
+        ...summary,
+      };
+
+      if (subtask.options.has("testSummaryIndex")) {
+        failureIndex += summary.failed;
+      }
+    }
+
+    if (
+      (isSubtaskResult && !subtaskResult.success) ||
+      // Backwards compatibility: old plugins may not return a Result, so fall
+      // back to the process exit code to detect failures
+      (process.exitCode !== undefined && process.exitCode !== 0)
+    ) {
+      hasFailures = true;
     }
   }
 
@@ -106,19 +150,19 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
   const outputLines: string[] = [];
 
   for (const [subtaskName, results] of Object.entries(testSummaries)) {
-    if (results.passed !== undefined && results.passed > 0) {
+    if (results.passed > 0) {
       passed.push([subtaskName, results.passed]);
     }
 
-    if (results.failed !== undefined && results.failed > 0) {
+    if (results.failed > 0) {
       failed.push([subtaskName, results.failed]);
     }
 
-    if (results.skipped !== undefined && results.skipped > 0) {
+    if (results.skipped > 0) {
       skipped.push([subtaskName, results.skipped]);
     }
 
-    if (results.todo !== undefined && results.todo > 0) {
+    if (results.todo > 0) {
       todo.push([subtaskName, results.todo]);
     }
 
@@ -176,9 +220,11 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
     console.log();
   }
 
-  if (process.exitCode !== undefined && process.exitCode !== 0) {
+  if (hasFailures) {
     console.error("Test run failed");
   }
+
+  return hasFailures ? errorResult() : successfulResult();
 };
 
 function logSummaryLine(