use core::{future::Future, pin::Pin, time::Duration};
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use async_graphql::{Context, EmptyMutation, EmptySubscription, Object, Schema};
use jiff::SignedDuration;
use super::{TowerDoor, installed_road};
use crate::{
AssembledTower, DeclaredTower, Lane, LaneIdent, RouterMissing, SearchBudget, SearchTower,
SeatsUnfilled, UnfilledSeat, WalkBudget, WalkClock,
};
static CORPUS: &[Lane] = &[
Lane::of(LaneIdent::new("en")),
Lane::of(LaneIdent::new("ja")),
];
struct Road;
struct RoadSteps {
minted: Arc<AtomicUsize>,
walked: usize,
}
impl SearchTower for Road {
type Question = String;
type Answer = String;
type Steps = RoadSteps;
}
impl DeclaredTower for Road {
type StepOptions = String;
type SearchOptions = ();
}
impl AssembledTower for Road {
type Refusal = core::convert::Infallible;
async fn run(
steps: &mut Self::Steps,
question: Self::Question,
options: Option<&Self::StepOptions>,
_asked: Option<Self::SearchOptions>,
) -> Result<Self::Answer, Self::Refusal> {
steps.walked += 1;
Ok(format!(
"{question}/{walked}/{named}",
walked = steps.walked,
named = options.map_or("none", String::as_str),
))
}
}
struct Awaited;
impl SearchTower for Awaited {
type Question = String;
type Answer = String;
type Steps = ();
}
impl DeclaredTower for Awaited {
type StepOptions = ();
type SearchOptions = ();
const ALL_SYNC: bool = false;
}
impl AssembledTower for Awaited {
type Refusal = core::convert::Infallible;
async fn run(
_steps: &mut Self::Steps,
question: Self::Question,
_options: Option<&Self::StepOptions>,
_asked: Option<Self::SearchOptions>,
) -> Result<Self::Answer, Self::Refusal> {
Ok(question)
}
}
struct Spent;
impl WalkClock for Spent {
fn elapsed<'a>(&'a self, _budget: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
Box::pin(core::future::ready(()))
}
}
struct Unfilled;
impl SearchTower for Unfilled {
type Question = String;
type Answer = String;
type Steps = ();
}
impl DeclaredTower for Unfilled {
type StepOptions = ();
type SearchOptions = ();
}
impl AssembledTower for Unfilled {
type Refusal = core::convert::Infallible;
fn check(_steps: &Self::Steps) -> Result<(), SeatsUnfilled> {
SeatsUnfilled::checked(
"Unfilled",
vec![
UnfilledSeat::widening("widen", "Synonyms"),
UnfilledSeat::crossing("fan", RouterMissing::new(CORPUS)),
],
)
}
async fn run(
_steps: &mut Self::Steps,
question: Self::Question,
_options: Option<&Self::StepOptions>,
_asked: Option<Self::SearchOptions>,
) -> Result<Self::Answer, Self::Refusal> {
Ok(question)
}
}
struct Root;
#[Object]
impl Root {
async fn walked(&self, ctx: &Context<'_>, asked: String) -> async_graphql::Result<String> {
let (mut steps, options, _wall) = installed_road::<Road>(ctx, "walked")?;
Ok(
Road::run(&mut steps, asked, options, None)
.await
.expect("this road refuses nothing"),
)
}
}
fn schema(door: Option<TowerDoor<Road>>) -> Schema<Root, EmptyMutation, EmptySubscription> {
let builder = Schema::build(Root, EmptyMutation, EmptySubscription);
match door {
Some(door) => door.install(builder).finish(),
None => builder.finish(),
}
}
fn road(minted: &Arc<AtomicUsize>) -> TowerDoor<Road> {
let tally = Arc::clone(minted);
TowerDoor::<Road>::installed(move || {
tally.fetch_add(1, Ordering::Relaxed);
RoadSteps {
minted: Arc::clone(&tally),
walked: 0,
}
})
.expect("this road declares nothing that could be missing")
}
async fn asked(schema: &Schema<Root, EmptyMutation, EmptySubscription>) -> async_graphql::Response {
schema.execute("{ walked(asked: \"harbour\") }").await
}
#[tokio::test]
async fn an_uninstalled_tower_refuses_and_names_the_install_line() {
let answer = asked(&schema(None)).await;
let said = answer
.errors
.first()
.map(|refusal| refusal.message.clone())
.expect("a road nobody installed cannot be walked");
assert!(said.contains("`walked`"), "{said}");
assert!(said.contains("Road"), "{said}");
assert!(said.contains("TowerDoor::<"), "{said}");
assert!(said.contains("installed"), "{said}");
}
#[tokio::test]
async fn an_installed_road_is_looked_up_and_run() {
let minted = Arc::new(AtomicUsize::new(0));
let answer = asked(&schema(Some(road(&minted)))).await;
assert!(answer.errors.is_empty(), "{:?}", answer.errors);
assert!(answer.data.to_string().contains("harbour/1/none"));
}
#[tokio::test]
async fn every_read_mints_its_own_road() {
let minted = Arc::new(AtomicUsize::new(0));
let schema = schema(Some(road(&minted)));
for _ in 0..3 {
let answer = asked(&schema).await;
assert!(answer.errors.is_empty(), "{:?}", answer.errors);
assert!(answer.data.to_string().contains("harbour/1/none"));
}
assert_eq!(minted.load(Ordering::Relaxed), 4);
}
#[tokio::test]
async fn the_deployments_own_knobs_arrive_with_the_road() {
let minted = Arc::new(AtomicUsize::new(0));
let door = road(&minted).with_step_options("launch".to_owned());
let answer = asked(&schema(Some(door))).await;
assert!(answer.errors.is_empty(), "{:?}", answer.errors);
assert!(answer.data.to_string().contains("harbour/1/launch"));
}
#[test]
fn the_gate_refuses_at_the_install_and_names_every_gap() {
let refused =
TowerDoor::<Unfilled>::installed(|| ()).expect_err("two declared words, two empty seats");
let said = refused.to_string();
assert_eq!(refused.unfilled().len(), 2);
assert!(said.contains("`widen`"), "{said}");
assert!(said.contains("`fan`"), "{said}");
}
#[test]
fn the_debug_line_names_the_tower_and_whether_knobs_were_named() {
let minted = Arc::new(AtomicUsize::new(0));
let rendered = format!("{:?}", road(&minted).with_step_options("launch".to_owned()));
assert!(rendered.contains("TowerDoor"), "{rendered}");
assert!(rendered.contains("Road"), "{rendered}");
assert!(rendered.contains("options: true"), "{rendered}");
assert!(rendered.contains("budget: None"), "{rendered}");
}
#[test]
fn the_budget_seat_holds_what_the_launch_named() {
let wall = SignedDuration::from_secs(30);
let door = TowerDoor::<Awaited>::installed(|| ())
.expect("this tower declares nothing that could be missing")
.with_budget(WalkBudget::new(Spent, SearchBudget::new().with_walk(wall)));
assert_eq!(
door.budget().map(|seat| seat.budget().walk()),
Some(Some(wall)),
);
let rendered = format!("{door:?}");
assert!(rendered.contains("WalkBudget"), "{rendered}");
assert!(rendered.contains("30s"), "{rendered}");
}
#[test]
fn a_budget_seat_can_be_cleared_after_construction() {
let mut door = TowerDoor::<Awaited>::installed(|| ())
.expect("this tower declares nothing that could be missing")
.with_budget(WalkBudget::new(Spent, SearchBudget::new()));
assert!(door.budget().is_some());
door.set_budget(None);
assert!(door.budget().is_none());
}
#[test]
fn a_minted_road_holds_what_its_deployment_gave_it() {
let minted = Arc::new(AtomicUsize::new(0));
let door = road(&minted);
let steps = door.mint();
assert!(Arc::ptr_eq(&steps.minted, &minted));
assert_eq!(steps.walked, 0);
}