Struct MockRelayPool 

pub struct MockRelayPool { /* private fields */ }

In-memory relay pool for deterministic, network-free testing.

Create one with MockRelayPool::new and pass it (wrapped in Arc) wherever an Arc<dyn RelayPoolTrait> is expected.

Implementations

impl MockRelayPool

pub fn new() -> Self

Create a new mock relay pool with a freshly generated ephemeral signing key.

pub fn mock_public_key(&self) -> PublicKey

The ephemeral public key used by this mock for signing.

pub fn mock_keys(&self) -> Keys

The ephemeral signing keys (for manual event injection in tests).

pub fn with_keys(keys: Keys) -> Self

Like new but with caller-provided signing keys.

pub fn create_pair() -> (Self, Self)

Create a pair of linked mock relay pools with different signing keys.

Both pools share the same event store and notification channel; events published by one are visible to the other’s notifications() receivers.

pub fn create_linked_group(n: usize) -> Vec<Self>

Create n linked mock relay pools with different signing keys.

All pools share the same event store and notification channel so events published by any one pool are visible to all others’ notifications() receivers. Useful for multi-client integration tests.

pub async fn stored_events(&self) -> Vec<Event>

Clone of all events published so far (useful for assertions in tests).

Trait Implementations

impl Default for MockRelayPool

fn default() -> Self

Returns the “default value” for a type.

impl RelayPoolTrait for MockRelayPool

fn connect<'life0, 'life1, 'async_trait>( &'life0 self, _relay_urls: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

No-op: the mock has no sockets to open.

fn disconnect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

No-op: the mock has no sockets to close.

fn publish_event<'life0, 'life1, 'async_trait>( &'life0 self, event: &'life1 Event, ) -> Pin<Box<dyn Future<Output = Result<EventId>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store the event and broadcast it to all current notifications() receivers.

fn publish<'life0, 'async_trait>( &'life0 self, builder: EventBuilder, ) -> Pin<Box<dyn Future<Output = Result<EventId>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sign builder with the ephemeral key, then call publish_event.

fn sign<'life0, 'async_trait>( &'life0 self, builder: EventBuilder, ) -> Pin<Box<dyn Future<Output = Result<Event>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sign builder with the ephemeral key and return the event without publishing.

fn signer<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn NostrSigner>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return the ephemeral key as a signer.

fn notifications(&self) -> Receiver<RelayPoolNotification>

Return a new broadcast receiver. Each call gets an independent receiver that sees all events published after this call, plus any replayed by a subsequent subscribe().

fn public_key<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PublicKey>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return the ephemeral public key.

fn subscribe<'life0, 'async_trait>( &'life0 self, filters: Vec<Filter>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register the filters and immediately replay any already-stored events that match them through the broadcast channel, mirroring the behaviour of a real relay that sends historical events before EOSE.