Struct ContractRunner

pub struct ContractRunner<'a> {
    pub name: &'a str,
    pub contract: &'a TestContract,
    pub libs_to_deploy: &'a Vec<Bytes>,
    pub executor: Executor,
    pub revert_decoder: &'a RevertDecoder,
    pub initial_balance: U256,
    pub sender: Address,
    pub debug: bool,
    pub progress: Option<&'a TestsProgress>,
    pub tokio_handle: &'a Handle,
    pub span: Span,
}

A type that executes all tests of a contract

Fields

name: &'a str

The name of the contract.

contract: &'a TestContract

The data of the contract.

libs_to_deploy: &'a Vec<Bytes>

The libraries that need to be deployed before the contract.

executor: Executor

The executor used by the runner.

revert_decoder: &'a RevertDecoder

Revert decoder. Contains all known errors.

initial_balance: U256

The initial balance of the test contract.

sender: Address

The address which will be used as the from field in all EVM calls.

debug: bool

Whether debug traces should be generated.

progress: Option<&'a TestsProgress>

Overall test run progress.

tokio_handle: &'a Handle

The handle to the tokio runtime.

span: Span

The span of the contract.

Implementations

impl ContractRunner<'_>

pub fn setup(&mut self, call_setup: bool) -> TestSetup

Deploys the test contract inside the runner from the sending account, and optionally runs the setUp function on the test contract.

fn _setup(&mut self, call_setup: bool) -> Result<TestSetup>

fn fuzz_fixtures(&mut self, address: Address) -> FuzzFixtures

Collect fixtures from test contract.

Fixtures can be defined:

• as storage arrays in test contract, prefixed with fixture
• as functions prefixed with fixture and followed by parameter name to be fuzzed

Storage array fixtures: uint256[] public fixture_amount = [1, 2, 3]; define an array of uint256 values to be used for fuzzing amount named parameter in scope of the current test.

Function fixtures: function fixture_owner() public returns (address[] memory){} returns an array of addresses to be used for fuzzing owner named parameter in scope of the current test.

pub fn run_tests( self, filter: &dyn TestFilter, test_options: &TestOptions, known_contracts: ContractsByArtifact, ) -> SuiteResult

Runs all tests for a contract whose names match the provided regular expression

pub fn run_unit_test( &self, func: &Function, should_fail: bool, setup: TestSetup, ) -> TestResult

Runs a single unit test.

Applies before test txes (if any), runs current test and returns the TestResult.

Before test txes are applied in order and state modifications committed to the EVM database (therefore the unit test call will be made on modified state). State modifications of before test txes and unit test function call are discarded after test ends, similar to eth_call.

pub fn run_invariant_test( &self, runner: TestRunner, setup: TestSetup, invariant_config: InvariantConfig, func: &Function, call_after_invariant: bool, known_contracts: &ContractsByArtifact, identified_contracts: &ContractsByAddress, ) -> TestResult

pub fn run_fuzz_test( &self, func: &Function, should_fail: bool, runner: TestRunner, setup: TestSetup, fuzz_config: FuzzConfig, ) -> TestResult

Runs a fuzzed test.

Applies the before test txes (if any), fuzzes the current function and returns the TestResult.

Before test txes are applied in order and state modifications committed to the EVM database (therefore the fuzz test will use the modified state). State modifications of before test txes and fuzz test are discarded after test ends, similar to eth_call.

fn prepare_test( &self, func: &Function, setup: TestSetup, ) -> Result<(Cow<'_, Executor>, TestResult, Address), TestResult>

Prepares single unit test and fuzz test execution:

• set up the test result and executor
• check if before test txes are configured and apply them in order

Before test txes are arrays of arbitrary calldata obtained by calling the beforeTest function with test selector as a parameter.

Unit tests within same contract (or even current test) are valid options for before test tx configuration. Test execution stops if any of before test txes fails.

Trait Implementations

impl<'a> Clone for ContractRunner<'a>

fn clone(&self) -> ContractRunner<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ContractRunner<'a>

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

Formats the value using the given formatter.

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: 3792 bytes