use crate::Context;
use core::{convert::Infallible, time::Duration};
use crate::{
Block, Buffered, Control, Declared, DeclaredOrigin, Delivery, Effect, Emitter, Enablement, Feed,
Fin, LaunchError, Listen, Operator, Refusal, Resources, Source, Unchanneled, Upstream,
};
struct Ticking;
impl Source for Ticking {
type Options = ();
type Yield = u64;
type Mutation = ();
type Error = Infallible;
fn build(_ctx: &Resources, (): ()) -> Result<Self, Self::Error> {
Ok(Self)
}
fn run(
self,
_ctx: Context,
_giving: Feed<u64>,
_eating: Control<Infallible>,
) -> Result<Fin, Self::Error> {
Ok(Fin::Spent)
}
}
impl DeclaredOrigin for Ticking {
type Mode = Block;
}
struct Ledger;
impl Operator for Ledger {
type Error = Infallible;
type In = u64;
type Out = u64;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<u64>,
_emitter: &mut Emitter<u64>,
) -> Result<(), Self::Error> {
Ok(())
}
}
impl Declared for Ledger {
const EFFECT: Effect = Effect::Lands;
const HOLDS_LANE: bool = true;
const UPSTREAMS: &'static [Upstream] = &[Upstream::of::<Ticking>("crate::Ticking")];
type Channels = Unchanneled;
type Mode = Block;
type Options = ();
type Pair = Buffered;
type Wires<O> = crate::Downstream<O>;
type Attribution<O> = ();
}
struct Mirror;
impl Operator for Mirror {
type Error = Infallible;
type In = u64;
type Out = u64;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<u64>,
_emitter: &mut Emitter<u64>,
) -> Result<(), Self::Error> {
Ok(())
}
}
impl Declared for Mirror {
const EFFECT: Effect = Effect::Lands;
const HOLDS_LANE: bool = true;
const UPSTREAMS: &'static [Upstream] = &[Upstream::of::<Ticking>("crate::Ticking")];
type Channels = Unchanneled;
type Mode = Block;
type Options = ();
type Pair = Buffered;
type Wires<O> = crate::Downstream<O>;
type Attribution<O> = ();
}
struct Sweeping;
impl Operator for Sweeping {
type Error = Infallible;
type In = u64;
type Out = u64;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<u64>,
_emitter: &mut Emitter<u64>,
) -> Result<(), Self::Error> {
Ok(())
}
}
impl Declared for Sweeping {
const EFFECT: Effect = Effect::Lands;
const HOLDS_LANE: bool = true;
const UPSTREAMS: &'static [Upstream] =
&[Upstream::of::<Ticking>("crate::Ticking").listening(Listen::Poll(Duration::from_secs(60)))];
type Channels = Unchanneled;
type Mode = Block;
type Options = ();
type Pair = Buffered;
type Wires<O> = crate::Downstream<O>;
type Attribution<O> = ();
}
fn arranged(enablement: Enablement) -> Result<crate::Wired, LaunchError> {
let mut blueprint = crate::Blueprint::new();
let _ = blueprint.origin::<Ticking>("ticking");
let _ = blueprint.node::<Ledger>("ledger");
blueprint
.into_plan()
.expect("the edge joins on the origin's own identity")
.with_enablement(enablement)
.validate()
}
fn refusals(refused: LaunchError) -> Vec<Refusal> {
let LaunchError::Refused(rows) = refused else {
panic!("a validate walk refuses with rows: {refused}");
};
rows
}
#[test]
fn a_deployment_that_launches_both_ends_of_an_origins_edge_checks_out() {
let _: crate::Wired = arranged(Enablement::new().launching("ticking").launching("ledger"))
.expect("the bridge opens that edge");
}
#[test]
fn an_origin_whose_consumer_is_dark_is_the_loose_arrangement() {
let _: crate::Wired =
arranged(Enablement::new().launching("ticking")).expect("the deployment checks out");
}
#[test]
fn a_consumer_whose_origin_is_dark_is_the_starved_upstream_row_instead() {
let refused =
arranged(Enablement::new().launching("ledger")).expect_err("its upstream is not launched");
let rows = refusals(refused);
assert!(rows.iter().any(Refusal::is_disabled_upstream), "{rows:?}");
assert!(
!rows.iter().any(Refusal::is_unbridged_origin),
"the origin is not launched, so nothing is listening to a running one: {rows:?}"
);
}
#[test]
fn a_consumer_that_listens_by_a_word_an_origin_cannot_answer_is_refused_by_name() {
let mut blueprint = crate::Blueprint::new();
let _ = blueprint.origin::<Ticking>("ticking");
let _ = blueprint.node::<Sweeping>("sweeping");
let refused = blueprint
.into_plan()
.expect("the edge joins")
.with_enablement(Enablement::new().launching("ticking").launching("sweeping"))
.validate()
.expect_err("an origin has no store to poll");
let rows = refusals(refused);
let [Refusal::UnbridgedOrigin(unheard)] = rows.as_slice() else {
panic!("one row, and it is the unheard word: {rows:?}");
};
assert_eq!(unheard.origin_name(), "ticking");
assert_eq!(unheard.consumer_name(), "sweeping");
assert_eq!(unheard.listen(), "poll");
assert_eq!(unheard.origin(), crate::NodeId::new(0));
assert_eq!(unheard.consumer(), crate::NodeId::new(1));
assert_eq!(unheard.edge(), crate::EdgeId::new(0));
assert_eq!(
rows[0].to_string(),
"node#1 (`sweeping`) listens to the origin node#0 (`ticking`) by `poll`, and an origin has \
nothing to be heard through that word with: it lands nothing, so there is no store to watch or \
poll, and it answers nobody, so there is no door to ask; subscribe to `ticking` over the \
channel, which is what an origin publishes on"
);
}
#[test]
fn two_launched_consumers_of_one_origin_are_refused_by_name() {
let mut blueprint = crate::Blueprint::new();
let _ = blueprint.origin::<Ticking>("ticking");
let _ = blueprint.node::<Ledger>("ledger");
let _ = blueprint.node::<Mirror>("mirror");
let refused = blueprint
.into_plan()
.expect("both edges join")
.with_enablement(
Enablement::new()
.launching("ticking")
.launching("ledger")
.launching("mirror"),
)
.validate()
.expect_err("an origin has one feed");
let rows = refusals(refused);
let [Refusal::SplitOrigin(split)] = rows.as_slice() else {
panic!("one row for the whole fan-out: {rows:?}");
};
assert_eq!(split.origin_name(), "ticking");
assert_eq!(split.origin(), crate::NodeId::new(0));
assert_eq!(split.count(), 2);
assert_eq!(split.consumers(), ["ledger", "mirror"]);
assert_eq!(
rows[0].to_string(),
"node#0 (`ticking`) is an origin and this deployment launches 2 consumers of it (`ledger`, \
`mirror`), but an origin has ONE feed and it becomes ONE edge — put a pass-through operator \
under `ticking` and fan out from there, or launch one of them"
);
}
#[test]
fn an_origin_with_two_declared_consumers_and_one_launched_checks_out() {
let mut blueprint = crate::Blueprint::new();
let _ = blueprint.origin::<Ticking>("ticking");
let _ = blueprint.node::<Ledger>("ledger");
let _ = blueprint.node::<Mirror>("mirror");
let _: crate::Wired = blueprint
.into_plan()
.expect("both edges join")
.with_enablement(Enablement::new().launching("ticking").launching("ledger"))
.validate()
.expect("one launched consumer is one edge");
}
#[test]
fn the_typed_origin_door_records_an_ordinary_edge() {
let mut builder = crate::GraphBuilder::new();
let ticking = builder.origin::<Ticking>("ticking", crate::DriverKind::Thread);
let ledger = builder.node::<Ledger>("ledger", crate::DriverKind::Thread);
let edge = builder.origin_edge(&ticking, &ledger, crate::FanoutKind::Direct);
assert_eq!(edge, crate::EdgeId::new(0));
let graph = builder
.validate()
.expect("one origin, one consumer, one edge");
assert!(graph.nodes()[0].is_source(), "an origin is a dataflow head");
assert_eq!(graph.edges()[0].from(), crate::NodeId::new(0));
assert_eq!(graph.edges()[0].to(), crate::NodeId::new(1));
}
#[test]
fn only_the_origin_door_states_the_originating_word() {
let mut blueprint = crate::Blueprint::new();
let _ = blueprint.origin::<Ticking>("ticking");
let _ = blueprint.node::<Ledger>("ledger");
let plan = blueprint
.into_plan()
.expect("the edge joins")
.with_enablement(Enablement::new().launching("ticking"));
let wired = plan.validate().expect("the deployment checks out");
let row = |at| {
wired
.node(crate::NodeId::new(at))
.expect("both are mounted")
.is_origin()
};
assert!(row(0), "the origin says so");
assert!(!row(1), "an operator does not");
}
#[test]
fn the_bridge_door_opens_an_origins_one_out_edge_from_its_own_end() {
let wired = arranged(Enablement::new().launching("ticking").launching("ledger"))
.expect("the bridge opens that edge");
let mut wiring = wired.create().wire();
let opened = wiring
.bridge::<u64>(crate::NodeId::new(0))
.expect("nothing to refuse")
.expect("both ends are launched");
let inbox = wiring
.inbox::<u64>(crate::NodeId::new(1))
.expect("nothing to refuse")
.expect("the deployment launches the consumer");
drop(opened);
drop(inbox);
}
#[test]
fn an_origin_whose_consumer_is_dark_has_no_edge_to_be_handed() {
let wired = arranged(Enablement::new().launching("ticking")).expect("the deployment checks out");
let mut wiring = wired.create().wire();
assert!(
wiring
.bridge::<u64>(crate::NodeId::new(0))
.expect("nothing to refuse")
.is_none(),
"the consumer this edge ends at is not launched"
);
}
#[test]
fn a_dark_origin_is_handed_nothing() {
let wired = arranged(Enablement::new().launching("ledger"));
assert!(
wired.is_err(),
"a launched consumer with a dark producer is refused"
);
let wired = arranged(Enablement::new()).expect("an empty deployment checks out");
let mut wiring = wired.create().wire();
assert!(
wiring
.bridge::<u64>(crate::NodeId::new(0))
.expect("nothing to refuse")
.is_none(),
"nobody named the origin, so there is no feed to open"
);
}
#[test]
fn a_bridge_asked_for_the_wrong_message_is_refused() {
let wired = arranged(Enablement::new().launching("ticking").launching("ledger"))
.expect("the bridge opens that edge");
let mut wiring = wired.create().wire();
let _ = wiring
.inbox::<u64>(crate::NodeId::new(1))
.expect("nothing to refuse")
.expect("the deployment launches the consumer");
let refused = wiring
.bridge::<String>(crate::NodeId::new(0))
.expect_err("this edge carries `u64`");
assert!(matches!(refused, LaunchError::Wiring { .. }), "{refused}");
}