feat(code/test): Generalize the test framework to make it work with any app

[romac]

Closes: #XXX

Summary

With this PR, any app can now use the test framework and re-use the existing tests (sort of).

For this, an application should first preferably create a new crate holding the tests, eg. myapp-test:

❯ tree myapp-test/
myapp-test/
├── Cargo.toml
└── src
    └── lib.rs

Then add dependencies on the following crates:

• myapp: Assuming that this crate is where the Context is defined
• malachitebft-test-framework: The test framework itself

In this crate, they can copy over the code/crates/starknet/test/src/tests folder from the Malachite source tree in this PR to myapp/src/tests:

❯ cp -R code/crates/starknet/test/src/tests myapp-test/src/tests
❯ tree myapp-test/
myapp-test/
├── Cargo.toml
└── src
    ├── lib.rs
    └── tests
        ├── full_nodes.rs
        ├── mod.rs
        ├── n3f0.rs
        ├── n3f0_consensus_mode.rs
        ├── n3f0_pubsub_protocol.rs
        ├── n3f1.rs
        ├── value_sync.rs
        ├── vote_sync.rs
        └── wal.rs

In myapp-test/src/lib.rs, paste the following and fill in the methods with todo!() (insert owl drawing here):

use std::collections::HashMap;
use std::path::PathBuf;

use async_trait::async_trait;
use tempfile::TempDir;
use tokio::task::JoinHandle;

use malachitebft_test_framework::HasTestRunner;
use malachitebft_test_framework::{NodeRunner, TestNode};

pub use malachitebft_test_framework::TestBuilder as GenTestBuilder;
pub use malachitebft_test_framework::{
    init_logging, EngineHandle, HandlerResult, Handles, Node, NodeId, TestParams,
};

use myapp::{MyAppContext, Height, PrivateKey, ValidatorSet};


#[cfg(test)]
pub mod tests;

pub type TestBuilder<S> = GenTestBuilder<MyAppContext, S>;

pub struct Handle {
    pub handle: JoinHandle<()>,
    pub tx_event: TxEvent<MockContext>,
}

#[async_trait]
impl NodeHandle<MyAppContext> for Handle {
    fn subscribe(&self) -> RxEvent< MyAppContext > {
        self.tx_event.subscribe()
    }

    async fn kill(&self, _reason: Option<String>) -> eyre::Result<()> {
        self.handle.abort();
        Ok(())
    }
}


impl HasTestRunner<TestRunner> for MyAppContext {
    type Runner = TestRunner;
}

#[derive(Clone)]
pub struct TestRunner {
    pub id: usize,
    pub params: TestParams,
    pub nodes_count: usize,
    pub start_height: HashMap<NodeId, Height>,
    pub home_dir: HashMap<NodeId, PathBuf>,
    pub private_keys: HashMap<NodeId, PrivateKey>,
    pub validator_set: ValidatorSet,
    pub consensus_base_port: usize,
    pub mempool_base_port: usize,
    pub metrics_base_port: usize,
}

fn temp_dir(id: NodeId) -> PathBuf {
    TempDir::with_prefix(format!("myapp-test-{id}-"))
        .unwrap()
        .into_path()
}

#[async_trait]
impl NodeRunner<MyAppContext> for TestRunner {
    type NodeHandle = Handle;

    fn new<S>(id: usize, nodes: &[TestNode<MyAppContext, S>], params: TestParams) -> Self {
        let nodes_count = nodes.len();
        let base_port = 20_000 + id * 1000;

        let (validators, private_keys) = make_validators(nodes);
        let validator_set = ValidatorSet::new(validators);

        let start_height = nodes
            .iter()
            .map(|node| (node.id, node.start_height))
            .collect();

        let home_dir = nodes
            .iter()
            .map(|node| (node.id, temp_dir(node.id)))
            .collect();

        Self {
            id,
            params,
            nodes_count,
            start_height,
            home_dir,
            private_keys,
            validator_set,
            consensus_base_port: base_port,
            mempool_base_port: base_port + 100,
            metrics_base_port: base_port + 200,
        }
    }

    /// Spawn a new node with the given id and return a set of handles 
    /// for the test framework to be able to kill the node
    async fn spawn(&self, id: NodeId) -> eyre::Result<Handle> {
        todo!()
    }

    /// Reset the database of the node with the given id.
    /// Must reset the WAL, the block store, etc.
    async fn reset_db(&self, id: NodeId) -> eyre::Result<()> {
        todo!()
    }
}

Notes

• Calling Handle::kill should stop both the application and consensus right away, and wait for both to be stopped before returning.
• Handle::tx_event must be a valid TxEvent instance which broadcasts events from the Consensus actor

---

PR author checklist

For all contributors

• Reference GitHub issue
• Ensure PR title follows the conventional commits spec

For external contributors

• Maintainers of Malachite are allowed to push changes to the branch

[ancazamfir]

looks great! 🚀