Struct MultiNodeTestEnv

pub struct MultiNodeTestEnv<Ctx, C>
where
    Ctx: Clone + Send + Sync + 'static,
    C: HeartbeatConsumer + Clone + Send + Sync + 'static,
{
    pub nodes: Arc<RwLock<Vec<NodeSlot<Ctx, C>>>>,
    pub command_tx: Sender<EnvironmentCommand<Ctx>>,
    pub event_tx: Sender<TestEvent>,
    pub config: Arc<TangleTestConfig>,
    pub initialized_tx: Option<Sender<()>>,
    pub running_nodes: Arc<AtomicUsize>,
}

Improved multi-node test environment with better control and observability

Fields

nodes: Arc<RwLock<Vec<NodeSlot<Ctx, C>>>>

command_tx: Sender<EnvironmentCommand<Ctx>>

event_tx: Sender<TestEvent>

config: Arc<TangleTestConfig>

initialized_tx: Option<Sender<()>>

running_nodes: Arc<AtomicUsize>

Implementations

impl<Ctx, C> MultiNodeTestEnv<Ctx, C>

where Ctx: Clone + Send + Sync + 'static, C: HeartbeatConsumer + Clone + Send + Sync + 'static,

pub fn new<const N: usize>(config: TangleTestConfig) -> Self

Creates a new multi-node test environment

pub async fn initialize(&mut self) -> Result<(), Error>

Initializes the multi node test environment with N nodes

Errors

Returns an error if the command channel closed prematurely

pub async fn add_job<J: Job<T, Ctx> + Clone + Send + Sync + 'static, T: 'static>( &self, job: J, )

Adds a job to the node to be executed when the test is run.

The job is added to the end of the list of jobs and can be stopped using the stop_job method.

pub async fn start(&mut self, context: Ctx) -> Result<(), Error>

Send a start command to all nodes

This will clone context to all nodes. If your context is node-specific (for example, in a networking blueprint), then see Self::start_with_contexts() for providing per-node contexts.

Panics

See Self::start_with_contexts()

Errors

See Self::start_with_contexts()

Examples

use blueprint_core::extract::Context;
use blueprint_tangle_testing_utils::TangleTestHarness;
use tempfile::TempDir;

// This context isn't node specific, it can safely be cloned to all nodes.
#[derive(Clone)]
struct MyContext {
    foo: u64,
}

async fn some_job(Context(_context): Context<MyContext>) {}

let tmp_dir = TempDir::new()?;

// Initialize the harness with the type, this is an indication that it will need the
// context later.
let harness = TangleTestHarness::<MyContext>::setup(tmp_dir).await?;

let (mut test_env, _service_id, _blueprint_id) = harness.setup_services::<1>(false).await?;

// Setup the test environment
test_env.initialize().await?;
test_env.add_job(some_job).await;

// Ready to start now, provide the context
let context = MyContext { foo: 0 };
test_env.start(context).await?;

pub async fn start_with_contexts( &mut self, contexts: Vec<Ctx>, ) -> Result<(), Error>

Send a start command to all nodes

This takes a list of contexts, that will be applied in the same order as the nodes appear in Self::node_handles().

Panics

This will panic if contexts.len() != nodes.len()

Errors

Returns an error if the command channel closed prematurely

Examples

use blueprint_core::extract::Context;
use blueprint_tangle_testing_utils::TangleTestHarness;
use tempfile::TempDir;

// This context is node specific. Each node needs its own copy.
#[derive(Clone)]
struct MyContext {
    foo: u64,
}

async fn some_job(Context(_context): Context<MyContext>) {}

// Start up a test with 2 nodes
const N: usize = 2;

let tmp_dir = TempDir::new()?;

// Initialize the harness with the type, this is an indication that it will need the
// context later.
let harness = TangleTestHarness::<MyContext>::setup(tmp_dir).await?;

let (mut test_env, _service_id, _blueprint_id) = harness.setup_services::<N>(false).await?;

// Setup the test environment
test_env.initialize().await?;
test_env.add_job(some_job).await;

// Ready to start now, provide the contexts
let mut contexts = Vec::new();
let handles = test_env.node_handles().await;
for (index, handle) in handles.iter().enumerate() {
    let context = MyContext { foo: index as u64 };
    contexts.push(context);
}

test_env.start_with_contexts(contexts).await?;

pub fn subscribe(&self) -> Receiver<TestEvent>

Subscribes to test environment events

pub async fn remove_node(&self, node_id: usize) -> Result<(), Error>

Removes a node from the test environment

Errors

Returns an error if the command channel closed prematurely

pub async fn shutdown(&self) -> Result<(), Error>

Shuts down the test environment

Errors

Returns an error if the command channel closed prematurely

pub async fn node_handles(&self) -> Vec<Arc<NodeHandle<Ctx, C>>>