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> = crate::layer0::environment::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> = crate::layer0::environment::vars().collect();
assert_eq!(before, after);
}
#[test]
fn context_service_binding() {
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);
}