use super::*;
#[test]
fn test_validate_string_and_integer() {
let lattice = default_lattice();
assert!(lattice.validate("string", "hello", 99).is_ok());
assert!(lattice.validate("integer", "42", 99).is_ok());
assert!(lattice.validate("integer", "3.14", 99).is_err());
}
#[test]
fn test_universe_levels() {
let lattice = default_lattice();
let string_info = lattice.get_type_info("string").unwrap();
let integer_info = lattice.get_type_info("integer").unwrap();
let a_mcard_info = lattice.get_type_info("a_mcard").unwrap();
assert_eq!(string_info.universe_level, 0);
assert_eq!(integer_info.universe_level, 0);
assert_eq!(a_mcard_info.universe_level, 1);
}
#[test]
fn test_stratification_error() {
let lattice = default_lattice();
assert!(lattice.validate("agent", r#"{"did":"did:key:z123"}"#, 1).is_err());
}
#[test]
fn test_vcard_token_field_list() {
let lattice = default_lattice();
let payload = r#"{"gate_type":"callback","result":"pass","pcard_hash":"sha256:abc","agent_did":"did:key:z6MkNodeA"}"#;
assert!(lattice.validate("vcard_token", payload, 99).is_ok());
}
#[test]
fn test_compile_produces_manifests() {
let lattice = default_lattice();
let compiled = lattice.compile();
assert!(compiled.manifests.contains_key("string"));
assert!(compiled.manifests.contains_key("integer"));
assert!(compiled.manifests.contains_key("a_mcard"));
assert!(compiled.manifests.contains_key("vcard_token"));
}
#[test]
fn test_compiled_verify_matches_recursive() {
let lattice = default_lattice();
let compiled = lattice.compile();
assert!(compiled.verify("string", "hello", 99, &lattice).is_ok());
assert!(compiled.verify("integer", "42", 99, &lattice).is_ok());
assert!(compiled.verify("integer", "3.14", 99, &lattice).is_err());
assert!(compiled.verify("agent", r#"{"did":"did:key:z123"}"#, 1, &lattice).is_err());
}
#[test]
fn test_verify_by_hash_enum_type() {
let lattice = default_lattice();
let compiled = lattice.compile();
let valid_hash = hash_value("callback");
let invalid_hash = hash_value("nonexistent_gate");
let manifest = compiled.manifests.get("vcard_token");
if let Some(m) = manifest {
if !m.enum_hashes.is_empty() {
assert!(compiled.verify_by_hash("vcard_token", &valid_hash) || !m.enum_hashes.contains(&valid_hash));
assert!(!compiled.verify_by_hash("vcard_token", &invalid_hash));
}
}
}
#[test]
fn test_compiled_lattice_cached() {
let a = compiled_lattice();
let b = compiled_lattice();
assert!(std::ptr::eq(a, b));
}
#[test]
fn test_hash_type_name_deterministic() {
let h1 = hash_type_name("string");
let h2 = hash_type_name("string");
assert_eq!(h1, h2);
let h3 = hash_type_name("integer");
assert_ne!(h1, h3);
}
#[test]
fn test_benchmark_compiled_vs_recursive() {
let lattice = default_lattice();
let compiled = lattice.compile();
let n = 10_000;
let start = std::time::Instant::now();
for _ in 0..n {
let _ = lattice.validate("integer", "42", 99);
}
let recursive_time = start.elapsed();
let start = std::time::Instant::now();
for _ in 0..n {
let _ = compiled.verify("integer", "42", 99, &lattice);
}
let compiled_time = start.elapsed();
assert!(
compiled_time.as_millis() < 100,
"compiled verification took {}ms for {} iterations (DoD: < 100ms)",
compiled_time.as_millis(),
n
);
assert!(
compiled_time <= recursive_time,
"compiled ({}) should be <= recursive ({})",
compiled_time.as_millis(),
recursive_time.as_millis()
);
}
#[test]
fn test_verify_by_hash_o1_characteristic() {
let lattice = default_lattice();
let compiled = lattice.compile();
let h = hash_value("test");
let start = std::time::Instant::now();
for _ in 0..10_000 {
let _ = compiled.verify_by_hash("string", &h);
}
let elapsed = start.elapsed();
assert!(
elapsed.as_millis() < 10,
"10k verify_by_hash calls took {}ms",
elapsed.as_millis()
);
}
#[test]
fn test_lattice_meet_and_join() {
let lattice = default_lattice();
let t_str = lattice.get_type_info("string").unwrap();
let t_int = lattice.get_type_info("integer").unwrap();
let meet = lattice.meet(&t_str, &t_int);
assert_eq!(meet.name, "(string ∧ integer)");
let join = lattice.join(&t_str, &t_int);
assert_eq!(join.name, "(string ∨ integer)");
let top = TypeLattice::top();
let bottom = TypeLattice::bottom();
assert_eq!(lattice.meet(&t_str, &top).name, "string");
assert_eq!(lattice.meet(&t_str, &bottom).name, "Bottom");
assert_eq!(lattice.join(&t_str, &top).name, "Top");
assert_eq!(lattice.join(&t_str, &bottom).name, "string");
assert!(lattice.is_subtype(&meet, &t_str));
assert!(lattice.is_subtype(&meet, &t_int));
assert!(lattice.is_subtype(&t_str, &join));
assert!(lattice.is_subtype(&t_int, &join));
assert!(lattice.is_subtype(&bottom, &t_str));
assert!(lattice.is_subtype(&t_str, &top));
}
#[test]
fn test_governance_type_validation_and_stratification() {
let manifest_body = include_str!("../types/governance/agent_write_scope.yaml");
let mut lattice = TypeLattice::new();
let info = parse_manifest("agent_write_scope", "types/governance/agent_write_scope.yaml", manifest_body)
.expect("parse agent_write_scope manifest");
assert_eq!(info.universe_level, 1, "agent_write_scope must be Universe Level 1");
lattice.add_type("agent_write_scope".to_string(), info);
let valid_payload = r#"{"agent_role": "winston", "agent_class": "EOA", "target_path": "docs/test.md"}"#;
assert!(lattice.validate("agent_write_scope", valid_payload, 1).is_ok());
assert!(lattice.validate("agent_write_scope", valid_payload, 2).is_ok());
let res = lattice.validate("agent_write_scope", valid_payload, 0);
match res {
Err(TypeValidationError::StratificationError { type_name, level, parent_level }) => {
assert_eq!(type_name, "agent_write_scope");
assert_eq!(level, 1);
assert_eq!(parent_level, 0);
}
other => panic!("Expected StratificationError, got: {:?}", other),
}
}
#[test]
fn test_all_subdirs_loaded_and_census() {
let manifest_dir = env!("CARGO_MANIFEST_DIR");
let clm_root = std::path::Path::new(manifest_dir)
.parent()
.and_then(|p| p.parent());
let types_dir = clm_root
.map(|r| r.join("types"))
.filter(|p| p.exists())
.unwrap_or_else(|| std::path::Path::new(manifest_dir).join("types"));
let root_str = types_dir.parent().unwrap_or(std::path::Path::new(manifest_dir)).to_string_lossy().to_string();
let mut lattice = TypeLattice::new();
lattice.load_registry(&root_str);
for &subdir in TypeLattice::TYPE_REGISTRY_SUBDIRS {
let subdir_path = types_dir.join(subdir);
if subdir_path.exists() {
let yaml_count = std::fs::read_dir(&subdir_path)
.unwrap()
.flatten()
.filter(|e| {
let name = e.file_name().to_string_lossy().to_string();
name.ends_with(".yaml") || name.ends_with(".yml")
})
.count();
assert!(yaml_count > 0, "Subdir {} must contain at least one YAML manifest", subdir);
}
}
assert!(
lattice.registry.len() >= 110,
"Lattice registry census: expected >= 110 types across 12 subdirectories, found {}",
lattice.registry.len()
);
for (name, info) in &lattice.registry {
assert!(
info.universe_level <= 4,
"Type '{}' has invalid universe level: {}",
name,
info.universe_level
);
}
}