use crate::Resources;
use super::{
DisabledUpstreamError, LandsNowhereError, PureLeafError, Refusal, UndeclaredResourceError,
UnknownNodeError,
};
use crate::{AsyncResource, EdgeId, NodeId, ResourceDemand};
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 starved() -> Box<DisabledUpstreamError> {
Box::new(DisabledUpstreamError::new(
EdgeId::new(1),
NodeId::new(2),
"captions".into(),
NodeId::new(1),
"keyframes".into(),
))
}
#[test]
fn every_row_names_the_thing_and_then_the_fix() {
let unknown = Refusal::UnknownNode(UnknownNodeError::new("keyfrmaes".into()));
let rendered = unknown.to_string();
assert!(rendered.contains("keyfrmaes"), "{rendered}");
assert!(rendered.contains("does not declare"), "{rendered}");
let undeclared = Refusal::UndeclaredResource(Box::new(UndeclaredResourceError::new(
NodeId::new(1),
"keyframes".into(),
ResourceDemand::of::<Whisper>().resource(),
)));
let rendered = undeclared.to_string();
assert!(rendered.contains("keyframes"), "{rendered}");
assert!(rendered.contains("Whisper"), "{rendered}");
assert!(rendered.contains("#[ingraph::resource]"), "{rendered}");
let leaf = Refusal::PureLeaf(PureLeafError::new(NodeId::new(2), "captions".into()));
let rendered = leaf.to_string();
assert!(rendered.contains("captions"), "{rendered}");
for way in ["a consumer", "a store", "a poll upstream", "a query arm"] {
assert!(rendered.contains(way), "{way} is a way out: {rendered}");
}
let nowhere = Refusal::LandsNowhere(LandsNowhereError::new(NodeId::new(2), "captions".into()));
let rendered = nowhere.to_string();
assert!(rendered.contains("captions"), "{rendered}");
assert!(rendered.contains("a lane of its own"), "{rendered}");
assert!(
rendered.contains("a consumer that lands what it emits"),
"{rendered}"
);
}
#[test]
fn the_leaf_and_the_landing_never_say_each_others_sentence() {
let leaf = Refusal::PureLeaf(PureLeafError::new(NodeId::new(2), "captions".into())).to_string();
let nowhere =
Refusal::LandsNowhere(LandsNowhereError::new(NodeId::new(2), "captions".into())).to_string();
assert!(leaf.contains("lands nothing"), "{leaf}");
assert!(!leaf.contains("declares that it lands"), "{leaf}");
assert!(nowhere.contains("declares that it lands"), "{nowhere}");
assert!(!nowhere.contains("polls nothing"), "{nowhere}");
}
#[test]
fn the_two_starved_edges_never_share_an_escape() {
let channel = Refusal::DisabledUpstream(starved()).to_string();
let query = Refusal::DisabledQueryUpstream(starved()).to_string();
assert!(
channel.contains("listen to its changes instead"),
"{channel}"
);
assert!(!channel.contains("no store to fall back on"), "{channel}");
assert!(query.contains("no store to fall back on"), "{query}");
assert!(!query.contains("listen to its changes"), "{query}");
for rendered in [&channel, &query] {
assert!(rendered.contains("captions"), "{rendered}");
assert!(rendered.contains("keyframes"), "{rendered}");
}
}
#[test]
fn a_starved_edge_names_the_one_darkness_there_is() {
let dark = Refusal::DisabledUpstream(starved()).to_string();
assert!(dark.contains("no section names it"), "{dark}");
assert!(!dark.contains("switched off"), "{dark}");
}
#[test]
fn a_row_is_reached_by_its_own_name() {
let leaf = Refusal::PureLeaf(PureLeafError::new(NodeId::new(2), "captions".into()));
assert!(leaf.is_pure_leaf());
assert!(!leaf.is_unknown_node());
assert_eq!(
leaf
.try_unwrap_pure_leaf_ref()
.expect("the pure-leaf arm")
.name(),
"captions"
);
assert!(leaf.try_unwrap_unknown_node_ref().is_err());
}