feat: define solidity test sources in config

v-next/example-project/hardhat.config.ts

@@ -163,6 +163,7 @@ const config: HardhatUserConfig = {
     tests: {
       mocha: "test/mocha",
       nodeTest: "test/node",
+      solidity: "test/contracts",
     },
   },
   solidity: {

v-next/hardhat/src/internal/builtin-plugins/solidity-test/helpers.ts

@@ -1,66 +1,117 @@
-import type { ArtifactsManager } from "../../../types/artifacts.js";
-import type { Artifact } from "@ignored/edr";
+import type {
+  Artifact as HardhatArtifact,
+  BuildInfo,
+} from "../../../types/artifacts.js";
+import type {
+  CompilationJobCreationError,
+  FailedFileBuildResult,
+  FileBuildResult,
+} from "../../../types/solidity/build-system.js";
+import type {
+  ArtifactId as EdrArtifactId,
+  Artifact as EdrArtifact,
+} from "@ignored/edr";
 
-import { HardhatError } from "@ignored/hardhat-vnext-errors";
-import { exists } from "@ignored/hardhat-vnext-utils/fs";
-import { resolveFromRoot } from "@ignored/hardhat-vnext-utils/path";
+import path from "node:path";
 
-export async function getArtifacts(
-  hardhatArtifacts: ArtifactsManager,
-): Promise<Artifact[]> {
-  const fqns = await hardhatArtifacts.getAllFullyQualifiedNames();
-  const artifacts: Artifact[] = [];
+import { HardhatError } from "@ignored/hardhat-vnext-errors";
+import { readJsonFile } from "@ignored/hardhat-vnext-utils/fs";
 
-  for (const fqn of fqns) {
-    const hardhatArtifact = await hardhatArtifacts.readArtifact(fqn);
-    const buildInfo = await hardhatArtifacts.getBuildInfo(fqn);
+import { FileBuildResultType } from "../../../types/solidity/build-system.js";
 
-    if (buildInfo === undefined) {
-      throw new HardhatError(
-        HardhatError.ERRORS.SOLIDITY_TESTS.BUILD_INFO_NOT_FOUND_FOR_CONTRACT,
-        {
-          fqn,
-        },
-      );
-    }
+type SolidityBuildResults =
+  | Map<string, FileBuildResult>
+  | CompilationJobCreationError;
+type SuccessfulSolidityBuildResults = Map<
+  string,
+  Exclude<FileBuildResult, FailedFileBuildResult>
+>;
 
-    const id = {
-      name: hardhatArtifact.contractName,
-      solcVersion: buildInfo.solcVersion,
-      source: hardhatArtifact.sourceName,
-    };
+/**
+ * This function asserts that the given Solidity build results are successful.
+ * It throws a HardhatError if the build results indicate that the compilation
+ * job failed.
+ */
+export function throwIfSolidityBuildFailed(
+  results: SolidityBuildResults,
+): asserts results is SuccessfulSolidityBuildResults {
+  if ("reason" in results) {
+    throw new HardhatError(
+      HardhatError.ERRORS.SOLIDITY.COMPILATION_JOB_CREATION_ERROR,
+      {
+        reason: results.formattedReason,
+        rootFilePath: results.rootFilePath,
+        buildProfile: results.buildProfile,
+      },
+    );
+  }
 
-    const contract = {
-      abi: JSON.stringify(hardhatArtifact.abi),
-      bytecode: hardhatArtifact.bytecode,
-      deployedBytecode: hardhatArtifact.deployedBytecode,
-    };
+  const sucessful = [...results.values()].every(
+    ({ type }) =>
+      type === FileBuildResultType.CACHE_HIT ||
+      type === FileBuildResultType.BUILD_SUCCESS,
+  );
 
-    const artifact = { id, contract };
-    artifacts.push(artifact);
+  if (!sucessful) {
+    throw new HardhatError(HardhatError.ERRORS.SOLIDITY.BUILD_FAILED);
   }
-
-  return artifacts;
 }
 
-export async function isTestArtifact(
-  root: string,
-  artifact: Artifact,
-): Promise<boolean> {
-  const { source } = artifact.id;
+/**
+ * This function returns the artifacts generated during the compilation associated
+ * with the given Solidity build results. It relies on the fact that each successful
+ * build result has a corresponding artifact generated property.
+ */
+export async function getArtifacts(
+  results: SuccessfulSolidityBuildResults,
+  artifactsRootPath: string,
+): Promise<EdrArtifact[]> {
+  const artifacts: EdrArtifact[] = [];
 
-  if (!source.endsWith(".t.sol")) {
-    return false;
-  }
+  for (const [source, result] of results.entries()) {
+    for (const artifactPath of result.contractArtifactsGenerated) {
+      const artifact: HardhatArtifact = await readJsonFile(artifactPath);
+      const buildInfo: BuildInfo = await readJsonFile(
+        path.join(artifactsRootPath, "build-info", `${result.buildId}.json`),
+      );
 
-  // NOTE: We also check whether the file exists in the workspace to filter out
-  // the artifacts from node modules.
-  const sourcePath = resolveFromRoot(root, source);
-  const sourceExists = await exists(sourcePath);
+      const id = {
+        name: artifact.contractName,
+        solcVersion: buildInfo.solcVersion,
+        source,
+      };
 
-  if (!sourceExists) {
-    return false;
+      const contract = {
+        abi: JSON.stringify(artifact.abi),
+        bytecode: artifact.bytecode,
+        deployedBytecode: artifact.deployedBytecode,
+      };
+
+      artifacts.push({
+        id,
+        contract,
+      });
+    }
   }
 
-  return true;
+  return artifacts;
+}
+
+/**
+ * This function returns the test suite ids associated with the given artifacts.
+ * The test suite ID is the relative path of the test file, relative to the
+ * project root.
+ */
+export async function getTestSuiteIds(
+  artifacts: EdrArtifact[],
+  rootTestFilePaths: string[],
+  projectRoot: string,
+): Promise<EdrArtifactId[]> {
+  const testSources = rootTestFilePaths.map((p) =>
+    path.relative(projectRoot, p),
+  );
+
+  return artifacts
+    .map(({ id }) => id)
+    .filter(({ source }) => testSources.includes(source));
 }

v-next/hardhat/src/internal/builtin-plugins/solidity-test/hook-handlers/config.ts

@@ -0,0 +1,61 @@
+import type { ConfigHooks } from "@ignored/hardhat-vnext/types/hooks";
+
+import { isObject } from "@ignored/hardhat-vnext-utils/lang";
+import { resolveFromRoot } from "@ignored/hardhat-vnext-utils/path";
+import {
+  conditionalUnionType,
+  validateUserConfigZodType,
+} from "@ignored/hardhat-vnext-zod-utils";
+import { z } from "zod";
+
+const userConfigType = z.object({
+  paths: z
+    .object({
+      test: conditionalUnionType(
+        [
+          [isObject, z.object({ solidity: z.string().optional() })],
+          [(data) => typeof data === "string", z.string()],
+        ],
+        "Expected a string or an object with an optional 'solidity' property",
+      ).optional(),
+    })
+    .optional(),
+});
+
+export default async (): Promise<Partial<ConfigHooks>> => {
+  const handlers: Partial<ConfigHooks> = {
+    validateUserConfig: async (userConfig) => {
+      return validateUserConfigZodType(userConfig, userConfigType);
+    },
+    resolveUserConfig: async (
+      userConfig,
+      resolveConfigurationVariable,
+      next,
+    ) => {
+      const resolvedConfig = await next(
+        userConfig,
+        resolveConfigurationVariable,
+      );
+
+      let testsPath = userConfig.paths?.tests;
+
+      // TODO: use isObject when the type narrowing issue is fixed
+      testsPath =
+        typeof testsPath === "object" ? testsPath.solidity : testsPath;
+      testsPath ??= "test";
+
+      return {
+        ...resolvedConfig,
+        paths: {
+          ...resolvedConfig.paths,
+          tests: {
+            ...resolvedConfig.paths.tests,
+            solidity: resolveFromRoot(resolvedConfig.paths.root, testsPath),
+          },
+        },
+      };
+    },
+  };
+
+  return handlers;
+};

v-next/hardhat/src/internal/builtin-plugins/solidity-test/index.ts

@@ -3,8 +3,13 @@ import type { HardhatPlugin } from "../../../types/plugins.js";
 import { ArgumentType } from "../../../types/arguments.js";
 import { task } from "../../core/config.js";
 
+import "./type-extensions.js";
+
 const hardhatPlugin: HardhatPlugin = {
   id: "builtin:solidity-tests",
+  hookHandlers: {
+    config: import.meta.resolve("./hook-handlers/config.js"),
+  },
   tasks: [
     task(["test", "solidity"], "Run the Solidity tests")
       .setAction(import.meta.resolve("./task-action.js"))

v-next/hardhat/src/internal/builtin-plugins/solidity-test/task-action.ts

@@ -1,12 +1,20 @@
 import type { RunOptions } from "./runner.js";
 import type { TestEvent } from "./types.js";
+import type { BuildOptions } from "../../../types/solidity/build-system.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 
 import { finished } from "node:stream/promises";
 
+import { getAllFilesMatching } from "@ignored/hardhat-vnext-utils/fs";
 import { createNonClosingWriter } from "@ignored/hardhat-vnext-utils/stream";
 
-import { getArtifacts, isTestArtifact } from "./helpers.js";
+import { shouldMergeCompilationJobs } from "../solidity/build-profiles.js";
+
+import {
+  getArtifacts,
+  getTestSuiteIds,
+  throwIfSolidityBuildFailed,
+} from "./helpers.js";
 import { testReporter } from "./reporter.js";
 import { run } from "./runner.js";
 
@@ -16,28 +24,44 @@ interface TestActionArguments {
 }
 
 const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
-  { timeout, noCompile },
+  { timeout },
   hre,
 ) => {
-  if (!noCompile) {
-    await hre.tasks.getTask("compile").run({});
-    console.log();
-  }
-
-  const artifacts = await getArtifacts(hre.artifacts);
-  const testSuiteIds = (
-    await Promise.all(
-      artifacts.map(async (artifact) => {
-        if (await isTestArtifact(hre.config.paths.root, artifact)) {
-          return artifact.id;
-        }
+  const rootSourceFilePaths = await hre.solidity.getRootFilePaths();
+  // NOTE: A test file is either a file with a `.sol` extension in the `tests.solidity`
+  // directory or a file with a `.t.sol` extension in the `sources.solidity` directory
+  const rootTestFilePaths = (
+    await Promise.all([
+      getAllFilesMatching(hre.config.paths.tests.solidity, (f) =>
+        f.endsWith(".sol"),
+      ),
+      ...hre.config.paths.sources.solidity.map(async (dir) => {
+        return getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
       }),
-    )
-  ).filter((artifact) => artifact !== undefined);
+    ])
+  ).flat(1);
+
+  const buildOptions: BuildOptions = {
+    force: false,
+    buildProfile: hre.globalOptions.buildProfile,
+    mergeCompilationJobs: shouldMergeCompilationJobs(
+      hre.globalOptions.buildProfile,
+    ),
+    quiet: false,
+  };
 
-  if (testSuiteIds.length === 0) {
-    return;
-  }
+  // NOTE: We compile all the sources together with the tests
+  const rootFilePaths = [...rootSourceFilePaths, ...rootTestFilePaths];
+  const results = await hre.solidity.build(rootFilePaths, buildOptions);
+
+  throwIfSolidityBuildFailed(results);
+
+  const artifacts = await getArtifacts(results, hre.config.paths.artifacts);
+  const testSuiteIds = await getTestSuiteIds(
+    artifacts,
+    rootTestFilePaths,
+    hre.config.paths.root,
+  );
 
   console.log("Running Solidity tests");
   console.log();

v-next/hardhat/src/internal/builtin-plugins/solidity-test/type-extensions.ts

@@ -0,0 +1,11 @@
+import "@ignored/hardhat-vnext/types/config";
+
+declare module "@ignored/hardhat-vnext/types/config" {
+  export interface TestPathsUserConfig {
+    solidity?: string;
+  }
+
+  export interface TestPathsConfig {
+    solidity: string;
+  }
+}

v-next/hardhat/src/internal/builtin-plugins/solidity/build-system/build-system.ts

@@ -67,7 +67,7 @@ export interface SolidityBuildSystemOptions {
 
 export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   readonly #options: SolidityBuildSystemOptions;
-  readonly #defaultConcurrenty = Math.max(os.cpus().length - 1, 1);
+  readonly #defaultConcurrency = Math.max(os.cpus().length - 1, 1);
   #downloadedCompilers = false;
 
   constructor(options: SolidityBuildSystemOptions) {
@@ -78,7 +78,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     const localFilesToCompile = (
       await Promise.all(
         this.#options.soliditySourcesPaths.map((dir) =>
-          getAllFilesMatching(dir, (f) => f.endsWith(".sol")),
+          getAllFilesMatching(
+            dir,
+            (f) => f.endsWith(".sol") && !f.endsWith(".t.sol"),
+          ),
         ),
       )
     ).flat(1);
@@ -118,7 +121,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       compilationJobs,
       (compilationJob) => this.runCompilationJob(compilationJob),
       {
-        concurrency: options?.concurrency ?? this.#defaultConcurrenty,
+        concurrency: options?.concurrency ?? this.#defaultConcurrency,
         // An error when running the compiler is not a compilation failure, but
         // a fatal failure trying to run it, so we just throw on the first error
         stopOnError: true,

v-next/hardhat/src/types/solidity/build-system.ts

@@ -149,7 +149,11 @@ export interface CacheHitFileBuildResult {
   type: FileBuildResultType.CACHE_HIT;
   // TODO: Should we remove this? It is a buildId of an already existing build
   // info.
+  // NOTE: The buildId and contractArtifactsGenerated are useful when one uses
+  // the build system programatically and wants to find out what artifacts
+  // were generated for a given file, and with what configuration.
   buildId: string;
+  contractArtifactsGenerated: string[];
 }
 
 export interface SuccessfulFileBuildResult {
@@ -265,7 +269,7 @@ export interface SolidityBuildSystem {
    * This method should only be used after a complete build has succeeded, as
    * it relies on the build system to have generated all the necessary artifact
    * files.
-   
+
    * @param rootFilePaths All the root files of the project.
    */
   cleanupArtifacts(rootFilePaths: string[]): Promise<void>;