clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![cfg(feature = "native")]
//! Sprint 140.6: Three-Node Federation Integration Test
//!
//! Verifies end-to-end federation: three PKC nodes on loopback with QUIC,
//! CRDT-backed state convergence, cross-PKC PCard dispatch, sheaf gluing,
//! and partition tolerance.

use clm_rust_core::crdt::{CrdtLog, VectorClock};
use clm_rust_core::federation::{FederationMessage, FederationRouter, Peer};
use clm_rust_core::quic_transport::{QuicEndpoint, generate_self_signed_cert};
use std::time::Duration;

#[path = "federation_support.rs"]
mod support;

use support::*;

#[test]
fn test_three_node_federation_router_registration() {
    let mut router = FederationRouter::new();

    let peer_a = Peer {
        did: "did:pkc:node-a".to_string(),
        verifying_key: "vk-a".to_string(),
        endpoint: "127.0.0.1:9095".to_string(),
    };
    let peer_b = Peer {
        did: "did:pkc:node-b".to_string(),
        verifying_key: "vk-b".to_string(),
        endpoint: "127.0.0.1:9096".to_string(),
    };
    let peer_c = Peer {
        did: "did:pkc:node-c".to_string(),
        verifying_key: "vk-c".to_string(),
        endpoint: "127.0.0.1:9097".to_string(),
    };

    router.register_peer(peer_a.clone());
    router.register_peer(peer_b.clone());
    router.register_peer(peer_c.clone());

    assert_eq!(router.peers.len(), 3);
    assert!(router.peers.contains_key("did:pkc:node-a"));
    assert!(router.peers.contains_key("did:pkc:node-b"));
    assert!(router.peers.contains_key("did:pkc:node-c"));
}

// ---------------------------------------------------------------------------
// Story 140.6.4 — CRDT Sync over QUIC (FederationMessage::CrdtSync)
// ---------------------------------------------------------------------------

#[tokio::test]
async fn test_crdt_sync_over_quic() {
    // Node A sends its CRDT log to Node B via FederationMessage::CrdtSync over QUIC

    let cert = generate_self_signed_cert("crdt-sync-test").unwrap();
    let server = QuicEndpoint::new_server(0, &cert).unwrap();
    let server_addr = server.local_addr().unwrap();

    let mut log_a = CrdtLog::new("node-a");
    let mut clock_a = VectorClock::new();
    clock_a.increment("node-a");
    let event = make_learning_event(
        "sha256:vcard-sync-1",
        "sha256:pcard-sync-1",
        "place-x",
        "token-x",
        "did:pkc:node-a",
        &clock_a,
    );
    log_a.append(event);

    let server_handle = tokio::spawn(async move {
        let conn = server.accept().await.unwrap();
        let (data, send_stream, _) = conn.recv_bi().await.unwrap();

        let msg: FederationMessage = serde_json::from_slice(&data).unwrap();
        match msg {
            FederationMessage::CrdtSync { log } => {
                assert_eq!(log.events.len(), 1);
                assert_eq!(log.events[0].vcard_hash, "sha256:vcard-sync-1");

                // Echo back an acknowledgment
                let ack = FederationMessage::Pong;
                let ack_json = serde_json::to_vec(&ack).unwrap();
                conn.respond(send_stream, &ack_json).await.unwrap();
            }
            _ => panic!("expected CrdtSync message"),
        }
        let _ = conn.conn.closed().await;
    });

    tokio::time::sleep(Duration::from_millis(100)).await;
    let client = QuicEndpoint::new_client().unwrap();
    let conn = client.connect(&server_addr.to_string(), "crdt-sync-test").await.unwrap();

    let msg = FederationMessage::CrdtSync { log: log_a.clone() };
    let json = serde_json::to_vec(&msg).unwrap();
    let response = conn.send(&json).await.unwrap();

    let ack: FederationMessage = serde_json::from_slice(&response).unwrap();
    assert_eq!(ack, FederationMessage::Pong);

    // Close first: the server task waits for this close, so awaiting it
    // before closing held each test for the 30 s QUIC idle timeout (INV-588).
    client.close();
    server_handle.await.unwrap();
}