clm-kernel 0.0.18

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

    #[test]
    fn test_peer_info_wg_public_key_default_none() {
        let json = r#"{"name":"test","ip":"127.0.0.1","port":9095,"did":"did:pkc:test","capabilities":[],"protocol":"challenge-response","discoveredAt":"2026-01-01T00:00:00Z"}"#;
        let peer: PeerInfo = serde_json::from_str(json).unwrap();
        assert!(peer.wg_public_key.is_none());
    }

    #[test]
    fn test_peer_info_wg_public_key_present() {
        let json = r#"{"name":"test","ip":"127.0.0.1","port":9095,"did":"did:pkc:test","capabilities":[],"protocol":"challenge-response","discoveredAt":"2026-01-01T00:00:00Z","wg_public_key":"abcdef0123456789"}"#;
        let peer: PeerInfo = serde_json::from_str(json).unwrap();
        assert_eq!(peer.wg_public_key.as_deref(), Some("abcdef0123456789"));
    }

    #[test]
    fn test_peer_info_wg_public_key_not_serialized_when_none() {
        let peer = PeerInfo {
            name: "test".to_string(),
            ip: "127.0.0.1".to_string(),
            port: 9095,
            did: "did:pkc:test".to_string(),
            capabilities: vec![],
            protocol: "challenge-response".to_string(),
            discovered_at: "2026-01-01T00:00:00Z".to_string(),
            wg_public_key: None,
        };
        let json = serde_json::to_string(&peer).unwrap();
        assert!(!json.contains("wg_public_key"));
    }

    #[test]
    fn test_peer_info_wg_public_key_serialized_when_some() {
        let peer = PeerInfo {
            name: "test".to_string(),
            ip: "127.0.0.1".to_string(),
            port: 9095,
            did: "did:pkc:test".to_string(),
            capabilities: vec![],
            protocol: "challenge-response".to_string(),
            discovered_at: "2026-01-01T00:00:00Z".to_string(),
            wg_public_key: Some("abcdef".to_string()),
        };
        let json = serde_json::to_string(&peer).unwrap();
        assert!(json.contains("wg_public_key"));
        assert!(json.contains("abcdef"));
    }

    #[test]
    fn test_no_tcp_imports_in_discovery_engine() {
        let source = include_str!("discovery_engine.rs");
        // Check for TCP usage in production code only (before test module)
        let prod_code = source.split("#[cfg(test)]").next().unwrap_or("");
        assert!(!prod_code.contains("TcpListener"), "TcpListener found in production code");
        assert!(!prod_code.contains("TcpStream"), "TcpStream found in production code");
    }

    #[tokio::test]
    async fn test_tcp_connection_to_quic_port_refused() {
        use std::net::TcpStream;
        use std::time::Duration;

        // A QUIC server listens on UDP, not TCP. A TCP connection to the same
        // port should be refused.
        let cert = crate::quic_transport::generate_self_signed_cert("tcp-refused-test").unwrap();
        let server = crate::quic_transport::QuicEndpoint::new_server(0, &cert).unwrap();
        let port = server.local_addr().unwrap().port();

        // Try TCP connect — should fail
        let result = TcpStream::connect_timeout(
            &format!("127.0.0.1:{}", port).parse().unwrap(),
            Duration::from_millis(500),
        );
        assert!(result.is_err(), "TCP connection to QUIC port should be refused");
    }

    #[tokio::test]
    async fn test_quic_discovery_handshake_round_trip() {
        use crate::quic_transport::{QuicEndpoint, generate_self_signed_cert};
        use ed25519_dalek::{SigningKey, VerifyingKey, Signer, Verifier};
        use ed25519_dalek::pkcs8::{EncodePublicKey, EncodePrivateKey};
        use pkcs8::LineEnding;

        // Generate keypair for client
        let signing_key = SigningKey::generate(&mut rand::rngs::OsRng);
        let verifying_key = VerifyingKey::from(&signing_key);
        let _public_key_pem = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
        let _private_key_pem = signing_key
            .to_pkcs8_pem(LineEnding::LF)
            .unwrap()
            .to_string();

        let did = "did:pkc:test:quic-discovery";

        // Set up QUIC server
        let cert = generate_self_signed_cert("discovery-server").unwrap();
        let server = QuicEndpoint::new_server(0, &cert).unwrap();
        let server_addr = server.local_addr().unwrap();

        // Server task: accept connection, perform challenge-response
        let did_clone = did.to_string();
        let verifying_key_clone = verifying_key;
        let server_handle = tokio::spawn(async move {
            let conn = server.accept().await.unwrap();

            // Server opens bi-stream for handshake (server-initiated)
            let (mut send_stream, _recv_stream) = conn.conn.open_bi().await.unwrap();

            // Send challenge
            let nonce = encode_hex(&generate_random_bytes(16));
            let challenge = serde_json::json!({
                "type": "challenge",
                "nonce": nonce,
            });
            let challenge_bytes = serde_json::to_vec(&challenge).unwrap();
            send_stream.write_all(&challenge_bytes).await.unwrap();
            send_stream.finish().unwrap();

            // Accept a new bi-stream for the client's response
            let (_, mut response_recv) = conn.conn.accept_bi().await.unwrap();
            let response_buf = response_recv.read_to_end(1024 * 1024).await.unwrap();
            let response: serde_json::Value = serde_json::from_slice(&response_buf).unwrap();
            assert_eq!(response["type"], "response");
            assert_eq!(response["did"], did_clone);

            // Verify signature
            let sig_hex = response["signature"].as_str().unwrap();
            let sig_bytes = decode_hex(sig_hex).unwrap();
            let signature = ed25519_dalek::Signature::from_slice(&sig_bytes).unwrap();
            assert!(verifying_key_clone.verify(nonce.as_bytes(), &signature).is_ok());

            // Send authorized response via uni-stream
            let mut auth_stream = conn.conn.open_uni().await.unwrap();
            let auth = serde_json::json!({"status": "authorized", "did": did_clone});
            let auth_bytes = serde_json::to_vec(&auth).unwrap();
            auth_stream.write_all(&auth_bytes).await.unwrap();
            auth_stream.finish().unwrap();

            let _ = conn.conn.closed().await;
        });

        // Client connects and performs handshake
        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
        let client = QuicEndpoint::new_client().unwrap();
        let conn = client.connect(&server_addr.to_string(), "discovery-server").await.unwrap();

        // Accept bi-stream (server-initiated) for handshake
        let (_, mut recv_stream) = conn.conn.accept_bi().await.unwrap();

        // Read challenge
        let challenge_buf = recv_stream.read_to_end(1024 * 1024).await.unwrap();
        let challenge: serde_json::Value = serde_json::from_slice(&challenge_buf).unwrap();
        assert_eq!(challenge["type"], "challenge");
        let nonce = challenge["nonce"].as_str().unwrap().to_string();

        // Sign nonce
        let signature = signing_key.sign(nonce.as_bytes());
        let sig_hex = encode_hex(&signature.to_bytes());

        // Open a new bi-stream to send the response
        let (mut send_stream, _) = conn.conn.open_bi().await.unwrap();

        // Send response
        let response = serde_json::json!({
            "type": "response",
            "did": did,
            "signature": sig_hex,
        });
        let response_bytes = serde_json::to_vec(&response).unwrap();
        send_stream.write_all(&response_bytes).await.unwrap();
        send_stream.finish().unwrap();

        // Read authorization from uni-stream
        let mut auth_stream = conn.conn.accept_uni().await.unwrap();
        let auth_buf = auth_stream.read_to_end(1024 * 1024).await.unwrap();
        let auth: serde_json::Value = serde_json::from_slice(&auth_buf).unwrap();
        assert_eq!(auth["status"], "authorized");
        assert_eq!(auth["did"], did);

        server_handle.await.unwrap();
        client.close();
    }