Struct TestBuilder 

pub struct TestBuilder<B: StorageBuilder> {
    pub initial_committee: Committee,
    pub validator_storages: HashMap<ValidatorPublicKey, B::Storage>,
    pub validator_key_pairs: HashMap<ValidatorPublicKey, ValidatorSecretKey>,
    pub chain_owners: BTreeMap<ChainId, AccountOwner>,
    pub signer: TestSigner,
    /* private fields */
}

Fields

initial_committee: Committee

validator_storages: HashMap<ValidatorPublicKey, B::Storage>

validator_key_pairs: HashMap<ValidatorPublicKey, ValidatorSecretKey>

chain_owners: BTreeMap<ChainId, AccountOwner>

signer: TestSigner

Implementations

impl<B> TestBuilder<B>

where B: StorageBuilder,

pub fn clock(&self) -> &TestClock

The simulated clock every storage here shares, so a test can drive the export queue’s tick in virtual time instead of sleeping through it.

pub async fn new( storage_builder: B, count: usize, with_faulty_validators: usize, signer: TestSigner, ) -> Result<Self, Error>

Creates a test setup with count validators, with_faulty_validators of which are faulty.

pub async fn new_with_block_export( storage_builder: B, count: usize, with_faulty_validators: usize, signer: TestSigner, ) -> Result<Self, Error>

Creates a test setup like TestBuilder::new, in which every validator also pushes the blocks it executes to the rest of the committee.

pub async fn new_with_block_export_and_ttl( storage_builder: B, count: usize, with_faulty_validators: usize, signer: TestSigner, chain_worker_ttl: Duration, ) -> Result<Self, Error>

Creates a test setup like TestBuilder::new_with_block_export with an explicit chain worker TTL, for asserting that workers expire even while export is enabled.

pub async fn new_with_block_export_config( storage_builder: B, count: usize, with_faulty_validators: usize, signer: TestSigner, config: BlockExportConfig, ) -> Result<Self, Error>

Creates a test setup like TestBuilder::new_with_block_export, with the export tuned by the caller. Used to shrink max_catch_up_blocks far below its default so that a backlog a test can actually produce still takes several rounds to drain.

pub fn test_block_export_config() -> BlockExportConfig

The export settings the block-export tests run with: production backoff is measured in seconds, which would make every test that exercises a failing destination wait it out.

pub fn with_policy(self, policy: ResourceControlPolicy) -> Self

Replaces the initial committee’s resource control policy.

pub fn with_cross_chain_message_chunk_limit(self, limit: usize) -> Self

Sets the cross-chain message chunk limit on every validator in the test setup.

pub fn fail_next_validator_set_builds(&self, count: usize)

Makes the next count attempts to build the validator set fail, so a test can force update_notification_streams to return Err at a chosen moment.

pub fn validator_set_build_failures_left(&self) -> usize

How many of the injected validator-set-build failures are still pending, so a test can count how often a failing update was retried.

pub async fn stall_chain_info_queries( &self, index: usize, ) -> OwnedRwLockWriteGuard<()>

Stalls every chain-info query at the validator at index until the returned guard is dropped, which stalls the initial sync a probe runs once subscribe succeeds.

pub fn slow_validator_set_builds(&self, by: TimeDelta)

Makes every validator-set build advance the clock, simulating a committee read slow enough that deadlines computed from a clock sampled BEFORE it are already elapsed.

pub fn validator_set_builds(&self) -> usize

Every attempt the chain clients have made to build the validator set.

pub async fn subscribe_calls(&self, index: usize) -> usize

How many times the validator at index has been asked to subscribe.

pub async fn disconnect_notification_subscribers(&self)

Severs every notification stream on every validator in the test setup, as a fleet-wide proxy restart does. Clients keep their (now dead) ends of the streams until they notice and re-subscribe.

pub fn fault_type(&self, public_key: &ValidatorPublicKey) -> Option<FaultType>

Returns the FaultType currently configured for the given validator, or None if no validator with that key is in the test setup.

pub fn set_fault_type( &mut self, indexes: impl AsRef<[usize]>, fault_type: FaultType, )

Sets the FaultType for the validators at the given indexes.

pub async fn add_root_chain( &mut self, index: u32, balance: Amount, ) -> Result<ChainClient<B::Storage>>

Creates the root chain with the given index, and returns a client for it.

Root chain 0 is the admin chain and needs to be initialized first, otherwise its balance is automatically set to zero.

pub async fn add_root_chain_with_ownership( &mut self, index: u32, balance: Amount, make_ownership: impl FnOnce(AccountOwner) -> ChainOwnership, ) -> Result<ChainClient<B::Storage>>

Creates the root chain with the given index and a genesis ownership built from its freshly generated owner key, and returns a client for it.

Root chain 0 is the admin chain and needs to be initialized first, otherwise its balance is automatically set to zero.

pub fn genesis_chains(&self) -> Vec<(AccountPublicKey, Amount)>

Returns the public key and balance of each genesis root chain.

pub fn admin_chain_id(&self) -> ChainId

Returns the admin chain’s ID, panicking if it has not been initialized.

pub fn admin_description(&self) -> Option<&ChainDescription>

Returns the admin chain description, if the admin chain has been initialized.

pub fn make_node_provider(&self) -> NodeProvider<B::Storage>

Returns a clone of the node provider backing this test setup.

pub fn validator_storage(&mut self, index: usize) -> B::Storage

Returns the storage of the validator at index, which holds every block that validator has processed.

pub fn node(&mut self, index: usize) -> LocalValidatorClient<B::Storage>

Returns a clone of the validator client at the given index.

pub async fn make_storage(&mut self) -> Result<B::Storage>

Builds a fresh storage seeded with the network description and genesis chains.

pub async fn make_client_with_options( &mut self, chain_id: ChainId, block_hash: Option<CryptoHash>, block_height: BlockHeight, options: Options, follow_only: bool, ) -> Result<ChainClient<B::Storage>>

Creates a chain client for the given chain with the given client options.

pub async fn make_client( &mut self, chain_id: ChainId, block_hash: Option<CryptoHash>, block_height: BlockHeight, ) -> Result<ChainClient<B::Storage>>

Creates a chain client for the given chain with default test options.

pub async fn check_that_validators_have_certificate( &self, chain_id: ChainId, block_height: BlockHeight, target_count: usize, ) -> Option<ConfirmedBlockCertificate>

Tries to find a (confirmation) certificate for the given chain_id and block height.

pub async fn check_that_validators_are_in_round( &self, chain_id: ChainId, block_height: BlockHeight, round: Round, target_count: usize, )

Tries to find a (confirmation) certificate for the given chain_id and block height, and are in the expected round.

pub async fn exported_heights( &self, index: usize, chain_id: ChainId, ) -> BTreeMap<ValidatorPublicKey, BlockHeight>

Returns how far the validator at index believes it has exported the given chain to each of the other validators.

pub async fn resident_chain_workers(&self, index: usize) -> usize

Returns how many chain workers the validator at index currently has resident.

pub async fn next_block_height( &self, index: usize, chain_id: ChainId, ) -> BlockHeight

Returns the next block height the validator at index has for the given chain.

pub async fn check_that_validators_have_empty_outboxes(&self, chain_id: ChainId)

Panics if any validator has a nonempty outbox for the given chain.