#![cfg(feature = "native")]
use clm_rust_core::crdt::{CrdtLog, LearningEvent, VectorClock};
use clm_rust_core::federation::{
CrossPkcDispatchRequest, CrossPkcDispatchResponse, co_sign_vcard,
dispatch_cross_pkc, receive_cross_pkc_dispatch,
FederationMessage, FederationRouter, Peer,
};
use clm_rust_core::quic_transport::{QuicEndpoint, generate_self_signed_cert};
use clm_rust_core::sheaf::{Marking, OpenSet, Place, Section, Sheaf};
use std::time::{Duration, Instant};
async fn start_pkc_server(
cert_name: &str,
port_hint: u16,
) -> (QuicEndpoint, std::net::SocketAddr) {
let cert = generate_self_signed_cert(cert_name).unwrap();
let server = QuicEndpoint::new_server(port_hint, &cert).unwrap();
let addr = server.local_addr().unwrap();
(server, addr)
}
fn make_learning_event(
vcard_hash: &str,
pcard_hash: &str,
place: &str,
token: &str,
agent_did: &str,
clock: &VectorClock,
) -> LearningEvent {
let mut marking = Marking::new();
marking = marking.with_token(place, token);
LearningEvent {
vcard_hash: vcard_hash.to_string(),
pcard_hash: pcard_hash.to_string(),
marking_delta: marking,
agent_did: agent_did.to_string(),
timestamp: chrono::Utc::now().to_rfc3339(),
vector_clock: clock.clone(),
}
}
#[tokio::test]
async fn test_three_node_setup_no_port_conflicts() {
let (server_a, addr_a) = start_pkc_server("node-a", 0).await;
let (server_b, addr_b) = start_pkc_server("node-b", 0).await;
let (server_c, addr_c) = start_pkc_server("node-c", 0).await;
assert_ne!(addr_a.port(), addr_b.port());
assert_ne!(addr_b.port(), addr_c.port());
assert_ne!(addr_a.port(), addr_c.port());
let handles = vec![
tokio::spawn(async move {
if let Ok(conn) = server_a.accept().await {
let _ = conn.conn.closed().await;
}
}),
tokio::spawn(async move {
if let Ok(conn) = server_b.accept().await {
let _ = conn.conn.closed().await;
}
}),
tokio::spawn(async move {
if let Ok(conn) = server_c.accept().await {
let _ = conn.conn.closed().await;
}
}),
];
let client = QuicEndpoint::new_client().unwrap();
let conn_a = client.connect(&addr_a.to_string(), "node-a").await.unwrap();
let conn_b = client.connect(&addr_b.to_string(), "node-b").await.unwrap();
let conn_c = client.connect(&addr_c.to_string(), "node-c").await.unwrap();
drop(conn_a);
drop(conn_b);
drop(conn_c);
client.close();
for h in handles {
let _ = h.await;
}
}
#[tokio::test]
async fn test_three_node_quic_pairwise_connections() {
let (server_a, addr_a) = start_pkc_server("pair-a", 0).await;
let (server_b, addr_b) = start_pkc_server("pair-b", 0).await;
let _h_a = tokio::spawn(async move {
let conn = server_a.accept().await.unwrap();
let _ = conn.conn.closed().await;
});
let _h_b = tokio::spawn(async move {
let conn = server_b.accept().await.unwrap();
let _ = conn.conn.closed().await;
});
tokio::time::sleep(Duration::from_millis(50)).await;
let client = QuicEndpoint::new_client().unwrap();
let _conn_a = client.connect(&addr_a.to_string(), "pair-a").await.unwrap();
let _conn_b = client.connect(&addr_b.to_string(), "pair-b").await.unwrap();
client.close();
}
#[tokio::test]
async fn test_three_node_disjoint_writes_converge() {
let mut log_a = CrdtLog::new("node-a");
let mut log_b = CrdtLog::new("node-b");
let mut log_c = CrdtLog::new("node-c");
let mut clock_a = VectorClock::new();
clock_a.increment("node-a");
let event_a = make_learning_event(
"sha256:vcard-alpha",
"sha256:pcard-alpha",
"alpha",
"token-alpha",
"did:pkc:node-a",
&clock_a,
);
log_a.append(event_a.clone());
let mut clock_b = VectorClock::new();
clock_b.increment("node-b");
let event_b = make_learning_event(
"sha256:vcard-beta",
"sha256:pcard-beta",
"beta",
"token-beta",
"did:pkc:node-b",
&clock_b,
);
log_b.append(event_b.clone());
log_c.merge(&log_a);
log_c.merge(&log_b);
log_a.merge(&log_c);
log_b.merge(&log_c);
assert_eq!(log_a.events.len(), 2);
assert_eq!(log_b.events.len(), 2);
assert_eq!(log_c.events.len(), 2);
let hashes_a: Vec<_> = log_a.events.iter().map(|e| &e.vcard_hash).collect();
let hashes_b: Vec<_> = log_b.events.iter().map(|e| &e.vcard_hash).collect();
let hashes_c: Vec<_> = log_c.events.iter().map(|e| &e.vcard_hash).collect();
assert_eq!(hashes_a, hashes_b);
assert_eq!(hashes_b, hashes_c);
let open_set = OpenSet::from_places(vec![Place::new("alpha"), Place::new("beta")]);
let mut marking = Marking::new();
marking = marking.with_token("alpha", "token-alpha");
marking = marking.with_token("beta", "token-beta");
let section = Section::new(open_set.clone(), marking);
let sheaf = Sheaf::new();
let cover = vec![open_set];
let result = sheaf.gluing_check(&[section], &cover);
assert!(result.is_ok(), "Sheaf gluing should pass for disjoint writes");
}
#[tokio::test]
async fn test_three_node_conflicting_writes_sheaf_failure() {
let mut log_a = CrdtLog::new("node-a");
let mut log_b = CrdtLog::new("node-b");
let mut clock_a = VectorClock::new();
clock_a.increment("node-a");
let event_a = make_learning_event(
"sha256:vcard-conflict-a",
"sha256:pcard-shared",
"shared",
"token-a",
"did:pkc:node-a",
&clock_a,
);
log_a.append(event_a.clone());
let mut clock_b = VectorClock::new();
clock_b.increment("node-b");
let event_b = make_learning_event(
"sha256:vcard-conflict-b",
"sha256:pcard-shared",
"shared",
"token-b",
"did:pkc:node-b",
&clock_b,
);
log_b.append(event_b.clone());
assert!(clock_a.is_concurrent_with(&clock_b));
let mut log_combined = CrdtLog::new("combined");
log_combined.merge(&log_a);
log_combined.merge(&log_b);
let open_set = OpenSet::from_places(vec![Place::new("shared")]);
let mut marking_a = Marking::new();
marking_a = marking_a.with_token("shared", "token-a");
let section_a = Section::new(open_set.clone(), marking_a);
let mut marking_b = Marking::new();
marking_b = marking_b.with_token("shared", "token-b");
let section_b = Section::new(open_set.clone(), marking_b);
let sheaf = Sheaf::new();
let cover = vec![open_set.clone(), open_set];
let result = sheaf.gluing_check(&[section_a, section_b], &cover);
assert!(result.is_err(), "Sheaf gluing should fail for conflicting concurrent writes to same place");
}
#[tokio::test]
async fn test_three_node_partition_tolerance() {
let start = Instant::now();
let mut log_a = CrdtLog::new("node-a");
let mut log_b = CrdtLog::new("node-b");
let mut log_c = CrdtLog::new("node-c");
let mut clock_a = VectorClock::new();
clock_a.increment("node-a");
let event_a = make_learning_event(
"sha256:vcard-part-a",
"sha256:pcard-part-a",
"gamma",
"token-gamma-a",
"did:pkc:node-a",
&clock_a,
);
log_a.append(event_a);
let mut clock_b = VectorClock::new();
clock_b.increment("node-b");
let event_b = make_learning_event(
"sha256:vcard-part-b",
"sha256:pcard-part-b",
"delta",
"token-delta-b",
"did:pkc:node-b",
&clock_b,
);
log_b.append(event_b);
assert_eq!(log_c.events.len(), 0);
log_c.merge(&log_a);
log_c.merge(&log_b);
assert_eq!(log_c.events.len(), 2);
log_a.merge(&log_c);
log_b.merge(&log_c);
assert_eq!(log_a.events.len(), 2);
assert_eq!(log_b.events.len(), 2);
assert_eq!(log_c.events.len(), 2);
let hashes_a: Vec<_> = log_a.events.iter().map(|e| &e.vcard_hash).collect();
let hashes_b: Vec<_> = log_b.events.iter().map(|e| &e.vcard_hash).collect();
let hashes_c: Vec<_> = log_c.events.iter().map(|e| &e.vcard_hash).collect();
assert_eq!(hashes_a, hashes_b);
assert_eq!(hashes_b, hashes_c);
let elapsed = start.elapsed();
assert!(elapsed.as_secs() < 30, "Full test should complete in < 30 seconds, took {}s", elapsed.as_secs());
}
#[tokio::test]
async fn test_three_node_cross_pkc_dispatch_over_quic() {
let cert = generate_self_signed_cert("three-node-dispatch").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
let server_handle = tokio::spawn(async move {
let conn = server.accept().await.unwrap();
let (request, send_stream) = receive_cross_pkc_dispatch(&conn).await.unwrap();
assert_eq!(request.pcard_hash, "sha256:pcard-remote");
assert_eq!(request.target_pkc_did, "did:pkc:node-b");
let vcard_yaml = format!(
"vcard_token:\n gate_type: \"dispatch\"\n result: \"pass\"\n pcard_hash: \"{}\"",
request.pcard_hash
);
let vcard_hash = clm_rust_core::fs_utils::compute_sha256_hex(vcard_yaml.as_bytes());
let response = CrossPkcDispatchResponse {
vcard_hash: format!("sha256:{}", vcard_hash),
vcard_yaml,
target_signature: "sig:did:pkc:node-b".to_string(),
exit_code: 0,
exec_output: "executed-remotely".to_string(),
};
let response_json = serde_json::to_vec(&response).unwrap();
conn.respond(send_stream, &response_json).await.unwrap();
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(), "three-node-dispatch").await.unwrap();
let request = CrossPkcDispatchRequest {
pcard_hash: "sha256:pcard-remote".to_string(),
input_marking: Marking::new(),
source_pkc_did: "did:pkc:node-a".to_string(),
target_pkc_did: "did:pkc:node-b".to_string(),
};
let response = dispatch_cross_pkc(&request, &conn).await.unwrap();
assert_eq!(response.exit_code, 0);
assert_eq!(response.exec_output, "executed-remotely");
let co_signed = co_sign_vcard(&response, "did:pkc:node-a", "did:pkc:node-b");
assert_eq!(co_signed.signatures.len(), 2);
assert!(co_signed.signatures.contains(&"sig:did:pkc:node-a".to_string()));
assert!(co_signed.signatures.contains(&"sig:did:pkc:node-b".to_string()));
server_handle.await.unwrap();
client.close();
}
#[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"));
}
#[tokio::test]
async fn test_crdt_sync_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");
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);
server_handle.await.unwrap();
client.close();
}