Allow suppressing console.log output for successful tests in EDR networks

[nikicat]

Describe the feature

When running tests, Solidity console.log() statements produce output regardless of test outcome. This clutters the terminal during successful test runs when debug output isn't needed.

Motivation:

I want to see console.log() output only when tests fail, keeping successful runs clean. Currently there's no way to conditionally control this from test runners or programmatically.

Proposed solution:

Expose the logger config option for EDR networks, allowing users to provide custom printLineFn/replaceLastLineFn handlers. This enables test frameworks to buffer or suppress output based on test results.

networks: {
  hardhat: {
    type: "edr-simulated",
    logger: {
      enabled: false,
      printLineFn: (line) => { /* custom handling */ },
      replaceLastLineFn: (line) => { /* custom handling */ },
    },
  },
}

Use case:

Test runners can buffer log output and only display it when a test fails, similar to how many test frameworks handle stdout.

Search terms

hide console.log in tests

[michalbrabec]

@nikicat the behaviour you are describing can be achieved by the -v verbosity parameter, you can call the tests like this

pnpm hardhat test solidity -v

Does that option work for you? Is there a use case the option does not cover?

[nikicat]

@michalbrabec I mean nodejs tests, and from what I can tell, --verbosity doesn't affect output from console.log(...) calls in Solidity.

[michalbrabec]

@nikicat --verbosity filters out the console.log(...) in Solidity but it currently works only for Solidity tests. We must fix the verbosity for JS/TS tests to unify the behaviour for both types.

I tested it with the following:

Counter.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
import "hardhat/console.sol";

contract Counter {
  uint public x = 0;
  function inc() public {
    console.log("inc called");
    x++;
  }
}

Counter.t.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
import {Counter} from "./Counter.sol";
import {Test} from "forge-std/Test.sol";

contract CounterTest is Test {
  Counter counter;

  function setUp() public {
    counter = new Counter();
  }

  function test_Inc() public {
    require(counter.x() == 0, "Initial value should be 0");
    counter.inc();
    require(counter.x() == 1, "Updated value should be 1");
  }
}

Running the test without verbosity set results in inc called printed:

root@5a079a243a54:~/hardhat_test# pnpm hardhat test solidity
No contracts to compile
No Solidity tests to compile

Running Solidity tests

  contracts/Counter.t.sol:CounterTest
inc called
    ✔ test_Inc()


  1 passing

Running the test with verbosity does not print the line:

root@5a079a243a54:~/hardhat_test# pnpm hardhat test solidity -v
No contracts to compile
No Solidity tests to compile

Running Solidity tests

  contracts/Counter.t.sol:CounterTest
    ✔ test_Inc()


  1 passing

The issue is with JS/TS tests, which ignore the verbosity and you can see it in the following example where I run both Solidity and TS tests with the -v option

Counter.ts

import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { network } from "hardhat";

describe("Counter", async function () {
  const { viem } = await network.connect();

  it("Should emit the Increment event when calling the inc() function", async function () {
    const counter = await viem.deployContract("Counter");
    
    assert.equal(0n, await counter.read.x());
    await counter.write.inc();
    assert.equal(1n, await counter.read.x());
  });
});

root@5a079a243a54:~/hardhat_test# pnpm hardhat test -v
No contracts to compile
No Solidity tests to compile

Running Solidity tests

  contracts/Counter.t.sol:CounterTest
    ✔ test_Inc()


  1 passing

Running node:test tests

inc called
  Counter
    ✔ Should emit the Increment event when calling the inc() function


  1 passing (1421ms)

Would implementing this behaviour for the JS/TS tests work for you?

[nikicat]

@michalbrabec Thank you for thoroughly explaining the current behavior. This approach will work partially for my case, as my project contains numerous tests that generate a substantial amount of logs through console.log() in Solidity code. Typically, only a few of these tests fail after code changes.
What I want - and what is currently implemented in a private repository - is for the test output (from both JS/TS and Solidity) to be captured in an in-memory buffer during the test run and not displayed. If the test passes, the output is discarded. However, if the test fails, all it's captured output is forwarded to stdout for debugging.
Using the -v flag would require applying --grep to filter only the failing tests, in order to avoid sifting through the massive amount of output from the successful tests.