use core::{
future::Future,
pin::Pin,
task::{Context, Poll},
time::Duration,
};
use std::sync::{
Arc, Mutex,
atomic::{AtomicUsize, Ordering},
};
use jiff::SignedDuration;
use super::{BudgetSpent, SearchBudget, WalkBudget, WalkClock, tightened_budget, walk_within};
struct After<T> {
polls: usize,
out: Option<T>,
}
impl<T> After<T> {
fn new(polls: usize, out: T) -> Self {
Self {
polls,
out: Some(out),
}
}
}
impl<T: Unpin> Future for After<T> {
type Output = T;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
if self.polls == 0 {
return Poll::Ready(
self
.out
.take()
.expect("a walk is not polled after it answered"),
);
}
self.polls -= 1;
cx.waker().wake_by_ref();
Poll::Pending
}
}
struct Scripted {
polls: usize,
handed: Arc<Mutex<Vec<Duration>>>,
consulted: Arc<AtomicUsize>,
}
impl Scripted {
fn new(polls: usize) -> (Self, Arc<Mutex<Vec<Duration>>>, Arc<AtomicUsize>) {
let handed = Arc::new(Mutex::new(Vec::new()));
let consulted = Arc::new(AtomicUsize::new(0));
(
Self {
polls,
handed: Arc::clone(&handed),
consulted: Arc::clone(&consulted),
},
handed,
consulted,
)
}
}
impl WalkClock for Scripted {
fn elapsed<'a>(&'a self, budget: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
self.consulted.fetch_add(1, Ordering::Relaxed);
self
.handed
.lock()
.expect("no test panics while holding this")
.push(budget);
Box::pin(After::new(self.polls, ()))
}
}
fn spent(budget: SearchBudget) -> (WalkBudget, Arc<Mutex<Vec<Duration>>>, Arc<AtomicUsize>) {
let (clock, handed, consulted) = Scripted::new(0);
(WalkBudget::new(clock, budget), handed, consulted)
}
fn patient(budget: SearchBudget) -> (WalkBudget, Arc<Mutex<Vec<Duration>>>, Arc<AtomicUsize>) {
let (clock, handed, consulted) = Scripted::new(usize::MAX);
(WalkBudget::new(clock, budget), handed, consulted)
}
#[test]
fn a_requests_budget_may_only_tighten_the_deployments() {
let (short, long) = (SignedDuration::from_secs(5), SignedDuration::from_secs(30));
assert_eq!(
tightened_budget(Some(short), Some(long)),
Some(short),
"the ask, well inside the wall"
);
assert_eq!(
tightened_budget(Some(SignedDuration::from_secs(300)), Some(long)),
Some(long),
"THE WALL — and no request may raise it",
);
assert_eq!(
tightened_budget(Some(short), None),
Some(short),
"an absent deployment budget is informed openness, so the ask stands"
);
assert_eq!(
tightened_budget(None, Some(long)),
Some(long),
"the deployment's, standing alone"
);
assert_eq!(tightened_budget(None, None), None, "nobody named one");
}
#[test]
fn a_budget_already_past_is_carried_through_rather_than_clamped_here() {
let past = SignedDuration::from_secs(-5);
assert_eq!(
tightened_budget(Some(past), Some(SignedDuration::from_secs(30))),
Some(past),
);
}
#[test]
fn an_unnamed_search_budget_names_nothing() {
assert_eq!(SearchBudget::new().walk(), None);
assert_eq!(SearchBudget::default(), SearchBudget::new());
let named = SearchBudget::new().with_walk(SignedDuration::from_secs(30));
assert_eq!(named.walk(), Some(SignedDuration::from_secs(30)));
let mut narrowed = named;
narrowed.set_walk(None);
assert_eq!(narrowed.walk(), None);
}
#[tokio::test]
async fn a_walk_nobody_budgeted_is_awaited_with_no_clock_at_all() {
let unseated = walk_within(None, None, "Bare", After::new(0, "answered")).await;
assert_eq!(unseated, Ok("answered"));
let (seat, handed, consulted) = patient(SearchBudget::new());
let unnamed = walk_within(Some(&seat), None, "Bare", After::new(0, "answered")).await;
assert_eq!(unnamed, Ok("answered"));
assert_eq!(
consulted.load(Ordering::Relaxed),
0,
"a seat that named no number still built a timer"
);
assert!(handed.lock().expect("no panic").is_empty());
}
#[tokio::test]
async fn a_walk_that_outlives_its_budget_refuses_by_name() {
let wall = SignedDuration::from_secs(30);
let (seat, handed, consulted) = spent(SearchBudget::new().with_walk(wall));
let refused = walk_within(
Some(&seat),
None,
"app::ClipText",
After::new(64, "answered"),
)
.await
.expect_err("a walk that never finishes cannot answer");
assert_eq!(refused, BudgetSpent::new("app::ClipText", wall));
assert_eq!(refused.tower(), "app::ClipText");
assert_eq!(refused.budget(), wall);
assert_eq!(consulted.load(Ordering::Relaxed), 1);
assert_eq!(
handed.lock().expect("no panic").as_slice(),
[Duration::from_secs(30)]
);
let said = refused.to_string();
assert!(said.contains("app::ClipText"), "{said}");
assert!(said.contains("did not finish"), "{said}");
assert!(said.contains("nothing was answered"), "{said}");
}
#[tokio::test]
async fn a_walk_ready_in_the_same_wake_as_the_clock_keeps_its_answer() {
let (seat, _, consulted) = spent(SearchBudget::new().with_walk(SignedDuration::from_secs(30)));
let answered = walk_within(
Some(&seat),
None,
"app::ClipText",
After::new(0, "answered"),
)
.await;
assert_eq!(answered, Ok("answered"));
assert_eq!(
consulted.load(Ordering::Relaxed),
1,
"the clock is built where a number was named, and the walk simply won"
);
}
#[tokio::test]
async fn the_clock_is_handed_the_number_the_two_tiers_agreed_on() {
let wall = SignedDuration::from_secs(30);
let (seat, handed, _) = patient(SearchBudget::new().with_walk(wall));
let _ = walk_within(
Some(&seat),
Some(SignedDuration::from_secs(5)),
"app::ClipText",
After::new(0, "answered"),
)
.await;
assert_eq!(
handed.lock().expect("no panic").as_slice(),
[Duration::from_secs(5)]
);
let (seat, handed, _) = patient(SearchBudget::new().with_walk(wall));
let _ = walk_within(
Some(&seat),
Some(SignedDuration::from_secs(300)),
"app::ClipText",
After::new(0, "answered"),
)
.await;
assert_eq!(
handed.lock().expect("no panic").as_slice(),
[Duration::from_secs(30)]
);
let (seat, handed, _) = patient(SearchBudget::new());
let _ = walk_within(
Some(&seat),
Some(SignedDuration::from_secs(7)),
"app::ClipText",
After::new(0, "answered"),
)
.await;
assert_eq!(
handed.lock().expect("no panic").as_slice(),
[Duration::from_secs(7)]
);
}
#[tokio::test]
async fn a_budget_already_past_is_handed_to_the_clock_as_zero() {
let past = SignedDuration::from_secs(-5);
let (seat, handed, _) = spent(SearchBudget::new().with_walk(past));
let refused = walk_within(
Some(&seat),
None,
"app::ClipText",
After::new(64, "answered"),
)
.await
.expect_err("a budget already past cannot be waited out");
assert_eq!(
handed.lock().expect("no panic").as_slice(),
[Duration::ZERO]
);
assert_eq!(
refused.budget(),
past,
"the refusal carries the COMPOSED number"
);
}
#[test]
fn a_seat_debugs_as_its_numbers() {
let (seat, _, _) = patient(SearchBudget::new().with_walk(SignedDuration::from_secs(30)));
let printed = format!("{seat:?}");
assert!(printed.contains("WalkBudget"), "{printed}");
assert!(printed.contains("30s"), "{printed}");
assert_eq!(
seat.budget().walk(),
Some(SignedDuration::from_secs(30)),
"the seat hands its numbers back unchanged"
);
}