use crate::{
Context, Delivery, Feed, Fin, Item, ItemId, Payload, ReasonName, Stopper, Wanted, feed,
operator::{Emission, Emitter, Operator, Skip, SkipLabel, SkipReason, StreamOperator, subscribe},
shutdown_signal,
};
struct Scenes;
impl Operator for Scenes {
type In = ();
type Out = &'static str;
type Error = core::convert::Infallible;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<Self::In>,
_emitter: &mut Emitter<Self::Out>,
) -> Result<(), Self::Error> {
Ok(())
}
}
struct Vlm;
impl Operator for Vlm {
type In = &'static str;
type Out = String;
type Error = core::convert::Infallible;
fn accept(
&mut self,
_ctx: &Context,
_delivery: Delivery<Self::In>,
_emitter: &mut Emitter<Self::Out>,
) -> Result<(), Self::Error> {
Ok(())
}
}
struct FilterEvens;
impl Operator for FilterEvens {
type In = u32;
type Out = u32;
type Error = core::convert::Infallible;
fn accept(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
emitter: &mut Emitter<Self::Out>,
) -> Result<(), Self::Error> {
for item in delivery.into_items() {
let value = item.into_value();
if value % 2 == 0 {
emitter.emit(value);
} else {
emitter.skip(SkipReason::Filtered);
}
}
Ok(())
}
}
#[test]
fn subscribe_wires_matching_output_to_input() {
subscribe(&Scenes, &Vlm);
}
#[test]
fn context_buffers_emissions_in_order() {
let mut emitter = Emitter::<u32>::new();
emitter.emit(1);
emitter.skip(SkipReason::Filtered);
emitter.emit(2);
let out: Vec<Emission<u32>> = emitter.drain();
assert_eq!(out.len(), 3);
assert!(out[0].is_emit());
assert!(out[1].is_skip());
assert!(out[2].is_emit());
assert_eq!(*out[0].unwrap_emit_ref(), 1);
assert_eq!(*out[2].unwrap_emit_ref(), 2);
}
#[test]
fn the_public_read_asserts_without_a_side_door() {
let mut emitter = Emitter::<u32>::new().wanting(Wanted::sole(true));
let delivery = Delivery::in_custody(Payload::Batch(vec![
Item::new(ItemId::new(0), 4),
Item::new(ItemId::new(1), 7),
]));
FilterEvens
.accept(&Context::new("filter-evens"), delivery, &mut emitter)
.unwrap();
let seen = emitter.emissions();
assert_eq!(seen.len(), 2);
assert!(seen[0].is_emit());
assert_eq!(*seen[0].unwrap_emit_ref(), 4);
assert!(seen[1].is_skip());
assert!(seen[1].unwrap_skip_ref().reason().is_filtered());
let out = emitter.into_emissions();
assert_eq!(out.len(), 2);
assert!(out[0].is_emit());
assert!(out[1].is_skip());
}
#[test]
fn skip_reason_names_are_stable() {
assert_eq!(SkipReason::Filtered.as_str(), "filtered");
assert_eq!(SkipReason::NoConsumers.as_str(), "no_consumers");
assert_eq!(SkipReason::ServiceInactive.as_str(), "service_inactive");
assert_eq!(SkipReason::NoConsumers.to_string(), "no_consumers");
}
#[test]
fn custom_skip_reason_round_trips() {
let r = SkipReason::custom("late_frame");
assert!(r.is_custom());
assert_eq!(r.as_str(), "late_frame");
assert_eq!(r.to_string(), "late_frame");
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Refusal {
Oversize,
Unreadable,
}
impl SkipLabel for Refusal {
fn label(&self) -> &'static ReasonName {
match self {
Self::Oversize => ReasonName::new("oversize"),
Self::Unreadable => ReasonName::new("unreadable"),
}
}
fn from_label(label: &ReasonName) -> Option<Self> {
match label.as_ref() {
"oversize" => Some(Self::Oversize),
"unreadable" => Some(Self::Unreadable),
_ => None,
}
}
}
#[derive(Debug, PartialEq, Eq)]
enum Verdict {
Stale,
}
impl SkipLabel for Verdict {
fn label(&self) -> &'static ReasonName {
ReasonName::new("stale")
}
fn from_label(label: &ReasonName) -> Option<Self> {
(label.as_ref() == "stale").then_some(Self::Stale)
}
}
#[test]
fn a_typed_reason_survives_the_erased_wire_form() {
for reason in [Refusal::Oversize, Refusal::Unreadable] {
let wire = SkipReason::encode(&reason);
assert!(wire.is_custom());
assert_eq!(wire.as_str(), reason.label().as_ref());
assert_eq!(wire.decode::<Refusal>(), Some(reason));
}
}
#[test]
fn a_label_outside_the_vocabulary_decodes_to_none() {
assert_eq!(
SkipReason::encode(&Verdict::Stale).decode::<Refusal>(),
None
);
assert_eq!(SkipReason::Filtered.decode::<Refusal>(), None);
assert_eq!(SkipReason::custom("oversized").decode::<Refusal>(), None);
assert_eq!(
SkipReason::encode(&Refusal::Oversize).decode::<Verdict>(),
None
);
}
#[test]
fn a_skip_composes_its_two_independent_facts() {
let bare = Skip::new(SkipReason::Filtered);
assert!(bare.reason().is_filtered());
assert_eq!(bare.content(), None);
let named = Skip::new(SkipReason::encode(&Refusal::Oversize)).about("chapter-9.md");
assert_eq!(named.reason().decode::<Refusal>(), Some(Refusal::Oversize));
assert_eq!(named.content(), Some("chapter-9.md"));
let mut emitter = Emitter::<u32>::new();
emitter.skip(SkipReason::Filtered);
emitter.skip(named.clone());
let out = emitter.drain();
assert_eq!(*out[0].unwrap_skip_ref(), bare);
assert_eq!(*out[1].unwrap_skip_ref(), named);
}
fn one(text: &str) -> Delivery<String> {
Delivery::in_custody(Payload::One(Item::new(ItemId::new(0), text.to_owned())))
}
struct Windows {
width: usize,
}
impl StreamOperator for Windows {
type In = String;
type Out = String;
type Error = core::convert::Infallible;
fn run(
&mut self,
ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
for window in item.into_value().into_bytes().chunks(self.width) {
if ctx.shutdown().is_shutdown() {
return Ok(Fin::Stopped);
}
if feed
.give(String::from_utf8_lossy(window).into_owned())
.is_err()
{
return Ok(Fin::Stopped);
}
}
}
Ok(Fin::Spent)
}
}
struct StoppedMidway {
announce_after: usize,
stopper: Stopper,
}
impl StreamOperator for StoppedMidway {
type In = String;
type Out = String;
type Error = core::convert::Infallible;
fn run(
&mut self,
ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
let mut given = 0;
for item in delivery.into_items() {
for window in item.into_value().into_bytes() {
if ctx.shutdown().is_shutdown() {
return Ok(Fin::Stopped);
}
if feed.give((window as char).to_string()).is_err() {
return Ok(Fin::Stopped);
}
given += 1;
if given == self.announce_after {
self.stopper.announce();
}
}
}
Ok(Fin::Spent)
}
}
#[derive(Debug, PartialEq, Eq)]
struct Torn {
after: usize,
}
struct Tearing {
after: usize,
}
impl StreamOperator for Tearing {
type In = String;
type Out = String;
type Error = Torn;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
let mut given = 0;
for item in delivery.into_items() {
for window in item.into_value().into_bytes() {
if given == self.after {
return Err(Torn { after: given });
}
if feed.give((window as char).to_string()).is_err() {
return Ok(Fin::Stopped);
}
given += 1;
}
}
Ok(Fin::Spent)
}
}
#[test]
fn a_stream_run_reaches_the_drain_and_ends_spent() {
let (given, yielded) = feed::<String>(16);
let (_stopper, stop) = shutdown_signal();
let ctx = Context::new("windows").halting(stop);
assert_eq!(
Windows { width: 3 }.run(&ctx, one("abcdefg"), given),
Ok(Fin::Spent)
);
assert_eq!(yielded.drain().collect::<Vec<_>>(), ["abc", "def", "g"]);
}
#[test]
fn the_line_closes_when_the_run_returns() {
let (given, yielded) = feed::<String>(16);
let (_stopper, stop) = shutdown_signal();
let ctx = Context::new("windows").halting(stop);
assert!(!yielded.is_disconnected());
assert_eq!(
Windows { width: 7 }.run(&ctx, one("abcdefg"), given),
Ok(Fin::Spent)
);
assert!(yielded.is_disconnected());
assert_eq!(yielded.take(), Some("abcdefg".to_owned()));
assert_eq!(yielded.take(), None);
}
#[test]
fn a_stop_heard_mid_run_ends_stopped_with_the_prefix_standing() {
let (given, yielded) = feed::<String>(16);
let (stopper, stop) = shutdown_signal();
let ctx = Context::new("windows").halting(stop);
let mut unit = StoppedMidway {
announce_after: 2,
stopper,
};
assert_eq!(unit.run(&ctx, one("abcdefg"), given), Ok(Fin::Stopped));
assert_eq!(yielded.drain().collect::<Vec<_>>(), ["a", "b"]);
}
#[test]
fn an_err_dead_letters_the_delivery_and_the_given_products_stand() {
let (given, yielded) = feed::<String>(16);
let (_stopper, stop) = shutdown_signal();
let ctx = Context::new("windows").halting(stop);
assert_eq!(
Tearing { after: 3 }.run(&ctx, one("abcdefg"), given),
Err(Torn { after: 3 })
);
assert_eq!(yielded.drain().collect::<Vec<_>>(), ["a", "b", "c"]);
}
#[test]
fn the_wait_for_room_is_what_carries_a_wide_stream_down_a_narrow_line() {
let (given, yielded) = feed::<String>(1);
let (_stopper, stop) = shutdown_signal();
let ctx = Context::new("windows").halting(stop);
let streamed = std::thread::spawn(move || Windows { width: 1 }.run(&ctx, one("abcdefg"), given));
let mut taken = Vec::new();
while let Some(window) = yielded.take() {
taken.push(window);
}
assert_eq!(streamed.join().unwrap(), Ok(Fin::Spent));
assert_eq!(taken, ["a", "b", "c", "d", "e", "f", "g"]);
}
#[test]
fn decode_reads_the_whole_reason_not_just_the_custom_payload() {
enum Everything {
Filtered,
}
impl SkipLabel for Everything {
fn label(&self) -> &'static ReasonName {
ReasonName::new("filtered")
}
fn from_label(label: &ReasonName) -> Option<Self> {
(label.as_ref() == "filtered").then_some(Self::Filtered)
}
}
assert!(SkipReason::Filtered.decode::<Everything>().is_some());
assert!(SkipReason::NoConsumers.decode::<Everything>().is_none());
}