clm-kernel 0.0.21

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

    // --- Story 140.2.3: TLS Certificate Generation Tests ---

    #[test]
    fn test_generate_self_signed_cert() {
        let cert = generate_self_signed_cert("pkc-node-test").unwrap();
        assert!(!cert.cert_der.is_empty());
        assert!(!cert.key_der.is_empty());
        assert_eq!(cert.subject, "pkc-node-test");
    }

    #[test]
    fn test_generate_different_certs_have_different_keys() {
        let cert1 = generate_self_signed_cert("node-1").unwrap();
        let cert2 = generate_self_signed_cert("node-2").unwrap();
        assert_ne!(cert1.cert_der, cert2.cert_der);
        assert_ne!(cert1.key_der, cert2.key_der);
    }

    // --- Story 140.2.1: QUIC Endpoint Tests ---

    #[tokio::test]
    async fn test_quic_server_binds_to_port() {
        let cert = generate_self_signed_cert("test-server").unwrap();
        let server = QuicEndpoint::new_server(0, &cert).unwrap();
        let addr = server.local_addr().unwrap();
        assert_eq!(addr.ip().to_string(), "127.0.0.1");
        assert!(addr.port() > 0);
        server.close();
    }

    #[tokio::test]
    async fn test_quic_client_creates() {
        let client = QuicEndpoint::new_client().unwrap();
        let addr = client.local_addr().unwrap();
        assert_eq!(addr.ip().to_string(), "127.0.0.1");
        // Port 0 means OS-assigned
        assert!(addr.port() > 0);
        client.close();
    }

    // --- Story 140.2.2: QUIC Connection Stream Tests ---

    #[tokio::test]
    async fn test_quic_round_trip_send_recv() {
        let cert = generate_self_signed_cert("round-trip-test").unwrap();
        let server = QuicEndpoint::new_server(0, &cert).unwrap();
        let server_addr = server.local_addr().unwrap();

        let client = QuicEndpoint::new_client().unwrap();

        // Spawn server task that accepts a connection and echoes data
        let server_handle = tokio::spawn(async move {
            let conn = server.accept().await.unwrap();
            let (data, send_stream, _recv_stream) = conn.recv_bi().await.unwrap();
            assert_eq!(data, b"hello quic");
            conn.respond(send_stream, b"echo: hello quic").await.unwrap();
            // Keep server alive until connection closes
            let _ = conn.conn.closed().await;
        });

        // Client connects and sends data
        let conn = client.connect(&server_addr.to_string(), "round-trip-test").await.unwrap();

        let (mut send_stream, mut recv_stream) = conn.conn
            .open_bi()
            .await
            .unwrap();

        send_stream.write_all(b"hello quic").await.unwrap();
        send_stream.finish().unwrap();

        let response = recv_stream.read_to_end(1024 * 1024).await.unwrap();
        assert_eq!(response, b"echo: hello quic");

        // 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();
    }

    #[tokio::test]
    async fn test_quic_large_message_round_trip() {
        let cert = generate_self_signed_cert("large-msg-test").unwrap();
        let server = QuicEndpoint::new_server(0, &cert).unwrap();
        let server_addr = server.local_addr().unwrap();

        let client = QuicEndpoint::new_client().unwrap();

        // Create 1MB message
        let large_message = vec![0xABu8; 1024 * 1024];

        let large_message_clone = large_message.clone();
        let server_handle = tokio::spawn(async move {
            let conn = server.accept().await.unwrap();
            let (data, send_stream, _) = conn.recv_bi().await.unwrap();
            assert_eq!(data.len(), large_message_clone.len());
            conn.respond(send_stream, &large_message_clone).await.unwrap();
            // Keep server alive until connection closes
            let _ = conn.conn.closed().await;
        });

        let conn = client.connect(&server_addr.to_string(), "large-msg-test").await.unwrap();

        let (mut send_stream, mut recv_stream) = conn.conn
            .open_bi()
            .await
            .unwrap();

        send_stream.write_all(&large_message).await.unwrap();
        send_stream.finish().unwrap();

        let response = recv_stream.read_to_end(2 * 1024 * 1024).await.unwrap();
        assert_eq!(response.len(), 1024 * 1024);

        // 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();
    }

    #[tokio::test]
    async fn test_quic_concurrent_streams() {
        let cert = generate_self_signed_cert("concurrent-test").unwrap();
        let server = QuicEndpoint::new_server(0, &cert).unwrap();
        let server_addr = server.local_addr().unwrap();

        let client = QuicEndpoint::new_client().unwrap();

        // Server handles multiple streams concurrently
        let server_handle = tokio::spawn(async move {
            let conn = server.accept().await.unwrap();

            // Handle 3 concurrent streams sequentially (QUIC multiplexes at protocol level)
            for _ in 0..3 {
                let (data, send_stream, _) = conn.recv_bi().await.unwrap();
                let response = format!("response-{}", String::from_utf8_lossy(&data));
                conn.respond(send_stream, response.as_bytes()).await.unwrap();
            }
            // Keep server alive until connection closes
            let _ = conn.conn.closed().await;
        });

        let conn = client.connect(&server_addr.to_string(), "concurrent-test").await.unwrap();

        // Open 3 concurrent streams
        let mut responses = Vec::new();
        for i in 0..3 {
            let (mut send_stream, mut recv_stream) = conn.conn
                .open_bi()
                .await
                .unwrap();

            let msg = format!("stream-{}", i);
            send_stream.write_all(msg.as_bytes()).await.unwrap();
            send_stream.finish().unwrap();

            let response = recv_stream.read_to_end(1024 * 1024).await.unwrap();
            responses.push(String::from_utf8(response).unwrap());
        }

        assert_eq!(responses.len(), 3);
        for r in &responses {
            assert!(r.starts_with("response-stream-"));
        }

        // 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();
    }

    // --- Story 140.2.4: Handshake Protocol Tests ---

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

        // Generate a keypair for the 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:handshake";

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

        // Server task: accept connection, perform handshake server side
        let server_handle = tokio::spawn(async move {
            let conn = server.accept().await.unwrap();

            // Stream 1: server opens bi-stream, sends challenge
            let (mut send_stream, _) = conn.conn
                .open_bi()
                .await
                .unwrap();

            let nonce = crate::discovery_engine::encode_hex(
                &crate::discovery_engine::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();

            // Stream 2: client opens bi-stream with response, server accepts
            let (mut send_stream2, mut recv_stream2) = conn.conn
                .accept_bi()
                .await
                .unwrap();

            let response_buf = recv_stream2.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);

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

            // Send authorized response
            let auth = serde_json::json!({"status": "authorized", "did": did});
            let auth_bytes = serde_json::to_vec(&auth).unwrap();
            send_stream2.write_all(&auth_bytes).await.unwrap();
            send_stream2.finish().unwrap();

            // Keep server alive
            let _ = conn.conn.closed().await;
        });

        // Client connects and performs handshake
        let client = QuicEndpoint::new_client().unwrap();
        let conn = client.connect(&server_addr.to_string(), "handshake-server").await.unwrap();

        // Stream 1: client accepts bi-stream (server-initiated), reads challenge
        let (_, mut recv_stream) = conn.conn
            .accept_bi()
            .await
            .unwrap();

        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 = hex::encode(signature.to_bytes());

        // Stream 2: client opens bi-stream, sends response, reads auth
        let (mut send_stream, mut recv_stream) = conn.conn
            .open_bi()
            .await
            .unwrap();

        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
        let auth_buf = recv_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);

        // 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();
    }

    #[test]
    fn test_dangerous_client_crypto_creates() {
        ensure_crypto_provider();
        let _config = build_dangerous_client_crypto();
        // If it creates without panicking, the test passes.
    }