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");
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;
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();
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;
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";
let cert = generate_self_signed_cert("discovery-server").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
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();
let (mut send_stream, _recv_stream) = conn.conn.open_bi().await.unwrap();
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();
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);
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());
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;
});
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();
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();
let signature = signing_key.sign(nonce.as_bytes());
let sig_hex = encode_hex(&signature.to_bytes());
let (mut send_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();
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();
}