clm-kernel 0.0.15

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


    #[test]
    fn test_vector_clock_happened_before() {
        let mut a = VectorClock::new();
        a.increment("n1");
        a.increment("n1");
        let mut b = a.clone();
        b.increment("n1");
        assert!(a.happened_before(&b));
        assert!(!b.happened_before(&a));
    }

    #[test]
    fn test_vector_clock_concurrent() {
        let mut a = VectorClock::new();
        a.increment("n1");
        let mut b = VectorClock::new();
        b.increment("n2");
        assert!(a.is_concurrent_with(&b));
    }

    #[test]
    fn test_crdt_log_merge_idempotent() {
        let mut log_a = CrdtLog::new("a");
        log_a.append(LearningEvent {
            vcard_hash: "h1".to_string(),
            pcard_hash: "p1".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:a".to_string(),
            timestamp: "t1".to_string(),
            vector_clock: VectorClock::new(),
        });
        let mut log_b = CrdtLog::new("b");
        log_b.merge(&log_a);
        assert_eq!(log_b.events.len(), 1);
        log_b.merge(&log_a);
        assert_eq!(log_b.events.len(), 1);
    }

    #[test]
    fn test_crdt_log_detects_concurrent_events() {
        let mut log_a = CrdtLog::new("a");
        log_a.append(LearningEvent {
            vcard_hash: "h1".to_string(),
            pcard_hash: "p1".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:a".to_string(),
            timestamp: "t1".to_string(),
            vector_clock: VectorClock::new(),
        });
        let mut log_b = CrdtLog::new("b");
        log_b.append(LearningEvent {
            vcard_hash: "h2".to_string(),
            pcard_hash: "p2".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:b".to_string(),
            timestamp: "t2".to_string(),
            vector_clock: VectorClock::new(),
        });
        let mut merged = CrdtLog::new("local");
        merged.merge(&log_a);
        merged.merge(&log_b);
        assert_eq!(merged.concurrent_pairs().len(), 1);
    }

    #[test]
    fn test_crdt_db_schema_creates_the_canonical_three() {
        // ORC-18: this test used to ASSERT THE EXISTENCE OF THE TABLE THE TRIAD FORBIDS.
        // It is not a fixture to migrate — it is a test of the removed schema, and it now
        // asserts the INVARIANT: the canonical three exist, and no `learning_event` does.
        let conn = rusqlite::Connection::open_in_memory().unwrap();
        conn.execute_batch(CANONICAL_DDL).unwrap();
        for table in ["card", "handle_registry", "handle_history"] {
            let exists: bool = conn
                .query_row(
                    "SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?1",
                    [table],
                    |r| r.get::<_, i64>(0),
                )
                .map(|n| n > 0)
                .unwrap();
            assert!(exists, "{table} must exist");
        }
        let leaked: i64 = conn
            .query_row(
                "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='learning_event'",
                [],
                |r| r.get(0),
            )
            .unwrap();
        assert_eq!(leaked, 0, "learning_event is the table ORC-23 dropped");
    }

    #[cfg(any(feature = "native", feature = "db"))]
    #[test]
    fn test_crdt_db_persist_and_load_learning_event() {
        let conn = rusqlite::Connection::open_in_memory().unwrap();
        conn.execute_batch(CANONICAL_DDL).unwrap();

        let event = LearningEvent {
            vcard_hash: "vcard-hash-1".to_string(),
            pcard_hash: "pcard-hash-1".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:node-a".to_string(),
            timestamp: "2026-07-16T10:00:00Z".to_string(),
            vector_clock: VectorClock::new(),
        };

        persist_learning_event(&conn, &event, "node-a").unwrap();

        let loaded = load_learning_events(&conn, None).unwrap();
        assert_eq!(loaded.len(), 1);
        assert_eq!(loaded[0].vcard_hash, "vcard-hash-1");
        assert_eq!(loaded[0].pcard_hash, "pcard-hash-1");
        assert_eq!(loaded[0].agent_did, "did:key:node-a");
    }

    #[cfg(any(feature = "native", feature = "db"))]
    #[test]
    fn test_crdt_db_persist_is_idempotent() {
        let conn = rusqlite::Connection::open_in_memory().unwrap();
        conn.execute_batch(CANONICAL_DDL).unwrap();

        let event = LearningEvent {
            vcard_hash: "vcard-dup".to_string(),
            pcard_hash: "pcard-1".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:a".to_string(),
            timestamp: "t1".to_string(),
            vector_clock: VectorClock::new(),
        };

        persist_learning_event(&conn, &event, "node-a").unwrap();
        persist_learning_event(&conn, &event, "node-a").unwrap();

        let loaded = load_learning_events(&conn, None).unwrap();
        assert_eq!(loaded.len(), 1, "duplicate persist should be idempotent");
    }

    #[cfg(any(feature = "native", feature = "db"))]
    #[test]
    fn test_crdt_db_load_returns_vector_clock_order() {
        let conn = rusqlite::Connection::open_in_memory().unwrap();
        conn.execute_batch(CANONICAL_DDL).unwrap();

        // Insert events out of order
        let event_b = LearningEvent {
            vcard_hash: "vcard-b".to_string(),
            pcard_hash: "pcard-b".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:b".to_string(),
            timestamp: "2026-07-16T12:00:00Z".to_string(),
            vector_clock: VectorClock::new(),
        };
        let event_a = LearningEvent {
            vcard_hash: "vcard-a".to_string(),
            pcard_hash: "pcard-a".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:a".to_string(),
            timestamp: "2026-07-16T10:00:00Z".to_string(),
            vector_clock: VectorClock::new(),
        };

        persist_learning_event(&conn, &event_b, "node-b").unwrap();
        persist_learning_event(&conn, &event_a, "node-a").unwrap();

        let loaded = load_learning_events(&conn, None).unwrap();
        assert_eq!(loaded.len(), 2);
        // Should be sorted by timestamp ascending
        assert_eq!(loaded[0].vcard_hash, "vcard-a");
        assert_eq!(loaded[1].vcard_hash, "vcard-b");
    }

    #[cfg(any(feature = "native", feature = "db"))]
    #[test]
    fn test_crdt_sync_merges_and_persists() {
        let conn = rusqlite::Connection::open_in_memory().unwrap();
        conn.execute_batch(CANONICAL_DDL).unwrap();

        let mut local = CrdtLog::new("node-local");
        local.append(LearningEvent {
            vcard_hash: "vcard-local".to_string(),
            pcard_hash: "pcard-1".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:local".to_string(),
            timestamp: "t1".to_string(),
            vector_clock: VectorClock::new(),
        });

        let mut remote = CrdtLog::new("node-remote");
        remote.append(LearningEvent {
            vcard_hash: "vcard-remote".to_string(),
            pcard_hash: "pcard-2".to_string(),
            marking_delta: Marking::new(),
            agent_did: "did:key:remote".to_string(),
            timestamp: "t2".to_string(),
            vector_clock: VectorClock::new(),
        });

        let report = sync_learning_events(&mut local, &remote, &conn).unwrap();
        assert_eq!(report.events_merged, 1);
        assert_eq!(report.events_appended, 1);
        assert_eq!(local.events.len(), 2);

        // Verify persisted to DB
        let loaded = load_learning_events(&conn, None).unwrap();
        assert_eq!(loaded.len(), 2);
    }

    #[cfg(any(feature = "native", feature = "db"))]
    #[test]
    fn test_crdt_sync_survives_restart() {
        // Simulate restart by using a file-based temp DB
        let tmp_dir = std::env::temp_dir();
        let db_path = tmp_dir.join("clm_crdt_restart_test.db");
        let _ = std::fs::remove_file(&db_path);

        // First "session": create table and persist
        {
            let conn = rusqlite::Connection::open(&db_path).unwrap();
            conn.execute_batch(CANONICAL_DDL).unwrap();

            let event = LearningEvent {
                vcard_hash: "vcard-restart".to_string(),
                pcard_hash: "pcard-1".to_string(),
                marking_delta: Marking::new(),
                agent_did: "did:key:restart".to_string(),
                timestamp: "t-restart".to_string(),
                vector_clock: VectorClock::new(),
            };
            persist_learning_event(&conn, &event, "node-restart").unwrap();
        }

        // Second "session": reopen and verify data survived
        {
            let conn = rusqlite::Connection::open(&db_path).unwrap();
            let loaded = load_learning_events(&conn, None).unwrap();
            assert_eq!(loaded.len(), 1);
            assert_eq!(loaded[0].vcard_hash, "vcard-restart");
        }

        let _ = std::fs::remove_file(&db_path);
    }

    #[cfg(feature = "native")]
    #[test]
    fn test_manifest_delta_compute() {
        let manifest_local = ArchiveManifest {
            archive_id: "archive:local".to_string(),
            g_time: "t1".to_string(),
            files: vec![
                ArchiveFileEntry { path: "f1.txt".to_string(), sha256: "hash1".to_string(), size: 10, mode: 0o644 },
                ArchiveFileEntry { path: "f2.txt".to_string(), sha256: "hash2".to_string(), size: 20, mode: 0o644 },
            ],
            top_level_vcard_hash: None,
            archiver_did: None,
            compression: None,
        };

        let manifest_peer = ArchiveManifest {
            archive_id: "archive:peer".to_string(),
            g_time: "t2".to_string(),
            files: vec![
                ArchiveFileEntry { path: "f1.txt".to_string(), sha256: "hash1".to_string(), size: 10, mode: 0o644 },
                ArchiveFileEntry { path: "f3.txt".to_string(), sha256: "hash3".to_string(), size: 30, mode: 0o644 },
            ],
            top_level_vcard_hash: None,
            archiver_did: None,
            compression: None,
        };

        let delta = compute_manifest_delta(&manifest_local, &manifest_peer);
        assert_eq!(delta.len(), 1);
        assert_eq!(delta[0].path, "f3.txt");
        assert_eq!(delta[0].sha256, "hash3");
    }