Struct Faulty 

pub struct Faulty<T> { /* private fields */ }

Wraps a [Transport] and fails a configurable number of upcoming sends.

This simulates an intermittent link so offline-first behavior can be proven rather than assumed: pair it with a store-and-forward drain and assert that every record still arrives, in order, once the link recovers.

Examples

use pamoja_core::Transport;
use pamoja_loopback::{Faulty, LoopbackBroker, LoopbackTransport};

let broker = LoopbackBroker::new();
let mut node = Faulty::new(LoopbackTransport::new(broker), 1);
node.connect().await?;

// The first send fails, simulating a dropped link; the next succeeds.
assert!(node.send("t", b"x").await.is_err());
node.send("t", b"x").await?;

Implementations

impl<T> Faulty<T>

pub fn new(inner: T, failures: usize) -> Self

Wraps inner, failing its next failures sends before passing through.

Arguments

• inner - the transport to decorate.
• failures - how many of the next send calls fail.

Returns

A decorator that injects the requested failures, then delegates to inner.

pub fn fail_next(&mut self, count: usize)

Arms the decorator to fail the next count sends.

Arguments

• count - the number of upcoming sends to fail, simulating another link outage.

Trait Implementations

impl<T: Transport + Send> Transport for Faulty<T>

async fn connect(&mut self) -> Result<()>

Establishes the connection to the broker, peer, or bus.

async fn send(&mut self, topic: &str, payload: &[u8]) -> Result<()>

Publishes a payload to a topic.

async fn subscribe(&mut self, topic: &str) -> Result<()>

Subscribes to a topic so that matching payloads are routed to this transport.