Enum Refusal 

#[non_exhaustive]
pub enum Refusal<Src> {
    PayloadOver {
        name: String,
        limit: usize,
    },
    Publish {
        name: String,
    },
    Subscription {
        source: Src,
    },
    Conflicting {
        open: Src,
        refused: Src,
    },
}

One thing the real server refuses, which refuses_like_the_server checks the in-process transport refuses too.

Src is the broker’s subscription descriptor; a list with no subscription probe names it with a turbofish (Refusal::<MySource>::Publish { .. }).

Examples

use ruststream::conformance::in_process::{self, Refusal};
use ruststream::memory::{MemoryBroker, MemorySource};

// What the server refuses, and so what the in-process transport must refuse too.
in_process::refuses_like_the_server(
    MemoryBroker::new,
    |connected| connected.publisher(),
    [
        Refusal::Subscription {
            source: MemorySource::new("orders.*"),
        },
        Refusal::PayloadOver {
            name: "orders".to_owned(),
            limit: 1024 * 1024,
        },
    ],
)
.await;

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

PayloadOver

A publish to name of exactly limit payload bytes is accepted and delivered, one byte more is refused. The check opens a subscription to name by name before it publishes.

Fields

name: String

A destination both transports accept publishes to.

limit: usize

The largest payload the server accepts there, in bytes.

Publish

A publish to name is refused: a name the server’s grammar rejects, or a destination it does not have.

Fields

name: String

The refused destination.

Subscription

Opening source is refused: an invalid name, a declaration the server rejects.

Fields

source: Src

The refused subscription.

Conflicting

With open subscribed, opening refused is refused: a redeclaration that conflicts with the first one, a second consumer where the server admits one.

Fields

open: Src

The subscription opened first, which the server accepts.

refused: Src

The subscription the server refuses beside it.

Trait Implementations

impl<Src: Clone> Clone for Refusal<Src>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Src: Debug> Debug for Refusal<Src>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.