use crate::Context;
use core::time::Duration;
use super::super::{
AckMode, Effect, Enablement, Feeder, LaunchError, Listen, NodeWiring, Plan, Refusal,
UpstreamWiring,
};
use crate::{
ChannelGraph, Delivery, DriverKind, Emitter, FanoutKind, GraphBuilder, NodeId, Operator,
};
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<Self::In>,
_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!(Keyframes);
node!(Captions);
fn chain() -> ChannelGraph {
let mut builder = GraphBuilder::new();
let scenes = builder.source::<Scenes>("scenes", DriverKind::Thread);
let keyframes = builder.node::<Keyframes>("keyframes", DriverKind::Async);
let captions = builder.node::<Captions>("captions", DriverKind::Async);
builder.edge(&scenes, &keyframes, FanoutKind::Broadcast);
builder.edge(&keyframes, &captions, FanoutKind::Broadcast);
builder.validate().expect("a chain of three validates")
}
fn everything(graph: &ChannelGraph) -> Enablement {
graph
.nodes()
.iter()
.fold(Enablement::new(), |enablement, node| {
enablement.launching(node.name())
})
}
fn everything_but(graph: &ChannelGraph, dark: &[&str]) -> Enablement {
graph
.nodes()
.iter()
.filter(|node| !dark.contains(&node.name()))
.fold(Enablement::new(), |enablement, node| {
enablement.launching(node.name())
})
}
fn only(refused: &LaunchError) -> &Refusal {
match refused.refusals() {
[refusal] => refusal,
rows => panic!(
"one refusal was expected, and {} came back: {refused}",
rows.len()
),
}
}
fn plan(graph: ChannelGraph) -> Plan {
let enablement = everything(&graph);
Plan::new(graph).with_enablement(enablement)
}
fn landing(graph: ChannelGraph) -> Plan {
let mut plan = plan(graph);
for index in 0..3 {
plan = plan.wiring(NodeId::new(index), NodeWiring::default().landing());
}
plan
}
#[test]
fn a_chain_whose_leaf_stores_is_launchable() {
let wired = landing(chain()).validate().expect("every node lands");
assert_eq!(wired.running().count(), 3);
assert!(wired.is_enabled(NodeId::new(0)));
assert_eq!(
wired.node(NodeId::new(2)).expect("declared").effect(),
Effect::Lands
);
assert_eq!(wired.graph().nodes().len(), 3);
}
#[test]
fn a_plan_nobody_named_a_node_in_is_the_empty_deployment() {
let wired = Plan::new(chain())
.validate()
.expect("a deployment that names nothing launches nothing");
assert_eq!(wired.running().count(), 0);
assert!(!wired.is_enabled(NodeId::new(0)));
}
#[test]
fn the_defaults_are_the_records_own() {
let refused = plan(chain()).validate().expect_err("the leaf is pure");
assert!(only(&refused).is_pure_leaf());
let wired = landing(chain()).validate().expect("lands");
let upstream = wired.upstream(crate::EdgeId::new(0)).expect("declared");
assert_eq!(upstream.listen(), Listen::Channel);
assert_eq!(upstream.ack(), AckMode::Local);
}
#[test]
fn a_pure_unit_with_nobody_to_publish_to_is_refused_by_name() {
let mut plan = plan(chain());
for index in 0..2 {
plan = plan.wiring(NodeId::new(index), NodeWiring::new(Effect::Lands));
}
let refused = plan.validate().expect_err("a pure leaf");
let payload = only(&refused)
.try_unwrap_pure_leaf_ref()
.expect("the pure-leaf arm");
assert_eq!(payload.name(), "captions");
assert_eq!(payload.node(), NodeId::new(2));
let rendered = refused.to_string();
assert!(rendered.contains("lands nothing"), "{rendered}");
assert!(rendered.contains("publishes to nobody"), "{rendered}");
assert!(rendered.contains("polls nothing"), "{rendered}");
}
#[test]
fn a_pure_leaf_with_a_poll_source_is_exempt_because_its_schedule_is_its_observability() {
let wired = plan(chain())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.upstream(
crate::EdgeId::new(1),
UpstreamWiring::new(Listen::Poll(Duration::from_secs(600)), AckMode::Local),
)
.validate()
.expect("a poll node is observable through its schedule");
assert!(wired.is_enabled(NodeId::new(2)));
assert_eq!(
wired
.upstream(crate::EdgeId::new(1))
.expect("declared")
.listen(),
Listen::Poll(Duration::from_secs(600))
);
}
#[test]
fn the_exemption_follows_the_edge_to_the_unit_that_polls_and_not_to_the_one_polled() {
let refused = plan(chain())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.upstream(
crate::EdgeId::new(0),
UpstreamWiring::new(Listen::Poll(Duration::from_secs(60)), AckMode::Local),
)
.validate()
.expect_err("captions still has no way to be observed");
assert_eq!(
only(&refused)
.try_unwrap_pure_leaf_ref()
.expect("the pure-leaf arm")
.name(),
"captions"
);
}
#[test]
fn a_poll_source_over_an_unlaunched_upstream_starts_and_runs() {
let graph = chain();
let enablement = everything_but(&graph, &["keyframes"]);
let wired = landing(graph)
.upstream(
crate::EdgeId::new(1),
UpstreamWiring::new(Listen::Poll(Duration::from_secs(600)), AckMode::Local),
)
.with_enablement(enablement)
.validate()
.expect("reaping does not need the dead alive");
assert!(wired.is_enabled(NodeId::new(2)));
assert!(!wired.is_enabled(NodeId::new(1)));
}
#[test]
fn a_poll_source_mixes_with_the_other_two_words_in_one_fan_in() {
let mut builder = GraphBuilder::new();
let scenes = builder.source::<Scenes>("scenes", DriverKind::Thread);
let ocr = builder.source::<Keyframes>("ocr", DriverKind::Thread);
let expiry = builder.source::<Keyframes>("expiry", DriverKind::Thread);
let reaper = builder.node::<Captions>("reaper", DriverKind::Async);
builder.edge(&scenes, &reaper, FanoutKind::Broadcast);
builder.edge(&ocr, &reaper, FanoutKind::Broadcast);
builder.edge(&expiry, &reaper, FanoutKind::Broadcast);
let graph = builder.validate().expect("a fan-in of three validates");
let wired = plan(graph)
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(2), NodeWiring::new(Effect::Lands))
.upstream(
crate::EdgeId::new(1),
UpstreamWiring::new(Listen::Changes(Feeder::InGraph), AckMode::Local),
)
.upstream(
crate::EdgeId::new(2),
UpstreamWiring::new(Listen::Poll(Duration::from_secs(10)), AckMode::Local),
)
.validate()
.expect("three words, one fan-in");
let words: Vec<&'static str> = (0..3)
.map(|edge| {
wired
.upstream(crate::EdgeId::new(edge))
.expect("declared")
.listen()
.as_str()
})
.collect();
assert_eq!(words, ["channel", "changes", "poll"]);
}
#[test]
fn a_pure_unit_that_publishes_is_fine() {
let plan = plan(chain())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(2), NodeWiring::default().landing());
assert!(plan.validate().is_ok());
}
#[test]
fn a_section_naming_a_unit_that_does_not_exist_refuses_at_start_up() {
let graph = chain();
let enablement = everything(&graph).launching("keyfrmaes");
let refused = landing(graph)
.with_enablement(enablement)
.validate()
.expect_err("a misspelling");
assert_eq!(
only(&refused)
.try_unwrap_unknown_node_ref()
.expect("the unknown-node arm")
.name(),
"keyfrmaes"
);
assert!(refused.to_string().contains("does not declare"));
}
#[test]
fn the_unknown_key_is_reported_before_anything_else_is_judged() {
let refused = plan(chain())
.with_enablement(Enablement::new().launching("nope"))
.validate()
.expect_err("the key");
assert!(refused.refusals()[0].is_unknown_node(), "{refused}");
}
#[test]
fn a_unit_that_says_it_lands_with_no_lane_and_no_consumer_is_refused_by_name() {
let refused = plan(chain())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(2), NodeWiring::new(Effect::Lands))
.validate()
.expect_err("the leaf lands nowhere");
let payload = only(&refused)
.try_unwrap_lands_nowhere_ref()
.expect("the lands-nowhere arm");
assert_eq!(payload.name(), "captions");
assert_eq!(payload.node(), NodeId::new(2));
let rendered = refused.to_string();
assert!(rendered.contains("declares that it lands"), "{rendered}");
assert!(rendered.contains("give it a lane of its own"), "{rendered}");
assert!(
rendered.contains("a consumer that lands what it emits"),
"{rendered}"
);
}
#[test]
fn a_lane_and_a_consumer_are_each_enough_on_their_own() {
let wired = plan(chain())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(2), NodeWiring::default().landing())
.validate()
.expect("a lane at the leaf, a consumer at the hop before it");
assert!(!wired.node(NodeId::new(1)).expect("declared").holds_lane());
assert!(wired.node(NodeId::new(2)).expect("declared").holds_lane());
}
#[test]
fn holding_a_lane_declares_the_effect_rather_than_asking_for_it() {
let wiring = NodeWiring::default().landing();
assert_eq!(wiring.effect(), Effect::Lands);
assert!(wiring.holds_lane());
assert!(!wiring.answers());
let both = NodeWiring::answering(Effect::Pure).landing();
assert_eq!(both.effect(), Effect::Lands);
assert!(both.holds_lane() && both.answers());
assert!(!NodeWiring::new(Effect::Lands).holds_lane());
}
#[test]
fn the_walk_collects_every_refusal_before_it_reports_one() {
let graph = chain();
let enablement = everything_but(&graph, &["keyframes"]).launching("keyfrmaes");
let refused = Plan::new(graph)
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.with_enablement(enablement)
.validate()
.expect_err("three things at once");
let rows = refused.refusals();
assert_eq!(rows.len(), 3, "{refused}");
assert!(rows[0].is_unknown_node(), "{refused}");
assert!(rows[1].is_pure_leaf(), "{refused}");
assert!(rows[2].is_disabled_upstream(), "{refused}");
let rendered = refused.to_string();
assert!(rendered.contains("3 thing(s) to fix"), "{rendered}");
assert!(rendered.contains("keyfrmaes"), "{rendered}");
assert!(rendered.contains("lands nothing"), "{rendered}");
assert!(rendered.contains("listen to its changes"), "{rendered}");
}
#[test]
fn the_names_that_name_nothing_come_out_in_a_stable_order() {
let graph = chain();
let enablement = everything(&graph)
.launching("zebra")
.launching("aardvark")
.launching("mongoose");
let refused = landing(graph)
.with_enablement(enablement)
.validate()
.expect_err("three names name nothing");
let named: Vec<&str> = refused
.refusals()
.iter()
.filter_map(|refusal| refusal.try_unwrap_unknown_node_ref().ok())
.map(super::UnknownNodeError::name)
.collect();
assert_eq!(named, ["aardvark", "mongoose", "zebra"]);
}
#[test]
fn a_unit_the_options_do_not_name_simply_does_not_run() {
let graph = chain();
let enablement = everything_but(&graph, &["captions"]);
let wired = landing(graph)
.with_enablement(enablement)
.validate()
.expect("nothing listens to captions");
assert_eq!(
wired.running().collect::<Vec<_>>(),
[NodeId::new(0), NodeId::new(1)]
);
assert!(!wired.is_enabled(NodeId::new(2)));
}
#[test]
fn a_channel_listener_on_an_unlaunched_upstream_is_refused_by_both_names() {
let graph = chain();
let enablement = everything_but(&graph, &["keyframes"]);
let refused = landing(graph)
.with_enablement(enablement)
.validate()
.expect_err("captions would starve");
let payload = only(&refused)
.try_unwrap_disabled_upstream_ref()
.expect("the disabled-upstream arm");
assert_eq!(payload.consumer_name(), "captions");
assert_eq!(payload.producer_name(), "keyframes");
assert_eq!(payload.edge(), crate::EdgeId::new(1));
let rendered = refused.to_string();
assert!(rendered.contains("captions"), "{rendered}");
assert!(rendered.contains("keyframes"), "{rendered}");
assert!(rendered.contains("no section names it"), "{rendered}");
assert!(
rendered.contains("listen to its changes instead"),
"{rendered}"
);
}
#[test]
fn a_changes_listener_on_an_unlaunched_upstream_is_legal_and_drains_the_store() {
let graph = chain();
let enablement = everything_but(&graph, &["keyframes"]);
let wired = landing(graph)
.upstream(
crate::EdgeId::new(1),
UpstreamWiring::new(Listen::Changes(Feeder::InGraph), AckMode::Local),
)
.with_enablement(enablement)
.validate()
.expect("a changes listener may consume an unlaunched upstream's store");
assert!(wired.is_enabled(NodeId::new(2)));
assert!(!wired.is_enabled(NodeId::new(1)));
assert_eq!(
wired
.upstream(crate::EdgeId::new(1))
.expect("declared")
.listen(),
Listen::Changes(Feeder::InGraph)
);
}
#[test]
fn an_unlaunched_consumer_is_not_asked_about_its_upstream() {
let graph = chain();
let enablement = everything_but(&graph, &["keyframes", "captions"]);
let wired = landing(graph)
.with_enablement(enablement)
.validate()
.expect("nothing is listening");
assert_eq!(wired.running().collect::<Vec<_>>(), [NodeId::new(0)]);
}
#[test]
fn an_unlaunched_leaf_is_not_asked_whether_it_is_pure() {
let graph = chain();
let enablement = everything_but(&graph, &["captions"]);
let wired = plan(graph)
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.with_enablement(enablement)
.validate()
.expect("a node that does not run cannot compute into nothing");
assert!(!wired.is_enabled(NodeId::new(2)));
}
#[test]
fn a_handle_from_another_graph_wires_nothing() {
let wired = landing(chain())
.wiring(NodeId::new(99), NodeWiring::new(Effect::Pure))
.upstream(
crate::EdgeId::new(99),
UpstreamWiring::new(Listen::Changes(Feeder::InGraph), AckMode::Chained),
)
.validate()
.expect("out-of-range handles were ignored");
assert!(wired.node(NodeId::new(99)).is_none());
assert!(wired.upstream(crate::EdgeId::new(99)).is_none());
assert!(!wired.is_enabled(NodeId::new(99)));
}
#[test]
fn a_source_can_be_wired_per_edge_within_one_fan_in() {
let mut builder = GraphBuilder::new();
let scenes = builder.source::<Scenes>("scenes", DriverKind::Thread);
let ocr = builder.source::<Keyframes>("ocr", DriverKind::Thread);
let captions = builder.node::<Captions>("captions", DriverKind::Async);
builder.edge(&scenes, &captions, FanoutKind::Broadcast);
builder.edge(&ocr, &captions, FanoutKind::Broadcast);
let graph = builder.validate().expect("a fan-in validates");
let wired = landing(graph)
.upstream(
crate::EdgeId::new(0),
UpstreamWiring::new(Listen::Changes(Feeder::InGraph), AckMode::Chained),
)
.validate()
.expect("mixed modes in one fan-in");
let first = wired.upstream(crate::EdgeId::new(0)).expect("declared");
let second = wired.upstream(crate::EdgeId::new(1)).expect("declared");
assert_eq!(first.listen(), Listen::Changes(Feeder::InGraph));
assert_eq!(first.ack(), AckMode::Chained);
assert_eq!(second.listen(), Listen::Channel);
assert_eq!(second.ack(), AckMode::Local);
}
#[test]
fn the_launch_refusals_are_errors() {
fn is_error<E: core::error::Error>(_: &E) {}
let refused: LaunchError = plan(chain()).validate().expect_err("a pure leaf");
is_error(&refused);
}
mod query {
use super::{
super::super::{AckMode, Effect, Listen, NodeWiring, Plan, UpstreamWiring},
Captions, Keyframes, Scenes, chain, everything_but, landing, only, plan,
};
use crate::{
AsyncResource, ChannelGraph, DeclaredResource, DriverKind, EdgeId, FanoutKind, GraphBuilder,
NodeId, ResourceCatalog, ResourceDemand, ResourceName, ResourceSource, Resources,
};
struct Egemma;
impl AsyncResource for Egemma {
type Options = ();
type Error = core::convert::Infallible;
async fn build(_ctx: &Resources, (): ()) -> Result<Self, Self::Error> {
Ok(Self)
}
}
impl DeclaredResource for Egemma {}
struct Whisper;
impl AsyncResource for Whisper {
type Options = ();
type Error = core::convert::Infallible;
async fn build(_ctx: &Resources, (): ()) -> Result<Self, Self::Error> {
Ok(Self)
}
}
fn tower_and_index() -> ChannelGraph {
let mut builder = GraphBuilder::new();
let images = builder.source::<Scenes>("images", DriverKind::Thread);
let tower = builder.source::<Keyframes>("tower", DriverKind::Thread);
let index = builder.node::<Captions>("index", DriverKind::Thread);
builder.edge(&images, &index, FanoutKind::Broadcast);
builder.edge(&tower, &index, FanoutKind::Broadcast);
builder.validate().expect("a fan-in of two validates")
}
fn fan_in() -> Plan {
plan(tower_and_index())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::answering(Effect::Pure))
.wiring(NodeId::new(2), NodeWiring::default().landing())
.upstream(
EdgeId::new(1),
UpstreamWiring::new(Listen::Transient, AckMode::Local),
)
}
#[test]
fn the_fourth_word_names_itself_and_mixes_with_the_other_three() {
let wired = fan_in().validate().expect("two edge kinds, one fan-in");
let words: Vec<&'static str> = (0..2)
.map(|edge| {
wired
.upstream(EdgeId::new(edge))
.expect("declared")
.listen()
.as_str()
})
.collect();
assert_eq!(words, ["channel", "transient"]);
assert!(Listen::Transient.is_transient());
assert_eq!(Listen::Transient.to_string(), "transient");
}
#[test]
fn a_query_only_unit_is_legal_because_somebody_is_holding_its_answer() {
fn lone_tower() -> ChannelGraph {
let mut builder = GraphBuilder::new();
builder.source::<Keyframes>("tower", DriverKind::Thread);
builder.node::<Captions>("index", DriverKind::Thread);
builder.validate().expect("two unconnected nodes validate")
}
let refused = plan(lone_tower())
.wiring(NodeId::new(1), NodeWiring::default().landing())
.validate()
.expect_err("a pure leaf with no arm at all");
assert_eq!(
only(&refused)
.try_unwrap_pure_leaf_ref()
.expect("the pure-leaf arm")
.name(),
"tower"
);
let wired = plan(lone_tower())
.wiring(NodeId::new(0), NodeWiring::answering(Effect::Pure))
.wiring(NodeId::new(1), NodeWiring::default().landing())
.validate()
.expect("a door is observability: somebody holds the other half of the oneshot");
assert!(wired.is_enabled(NodeId::new(0)));
assert!(wired.node(NodeId::new(0)).expect("declared").answers());
}
#[test]
fn a_transient_inbound_exempts_the_hop_it_feeds_and_not_the_one_it_leaves() {
let refused = plan(tower_and_index())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::answering(Effect::Pure))
.validate()
.expect_err("`index` is a pure leaf while its inbound is a plain channel");
assert_eq!(
only(&refused)
.try_unwrap_pure_leaf_ref()
.expect("the pure-leaf arm")
.name(),
"index"
);
let wired = plan(tower_and_index())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::answering(Effect::Pure))
.upstream(
EdgeId::new(1),
UpstreamWiring::new(Listen::Transient, AckMode::Local),
)
.validate()
.expect("the transient inbound is `index`'s arm");
assert!(wired.is_enabled(NodeId::new(2)));
}
#[test]
fn the_refusal_still_names_every_way_out_it_has() {
let refused = plan(chain())
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::new(Effect::Lands))
.validate()
.expect_err("a pure leaf");
let rendered = refused.to_string();
for way in [
"lands nothing",
"publishes to nobody",
"polls nothing",
"answers nobody",
"query arm",
] {
assert!(rendered.contains(way), "{rendered}");
}
}
#[test]
fn an_unlaunched_embedder_under_a_running_index_is_refused_in_its_own_words() {
let graph = tower_and_index();
let enablement = everything_but(&graph, &["tower"]);
let refused = plan(graph)
.wiring(NodeId::new(0), NodeWiring::new(Effect::Lands))
.wiring(NodeId::new(1), NodeWiring::answering(Effect::Pure))
.wiring(NodeId::new(2), NodeWiring::default().landing())
.upstream(
EdgeId::new(1),
UpstreamWiring::new(Listen::Transient, AckMode::Local),
)
.with_enablement(enablement)
.validate()
.expect_err("the index's query edge starves");
let payload = only(&refused)
.try_unwrap_disabled_query_upstream_ref()
.expect("the disabled-query-upstream arm");
assert_eq!(payload.consumer_name(), "index");
assert_eq!(payload.producer_name(), "tower");
assert_eq!(payload.edge(), EdgeId::new(1));
let rendered = refused.to_string();
assert!(rendered.contains("query edge"), "{rendered}");
assert!(rendered.contains("no store to fall back on"), "{rendered}");
assert!(
!rendered.contains("listen to its changes"),
"the channel listener's escape is not offered: {rendered}"
);
}
#[test]
fn a_demanded_resource_that_nothing_declared_refuses_by_name() {
let refused = landing(chain())
.with_resources(ResourceCatalog::new().with::<Egemma>("egemma", ResourceSource::Section))
.demanding(NodeId::new(1), ResourceDemand::of::<Whisper>())
.validate()
.expect_err("nothing declared `Whisper`");
let payload = only(&refused)
.try_unwrap_undeclared_resource_ref()
.expect("the undeclared-resource arm");
assert_eq!(payload.name(), "keyframes");
assert_eq!(payload.node(), NodeId::new(1));
assert!(
payload.resource().as_str().ends_with("Whisper"),
"the refusal names the resource: {}",
payload.resource().as_str()
);
let rendered = refused.to_string();
assert!(rendered.contains("keyframes"), "{rendered}");
assert!(rendered.contains("Whisper"), "{rendered}");
assert!(rendered.contains("#[ingraph::resource]"), "{rendered}");
}
#[test]
fn a_declared_resource_satisfies_every_unit_that_demands_it() {
let wired = landing(chain())
.with_resources(ResourceCatalog::new().with::<Egemma>("egemma", ResourceSource::Section))
.demanding(NodeId::new(0), ResourceDemand::of::<Egemma>())
.demanding(NodeId::new(1), ResourceDemand::of::<Egemma>())
.validate()
.expect("one declaration serves every demand");
assert_eq!(wired.running().count(), 3);
}
#[test]
fn the_declared_set_and_the_demand_agree_because_one_call_makes_both() {
assert_eq!(
<Egemma as DeclaredResource>::resource(),
ResourceDemand::of::<Egemma>().resource()
);
assert!(
ResourceCatalog::new()
.with::<Egemma>("egemma", ResourceSource::Section)
.declares(ResourceDemand::of::<Egemma>().resource())
);
}
#[test]
fn an_unlaunched_unit_demands_nothing_because_it_is_not_there_to_hold_it() {
let graph = chain();
let enablement = everything_but(&graph, &["captions"]);
let wired = landing(graph)
.demanding(NodeId::new(2), ResourceDemand::of::<Whisper>())
.with_enablement(enablement)
.validate()
.expect("a node that does not run demands nothing");
assert!(!wired.is_enabled(NodeId::new(2)));
}
#[test]
fn the_checked_plan_carries_the_lazy_rule_forward_rather_than_asking_it_twice() {
let graph = chain();
let enablement = everything_but(&graph, &["captions"]);
let wired = landing(graph)
.with_resources(ResourceCatalog::new().with::<Egemma>("egemma", ResourceSource::Section))
.demanding(NodeId::new(0), ResourceDemand::of::<Egemma>())
.demanding(NodeId::new(2), ResourceDemand::of::<Whisper>())
.with_enablement(enablement)
.validate()
.expect("a node that does not run demands nothing");
assert!(wired.demands(<Egemma as DeclaredResource>::resource()));
assert!(!wired.demands(ResourceDemand::of::<Whisper>().resource()));
assert_eq!(wired.demanded().count(), 1);
}
#[test]
fn the_resource_row_is_reported_before_the_observability_one_and_both_are_reported() {
let refused = plan(chain())
.demanding(NodeId::new(2), ResourceDemand::of::<Whisper>())
.validate()
.expect_err("both a missing resource and a pure leaf");
let rows = refused.refusals();
assert_eq!(rows.len(), 2, "{refused}");
assert!(rows[0].is_undeclared_resource(), "{refused}");
assert!(rows[1].is_pure_leaf(), "{refused}");
}
#[test]
fn a_plan_reports_the_resources_and_demands_it_was_wired_with() {
let plan = landing(chain())
.with_resources(ResourceCatalog::new().with::<Egemma>("egemma", ResourceSource::Section))
.demanding(NodeId::new(1), ResourceDemand::of::<Egemma>());
assert_eq!(plan.resources().len(), 1);
assert_eq!(plan.demands().count(), 1);
assert_eq!(
plan.resources().names().next().map(ResourceName::as_str),
Some(<Egemma as DeclaredResource>::resource().as_str())
);
}
}