clm-kernel 0.0.7

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
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();
        // agent is U2 nested inside a_mcard (U1) context should fail.
        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());
    }

    // ── Compiled Type Lattice tests (Story 139.2.2) ──

    #[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();
        // Positive cases
        assert!(compiled.verify("string", "hello", 99, &lattice).is_ok());
        assert!(compiled.verify("integer", "42", 99, &lattice).is_ok());
        // Negative cases
        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();
        // vcard_token has enum constraints on gate_type and result.
        // verify_by_hash should work for enum values.
        let valid_hash = hash_value("callback");
        let invalid_hash = hash_value("nonexistent_gate");
        // For enum-constrained types, verify_by_hash should return true
        // for allowed values and false for disallowed ones.
        // Note: verify_by_hash checks if the hash is in the enum set.
        // If vcard_token has enum hashes, this should work.
        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() {
        // Calling compiled_lattice() twice should return the same reference.
        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;

        // Benchmark recursive validation (baseline — still recompiles regexes).
        let start = std::time::Instant::now();
        for _ in 0..n {
            let _ = lattice.validate("integer", "42", 99);
        }
        let recursive_time = start.elapsed();

        // Benchmark compiled verification (uses pre-compiled regexes).
        let start = std::time::Instant::now();
        for _ in 0..n {
            let _ = compiled.verify("integer", "42", 99, &lattice);
        }
        let compiled_time = start.elapsed();

        // DoD: 10,000 compiled validations must complete in < 100ms.
        assert!(
            compiled_time.as_millis() < 100,
            "compiled verification took {}ms for {} iterations (DoD: < 100ms)",
            compiled_time.as_millis(),
            n
        );
        // Compiled path should be faster than recursive.
        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");

        // verify_by_hash should be O(1) — constant time regardless of
        // the number of types or manifest complexity.
        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();

        // Meet: Product / Intersection
        let meet = lattice.meet(&t_str, &t_int);
        assert_eq!(meet.name, "(string ∧ integer)");

        // Join: Sum / Union
        let join = lattice.join(&t_str, &t_int);
        assert_eq!(join.name, "(string ∨ integer)");

        // Identities: Top & Bottom
        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");

        // Subtyping
        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);

        // Validating with parent_level >= 1 succeeds
        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());

        // Validating under parent_level 0 MUST trigger StratificationError
        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);

        // Assert all 12 subdirectories are recognized and checked
        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);
            }
        }

        // Census count assertion: All 110 types across 12 subdirectories are registered
        assert!(
            lattice.registry.len() >= 110,
            "Lattice registry census: expected >= 110 types across 12 subdirectories, found {}",
            lattice.registry.len()
        );

        // Every registered type must have a valid universe level (0..=4)
        for (name, info) in &lattice.registry {
            assert!(
                info.universe_level <= 4,
                "Type '{}' has invalid universe level: {}",
                name,
                info.universe_level
            );
        }
    }