ingraph 0.1.0

A declaration-driven indexing framework: records and nodes are written as Rust types, and the storage rows, the dataflow between them and the GraphQL query surface are emitted from the declaration.
Documentation
use core::time::Duration;

use std::{thread, time::Instant};

use super::Shutdown;

#[test]
fn a_registry_nobody_enrolled_in_waits_for_nothing() {
  let shutdown = Shutdown::new();
  assert!(shutdown.is_empty());
  assert_eq!(shutdown.len(), 0);
  assert!(shutdown.parties().is_empty());
}

#[test]
fn registering_counts_the_parties_and_keeps_the_order_it_was_told() {
  let mut shutdown = Shutdown::new();
  let _decode = shutdown.register("decode");
  let _scenes = shutdown.register("scenes");
  let _titles = shutdown.register("titles");

  assert_eq!(shutdown.len(), 3, "the walk knew N");
  let named: Vec<&str> = shutdown
    .parties()
    .iter()
    .map(|party| party.name().as_str())
    .collect();
  assert_eq!(named, ["decode", "scenes", "titles"]);
}

#[test]
fn a_party_hears_the_wind_down_and_only_the_one_it_was_told() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let scenes = shutdown.register("scenes");

  assert!(!decode.winding(), "nothing has been said yet");
  assert!(!scenes.winding());

  assert!(shutdown.parties()[0].announce(), "the party is still there");
  assert!(decode.winding(), "it was told");
  assert!(!scenes.winding(), "and its neighbour was not");
}

#[test]
fn a_second_announcement_coalesces_into_the_first() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let party = &shutdown.parties()[0];

  assert!(party.announce());
  assert!(party.announce(), "a full slot is not a refusal");
  assert!(decode.winding());
}

#[test]
fn announcing_to_a_party_that_has_gone_answers_false() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  drop(decode);

  assert!(
    !shutdown.parties()[0].announce(),
    "a party that has finished has nothing left to be told"
  );
}

#[test]
fn the_completion_is_the_positive_signal_and_a_look_rather_than_a_take() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");

  assert!(!shutdown.parties()[0].settled(), "it is still running");
  decode.settle();
  assert!(shutdown.parties()[0].settled());
  assert!(
    shutdown.parties()[0].settled(),
    "asking twice answers twice — the shutdown walks the registry more than once"
  );
}

#[test]
fn a_party_that_dropped_without_firing_is_unanswered_forever() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let scenes = shutdown.register("scenes");
  scenes.settle();
  // Panicked, aborted, or simply never wired to fire — the registry cannot tell, and the report it
  // feeds does not have to: what it names is who did not answer.
  drop(decode);

  assert!(!shutdown.parties()[0].settled());
  assert!(shutdown.parties()[1].settled());
  let unanswered: Vec<&str> = shutdown
    .parties()
    .iter()
    .filter(|party| !party.settled())
    .map(|party| party.name().as_str())
    .collect();
  assert_eq!(unanswered, ["decode"]);
}

#[test]
fn a_party_finishes_by_settling_or_by_vanishing_and_the_registry_can_tell_them_apart() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let scenes = shutdown.register("scenes");

  assert!(!shutdown.parties()[0].finished(), "both are still running");
  assert!(!shutdown.is_finished());

  decode.settle();
  drop(scenes);

  assert!(shutdown.is_finished(), "neither is running any more");
  assert!(shutdown.parties()[0].settled(), "one answered");
  assert!(
    !shutdown.parties()[1].settled(),
    "and the other only stopped"
  );
}

#[test]
fn the_park_wakes_once_per_party_however_that_party_ended() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let scenes = shutdown.register("scenes");
  decode.settle();
  drop(scenes);

  assert!(
    shutdown.park(Some(Duration::from_secs(5))),
    "the settled one"
  );
  assert!(
    shutdown.park(Some(Duration::from_secs(5))),
    "the vanished one"
  );
  assert!(
    !shutdown.park(Some(Duration::from_millis(10))),
    "and nobody else is left to finish"
  );
  assert!(
    shutdown.parties()[0].settled(),
    "the wake is not the answer — the look survives being parked on"
  );
}

#[test]
fn the_park_waits_for_a_party_that_is_still_working() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let hand = thread::spawn(move || {
    thread::sleep(Duration::from_millis(20));
    decode.settle();
  });

  let began = Instant::now();
  assert!(shutdown.park(None), "it parked until the party finished");
  assert!(began.elapsed() >= Duration::from_millis(20));
  assert!(shutdown.is_finished());
  hand.join().expect("the party's own thread");
}

#[test]
fn a_registry_nobody_enrolled_in_has_nothing_to_park_for() {
  let shutdown = Shutdown::new();
  assert!(shutdown.is_finished(), "an empty deployment is finished");
  assert!(
    !shutdown.park(None),
    "and a wait that could never end is not the honest answer to it"
  );
}

#[test]
fn a_party_has_no_engine_until_an_ignition_says_it_does() {
  // The mark the failed-launch unwind reads: mid-walk the registry holds both kinds of party at
  // once, and what tells them apart is whether an enrolment has actually reached an engine. It is
  // a fact about BEGINNING and answers independently of how the party then ended.
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  let scenes = shutdown.register("scenes");

  assert!(!shutdown.parties()[0].ignited(), "nothing has started it");
  assert!(!shutdown.parties()[1].ignited());

  decode.mark().ignite();
  assert!(shutdown.parties()[0].ignited());
  assert!(
    !shutdown.parties()[1].ignited(),
    "and its neighbour is still waiting for a walk that may never reach it"
  );

  decode.settle();
  drop(scenes);
  assert!(
    shutdown.parties()[0].ignited(),
    "a party that began and finished still began"
  );
  assert!(!shutdown.parties()[1].ignited());
}

#[test]
fn a_party_whose_framework_half_is_gone_reads_it_as_the_same_instruction() {
  let mut shutdown = Shutdown::new();
  let decode = shutdown.register("decode");
  assert!(!decode.winding());
  drop(shutdown);
  assert!(
    decode.winding(),
    "nobody is left to ask this party for anything"
  );
}