fix: do not use stdio nor global cache dir during console tests

Author: galargh

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

@@ -7,6 +7,11 @@ const hardhatPlugin: HardhatPlugin = {
   tasks: [
     task("console", "Opens a hardhat console")
       .setAction(import.meta.resolve("./task-action.js"))
+      .addOption({
+        name: "history",
+        description: "Path to a history file",
+        defaultValue: "console-history.txt",
+      })
       .addVariadicArgument({
         name: "commands",
         description: "Commands to run in the console",

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

@@ -11,35 +11,47 @@ const log = debug("hardhat:core:tasks:console");
 
 interface ConsoleActionArguments {
   commands: string[];
+  history: string;
+  // We accept ReplOptions as an argument to allow tests overriding the IO streams
+  options?: repl.ReplOptions;
 }
 
 const consoleAction: NewTaskActionFunction<ConsoleActionArguments> = async (
-  { commands },
+  { commands, history, options },
   _hre,
 ) => {
-  const globalCacheDir = await getCacheDir();
+  // Resolve the history path if it is not empty
+  let historyPath: string | undefined;
+  if (history !== "") {
+    const globalCacheDir = await getCacheDir();
+    historyPath = path.isAbsolute(history)
+      ? history
+      : path.resolve(globalCacheDir, history);
+  }
 
   return new Promise<REPLServer>((resolve) => {
     // Start a new REPL server with the default options
-    const replServer = repl.start();
-
-    // Set up the REPL history file in the global cache directory
-    const historyPath = path.join(globalCacheDir, "console-history.txt");
-    replServer.setupHistory(historyPath, (err: Error | null) => {
-      if (err !== null) {
-        log(`Failed to setup REPL history: ${err.message}`);
-      }
+    const replServer = repl.start(options);
+
+    // Resolve the task action promise only when the REPL server exits
+    replServer.on("exit", () => {
+      resolve(replServer);
     });
 
+    // Set up the REPL history file if the historyPath has been set
+    if (historyPath !== undefined) {
+      replServer.setupHistory(historyPath, (err: Error | null) => {
+        // Fail silently if the history file cannot be set up
+        if (err !== null) {
+          log(`Failed to setup REPL history: ${err.message}`);
+        }
+      });
+    }
+
     // Execute each command in the REPL server
     for (const command of commands) {
       replServer.write(`${command}\n`);
     }
-
-    // Resolve the task action promise when the REPL server exits
-    replServer.on("exit", () => {
-      resolve(replServer);
-    });
   });
 };
 

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

@@ -1,7 +1,12 @@
 import type { HardhatRuntimeEnvironment } from "@ignored/hardhat-vnext-core/types/hre";
+import type repl from "node:repl";
 
 import assert from "node:assert/strict";
-import { before, describe, it } from "node:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { PassThrough } from "node:stream";
+import { afterEach, before, beforeEach, describe, it } from "node:test";
 
 import { ensureError } from "@ignored/hardhat-vnext-utils/error";
 
@@ -11,33 +16,56 @@ import { useFixtureProject } from "../../../helpers/project.js";
 
 describe("console/task-action", function () {
   let hre: HardhatRuntimeEnvironment;
+  let options: repl.ReplOptions;
 
   before(async function () {
     hre = await createHardhatRuntimeEnvironment({});
   });
 
+  beforeEach(function () {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    output.pipe(process.stdout);
+    options = {
+      input,
+      output,
+    };
+  });
+
   describe("javascript", function () {
     useFixtureProject("run-js-script");
 
     it("should throw inside the console if script does not exist", async function () {
       const replServer = await consoleAction(
-        { commands: ['await import("./scripts/non-existent.js");', ".exit"] },
+        {
+          commands: ['await import("./scripts/non-existent.js");', ".exit"],
+          history: "",
+          options,
+        },
         hre,
       );
       ensureError(replServer.lastError);
     });
 
     it("should run a script inside the console successfully", async function () {
       const replServer = await consoleAction(
-        { commands: ['await import("./scripts/success.js");', ".exit"] },
+        {
+          commands: [".help", 'await import("./scripts/success.js");', ".exit"],
+          history: "",
+          options,
+        },
         hre,
       );
       assert.equal(replServer.lastError, undefined);
     });
 
     it("should throw inside the console if the script throws", async function () {
       const replServer = await consoleAction(
-        { commands: ['await import("./scripts/throws.js");', ".exit"] },
+        {
+          commands: ['await import("./scripts/throws.js");', ".exit"],
+          history: "",
+          options,
+        },
         hre,
       );
       ensureError(replServer.lastError);
@@ -49,26 +77,74 @@ describe("console/task-action", function () {
 
     it("should throw inside the console if script does not exist", async function () {
       const replServer = await consoleAction(
-        { commands: ['await import("./scripts/non-existent.ts");', ".exit"] },
+        {
+          commands: ['await import("./scripts/non-existent.ts");', ".exit"],
+          history: "",
+          options,
+        },
         hre,
       );
       ensureError(replServer.lastError);
     });
 
     it("should run a script inside the console successfully", async function () {
       const replServer = await consoleAction(
-        { commands: ['await import("./scripts/success.ts");', ".exit"] },
+        {
+          commands: ['await import("./scripts/success.ts");', ".exit"],
+          history: "",
+          options,
+        },
         hre,
       );
       assert.equal(replServer.lastError, undefined);
     });
 
     it("should throw inside the console if the script throws", async function () {
       const replServer = await consoleAction(
-        { commands: ['await import("./scripts/throws.ts");', ".exit"] },
+        {
+          commands: ['await import("./scripts/throws.ts");', ".exit"],
+          history: "",
+          options,
+        },
         hre,
       );
       ensureError(replServer.lastError);
     });
   });
+
+  describe("history", function () {
+    let cacheDir: string;
+    let history: string;
+
+    beforeEach(function () {
+      cacheDir = fs.mkdtempSync(
+        path.resolve(os.tmpdir(), "console-action-test-"),
+      );
+      history = path.resolve(cacheDir, "console-history.txt");
+    });
+
+    afterEach(function () {
+      fs.rmSync(cacheDir, { recursive: true });
+    });
+
+    it("should create a history file", async function () {
+      assert.ok(
+        !fs.existsSync(history),
+        "History file exists before running the console",
+      );
+      const replServer = await consoleAction(
+        {
+          commands: [".help", ".exit"],
+          history,
+          options,
+        },
+        hre,
+      );
+      assert.equal(replServer.lastError, undefined);
+      assert.ok(
+        fs.existsSync(history),
+        "History file does not exist after running the console",
+      );
+    });
+  });
 });