use core::error::Error;
use std::{
sync::{Arc, Mutex},
thread,
time::{Duration, Instant},
};
use jiff::SignedDuration;
use crate::{AsyncTeardown, Resources, Shutdown, Taps};
use super::{App, Farewell};
type Record = Arc<Mutex<Vec<&'static str>>>;
fn record() -> Record {
Arc::new(Mutex::new(Vec::new()))
}
fn seen(record: &Record) -> Vec<&'static str> {
record.lock().expect("the stop's record").clone()
}
struct Says {
name: &'static str,
record: Record,
}
impl AsyncTeardown for Says {
async fn teardown(self) -> Result<(), Box<dyn Error + Send + Sync>> {
self
.record
.lock()
.expect("the stop's record")
.push(self.name);
Ok(())
}
}
fn goodbye(name: &'static str, record: &Record) -> Farewell {
Farewell::new(
name,
Says {
name,
record: Arc::clone(record),
},
)
}
struct Admitting {
name: &'static str,
record: Record,
}
impl Drop for Admitting {
fn drop(&mut self) {
self
.record
.lock()
.expect("the stop's record")
.push(self.name);
}
}
fn source(name: &'static str, record: &Record) -> Box<dyn core::any::Any + Send> {
Box::new(Admitting {
name,
record: Arc::clone(record),
})
}
fn world(
shutdown: Shutdown,
sources: Vec<Box<dyn core::any::Any + Send>>,
teardowns: Vec<Farewell>,
) -> App<()> {
App::new(
std::sync::Arc::new(Resources::new()),
shutdown,
Taps::new(),
std::sync::Arc::new(crate::Registries::default()),
Vec::new(),
sources,
Vec::new(),
Vec::new(),
Vec::new(),
teardowns,
std::collections::HashMap::new(),
std::collections::HashMap::new(),
std::collections::HashMap::new(),
)
}
#[test]
fn a_world_that_has_already_settled_stops_cleanly_and_says_its_goodbyes() {
let record = record();
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let scenes = shutdown.register("scenes");
decode.settle();
scenes.settle();
let stopped = world(
shutdown,
Vec::new(),
vec![goodbye("pool", &record), goodbye("device", &record)],
)
.shutdown(None);
assert_eq!(stopped.settled(), 2);
assert_eq!(stopped.unsettled().len(), 0);
assert!(!stopped.overran());
assert!(stopped.is_clean());
assert_eq!(
seen(&record),
["device", "pool"],
"last enrolled, first to say goodbye"
);
}
#[test]
fn the_sources_stop_before_anything_is_waited_for_and_last_started_first() {
let record = record();
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let stopping = Arc::clone(&record);
let hand = thread::spawn(move || {
while stopping.lock().expect("the stop's record").len() < 2 {
thread::yield_now();
}
decode.settle();
});
let stopped = world(
shutdown,
vec![source("intake", &record), source("clock", &record)],
vec![goodbye("pool", &record)],
)
.shutdown(None);
hand.join().expect("the party's own thread");
assert!(stopped.is_clean());
assert_eq!(
seen(&record),
["clock", "intake", "pool"],
"intake stops last-started-first, and only then is anybody told goodbye"
);
}
#[test]
fn a_deadline_that_runs_out_names_who_did_not_answer_and_says_no_goodbye() {
let record = record();
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let scenes = shutdown.register("scenes");
scenes.settle();
let began = Instant::now();
let stopped = world(shutdown, Vec::new(), vec![goodbye("pool", &record)])
.shutdown(Some(SignedDuration::from_millis(30)));
assert!(began.elapsed() >= Duration::from_millis(30), "it waited");
assert!(stopped.overran());
assert_eq!(stopped.settled(), 1);
let unanswered: Vec<&str> = stopped.unsettled().map(|name| name.as_str()).collect();
assert_eq!(unanswered, ["decode"]);
assert!(!stopped.is_clean());
assert_eq!(stopped.untorn().len(), 1, "the goodbye is named as un-torn");
assert_eq!(stopped.untorn()[0].name().as_str(), "pool");
assert!(stopped.untorn()[0].error().is_none(), "it was never said");
assert!(
seen(&record).is_empty(),
"a store is not flushed while the node writing to it is still running"
);
drop(decode);
}
#[test]
fn a_deadline_that_passed_before_it_was_given_waits_for_nothing() {
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let began = Instant::now();
let stopped =
world(shutdown, Vec::new(), Vec::new()).shutdown(Some(SignedDuration::from_millis(-500)));
assert!(began.elapsed() < Duration::from_millis(400));
assert!(stopped.overran());
assert_eq!(stopped.settled(), 0);
drop(decode);
}
#[test]
fn an_abort_stops_now_and_reports_whoever_had_already_answered() {
let record = record();
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let scenes = shutdown.register("scenes");
scenes.settle();
let began = Instant::now();
let stopped = world(
shutdown,
vec![source("intake", &record)],
vec![goodbye("pool", &record)],
)
.abort();
assert!(
began.elapsed() < Duration::from_millis(500),
"it did not wait"
);
assert!(!stopped.overran(), "no deadline ran out — none was given");
assert_eq!(stopped.settled(), 1);
let unanswered: Vec<&str> = stopped.unsettled().map(|name| name.as_str()).collect();
assert_eq!(unanswered, ["decode"]);
assert_eq!(
seen(&record),
["intake"],
"the intake still stopped, and no goodbye was said"
);
assert_eq!(stopped.untorn().len(), 1);
drop(decode);
}
#[test]
fn an_abort_of_a_settled_world_still_says_no_goodbye() {
let record = record();
let mut shutdown = Shutdown::new();
shutdown.register("decode").settle();
let stopped = world(shutdown, Vec::new(), vec![goodbye("pool", &record)]).abort();
assert_eq!(stopped.settled(), 1);
assert!(
seen(&record).is_empty(),
"a stop that would not wait for its nodes does not wait for their stores"
);
assert_eq!(stopped.untorn().len(), 1);
}
#[test]
fn until_stopped_parks_until_the_world_ends_of_itself() {
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let hand = thread::spawn(move || {
thread::sleep(Duration::from_millis(20));
decode.settle();
});
let running = world(shutdown, Vec::new(), Vec::new());
let began = Instant::now();
running.until_stopped();
assert!(began.elapsed() >= Duration::from_millis(20));
hand.join().expect("the party's own thread");
let stopped = running.shutdown(None);
assert_eq!(stopped.settled(), 1);
assert!(stopped.is_clean());
}
#[test]
fn an_empty_deployment_is_stopped_the_moment_it_is_asked() {
let running = world(Shutdown::new(), Vec::new(), Vec::new());
running.until_stopped();
let stopped = running.shutdown(None);
assert_eq!(stopped.settled(), 0);
assert!(stopped.is_clean());
assert_eq!(stopped.to_string(), "stopped: 0 settled");
}
#[test]
fn the_report_reads_as_rows_under_a_summary() {
let mut shutdown = Shutdown::new();
let decode = shutdown.register("decode");
let stopped = world(shutdown, Vec::new(), Vec::new()).abort();
let rendered = stopped.to_string();
assert!(rendered.starts_with("stopped: 0 settled"));
assert!(rendered.contains("`decode` did not answer"));
drop(decode);
}
mod halt_on {
use super::{App, Record, Resources, Shutdown, Taps, record, seen};
use crate::conduit;
use std::{
sync::Arc,
thread,
time::{Duration, Instant},
};
fn parked() -> (App<()>, crate::Enrolled) {
let mut shutdown = Shutdown::new();
let party = shutdown.register("decode");
let app = App::new(
Arc::new(Resources::new()),
shutdown,
Taps::new(),
Arc::new(crate::Registries::default()),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
std::collections::HashMap::new(),
std::collections::HashMap::new(),
std::collections::HashMap::new(),
);
(app, party)
}
fn woken(app: App<()>, patience: Duration, record: &Record) -> bool {
let written = Arc::clone(record);
let hand = thread::spawn(move || {
app.until_stopped();
written.lock().expect("the halt's record").push("woken");
app.halted()
});
let end = Instant::now() + patience;
while Instant::now() < end && !hand.is_finished() {
thread::yield_now();
}
assert!(hand.is_finished(), "the park never returned");
hand.join().expect("the parked thread")
}
#[test]
fn a_registered_source_that_speaks_wakes_the_park() {
let record = record();
let (mut app, party) = parked();
let (fired, source) = conduit::bounded::<()>(1);
app.halt_on(source);
assert!(!app.halted(), "nothing has been said yet");
fired.send(()).expect("the watcher is listening");
assert!(woken(app, Duration::from_secs(5), &record));
assert_eq!(seen(&record), ["woken"]);
drop(party);
}
#[test]
fn a_registered_source_that_hangs_up_is_the_same_news() {
let record = record();
let (mut app, party) = parked();
let (fired, source) = conduit::bounded::<()>(1);
app.halt_on(source);
drop(fired);
assert!(woken(app, Duration::from_secs(5), &record));
drop(party);
}
#[test]
fn two_sources_are_two_registrations_and_either_one_wakes_the_park() {
let record = record();
let (mut app, party) = parked();
let (_signals, from_signals) = conduit::bounded::<()>(1);
let (supervisor, from_supervisor) = conduit::bounded::<()>(1);
app.halt_on(from_signals);
app.halt_on(from_supervisor);
supervisor.send(()).expect("the watcher is listening");
assert!(woken(app, Duration::from_secs(5), &record));
drop(party);
}
#[test]
fn a_source_that_fired_before_the_park_is_not_waited_past() {
let record = record();
let (mut app, party) = parked();
let (fired, source) = conduit::bounded::<()>(1);
app.halt_on(source);
fired.send(()).expect("the watcher is listening");
while !app.halted() {
thread::yield_now();
}
assert!(woken(app, Duration::from_secs(5), &record));
drop(party);
}
#[test]
fn the_ordinary_park_still_ends_when_every_party_finishes() {
let record = record();
let (mut app, party) = parked();
let (_fired, source) = conduit::bounded::<()>(1);
app.halt_on(source);
party.settle();
assert!(
!woken(app, Duration::from_secs(5), &record),
"the world ended of itself, so no exit source had fired"
);
}
}