use super::*;
#[test]
fn test_empty_root_context() {
let ctx = Context::root();
assert_eq!(ctx.scope_id, "root");
assert!(ctx.services.is_empty());
assert!(ctx.fibers.is_empty());
}
#[test]
fn test_fiber_coeffect_satisfaction_lifecycle() {
let ctx = Context::root();
let fiber = ctx.spawn_fiber("worker_1", vec!["mcardfs".to_string(), "signer".to_string()]);
assert_eq!(fiber.get_state(), FiberState::Pending);
ctx.register_service("mcardfs", "StorageEngineMock".to_string());
assert_eq!(fiber.get_state(), FiberState::Pending);
ctx.register_service("signer", "Ed25519SignerMock".to_string());
assert_eq!(fiber.get_state(), FiberState::Active);
let cleaned = Arc::new(Mutex::new(false));
let cleaned_clone = Arc::clone(&cleaned);
fiber.register_disposable(move || {
*cleaned_clone.lock().unwrap() = true;
Ok(())
});
assert!(fiber.dispose().is_ok());
assert_eq!(fiber.get_state(), FiberState::Disposed);
assert!(*cleaned.lock().unwrap());
}
#[test]
fn test_algebraic_isolation() {
let ctx = Context::root();
ctx.register_service("public_db", 100u32);
ctx.register_service("private_keys", 999u32);
let isolated = ctx.isolate(&["public_db"]);
assert!(isolated.get_service::<u32>("public_db").is_some());
assert!(isolated.get_service::<u32>("private_keys").is_none());
}
#[test]
fn test_mask_capability_filtering() {
let ctx = Context::root();
ctx.provide("clm.io.read", 100u32);
ctx.provide("clm.io.write", 200u32);
let masked = ctx.mask(&["clm.io.write"]);
assert!(masked.require("clm.io.read"));
assert!(!masked.require("clm.io.write"));
}
#[test]
fn test_fiber_vcard_sandwich_state_transitions() {
let ctx = Context::root();
let fiber = ctx.spawn_fiber("sandwich_test", vec![]);
assert_eq!(fiber.get_state(), FiberState::Active);
fiber.transition_to(FiberState::Loading).unwrap();
assert_eq!(fiber.get_state(), FiberState::Loading);
fiber.transition_to(FiberState::Active).unwrap();
assert_eq!(fiber.get_state(), FiberState::Active);
assert!(fiber.dispose().is_ok());
assert_eq!(fiber.get_state(), FiberState::Disposed);
}
#[test]
fn test_fiber_hmr_lifecycle_and_registry() {
let ctx = Context::root();
let fiber = ctx.create_fiber("hmr_worker", vec![]).unwrap();
assert_eq!(fiber.get_state(), FiberState::Active);
assert!(ctx.get_fiber("hmr_worker").is_some());
assert_eq!(ctx.list_fibers().len(), 1);
let dummy_ast = serde_json::json!({
"invariants": {
"preconditions": ["inv_1"],
"postconditions": ["inv_2"]
}
});
fiber.set_ast(dummy_ast.clone());
assert_eq!(fiber.get_ast(), Some(dummy_ast));
let unwound = Arc::new(Mutex::new(false));
let unwound_clone = Arc::clone(&unwound);
fiber.register_disposable(move || {
*unwound_clone.lock().unwrap() = true;
Ok(())
});
assert!(fiber.pause().is_ok());
assert_eq!(fiber.get_state(), FiberState::Paused);
assert!(fiber.unwind_disposables().is_ok());
assert!(*unwound.lock().unwrap());
assert_eq!(fiber.get_state(), FiberState::Paused);
assert!(fiber.activate().is_ok());
assert_eq!(fiber.get_state(), FiberState::Active);
assert!(ctx.remove_fiber("hmr_worker").is_some());
assert!(ctx.get_fiber("hmr_worker").is_none());
assert_eq!(ctx.list_fibers().len(), 0);
}
fn disposed_fiber() -> Fiber {
let fiber = Fiber::new("disposed", vec![]);
fiber.dispose().unwrap();
fiber
}
const UNIT_STATES: [FiberState; 7] = [
FiberState::Pending,
FiberState::Loading,
FiberState::Active,
FiberState::Paused,
FiberState::Suspended,
FiberState::Unloading,
FiberState::Disposed,
];
#[test]
fn a_disposed_fiber_cannot_be_resurrected() {
let attempts: [(&str, fn(&Fiber) -> Result<(), String>); 6] = [
("transition_to(Active)", |f| f.transition_to(FiberState::Active)),
("transition_to(Loading)", |f| f.transition_to(FiberState::Loading)),
("activate", Fiber::activate),
("resume", Fiber::resume),
("pause", Fiber::pause),
("suspend", Fiber::suspend),
];
for (name, attempt) in attempts {
let fiber = disposed_fiber();
let refused = attempt(&fiber).expect_err(name);
assert!(refused.starts_with("illegal fiber transition disposed -> "), "{name}: {refused}");
assert_eq!(fiber.get_state(), FiberState::Disposed, "{name}");
}
let fiber = Fiber::new("waiting", vec!["late".to_string()]);
fiber.dispose().unwrap();
assert!(!fiber.satisfy_coeffect("late"));
assert_eq!(fiber.get_state(), FiberState::Disposed);
}
#[test]
fn dispose_is_idempotent_on_a_disposed_fiber() {
let ctx = Context::root();
let fiber = ctx.spawn_fiber("twice", vec![]);
let runs = Arc::new(Mutex::new(0));
let counter = Arc::clone(&runs);
fiber.register_disposable(move || {
*counter.lock().unwrap() += 1;
Ok(())
});
assert_eq!(fiber.dispose(), Ok(()));
assert_eq!(fiber.dispose(), Ok(()));
assert_eq!(ctx.dispose(), Ok(()));
assert_eq!(fiber.get_state(), FiberState::Disposed);
assert_eq!(*runs.lock().unwrap(), 1);
}
#[test]
fn a_failed_fiber_leaves_only_through_dispose() {
let fiber = Fiber::new("failed", vec![]);
let failed = FiberState::Failed("boom".to_string());
fiber.transition_to(failed.clone()).unwrap();
for refused in [fiber.activate(), fiber.resume(), fiber.transition_to(FiberState::Loading)] {
assert!(refused.unwrap_err().starts_with("illegal fiber transition failed -> "));
assert_eq!(fiber.get_state(), failed);
}
assert_eq!(fiber.dispose(), Ok(()));
assert_eq!(fiber.get_state(), FiberState::Disposed);
}
#[test]
fn a_failing_disposer_fails_the_fiber_and_is_reported() {
let fiber = Fiber::new("leaky", vec![]);
fiber.register_disposable(|| Err("disposer boom".to_string()));
assert_eq!(fiber.dispose(), Err(vec!["disposer boom".to_string()]));
assert_eq!(fiber.get_state(), FiberState::Failed("Disposal errors encountered".to_string()));
}
#[test]
fn step_moves_along_a_table_edge_and_refuses_the_rest() {
let moved = step(&TABLE, &FiberState::Pending, FiberEvent::to(FiberState::Loading)).unwrap();
assert_eq!(moved, Moved { state: FiberState::Loading, effects: &[] });
let refused = step(&TABLE, &FiberState::Pending, FiberEvent::to(FiberState::Paused)).unwrap_err();
assert_eq!(
refused,
Illegal {
profile: "legacy_rust",
from: FiberState::Pending,
to: FiberState::Paused,
allowed: &["loading", "active"],
}
);
assert_eq!(
refused.to_string(),
"illegal fiber transition pending -> paused under the legacy_rust profile; allowed targets: [\"loading\", \"active\"]"
);
for from in &UNIT_STATES {
let (_, targets) = lifecycle::VALID_TRANSITIONS.iter().find(|(name, _)| *name == from.name()).unwrap();
for to in &UNIT_STATES {
let legal = step(&TABLE, from, FiberEvent::to(to.clone())).is_ok();
assert_eq!(legal, targets.contains(&to.name()), "{from:?} -> {to:?}");
}
assert!(step(&TABLE, &FiberState::Disposed, FiberEvent::to(from.clone())).is_err(), "disposed -> {from:?}");
}
}
#[test]
fn step_fires_the_dispose_bypass_from_every_state_but_disposed() {
let dispose = || FiberEvent::bypass(&lifecycle::RUST_DISPOSE, FiberState::Unloading);
let failed = FiberState::Failed("boom".to_string());
for from in UNIT_STATES.iter().chain([&failed]).filter(|state| **state != FiberState::Disposed) {
let moved = step(&TABLE, from, dispose()).unwrap();
assert_eq!(moved, Moved { state: FiberState::Unloading, effects: &[FiberEffect::UnwindDisposables] }, "{from:?}");
}
assert!(step(&TABLE, &FiberState::Disposed, dispose()).is_err());
let wrong_target = FiberEvent::bypass(&lifecycle::RUST_DISPOSE, FiberState::Disposed);
assert!(step(&TABLE, &FiberState::Active, wrong_target).is_err());
let no_bypasses = FiberTable { bypasses: &[], ..TABLE };
assert!(step(&no_bypasses, &FiberState::Active, dispose()).is_err());
}
#[test]
fn a_fiber_reports_the_profile_it_was_built_with() {
assert_eq!(Fiber::new("profiled", vec![]).profile(), "legacy_rust");
}
#[test]
fn a_context_draws_identifiers_from_its_source() {
let ctx = Context::root_with_ids(Arc::new(|| "fixed".to_string()));
assert_eq!(ctx.isolate(&[]).scope_id, "root/isolate:fixed");
assert_eq!(ctx.mask(&[]).scope_id, "root/mask:fixed");
assert_eq!(ctx.user("u").channel("c").isolate(&[]).scope_id, "root/user:u/channel:c/isolate:fixed");
let clocked = Context::root().isolate(&[]).scope_id;
let id = clocked.strip_prefix("root/isolate:").unwrap();
assert!(u128::from_str_radix(id, 16).unwrap() > 0, "{clocked}");
}
#[test]
fn state_names_on_the_wire_keep_their_debug_bytes() {
let rendered: Vec<String> = UNIT_STATES.iter().map(|state| format!("{state:?}")).collect();
assert_eq!(rendered, ["Pending", "Loading", "Active", "Paused", "Suspended", "Unloading", "Disposed"]);
assert_eq!(format!("{:?}", FiberState::Failed("why".to_string())), "Failed(\"why\")");
}
#[test]
fn no_production_source_discards_a_lifecycle_result() {
fn sources(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
for entry in std::fs::read_dir(dir).unwrap() {
let path = entry.unwrap().path();
if path.is_dir() {
sources(&path, out);
} else if path.extension().is_some_and(|ext| ext == "rs") {
out.push(path);
}
}
}
let mut files = Vec::new();
sources(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src"), &mut files);
assert!(files.len() > 100, "the scan must see the crate sources, saw {}", files.len());
let moves = ["transition_to(", "resume()", "dispose()", "activate()", "pause()", "suspend()"];
let discards = ["let _ ", "let _="];
let mut offenders = Vec::new();
for path in files.iter().filter(|path| !path.ends_with("context_tests.rs")) {
for (number, line) in std::fs::read_to_string(path).unwrap().lines().enumerate() {
let discarded = discards.iter().any(|discard| line.trim_start().starts_with(discard));
if discarded && moves.iter().any(|call| line.contains(&format!(".{call}"))) {
offenders.push(format!("{}:{}: {}", path.display(), number + 1, line.trim()));
}
}
}
assert_eq!(offenders, Vec::<String>::new(), "a fiber lifecycle result is discarded");
}