clm-kernel 0.0.15

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use super::*;
    use std::thread;

    #[test]
    fn context_vectors() {
        let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
        let vectors_path = manifest_dir
            .parent()
            .unwrap()
            .parent()
            .unwrap()
            .join("types/lattice/context_vectors.json");
        let raw = std::fs::read_to_string(&vectors_path).expect("read context_vectors.json");
        let doc: serde_json::Value = serde_json::from_str(&raw).expect("parse context_vectors.json");
        let cases = doc["cases"].as_array().unwrap();

        for case in cases {
            let mut snap = HashMap::new();
            for (k, v) in case["env_snapshot"].as_object().unwrap() {
                if let Some(s) = v.as_str() {
                    snap.insert(k.clone(), s.to_string());
                }
            }
            let parent = CLMContext::from_process_environment(&snap);
            let active = if let Some(ov) = case["child_overrides"].as_object() {
                let mut overrides = CLMContextOverrides::default();
                if let Some(rt) = ov.get("runtime").and_then(|x| x.as_str()) {
                    overrides.runtime = Some(rt.to_string());
                }
                if let Some(did) = ov.get("agent_did").and_then(|x| x.as_str()) {
                    overrides.agent_did = Some(did.to_string());
                }
                if let Some(zfs) = ov.get("zero_fs").and_then(|x| x.as_bool()) {
                    overrides.zero_fs = Some(zfs);
                }
                if let Some(tf) = ov.get("target_file").and_then(|x| x.as_str()) {
                    overrides.target_file = Some(PathBuf::from(tf));
                }
                let child = parent.with_child_scope(overrides);
                if let Some(exp_parent) = case.get("expected_parent").and_then(|x| x.as_object()) {
                    assert_eq!(parent.runtime(), exp_parent["runtime"].as_str().unwrap());
                    assert_eq!(
                        parent.agent_did(),
                        exp_parent["agent_did"].as_str().unwrap()
                    );
                    assert_eq!(parent.zero_fs(), exp_parent["zero_fs"].as_bool().unwrap());
                    assert_eq!(
                        parent.target_file().and_then(|p| p.to_str()),
                        exp_parent["target_file"].as_str()
                    );
                }
                child
            } else {
                parent
            };

            let exp = case["expected"].as_object().unwrap();
            assert_eq!(active.runtime(), exp["runtime"].as_str().unwrap());
            assert_eq!(active.agent_did(), exp["agent_did"].as_str().unwrap());
            assert_eq!(active.zero_fs(), exp["zero_fs"].as_bool().unwrap());
            assert_eq!(
                active.forbid_subprocess(),
                exp["forbid_subprocess"].as_bool().unwrap()
            );
            assert_eq!(active.hash_algo(), exp["hash_algo"].as_str().unwrap());
            assert_eq!(
                active.target_file().and_then(|p| p.to_str()),
                exp["target_file"].as_str()
            );

            let passthrough = active.passthrough_env_map();
            for forbidden in case["forbidden_passthrough_keys"].as_array().unwrap() {
                let fkey = forbidden.as_str().unwrap();
                assert!(!passthrough.contains_key(fkey));
            }
        }
    }

    #[test]
    fn context_isolation() {
        let base = CLMContext::for_test_sandbox();
        let mut handles = Vec::new();
        for i in 0..32 {
            let parent = base.clone();
            handles.push(thread::spawn(move || {
                let did = format!("did:clm:agent:worker-{}", i);
                let locale = format!("blake3:{:064x}", i);
                let tf = PathBuf::from(format!("spec_{}.yaml", i));
                let child = parent.with_child_scope(CLMContextOverrides {
                    agent_did: Some(did.clone()),
                    execution_locale_hash: Some(locale.clone()),
                    target_file: Some(tf.clone()),
                    zero_fs: Some(i % 2 == 0),
                    ..Default::default()
                });
                assert_eq!(child.agent_did(), did);
                assert_eq!(child.execution_locale_hash(), locale);
                assert_eq!(child.target_file(), Some(tf.as_path()));
                assert_eq!(child.zero_fs(), i % 2 == 0);
                assert_eq!(parent.agent_did(), "did:clm:system:bootstrap");
            }));
        }
        for h in handles {
            h.join().expect("worker thread panicked");
        }
    }

    #[test]
    fn environment_snapshot() {
        let before: HashMap<String, String> = std::env::vars().collect();
        let mut snap = HashMap::new();
        snap.insert("CLM_RUNTIME".to_string(), "python".to_string());
        snap.insert("SECRET_SENTINEL_490".to_string(), "classified".to_string());
        let ctx = CLMContext::from_process_environment(&snap);
        let child = ctx.with_child_scope(CLMContextOverrides {
            agent_did: Some("did:clm:agent:test".to_string()),
            ..Default::default()
        });
        let exported = child.passthrough_env_map();
        assert!(!exported.contains_key("SECRET_SENTINEL_490"));
        assert_eq!(exported.get("CLM_RUNTIME").map(String::as_str), Some("python"));
        let after: HashMap<String, String> = std::env::vars().collect();
        assert_eq!(before, after);
    }

    #[test]
    fn context_service_binding() {
        // Verify Cordis-style lexical service scope restoration (`clm.context` and `clm.storage`)
        let mut services: HashMap<&'static str, String> = HashMap::new();
        let parent_ctx = CLMContext::for_test_sandbox();
        services.insert("clm.context", parent_ctx.agent_did().to_string());
        services.insert("clm.storage", "memory://parent".to_string());

        let saved_ctx = services.get("clm.context").cloned().unwrap();
        let saved_storage = services.get("clm.storage").cloned().unwrap();
        {
            let child_ctx = parent_ctx.with_child_scope(CLMContextOverrides {
                agent_did: Some("did:clm:agent:scoped".to_string()),
                ..Default::default()
            });
            services.insert("clm.context", child_ctx.agent_did().to_string());
            services.insert("clm.storage", "memory://child".to_string());
            assert_eq!(services.get("clm.context").map(String::as_str), Some("did:clm:agent:scoped"));
            assert_eq!(services.get("clm.storage").map(String::as_str), Some("memory://child"));
        }
        services.insert("clm.context", saved_ctx);
        services.insert("clm.storage", saved_storage);
        assert_eq!(services.get("clm.context").map(String::as_str), Some("did:clm:system:bootstrap"));
        assert_eq!(services.get("clm.storage").map(String::as_str), Some("memory://parent"));
    }

    #[test]
    fn evaluation_context_compat() {
        let mut ctx1 = EvaluationContext::new()
            .with_root("/tmp/clm_root")
            .with_nested_exec(true)
            .with_zero_fs(true);
        ctx1.set_var("LOCAL_FLAG", "value1");

        let mut ctx2 = EvaluationContext::new().with_nested_exec(false);
        ctx2.set_var("LOCAL_FLAG", "value2");

        assert!(ctx1.is_nested());
        assert!(ctx1.is_zero_fs());
        assert_eq!(ctx1.root(), Some(Path::new("/tmp/clm_root")));
        assert_eq!(ctx1.get_var("LOCAL_FLAG").as_deref(), Some("value1"));
        assert!(!ctx2.is_nested());
        assert_eq!(ctx2.get_var("LOCAL_FLAG").as_deref(), Some("value2"));
        ctx1.remove_var("LOCAL_FLAG");
        assert_eq!(ctx1.get_var("LOCAL_FLAG"), None);
    }