clm-kernel 0.0.16

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.state.lock().unwrap(), FiberState::Pending);

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

        // Register signer -> both coeffects satisfied -> transitions to ACTIVE
        ctx.register_service("signer", "Ed25519SignerMock".to_string());
        assert_eq!(*fiber.state.lock().unwrap(), 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.state.lock().unwrap(), 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);
    }