use crate::Context;
use crate::{
AckMode, ChannelGraph, Delivery, DriverKind, EdgeId, Effect, Emitter, Enablement, FanoutKind,
Feeder, GraphBuilder, LaunchError, Listen, NodeId, NodeWiring, Operator, Plan, Refusal,
UpstreamWiring,
};
macro_rules! node {
($name:ident) => {
struct $name;
impl Operator for $name {
type Error = core::convert::Infallible;
type In = u8;
type Out = u8;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<u8>,
_emitter: &mut Emitter<u8>,
) -> Result<(), Self::Error> {
Ok(())
}
}
impl crate::Declared for $name {
const EFFECT: crate::Effect = crate::Effect::Pure;
type Channels = crate::Unchanneled;
type Mode = crate::Block;
type Options = ();
type Pair = crate::Buffered;
type Wires<O> = crate::Downstream<O>;
type Attribution<O> = ();
}
};
}
node!(Scenes);
node!(Captions);
fn watching() -> ChannelGraph {
let mut builder = GraphBuilder::new();
let scenes = builder.source::<Scenes>("scenes", DriverKind::Thread);
let captions = builder.node::<Captions>("captions", DriverKind::Async);
builder.edge(&scenes, &captions, FanoutKind::Broadcast);
builder.validate().expect("a pair validates")
}
fn plan(graph: ChannelGraph, watched: Effect, feeder: Feeder) -> Plan {
let enablement = graph
.nodes()
.iter()
.fold(Enablement::new(), |enablement, node| {
enablement.launching(node.name())
});
Plan::new(graph)
.with_enablement(enablement)
.wiring(NodeId::new(0), NodeWiring::new(watched))
.wiring(NodeId::new(1), NodeWiring::default().landing())
.upstream(
EdgeId::new(0),
UpstreamWiring::new(Listen::Changes(feeder), AckMode::Local),
)
}
fn refusals(plan: Plan) -> Vec<String> {
match plan.validate() {
Err(LaunchError::Refused(rows)) => rows.iter().map(ToString::to_string).collect(),
Err(other) => panic!("the walk refused for another reason: {other}"),
Ok(_) => Vec::new(),
}
}
#[test]
fn a_default_feed_with_no_lander_is_refused_with_its_three_roads() {
let rows = refusals(plan(watching(), Effect::Pure, Feeder::InGraph));
let row = rows
.iter()
.find(|row| row.contains("listens to the changes of"))
.unwrap_or_else(|| panic!("the feeder row is missing: {rows:?}"));
assert!(row.contains("`captions`"), "{row}");
assert!(row.contains("`scenes`"), "{row}");
assert!(row.contains("say `external`"), "{row}");
assert!(row.contains("subscribe to `scenes` directly"), "{row}");
assert!(row.contains("add the node that lands into it"), "{row}");
}
#[test]
fn the_row_joins_the_collect_list_rather_than_stopping_the_walk() {
let rows = refusals(plan(watching(), Effect::Pure, Feeder::InGraph));
assert!(
matches!(
plan(watching(), Effect::Pure, Feeder::InGraph).validate(),
Err(LaunchError::Refused(_))
),
"the walk collects"
);
assert_eq!(rows.len(), 1, "{rows:?}");
}
#[test]
fn an_external_feed_needs_no_lander() {
assert_eq!(
refusals(plan(watching(), Effect::Pure, Feeder::External)),
Vec::<String>::new()
);
}
#[test]
fn a_watched_store_with_a_lander_passes() {
assert_eq!(
refusals(plan(watching(), Effect::Lands, Feeder::InGraph)),
Vec::<String>::new()
);
}
#[test]
fn an_unlaunched_lander_is_the_reindex_posture_and_not_this_row() {
let graph = watching();
let plan = Plan::new(graph)
.with_enablement(Enablement::new().launching("captions"))
.wiring(NodeId::new(0), NodeWiring::default().landing())
.wiring(NodeId::new(1), NodeWiring::default().landing())
.upstream(
EdgeId::new(0),
UpstreamWiring::new(Listen::Changes(Feeder::InGraph), AckMode::Local),
);
assert_eq!(refusals(plan), Vec::<String>::new());
}
#[test]
fn the_row_is_its_own_variant() {
let Err(LaunchError::Refused(rows)) = plan(watching(), Effect::Pure, Feeder::InGraph).validate()
else {
panic!("the walk refuses");
};
let [Refusal::FeederAbsent(absent)] = rows.as_slice() else {
panic!("one row, and it is the feeder's: {rows:?}");
};
assert_eq!(absent.consumer_name(), "captions");
assert_eq!(absent.watched_name(), "scenes");
assert_eq!(absent.edge(), EdgeId::new(0));
}