path: root/grasp-audit/src/specs/grasp01_nostr_relay.rs

//! GRASP-01 Nostr Relay Tests
//!
//! Tests for GRASP-01 Nostr relay requirements (lines 1-14 of ../grasp/01.md)
//!
//! These tests validate that a GRASP-01 compliant relay:
//! - Accepts valid NIP-34 repository announcements and state announcements
//! - Rejects announcements that don't list the service
//! - Accepts related events (issues, patches, PRs)
//! - Serves proper NIP-11 relay information document

use crate::{AuditClient, AuditResult, TestResult};
use nostr_sdk::prelude::*;

pub struct Grasp01NostrRelayTests;

impl Grasp01NostrRelayTests {
    /// Run all GRASP-01 Nostr relay tests
    pub async fn run_all(client: &AuditClient) -> AuditResult {
        let mut results = AuditResult::new("GRASP-01 Nostr Relay Tests");
        
        // Repository announcement acceptance tests
        results.add(Self::test_accept_valid_repo_announcement(client).await);
        results.add(Self::test_reject_repo_announcement_missing_clone_tag(client).await);
        results.add(Self::test_reject_repo_announcement_missing_relays_tag(client).await);
        
        // Repository state announcement tests
        results.add(Self::test_accept_valid_repo_state_announcement(client).await);
        
        // Related event acceptance tests
        results.add(Self::test_accept_event_tagging_repo_announcement(client).await);
        results.add(Self::test_accept_event_tagged_by_repo(client).await);
        results.add(Self::test_accept_patch_for_repo(client).await);
        results.add(Self::test_accept_pull_request_for_repo(client).await);
        results.add(Self::test_accept_issue_for_repo(client).await);
        results.add(Self::test_accept_reply_to_issue(client).await);
        
        // NIP-11 relay information tests
        results.add(Self::test_nip11_document_exists(client).await);
        results.add(Self::test_nip11_supported_grasps_field(client).await);
        results.add(Self::test_nip11_repo_acceptance_criteria_field(client).await);
        results.add(Self::test_nip11_curation_field(client).await);
        
        // Policy tests (document behavior)
        results.add(Self::test_custom_rejection_allowed(client).await);
        results.add(Self::test_spam_prevention_allowed(client).await);
        
        results
    }
    
    // =========================================================================
    // Repository Announcement Acceptance Tests
    // =========================================================================
    
    /// Test: Accept valid repository announcements
    ///
    /// Spec: Lines 3-5 of ../grasp/01.md
    /// Requirement: MUST accept repo announcements listing service in clone & relays tags
    async fn test_accept_valid_repo_announcement(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_valid_repo_announcement",
            "GRASP-01:nostr-relay:3-5",
            "Accept valid repository announcements with service in clone and relays tags",
        )
        .run(|| async {
            // Create a NIP-34 repository announcement event
            let event = client.create_repo_announcement("accept_valid_repo_announcement").await
                .map_err(|e| format!("Failed to create repository announcement: {}", e))?;
            
            // Get relay URL for validation
            let relay_url = client.client().relays().await
                .keys()
                .next()
                .ok_or("No relay connected")?
                .to_string();
            
            // Convert WebSocket URL to HTTP URL for validation
            let http_url = relay_url
                .replace("ws://", "http://")
                .replace("wss://", "https://");
            
            // Extract repo_id from the event's d tag
            let repo_id = event.tags.iter()
                .find(|t| t.kind() == TagKind::d())
                .and_then(|t| t.content())
                .ok_or("Missing d tag in announcement")?
                .to_string();
            
            // Send the event
            let event_id = client.send_event(event.clone()).await
                .map_err(|e| format!("Failed to send repository announcement to relay: {}", e))?;
            
            // Query back to verify it was accepted and stored
            let filter = Filter::new()
                .kind(Kind::GitRepoAnnouncement)
                .author(client.public_key())
                .identifier(&repo_id);
            
            let events = client.query(filter).await
                .map_err(|e| format!("Failed to query events from relay: {}", e))?;
            
            // Verify we got the event back
            if events.is_empty() {
                return Err(format!(
                    "Event was not stored in relay (possibly rejected). Event ID: {}, Repo ID: {}",
                    event_id, repo_id
                ));
            }
            
            // Verify it's the same event
            let stored_event = events.iter()
                .find(|e| e.id == event_id)
                .ok_or(format!(
                    "Stored event ID doesn't match sent event. Expected: {}, Got {} events",
                    event_id, events.len()
                ))?;
            
            // Verify key tags are present
            let has_clone_tag = stored_event.tags.iter()
                .any(|t| {
                    t.kind() == TagKind::Custom("clone".into()) &&
                    t.content().map(|c| c.contains(&http_url)).unwrap_or(false)
                });
            
            let has_relays_tag = stored_event.tags.iter()
                .any(|t| {
                    t.kind() == TagKind::Custom("relays".into()) &&
                    t.content() == Some(&relay_url)
                });
            
            if !has_clone_tag {
                return Err(format!("Stored event missing clone tag with service URL ({})", http_url));
            }
            
            if !has_relays_tag {
                return Err(format!("Stored event missing relays tag with service URL ({})", relay_url));
            }
            
            Ok(())
        })
        .await
    }
    
    /// Test: Reject repo announcements not listing service in clone tag
    ///
    /// Spec: Line 5 of ../grasp/01.md
    /// Requirement: MUST reject announcements not listing service (unless GRASP-05)
    async fn test_reject_repo_announcement_missing_clone_tag(client: &AuditClient) -> TestResult {
        TestResult::new(
            "reject_repo_announcement_missing_clone_tag",
            "GRASP-01:nostr-relay:5",
            "Reject repository announcements without service in clone tag",
        )
        .run(|| async {
            // Get relay URL from client
            let relay_url = client.client().relays().await
                .keys()
                .next()
                .ok_or("No relay connected - client has no active relay connections")?
                .to_string();
            
            // Create unique repository identifier
            let timestamp = Timestamp::now().as_u64();
            let repo_id = format!("test-repo-no-clone-{}", timestamp);
            
            // Create repo announcement WITHOUT service in clone tag
            let event = client.event_builder(Kind::GitRepoAnnouncement, "")
                .tag(Tag::identifier(&repo_id))
                .tag(Tag::custom(TagKind::Custom("name".into()), vec!["Test Repo No Clone"]))
                .tag(Tag::custom(TagKind::Custom("clone".into()), vec!["https://github.com/user/repo.git"])) // NOT this service
                .tag(Tag::custom(TagKind::Custom("relays".into()), vec![relay_url.clone()])) // Correct relay
                .build(client.keys())
                .map_err(|e| format!("Failed to build event: {}", e))?;
            
            let event_id = event.id;
            
            // Send event - expect rejection
            let send_result = client.send_event(event.clone()).await;
            
            // Query to verify event is NOT stored
            let filter = Filter::new()
                .kind(Kind::GitRepoAnnouncement)
                .author(client.public_key())
                .identifier(&repo_id);
            
            let events = client.query(filter).await
                .map_err(|e| format!("Failed to query events from relay: {}", e))?;
            
            // Verify event was rejected (not stored)
            if events.iter().any(|e| e.id == event_id) {
                return Err(format!(
                    "Relay incorrectly accepted announcement without service in clone tag. \
                    Event ID: {}, Clone URL: https://github.com/user/repo.git (should require {})",
                    event_id, relay_url
                ));
            }
            
            Ok(())
        })
        .await
    }
    
    /// Test: Reject repo announcements not listing service in relays tag
    ///
    /// Spec: Line 5 of ../grasp/01.md
    /// Requirement: MUST reject announcements not listing service in relays
    async fn test_reject_repo_announcement_missing_relays_tag(client: &AuditClient) -> TestResult {
        TestResult::new(
            "reject_repo_announcement_missing_relays_tag",
            "GRASP-01:nostr-relay:5",
            "Reject repository announcements without service in relays tag",
        )
        .run(|| async {
            // Get relay URL from client
            let relay_url = client.client().relays().await
                .keys()
                .next()
                .ok_or("No relay connected - client has no active relay connections")?
                .to_string();
            
            // Convert WebSocket URL to HTTP URL for clone tag
            let http_url = relay_url
                .replace("ws://", "http://")
                .replace("wss://", "https://");
            
            // Create unique repository identifier
            let timestamp = Timestamp::now().as_u64();
            let repo_id = format!("test-repo-no-relays-{}", timestamp);
            
            // Create repo announcement WITHOUT service in relays tag
            let event = client.event_builder(Kind::GitRepoAnnouncement, "")
                .tag(Tag::identifier(&repo_id))
                .tag(Tag::custom(TagKind::custom("name"), vec!["Test Repo No Relays"]))
                .tag(Tag::custom(TagKind::custom("clone"), vec![format!("{}/{}/test-repo.git", http_url, client.public_key())])) // Correct clone
                .tag(Tag::custom(TagKind::custom("relays"), vec!["wss://relay.damus.io"])) // NOT this service
                .build(client.keys())
                .map_err(|e| format!("Failed to build event: {}", e))?;
            
            let event_id = event.id;
            
            // Send event - expect rejection
            let _send_result = client.send_event(event.clone()).await;
            
            // Query to verify event is NOT stored
            let filter = Filter::new()
                .kind(Kind::GitRepoAnnouncement)
                .author(client.public_key())
                .identifier(&repo_id);
            
            let events = client.query(filter).await
                .map_err(|e| format!("Failed to query events from relay: {}", e))?;
            
            // Verify event was rejected (not stored)
            if events.iter().any(|e| e.id == event_id) {
                return Err(format!(
                    "Relay incorrectly accepted announcement without service in relays tag. \
                    Event ID: {}, Relays URL: wss://relay.damus.io (should require {})",
                    event_id, relay_url
                ));
            }
            
            Ok(())
        })
        .await
    }
    
    // =========================================================================
    // Repository State Announcement Tests
    // =========================================================================
    
    /// Test: Accept valid repository state announcements
    ///
    /// Spec: Lines 6-7 of ../grasp/01.md
    /// Requirement: MUST accept repo state announcements with d, maintainers, and r tags
    async fn test_accept_valid_repo_state_announcement(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_valid_repo_state_announcement",
            "GRASP-01:nostr-relay:6-7",
            "Accept valid state announcements after repo announcement accepted",
        )
        .run(|| async {
            // First, create a repository announcement (kind 30617) by the same author
            let test_name = format!("test-repo-multi-refs-{}", Timestamp::now().as_u64());
            let repo_event = client.create_repo_announcement(&test_name).await
                .map_err(|e| format!("Failed to create repository announcement: {}", e))?;
            
            // Extract repo_id from the repository announcement
            let repo_id = repo_event.tags.iter()
                .find(|t| t.kind() == TagKind::d())
                .and_then(|t| t.content())
                .ok_or("Missing d tag in repository announcement")?
                .to_string();
            
            // Get maintainer npub
            let npub = client.public_key().to_bech32()
                .map_err(|e| format!("Failed to convert public key to bech32: {}", e))?;
            
            // Create kind 30618 repository state announcement with multiple refs
            // Format: ["r", "refs/heads/main", "<commit-id>"]
            let event = client.event_builder(Kind::Custom(30618), "")
                .tag(Tag::identifier(&repo_id))
                .tag(Tag::custom(TagKind::custom("refs/heads/main"), vec![
                    "abc123def456789012345678901234567890abcd"
                ]))
                .tag(Tag::custom(TagKind::custom("refs/heads/develop"), vec![
                    "def456789012345678901234567890abcdef123"
                ]))
                .tag(Tag::custom(TagKind::custom("refs/tags/v1.0.0"), vec![
                    "123456789012345678901234567890abcdef456"
                ]))
                .tag(Tag::custom(TagKind::custom("HEAD"), vec![
                    "ref: refs/heads/main"
                ]))
                .build(client.keys())
                .map_err(|e| format!("Failed to build state announcement: {}", e))?;
            
            let event_id = event.id;

            // Send the repo announcement event
            client.send_event(repo_event.clone()).await
                .map_err(|e| format!("Failed to send state announcement to relay: {}", e))?;

            // Send the state event
            client.send_event(event.clone()).await
                .map_err(|e| format!("Failed to send state announcement to relay: {}", e))?;
            
            // Query back to verify it was accepted and stored
            let filter = Filter::new()
                .kind(Kind::Custom(30618))
                .author(client.public_key())
                .identifier(&repo_id);
            
            let events = client.query(filter).await
                .map_err(|e| format!("Failed to query events from relay: {}", e))?;
            
            // Verify we got the event back
            if events.is_empty() {
                return Err(format!(
                    "Event was not stored in relay (possibly rejected). Event ID: {}, Repo ID: {}",
                    event_id, repo_id
                ));
            }
                        
            Ok(())
        })
        .await
    }
    
     
    // =========================================================================
    // Related Event Acceptance Tests
    // =========================================================================
    
    /// Test: Accept events tagging accepted repo announcements
    ///
    /// Spec: Lines 7-9 of ../grasp/01.md
    /// Requirement: MUST accept events that tag accepted repo announcements
    async fn test_accept_event_tagging_repo_announcement(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_event_tagging_repo_announcement",
            "GRASP-01:nostr-relay:7-9",
            "Accept events that tag accepted repository announcements",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Create and send kind 30617 repo announcement
            // 2. Create kind 1621 (issue) event with:
            //    - a tag: "30617:{pubkey}:{d-tag}"
            //    - p tag: repo owner pubkey
            //    - subject tag: "Test Issue"
            //    - content: "This is a test issue"
            // 3. Send issue event
            // 4. Verify acceptance
            // 5. Query to confirm issue is stored
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: Accept events tagged by repo announcements
    ///
    /// Spec: Lines 7-9 of ../grasp/01.md
    /// Requirement: MUST accept events tagged by accepted announcements
    async fn test_accept_event_tagged_by_repo(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_event_tagged_by_repo",
            "GRASP-01:nostr-relay:7-9",
            "Accept events that are tagged by accepted repository announcements",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Create kind 1 note event (regular note)
            // 2. Send the note
            // 3. Create kind 30617 repo announcement that tags the note
            //    - Include e tag pointing to note event ID
            // 4. Send repo announcement
            // 5. Verify both events are stored
            // 6. This tests that related events are retained
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: Accept patches (kind 1617) for accepted repos
    ///
    /// Spec: Lines 8-9 of ../grasp/01.md
    /// Requirement: MUST accept patches for accepted repos
    async fn test_accept_patch_for_repo(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_patch_for_repo",
            "GRASP-01:nostr-relay:8-9",
            "Accept patch events (kind 1617) for accepted repositories",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Create and send kind 30617 repo announcement
            // 2. Create kind 1617 patch event with:
            //    - a tag: "30617:{pubkey}:{d-tag}"
            //    - p tag: repo owner
            //    - r tag: earliest-unique-commit-id
            //    - t tag: "root" (first patch in series)
            //    - content: actual git format-patch output
            // 3. Send patch event
            // 4. Verify acceptance
            // 5. Query to confirm patch is stored
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: Accept pull requests (kind 1618) for accepted repos
    ///
    /// Spec: Lines 8-9 of ../grasp/01.md
    /// Requirement: MUST accept PRs for accepted repos
    async fn test_accept_pull_request_for_repo(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_pull_request_for_repo",
            "GRASP-01:nostr-relay:8-9",
            "Accept pull request events (kind 1618) for accepted repositories",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Create and send kind 30617 repo announcement
            // 2. Create kind 1618 PR event with:
            //    - a tag: "30617:{pubkey}:{d-tag}"
            //    - p tag: repo owner
            //    - r tag: earliest-unique-commit-id
            //    - subject tag: "Add feature X"
            //    - c tag: commit SHA of PR tip
            //    - clone tag: URL where commit can be fetched
            //    - content: PR description
            // 3. Send PR event
            // 4. Verify acceptance
            // 5. Query to confirm PR is stored
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: Accept issues (kind 1621) for accepted repos
    ///
    /// Spec: Lines 8-9 of ../grasp/01.md
    /// Requirement: MUST accept issues for accepted repos
    async fn test_accept_issue_for_repo(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_issue_for_repo",
            "GRASP-01:nostr-relay:8-9",
            "Accept issue events (kind 1621) for accepted repositories",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Create and send kind 30617 repo announcement
            // 2. Create kind 1621 issue event with:
            //    - a tag: "30617:{pubkey}:{d-tag}"
            //    - p tag: repo owner
            //    - subject tag: "Bug: Something is broken"
            //    - t tag: "bug" (label)
            //    - content: issue description
            // 3. Send issue event
            // 4. Verify acceptance
            // 5. Query to confirm issue is stored
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: Accept replies to accepted patches/PRs/issues
    ///
    /// Spec: Lines 8-9 of ../grasp/01.md
    /// Requirement: MUST accept replies to accepted events
    async fn test_accept_reply_to_issue(client: &AuditClient) -> TestResult {
        TestResult::new(
            "accept_reply_to_issue",
            "GRASP-01:nostr-relay:8-9",
            "Accept reply events to accepted issues/patches/PRs",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Create and send kind 30617 repo announcement
            // 2. Create and send kind 1621 issue
            // 3. Create NIP-22 comment (kind 1111) replying to issue:
            //    - E tag: issue event ID
            //    - P tag: issue author
            //    - content: reply text
            // 4. Send reply event
            // 5. Verify acceptance
            // 6. Query to confirm reply is stored
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    // =========================================================================
    // NIP-11 Relay Information Tests
    // =========================================================================
    
    /// Test: Serve NIP-11 document
    ///
    /// Spec: Line 11 of ../grasp/01.md
    /// Requirement: MUST serve NIP-11 document
    async fn test_nip11_document_exists(client: &AuditClient) -> TestResult {
        TestResult::new(
            "nip11_document_exists",
            "GRASP-01:nostr-relay:11",
            "Serve NIP-11 relay information document",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Extract HTTP(S) URL from client's WebSocket URL
            //    - ws://localhost:8081 -> http://localhost:8081
            //    - wss://relay.example.com -> https://relay.example.com
            // 2. HTTP GET to base URL with header:
            //    - Accept: application/nostr+json
            // 3. Verify 200 OK response
            // 4. Verify response is valid JSON
            // 5. Parse as NIP-11 document
            // 6. Verify has required fields (name, description, etc.)
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: NIP-11 includes supported_grasps field
    ///
    /// Spec: Line 12 of ../grasp/01.md
    /// Requirement: MUST list supported GRASPs as string array
    async fn test_nip11_supported_grasps_field(client: &AuditClient) -> TestResult {
        TestResult::new(
            "nip11_supported_grasps_field",
            "GRASP-01:nostr-relay:12",
            "NIP-11 document includes supported_grasps field with GRASP-01",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Fetch NIP-11 document (same as above)
            // 2. Verify `supported_grasps` field exists
            // 3. Verify it's a JSON array of strings
            // 4. Verify array includes "GRASP-01"
            // 5. Verify format: each entry matches pattern "GRASP-\d{2}"
            // 6. Document other GRASPs found (for info)
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: NIP-11 includes repo_acceptance_criteria field
    ///
    /// Spec: Line 13 of ../grasp/01.md
    /// Requirement: MUST list repository acceptance criteria
    async fn test_nip11_repo_acceptance_criteria_field(client: &AuditClient) -> TestResult {
        TestResult::new(
            "nip11_repo_acceptance_criteria_field",
            "GRASP-01:nostr-relay:13",
            "NIP-11 document includes repo_acceptance_criteria field",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Fetch NIP-11 document
            // 2. Verify `repo_acceptance_criteria` field exists
            // 3. Verify it's a string (human-readable)
            // 4. Verify non-empty
            // 5. Document the criteria (for info)
            // Examples: "Must list this relay in clone and relays tags"
            //           "Pre-payment required via Lightning invoice"
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    /// Test: NIP-11 curation field handling
    ///
    /// Spec: Line 14 of ../grasp/01.md
    /// Requirement: MUST include curation if curated, omit otherwise
    async fn test_nip11_curation_field(client: &AuditClient) -> TestResult {
        TestResult::new(
            "nip11_curation_field",
            "GRASP-01:nostr-relay:14",
            "NIP-11 curation field present if curated, absent otherwise",
        )
        .run(|| async {
            // TODO: Implementation
            // 1. Fetch NIP-11 document
            // 2. Check if `curation` field exists
            // 3. If present:
            //    - Verify it's a non-empty string
            //    - Document the curation policy
            // 4. If absent:
            //    - Document that no curation beyond SPAM prevention
            // 5. Both cases are valid per spec
            
            Err("Not implemented yet".to_string())
        })
        .await
    }
    
    // =========================================================================
    // Policy Tests (Document Allowed Behavior)
    // =========================================================================
    
    /// Test: Custom rejection criteria allowed
    ///
    /// Spec: Line 6 of ../grasp/01.md
    /// Requirement: MAY reject based on custom criteria (document behavior)
    async fn test_custom_rejection_allowed(client: &AuditClient) -> TestResult {
        TestResult::new(
            "custom_rejection_allowed",
            "GRASP-01:nostr-relay:6",
            "Document that custom rejection criteria are allowed",
        )
        .run(|| async {
            // TODO: Implementation
            // This is a policy test, not a functional test
            // 
            // The spec says relay MAY reject based on:
            // - Pre-payment
            // - Quotas
            // - WoT (Web of Trust)
            // - Whitelist
            // - SPAM prevention
            // - etc.
            //
            // This test should:
            // 1. Document that such rejections are allowed
            // 2. Check NIP-11 repo_acceptance_criteria for policy
            // 3. Optionally test if relay enforces any criteria
            // 4. Mark as PASS (this is permissive, not mandatory)
            
            Ok(())  // This is always allowed
        })
        .await
    }
    
    /// Test: SPAM prevention allowed
    ///
    /// Spec: Line 10 of ../grasp/01.md
    /// Requirement: MAY reject/delete for SPAM prevention
    async fn test_spam_prevention_allowed(client: &AuditClient) -> TestResult {
        TestResult::new(
            "spam_prevention_allowed",
            "GRASP-01:nostr-relay:10",
            "Document that SPAM prevention is allowed",
        )
        .run(|| async {
            // TODO: Implementation
            // Similar to above - this is permissive
            //
            // The spec says relay MAY reject or delete events for:
            // - Generic SPAM prevention
            // - Curation (WoT, whitelist, user bans, banned topics)
            //
            // This test should:
            // 1. Document that SPAM prevention is allowed
            // 2. Check NIP-11 curation field for policy
            // 3. Mark as PASS (this is implementation-specific)
            
            Ok(())  // This is always allowed
        })
        .await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::AuditConfig;
    
#[tokio::test]
#[ignore] // Requires running relay
async fn test_grasp01_nostr_relay_against_relay() {
    // Read relay URL from environment variable - must be supplied
    let relay_url = std::env::var("RELAY_URL")
        .expect("RELAY_URL environment variable must be set. Example: RELAY_URL=ws://localhost:18081");
    
    let config = AuditConfig::ci();
    let client = AuditClient::new(&relay_url, config)
        .await
        .expect(&format!(
            "Failed to connect to relay at {}. Ensure relay is running and accessible. \
            Try: docker run --rm -p 18081:8081 ghcr.io/danconwaydev/ngit-relay:latest",
            relay_url
        ));
        
        let results = Grasp01NostrRelayTests::run_all(&client).await;
        results.print_report();
        
        // Don't assert all passed yet - tests not implemented
        // assert!(results.all_passed(), "Some GRASP-01 Nostr relay tests failed");
    }
}