clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
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();

        // Spawn a fiber that requires 'mcardfs' and 'signer'
        let fiber = ctx.spawn_fiber("worker_1", vec!["mcardfs".to_string(), "signer".to_string()]);
        assert_eq!(fiber.get_state(), FiberState::Pending);

        // Register mcardfs -> still Pending
        ctx.register_service("mcardfs", "StorageEngineMock".to_string());
        assert_eq!(fiber.get_state(), FiberState::Pending);

        // Register signer -> both coeffects satisfied -> transitions to ACTIVE
        ctx.register_service("signer", "Ed25519SignerMock".to_string());
        assert_eq!(fiber.get_state(), FiberState::Active);

        // Register a disposable effect
        let cleaned = Arc::new(Mutex::new(false));
        let cleaned_clone = Arc::clone(&cleaned);
        fiber.register_disposable(move || {
            *cleaned_clone.lock().unwrap() = true;
            Ok(())
        });

        // Dispose fiber
        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);

        // Registry queries
        assert!(ctx.get_fiber("hmr_worker").is_some());
        assert_eq!(ctx.list_fibers().len(), 1);

        // AST storage
        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));

        // Register disposable
        let unwound = Arc::new(Mutex::new(false));
        let unwound_clone = Arc::clone(&unwound);
        fiber.register_disposable(move || {
            *unwound_clone.lock().unwrap() = true;
            Ok(())
        });

        // Pause fiber for HMR
        assert!(fiber.pause().is_ok());
        assert_eq!(fiber.get_state(), FiberState::Paused);

        // Unwind disposables without disposing fiber
        assert!(fiber.unwind_disposables().is_ok());
        assert!(*unwound.lock().unwrap());
        assert_eq!(fiber.get_state(), FiberState::Paused);

        // Resume/Activate
        assert!(fiber.activate().is_ok());
        assert_eq!(fiber.get_state(), FiberState::Active);

        // Remove from registry
        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");
    }