Struct exonum_testkit::StoppedTestKit

pub struct StoppedTestKit { /* fields omitted */ }

Persistent state of an Exonum node allowing to emulate node restart.

The persistent state holds the database (including uncommitted transactions) and the network configuration, but does not retain the internal state of the services.

This method is useful to test scenarios that may play a different way depending on node restarts, such as services with dynamic internal state modified in response to blockchain events (e.g., in Service::after_commit).

Examples

// Service with internal state modified by a custom `after_commit` hook.
struct AfterCommitService {
    counter: Arc<AtomicUsize>,
}

impl AfterCommitService {
    pub fn new() -> Self {
        AfterCommitService { counter: Arc::new(AtomicUsize::default()) }
    }

    pub fn counter(&self) -> usize {
        self.counter.load(Ordering::SeqCst)
    }
}

impl Service for AfterCommitService {
    fn after_commit(&self, _: AfterCommitContext) {
        self.counter.fetch_add(1, Ordering::SeqCst);
    }
}

let service = AfterCommitService::new();
let mut testkit = TestKit::for_rust_service(
    service.clone(),
    "after_commit",
    SERVICE_ID,
    (),
);
testkit.create_blocks_until(Height(5));
assert_eq!(service.counter(), 5);

// Stop the testkit.
let stopped = testkit.stop();
assert_eq!(stopped.height(), Height(5));

// Resume with the same single service with a fresh state.
let service = AfterCommitService::new();
let rust_runtime = RustRuntime::builder().with_factory(service.clone());
let mut testkit = stopped.resume(rust_runtime);
testkit.create_blocks_until(Height(8));
assert_eq!(service.counter(), 3); // We've only created 3 new blocks.

Methods

impl StoppedTestKit

pub fn snapshot(&self) -> Box<dyn Snapshot>

Returns a snapshot of the database state.

pub fn height(&self) -> Height

Returns the height of latest committed block.

pub fn network(&self) -> &TestNetwork

Returns the reference to test network.

pub fn resume(self, rust_runtime: RustRuntimeBuilder) -> TestKit

Resumes the operation of the testkit with the Rust runtime.

Note that services in the Rust runtime may differ from the initially passed to the TestKit (which is also what may happen with real Exonum apps).

pub fn resume_with_runtimes(
    self,
    rust_runtime: RustRuntimeBuilder,
    external_runtimes: Vec<RuntimeInstance>
) -> TestKit

Resumes the operation fo the testkit with the specified runtimes.

Trait Implementations

impl Debug for StoppedTestKit

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.