use std::{collections::HashSet, sync::Arc};
use super::super::{
Ack, Answer, Custody, Delivery, Item, ItemId, Lifecycle, NodeName, Observation, Payload, Station,
Unreceipted, ack_channel,
};
use crate::{LifecycleTap, Skip, SkipReason};
fn one(seq: u64) -> Payload<u8> {
Payload::One(Item::new(ItemId::new(seq), seq as u8))
}
fn batch(seqs: &[u64]) -> Payload<u8> {
Payload::Batch(
seqs
.iter()
.map(|&seq| Item::new(ItemId::new(seq), seq as u8))
.collect(),
)
}
#[test]
fn a_single_item_payload_is_one_item_and_allocates_no_vec() {
let payload = one(7);
assert_eq!(payload.len(), 1);
assert!(!payload.is_empty());
assert_eq!(
payload.keys().copied().collect::<Vec<_>>(),
[ItemId::new(7)]
);
let mut walk = payload.into_iter();
assert_eq!(walk.size_hint(), (1, Some(1)));
assert_eq!(walk.next().map(Item::into_parts), Some((ItemId::new(7), 7)));
assert_eq!(walk.size_hint(), (0, Some(0)));
assert!(walk.next().is_none());
}
#[test]
fn a_batch_keeps_send_order_through_the_walk() {
let payload = batch(&[3, 1, 2]);
assert_eq!(payload.len(), 3);
assert_eq!(
payload.keys().copied().collect::<Vec<_>>(),
[ItemId::new(3), ItemId::new(1), ItemId::new(2)]
);
assert_eq!(
payload.into_iter().map(|i| *i.key()).collect::<Vec<_>>(),
[ItemId::new(3), ItemId::new(1), ItemId::new(2)]
);
}
#[test]
fn an_empty_batch_is_empty() {
let payload: Payload<u8> = Payload::Batch(Vec::new());
assert_eq!(payload.len(), 0);
assert!(payload.is_empty());
}
#[test]
fn a_delivery_splits_into_its_payload_and_its_oneshot() {
let (ack, answers) = ack_channel::<ItemId>();
let delivery = Delivery::new(one(1), ack);
assert_eq!(delivery.payload().len(), 1);
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
assert_eq!(payload.len(), 1);
assert!(ack.send(Ack::<ItemId, ()>::holding(
"consumer",
Lifecycle::Processed(())
)));
assert!(answers.take().is_settled());
}
#[test]
fn a_delivery_in_custody_carries_the_message_and_not_the_promise() {
let delivery = Delivery::in_custody(batch(&[1, 2, 3]));
assert_eq!(delivery.payload().len(), 3);
let values: Vec<u8> = delivery.into_items().map(Item::into_value).collect();
assert_eq!(values, [1, 2, 3]);
let delivery = Delivery::in_custody(one(7));
assert!(delivery.into_parts().1.is_none(), "nothing to answer on");
}
#[test]
fn an_ack_that_holds_releases_nothing() {
let ack = Ack::<ItemId, ()>::holding("consumer", Lifecycle::Processed(()));
assert!(ack.released().is_empty());
assert_eq!(ack.lifecycle().station(), Station::Processed);
}
#[test]
fn releasing_names_exactly_what_it_was_given() {
let ack = Ack::<ItemId, ()>::holding("consumer", Lifecycle::Processed(()))
.releasing(ItemId::new(1))
.releasing(ItemId::new(3));
let released: HashSet<ItemId> = ack.released().clone();
assert_eq!(released.len(), 2);
assert!(released.contains(&ItemId::new(1)));
assert!(!released.contains(&ItemId::new(2)));
}
#[test]
fn an_ack_built_from_a_set_keeps_it_verbatim() {
let set: HashSet<ItemId> = (0..4).map(ItemId::new).collect();
let ack = Ack::new(set.clone(), "consumer", Lifecycle::Persisted(9u32));
assert_eq!(ack.released(), &set);
assert_eq!(*ack.lifecycle().unwrap_persisted_ref(), 9);
}
#[test]
fn the_oneshot_answers_once_and_the_receiver_reads_the_split_halves() {
let (ack, answers) = ack_channel::<ItemId>();
assert!(answers.take().is_waiting());
let sent = Ack::holding("consumer", Lifecycle::Persisted(())).releasing(ItemId::new(4));
assert!(ack.send(sent));
let Answer::Settled(settled) = answers.take() else {
panic!("the answer was sent");
};
assert_eq!(settled.released().len(), 1);
assert_eq!(settled.observation().station(), Some(Station::Persisted));
let (released, worker, observation, message, receipts) = settled.into_parts();
assert!(released.contains(&ItemId::new(4)));
assert_eq!(worker, "consumer");
assert_eq!(observation.station(), Some(Station::Persisted));
assert!(message.is_none());
assert!(receipts.is_none());
}
#[test]
fn a_dropped_oneshot_reads_as_hung_up_and_never_as_an_answer() {
let (ack, answers) = ack_channel::<ItemId>();
drop(ack);
assert!(answers.take().is_hung_up());
}
#[test]
fn a_sender_whose_receiver_is_gone_reports_that_it_was_not_heard() {
let (ack, answers) = ack_channel::<ItemId>();
drop(answers);
assert!(!ack.send(Ack::<ItemId, ()>::holding(
"consumer",
Lifecycle::Processed(())
)));
}
#[test]
fn the_info_type_is_erased_at_the_oneshot_and_asked_for_back_at_the_tap() {
#[derive(Debug, PartialEq)]
struct Bytes(usize);
#[derive(Debug, PartialEq)]
struct Rows(&'static str);
fn answer<I: core::any::Any + Send + Sync>(info: I) -> Observation {
let (ack, answers) = ack_channel::<ItemId>();
assert!(ack.send(Ack::<ItemId, I>::holding(
"consumer",
Lifecycle::Persisted(info)
)));
let Answer::Settled(settled) = answers.take() else {
panic!("the answer was sent");
};
settled.into_parts().2
}
let bytes = answer(Bytes(4096));
assert_eq!(bytes.info::<Bytes>(), Some(&Bytes(4096)));
assert_eq!(bytes.info::<Rows>(), None);
let rows = answer(Rows("scene"));
assert_eq!(rows.info::<Rows>(), Some(&Rows("scene")));
assert_eq!(rows.info::<usize>(), None);
}
#[test]
fn a_refusal_crosses_whole_and_a_failure_crosses_erased() {
let (ack, answers) = ack_channel::<ItemId>();
let skip = Skip::new(SkipReason::custom("oversize")).about("scene#3");
assert!(ack.send(Ack::<ItemId, ()>::holding(
"consumer",
Lifecycle::Skipped(skip)
)));
let Answer::Settled(settled) = answers.take() else {
panic!("the answer was sent");
};
let observation = settled.into_parts().2;
assert_eq!(observation.station(), Some(Station::Skipped));
let skip = observation.skip().expect("a skipped station carries one");
assert_eq!(skip.reason().as_str(), "oversize");
assert_eq!(skip.content(), Some("scene#3"));
assert!(observation.failure().is_none());
}
#[derive(Default)]
struct Counting {
stations: std::sync::Mutex<Vec<(String, Station, Option<usize>)>>,
}
impl LifecycleTap for Counting {
fn observe(&self, node: &NodeName, observation: &Observation) {
let Some(arrival) = observation.arrival() else {
return;
};
self.stations.lock().expect("the tap's lock").push((
node.as_str().to_owned(),
arrival.station(),
arrival.info::<usize>().copied(),
));
}
}
#[test]
fn one_tap_observes_units_carrying_different_info_types() {
let tap = Arc::new(Counting::default());
let taps = crate::Taps::new().with(tap.clone());
for (node, observation) in [
("decode", Lifecycle::<usize>::Processed(12).erase()),
(
"store",
Lifecycle::<&'static str>::Persisted("rows").erase(),
),
] {
<crate::Taps as LifecycleTap>::observe(&taps, NodeName::new(node), &observation);
}
let seen = tap.stations.lock().expect("the tap's lock").clone();
assert_eq!(
seen,
vec![
("decode".to_owned(), Station::Processed, Some(12)),
("store".to_owned(), Station::Persisted, None),
]
);
}
#[test]
fn a_delivery_can_be_answered_by_a_consumer_that_never_reads_the_payload() {
let (ack, answers) = ack_channel::<ItemId>();
let delivery = Delivery::new(batch(&[1, 2, 3]), ack);
let (payload, ack): (_, Option<Custody<ItemId>>) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
let released: HashSet<ItemId> = payload.keys().copied().collect();
assert!(ack.send(Ack::new(released, "consumer", Lifecycle::Persisted(()))));
let Answer::Settled(settled) = answers.take() else {
panic!("answered");
};
assert_eq!(settled.released().len(), 3);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct SceneId(u64);
struct SceneOpen;
impl crate::Receipts for SceneOpen {
type Receipt = SceneId;
}
#[test]
fn an_ack_carries_a_typed_receipt_per_item_and_the_producer_reads_it_back() {
let (ack, answers) = ack_channel::<ItemId>();
let delivery = Delivery::new(batch(&[1, 2]), ack);
let (payload, custody) = delivery.into_parts();
let custody = custody.expect("a delivery off the wire carries its custody token");
let released: HashSet<ItemId> = payload.keys().copied().collect();
assert!(custody.send(
Ack::new(released, "seat", Lifecycle::Persisted(())).receipting(ItemId::new(1), SceneId(4242))
));
let Answer::Settled(mut settled) = answers.take() else {
panic!("answered");
};
assert_eq!(settled.released().len(), 2);
assert!(settled.has_receipt(&ItemId::new(1)));
assert_eq!(
settled.receipt::<SceneId>(&ItemId::new(1)),
Ok(&SceneId(4242))
);
assert_eq!(
settled.receipt::<SceneId>(&ItemId::new(2)),
Err(Unreceipted::Silent)
);
assert_eq!(
settled.take_receipt::<String>(&ItemId::new(1)),
Err(Unreceipted::Mismatched)
);
assert_eq!(
settled.take_receipt::<SceneId>(&ItemId::new(1)),
Ok(SceneId(4242))
);
assert_eq!(
settled.take_receipt::<SceneId>(&ItemId::new(1)),
Err(Unreceipted::Silent)
);
}
#[test]
fn a_receipt_does_not_release_and_a_release_does_not_receipt() {
let (ack, answers) = ack_channel::<ItemId>();
let delivery = Delivery::new(one(9), ack);
let (_payload, custody) = delivery.into_parts();
let custody = custody.expect("token");
assert!(
custody.send(
Ack::<ItemId, ()>::holding(
"seat",
Lifecycle::Failed(crate::Failure::new(std::io::Error::other(
"the store would not take it"
)))
)
.receipting(ItemId::new(9), SceneId(1))
)
);
let Answer::Settled(settled) = answers.take() else {
panic!("answered");
};
assert!(
settled.released().is_empty(),
"a receipt released a key nothing said to release"
);
assert_eq!(settled.receipt::<SceneId>(&ItemId::new(9)), Ok(&SceneId(1)));
assert_eq!(settled.observation().station(), Some(Station::Failed));
}
#[test]
fn a_fate_carries_no_receipt_because_no_consumer_saw_it() {
let (ack, answers) = ack_channel::<ItemId>();
let released: HashSet<ItemId> = [ItemId::new(3)].into_iter().collect();
assert!(ack.fate(
released,
"gate",
crate::Fate::GivenUp {
attempt: 3,
failure: None,
message: (),
}
));
let Answer::Settled(settled) = answers.take() else {
panic!("answered");
};
assert!(!settled.has_receipt(&ItemId::new(3)));
assert_eq!(
settled.receipt::<SceneId>(&ItemId::new(3)),
Err(Unreceipted::Silent)
);
}
#[test]
fn an_obligation_carries_its_receipts_through_to_the_settle() {
let (ack, answers) = ack_channel::<ItemId>();
let delivery = Delivery::new(batch(&[5, 6]), ack);
let (payload, custody) = delivery.into_parts();
let mut owed = super::super::Owed::open(payload.keys().copied(), custody);
owed.receipt_of::<SceneOpen>(ItemId::new(5), SceneId(55));
owed.release(ItemId::new(5));
owed.release(ItemId::new(6));
assert!(owed.settle("seat", Lifecycle::Persisted(())));
let Answer::Settled(settled) = answers.take() else {
panic!("answered");
};
assert_eq!(
settled.receipt::<SceneId>(&ItemId::new(5)),
Ok(&SceneId(55))
);
assert_eq!(
settled.receipt::<SceneId>(&ItemId::new(6)),
Err(Unreceipted::Silent)
);
}
#[test]
fn a_joined_custody_answers_on_each_member_and_carries_no_composed_receipt() {
let (ack, answers) = ack_channel::<ItemId>();
let delivery = Delivery::new(one(1), ack);
let (payload, custody) = delivery.into_parts();
let owing = super::super::Owing::open(payload.keys().copied(), custody);
let composed = Custody::joined(ItemId::new(70), vec![owing.share(ItemId::new(1))]);
assert!(
composed.send(
Ack::new(
[ItemId::new(70)].into_iter().collect(),
"join",
Lifecycle::Processed(())
)
.receipting(ItemId::new(70), SceneId(7))
)
);
let Answer::Settled(settled) = answers.take() else {
panic!("the member's own token was answered");
};
assert!(settled.released().contains(&ItemId::new(1)));
assert!(
!settled.has_receipt(&ItemId::new(70)),
"the composed answer's receipt reached a member's token"
);
}
#[test]
fn a_waiting_door_and_a_polling_door_read_one_oneshot() {
let (ack, answers) = ack_channel::<ItemId>();
assert!(answers.take().is_waiting());
drop(ack);
assert_eq!(
answers
.settled_within(core::time::Duration::from_secs(5))
.err(),
Some(super::Unsettled::HungUp)
);
let (ack, answers) = ack_channel::<ItemId>();
assert_eq!(
answers
.settled_within(core::time::Duration::from_millis(50))
.err(),
Some(super::Unsettled::TimedOut)
);
drop(ack);
}