Rust <-> Solidity Unit Testing

[JayWhite2357]

One thing that is particularly interesting for our project (and many others) is the ability to send data between Solidity and a Rust service.
Having the ability to unit test the combination of the two of these languages would be a powerful primitive. Here's what I have gotten to work for us.

It feels a bit hacky, and I'm sure there could be a much simpler integration done quite easily. One concrete request from my end is for forge-script to be published to crates.io in order for dependencies to resolve more easily, as this was, by far, the most difficult part.

If anyone has suggestions on a better way of going about this, and if I'm missing something obvious here, I'm all ears. Perhaps revm+foundry-compilers is the correct way to do this, but I didn't see anything as immediately simple as forge-script.

TestScript.t.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

library TestScript {
    struct CustomStruct {
        uint256 value;
    }

    error DummyError();

    function rustTestWeCanThrowErrorDependingOnParameter(uint256 x) public pure {
        if (x != 1234) revert DummyError();
    }

    function rustTestWeCanDecodeCustomStruct(bytes memory x) public pure {
        (CustomStruct memory y) = abi.decode(x, (CustomStruct)); // solhint-disable-line no-unused-vars
        if (y.value != 1234) revert DummyError();
    }

    function testWeCanRunForgeTests() public pure {} // solhint-disable-line no-empty-blocks
}

sol_test.rs

use alloy_primitives::{Bytes, U256};
use alloy_sol_types::{sol, SolValue};
use forge_script::ScriptArgs;

#[tokio::test(flavor = "multi_thread")]
async fn we_can_run_solidity_script_from_rust() {
    ScriptArgs {
        path: "./src/tests/TestScript.t.sol".to_string(),
        sig: "rustTestWeCanThrowErrorDependingOnParameter".to_string(),
        args: vec![U256::from(1234).to_string()],
        ..Default::default()
    }
    .run_script()
    .await
    .unwrap();

    assert!(ScriptArgs {
        path: "./src/tests/TestScript.t.sol".to_string(),
        sig: "rustTestWeCanThrowErrorDependingOnParameter".to_string(),
        args: vec![U256::from(0).to_string()],
        ..Default::default()
    }
    .run_script()
    .await
    .is_err());
}
#[tokio::test(flavor = "multi_thread")]
async fn we_can_pass_custom_struct_into_solidity_from_rust() {
    sol!("./src/tests/TestScript.t.sol");
    let arg = TestScript::CustomStruct {
        value: U256::from(1234),
    };
    ScriptArgs {
        path: "./src/tests/TestScript.t.sol".to_string(),
        sig: "rustTestWeCanDecodeCustomStruct".to_string(),
        args: vec![Bytes::from(arg.abi_encode()).to_string()],
        ..Default::default()
    }
    .run_script()
    .await
    .unwrap();
}

[simon-something]

Side note: you can silent out the script output using a "fake" shell, to keep tests a bit more clean:

    use foundry_common::shell::{ColorChoice, OutputFormat, OutputMode, Shell};
    
    let shell = Shell::new_with(OutputFormat::Json, OutputMode::Quiet, ColorChoice::Never, 0);
    shell.set();

But having a TestArgs::run_test() would be really nice imo:)