Struct TestRunner 

pub struct TestRunner {
    pub env: Env,
    pub target_address: Option<Address>,
    pub evm_version: EVMVersion,
    pub cheats_config: Arc<CheatsConfig>,
    pub trace_requirements: TraceRequirements,
    pub collect_logs: bool,
    pub live_logs: bool,
    pub isolation: bool,
    pub initial_balance: U256,
    pub networks: NetworkConfigs,
    pub fork: Option<CreateFork>,
}

Runs test macros on Foundry’s executor, with its cheatcodes, tracer and log collector.

Fields

env: Env

Environment every test starts from, including the sender of its call

target_address: Option<Address>

Address the test macros run at instead of being deployed

evm_version: EVMVersion

EVM version the test macros are compiled for

cheats_config: Arc<CheatsConfig>

Settings of the Foundry cheatcodes the tests can call

trace_requirements: TraceRequirements

What the tracer records of each test

collect_logs: bool

Whether to collect the logs of each test, for console logs in the report

live_logs: bool

Whether to print console logs while a test runs

isolation: bool

Whether to run every call of a test as its own transaction, as Foundry’s --isolate does

initial_balance: U256

The balance a deployed test and its sender start with

networks: NetworkConfigs

The network families the executor runs for

fork: Option<CreateFork>

The chain every test forks, or none to start each test on an empty chain

Implementations

impl TestRunner

pub fn new( env: Env, target_address: Option<Address>, evm_version: EVMVersion, cheats_config: Arc<CheatsConfig>, ) -> Self

pub fn new_executor(&self) -> Result<Executor<EthEvmNetwork>, RunnerError>

A fresh executor for one test, on an empty chain or the runner’s fork

pub fn set_balance( &self, executor: &mut Executor<EthEvmNetwork>, address: Address, amount: U256, ) -> Result<(), RunnerError>

Set the balance of an account.

pub fn deploy_code( &self, executor: &mut Executor<EthEvmNetwork>, code: &str, ) -> Result<Address, RunnerError>

Deploy arbitrary bytecode and return the contract address.

pub fn call( &self, name: String, executor: &mut Executor<EthEvmNetwork>, transact_to: Address, value: U256, data: String, ) -> Result<TestResult, RunnerError>

Perform a call to a deployed contract

fn call_from( &self, name: String, executor: &mut Executor<EthEvmNetwork>, sender: Address, transact_to: Address, value: U256, calldata: Bytes, ) -> Result<TestResult, RunnerError>

Perform a call to a deployed contract from the given sender, in the executor’s current environment; the sender must already hold the funds for the call

pub fn run_test( &self, executor: &mut Executor<EthEvmNetwork>, m: &MacroDefinition, contract: &Contract, ) -> Result<TestResult, RunnerError>

Compile a test macro and run it on the executor, which holds the chain state of this test

Trait Implementations

impl Debug for TestRunner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TestRunner

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1824 bytes