3 files changed, 453 insertions, 0 deletions

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<oneshot::Sender<()>>,
+    /// Server task handle
+    handle: Option<tokio::task::JoinHandle<()>>,
+    /// Server URL (ws://127.0.0.1:<port>)
+    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<hyper::body::Incoming>,
+    relay: LocalRelay,
+    addr: SocketAddr,
+) -> Result<Response<Full<Bytes>>, 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", "<current-commit-id>"],
+///     ["clone", "<clone-url>", ...], // 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<Event, String> {
+    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<String> = 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");
+    }
 }