#![cfg(feature = "native")]
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"));
}
#[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);
client.close();
server_handle.await.unwrap();
}