From 7467aa9ace94b4e132eedd03c9daddb2d59813c4 Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Wed, 7 Jan 2026 20:41:01 +0000 Subject: test: added purgatory git data sync intergration tests agregating from mulitple git servers --- tests/common/mock_relay.rs | 336 ++++++++++++++++++++++++++++++++++++++ tests/common/mod.rs | 2 + tests/common/purgatory_helpers.rs | 115 +++++++++++++ 3 files changed, 453 insertions(+) create mode 100644 tests/common/mock_relay.rs (limited to 'tests/common') diff --git a/tests/common/mock_relay.rs b/tests/common/mock_relay.rs new file mode 100644 index 0000000..123c29e --- /dev/null +++ b/tests/common/mock_relay.rs @@ -0,0 +1,336 @@ +//! Mock Nostr Relay for Testing +//! +//! Provides a simple Nostr relay that accepts all events without validation. +//! Uses rust-nostr's `LocalRelayBuilder` to create an in-memory relay. +//! +//! # Usage +//! +//! ```ignore +//! use common::MockRelay; +//! +//! #[tokio::test] +//! async fn test_mock_relay() { +//! // Start the mock relay +//! let mock = MockRelay::start().await; +//! +//! // Use mock.url() for WebSocket connections +//! let client = Client::new(keys); +//! client.add_relay(mock.url()).await.unwrap(); +//! +//! // All events are accepted without validation +//! client.send_event(&event).await.unwrap(); +//! +//! // Cleanup +//! mock.stop().await; +//! } +//! ``` +//! +//! # How It Works +//! +//! The mock relay: +//! - Uses `LocalRelayBuilder::default().build()` which accepts all events +//! - Runs an HTTP server with WebSocket upgrade support +//! - Stores events in an in-memory database +//! - Does NOT perform any GRASP validation (no purgatory, no git data checks) + +use std::net::SocketAddr; +use std::sync::Arc; + +use http_body_util::Full; +use hyper::body::Bytes; +use hyper::header::{CONNECTION, SEC_WEBSOCKET_ACCEPT, SEC_WEBSOCKET_KEY, UPGRADE}; +use hyper::server::conn::http1; +use hyper::service::service_fn; +use hyper::{Request, Response, StatusCode}; +use hyper_util::rt::TokioIo; +use nostr_relay_builder::prelude::*; +use tokio::net::TcpListener; +use tokio::sync::oneshot; + +/// Mock Nostr relay that accepts all events without validation. +/// +/// This relay is useful for testing scenarios where you need a relay +/// that serves events without GRASP validation (no purgatory, no git checks). +pub struct MockRelay { + /// Shutdown signal sender + shutdown_tx: Option>, + /// Server task handle + handle: Option>, + /// Server URL (ws://127.0.0.1:) + url: String, + /// Server port + #[allow(dead_code)] + port: u16, + /// The underlying LocalRelay (kept alive for the server lifetime) + #[allow(dead_code)] + relay: LocalRelay, +} + +impl MockRelay { + /// Start a mock relay on a random free port. + /// + /// The relay accepts all events without validation and stores them + /// in an in-memory database. + pub async fn start() -> Self { + let port = find_free_port(); + Self::start_on_port(port).await + } + + /// Start a mock relay on a specific port. + pub async fn start_on_port(port: u16) -> Self { + let addr: SocketAddr = ([127, 0, 0, 1], port).into(); + + // Create a simple relay with no write policy (accepts all events) + let relay = LocalRelayBuilder::default().build(); + + // Create shutdown channel + let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>(); + + // Clone relay for the server task + let server_relay = relay.clone(); + + // Start the HTTP/WebSocket server + let listener = TcpListener::bind(addr) + .await + .expect("Failed to bind to address"); + + let handle = tokio::spawn(async move { + loop { + tokio::select! { + accept_result = listener.accept() => { + match accept_result { + Ok((stream, remote_addr)) => { + let relay = server_relay.clone(); + let io = TokioIo::new(stream); + + tokio::spawn(async move { + let service = service_fn(move |req| { + let relay = relay.clone(); + async move { handle_request(req, relay, remote_addr).await } + }); + + if let Err(e) = http1::Builder::new() + .serve_connection(io, service) + .with_upgrades() + .await + { + // Connection errors are expected when client disconnects + if !e.to_string().contains("connection") { + eprintln!("MockRelay connection error: {}", e); + } + } + }); + } + Err(e) => { + eprintln!("MockRelay accept error: {}", e); + } + } + } + _ = &mut shutdown_rx => { + // Shutdown signal received + break; + } + } + } + }); + + let url = format!("ws://127.0.0.1:{}", port); + + // Wait for server to be ready + wait_for_server_ready(port).await; + + Self { + shutdown_tx: Some(shutdown_tx), + handle: Some(handle), + url, + port, + relay, + } + } + + /// Get the relay WebSocket URL. + pub fn url(&self) -> &str { + &self.url + } + + /// Stop the mock relay. + pub async fn stop(mut self) { + // Send shutdown signal + if let Some(tx) = self.shutdown_tx.take() { + let _ = tx.send(()); + } + + // Wait for server task to complete + if let Some(handle) = self.handle.take() { + let _ = handle.await; + } + } +} + +impl Drop for MockRelay { + fn drop(&mut self) { + // Send shutdown signal if not already sent + if let Some(tx) = self.shutdown_tx.take() { + let _ = tx.send(()); + } + } +} + +/// Handle an HTTP request, upgrading to WebSocket if requested. +async fn handle_request( + req: Request, + relay: LocalRelay, + addr: SocketAddr, +) -> Result>, hyper::Error> { + // Check for WebSocket upgrade request + let is_websocket = req + .headers() + .get(UPGRADE) + .map(|v| v.to_str().unwrap_or("").to_lowercase() == "websocket") + .unwrap_or(false); + + if is_websocket { + // Get the Sec-WebSocket-Key header + let key = req + .headers() + .get(SEC_WEBSOCKET_KEY) + .and_then(|k| k.to_str().ok()) + .map(|k| k.to_string()); + + if let Some(key) = key { + let accept_key = derive_accept_key(key.as_bytes()); + + // Spawn task to handle the upgraded connection + tokio::spawn(async move { + match hyper::upgrade::on(req).await { + Ok(upgraded) => { + if let Err(e) = relay.take_connection(TokioIo::new(upgraded), addr).await { + eprintln!("MockRelay WebSocket error: {}", e); + } + } + Err(e) => eprintln!("MockRelay upgrade error: {}", e), + } + }); + + // Return 101 Switching Protocols + return Ok(Response::builder() + .status(StatusCode::SWITCHING_PROTOCOLS) + .header(CONNECTION, "upgrade") + .header(UPGRADE, "websocket") + .header(SEC_WEBSOCKET_ACCEPT, accept_key) + .body(Full::new(Bytes::new())) + .unwrap()); + } + } + + // Non-WebSocket request - return simple response + Ok(Response::builder() + .status(StatusCode::OK) + .header("Content-Type", "text/plain") + .body(Full::new(Bytes::from("MockRelay - Nostr test relay"))) + .unwrap()) +} + +/// Derive the Sec-WebSocket-Accept key from the request key. +fn derive_accept_key(request_key: &[u8]) -> String { + use nostr_sdk::hashes::sha1::Hash as Sha1Hash; + use nostr_sdk::hashes::{Hash, HashEngine}; + + const WS_GUID: &[u8] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + + let mut engine = Sha1Hash::engine(); + engine.input(request_key); + engine.input(WS_GUID); + let hash = Sha1Hash::from_engine(engine); + base64::Engine::encode(&base64::engine::general_purpose::STANDARD, hash.as_byte_array()) +} + +/// Find a free port to use for the server. +fn find_free_port() -> u16 { + use std::net::TcpListener; + + let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind to random port"); + let port = listener + .local_addr() + .expect("Failed to get local addr") + .port(); + drop(listener); + port +} + +/// Wait for the server to be ready to accept connections. +async fn wait_for_server_ready(port: u16) { + let max_attempts = 50; // 5 seconds total + let delay = std::time::Duration::from_millis(100); + + for attempt in 0..max_attempts { + match tokio::net::TcpStream::connect(format!("127.0.0.1:{}", port)).await { + Ok(_) => { + // Connection successful, server is ready + tokio::time::sleep(std::time::Duration::from_millis(50)).await; + return; + } + Err(_) => { + if attempt == max_attempts - 1 { + panic!( + "MockRelay failed to start after {} attempts", + max_attempts + ); + } + tokio::time::sleep(delay).await; + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use nostr_sdk::prelude::*; + use std::time::Duration; + + #[tokio::test] + async fn test_mock_relay_starts_and_stops() { + let mock = MockRelay::start().await; + + // Verify URL is set + assert!(mock.url().starts_with("ws://127.0.0.1:")); + + mock.stop().await; + } + + #[tokio::test] + async fn test_mock_relay_accepts_events() { + let mock = MockRelay::start().await; + + // Create a client and connect + let keys = Keys::generate(); + let client = Client::new(keys.clone()); + client.add_relay(mock.url()).await.expect("Failed to add relay"); + client.connect().await; + + // Wait for connection + tokio::time::sleep(Duration::from_millis(500)).await; + + // Create and send a simple event + let event = EventBuilder::text_note("Test note from MockRelay test") + .sign_with_keys(&keys) + .expect("Failed to sign event"); + + let result = client.send_event(&event).await; + assert!(result.is_ok(), "MockRelay should accept events"); + + // Verify event was stored by fetching it back + let filter = Filter::new().id(event.id); + let events = client + .fetch_events(filter, Duration::from_secs(2)) + .await + .expect("Failed to fetch events"); + + assert!(!events.is_empty(), "Event should be stored and retrievable"); + assert_eq!(events.first().unwrap().id, event.id); + + client.disconnect().await; + mock.stop().await; + } +} diff --git a/tests/common/mod.rs b/tests/common/mod.rs index e70bd71..32ce1b7 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -3,11 +3,13 @@ #![allow(unused_imports)] // Re-exports may not be used in all test configurations pub mod git_server; +pub mod mock_relay; pub mod purgatory_helpers; pub mod relay; pub mod sync_helpers; pub use git_server::SimpleGitServer; +pub use mock_relay::MockRelay; pub use purgatory_helpers::*; pub use relay::TestRelay; pub use sync_helpers::*; diff --git a/tests/common/purgatory_helpers.rs b/tests/common/purgatory_helpers.rs index 7d8e908..fa1be73 100644 --- a/tests/common/purgatory_helpers.rs +++ b/tests/common/purgatory_helpers.rs @@ -271,6 +271,60 @@ pub fn create_pr_event( .map_err(|e| format!("Failed to sign PR event: {}", e)) } +/// Create a PR event (kind 1618) with clone URLs. +/// +/// Creates a properly formatted NIP-34 PR event that references a repository +/// via an `a` tag, includes the commit hash via a `c` tag, and specifies +/// clone URLs where the PR commit can be fetched from. +/// +/// Per NIP-34, PR events can include a `clone` tag: +/// ```jsonc +/// { +/// "kind": 1618, +/// "tags": [ +/// ["c", ""], +/// ["clone", "", ...], // at least one git clone url where commit can be downloaded +/// // ... +/// ] +/// } +/// ``` +/// +/// # Arguments +/// * `keys` - Keys for signing +/// * `repo_coord` - Repository coordinate (format: "30617:pubkey_hex:identifier") +/// * `commit_hash` - The commit hash (c-tag) +/// * `title` - PR title (used as content) +/// * `clone_urls` - Clone URLs where the PR commit can be fetched +/// +/// # Returns +/// * `Ok(Event)` - Signed PR event ready to send +/// * `Err(String)` - If signing fails +pub fn create_pr_event_with_clone( + keys: &Keys, + repo_coord: &str, + commit_hash: &str, + title: &str, + clone_urls: &[&str], +) -> Result { + let mut tags = vec![ + // a-tag referencing the repository + Tag::custom(TagKind::custom("a"), vec![repo_coord.to_string()]), + // c-tag with the commit hash + Tag::custom(TagKind::custom("c"), vec![commit_hash.to_string()]), + ]; + + // Add clone URLs if provided + if !clone_urls.is_empty() { + let urls: Vec = clone_urls.iter().map(|s| s.to_string()).collect(); + tags.push(Tag::custom(TagKind::Clone, urls)); + } + + EventBuilder::new(Kind::Custom(KIND_PR), title) + .tags(tags) + .sign_with_keys(keys) + .map_err(|e| format!("Failed to sign PR event: {}", e)) +} + /// Build a repository coordinate string for use in 'a' tags. /// /// Format: `30617:pubkey_hex:identifier` @@ -738,4 +792,65 @@ mod tests { let branch_commit = String::from_utf8_lossy(&output.stdout).trim().to_string(); assert_eq!(branch_commit, commit_hash); } + + #[test] + fn test_create_pr_event_with_clone_has_correct_tags() { + let keys = Keys::generate(); + let repo_coord = build_repo_coord(&keys, "test-repo"); + let event = create_pr_event_with_clone( + &keys, + &repo_coord, + "abc123def456", + "Test PR with clone", + &["http://fork-server.com/repo.git", "http://another-server.com/repo.git"], + ) + .expect("Failed to create PR event with clone"); + + assert_eq!(event.kind.as_u16(), KIND_PR); + + // Check a-tag + let has_a_tag = event.tags.iter().any(|tag| { + let slice = tag.as_slice(); + slice.first().is_some_and(|t| t == "a") && slice.get(1).is_some_and(|v| v == &repo_coord) + }); + assert!(has_a_tag, "Event should have 'a' tag"); + + // Check c-tag + let has_c_tag = event.tags.iter().any(|tag| { + let slice = tag.as_slice(); + slice.first().is_some_and(|t| t == "c") + && slice.get(1).is_some_and(|v| v == "abc123def456") + }); + assert!(has_c_tag, "Event should have 'c' tag with commit"); + + // Check clone tag with both URLs + let has_clone_tag = event.tags.iter().any(|tag| { + let slice = tag.as_slice(); + slice.first().is_some_and(|t| t == "clone") + && slice.get(1).is_some_and(|v| v == "http://fork-server.com/repo.git") + && slice.get(2).is_some_and(|v| v == "http://another-server.com/repo.git") + }); + assert!(has_clone_tag, "Event should have 'clone' tag with URLs"); + } + + #[test] + fn test_create_pr_event_with_clone_empty_urls() { + let keys = Keys::generate(); + let repo_coord = build_repo_coord(&keys, "test-repo"); + let event = create_pr_event_with_clone( + &keys, + &repo_coord, + "abc123def456", + "Test PR without clone URLs", + &[], // Empty clone URLs + ) + .expect("Failed to create PR event"); + + // Should not have clone tag when no URLs provided + let has_clone_tag = event.tags.iter().any(|tag| { + let slice = tag.as_slice(); + slice.first().is_some_and(|t| t == "clone") + }); + assert!(!has_clone_tag, "Event should not have 'clone' tag when no URLs provided"); + } } -- cgit v1.2.3