remove recursive relay discovery test

Recursive discovery relied on announcement events being gossiped across
relays regardless of whether they listed the service. Now that
announcements enter purgatory until state event and git data arrive,
cross-relay discovery cannot be triggered by a synced announcement alone,
making the three-relay recursive discovery scenario impossible.

2 files changed, 4 insertions, 137 deletions

diff --git a/tests/sync/discovery.rs b/tests/sync/discovery.rs
index 5fcda69..d45a290 100644
--- a/tests/sync/discovery.rs
+++ b/tests/sync/discovery.rs
@@ -3,10 +3,6 @@
 //! Tests for relay discovery from announcement events.
 //! When a relay receives an announcement listing another relay,
 //! it should discover and connect to that relay to sync events.
-//!
-//! # Tests
-//! - Test 2: Direct Layer 3 discovery from Layer 2
-//! - Test 3: Recursive multi-hop Layer 3 discovery
 
 use std::time::Duration;
 
@@ -240,130 +236,3 @@ async fn test_relay_discovery_via_announcements_with_historic_sync() {
     );
 }
 
-/// Test 3: 3-relay recursive discovery - relay discovers third relay through bootstrap
-///
-/// Scenario:
-/// ```text
-///     relay_a (SUT)       relay_b (bootstrap)     relay_c (discovered)
-///         │                     │                       │
-///         │                     │ has announcement_x    │ has announcement_y
-///         │                     │ listing A+B+C         │ listing A+C
-///         │                     │                       │
-///         ├────connect──────────►                       │
-///         │◄───sync announcement_x───────────────────────
-///         │                                             │
-///         │    discovers relay_c from announcement_x    │
-///         │                                             │
-///         ├─────────────connect─────────────────────────►
-///         │◄────────────sync announcement_y─────────────┘
-/// ```
-///
-/// This tests that relay_a:
-/// 1. Connects to relay_b (configured as bootstrap)
-/// 2. Receives announcement_x which lists relay_c
-/// 3. Discovers and connects to relay_c
-/// 4. Syncs announcement_y from relay_c
-///
-#[tokio::test]
-async fn test_recursive_relay_discovery_via_announcements_with_historic_sync() {
-    // 1. Start all three relays
-
-    // relay_b - will be the bootstrap relay, has announcement_x
-    let relay_b = TestRelay::start().await;
-    println!(
-        "relay_b (bootstrap) started at {} (domain: {})",
-        relay_b.url(),
-        relay_b.domain()
-    );
-
-    // relay_c - will be discovered via announcement_x, has announcement_y
-    let relay_c = TestRelay::start().await;
-    println!(
-        "relay_c (to be discovered) started at {} (domain: {})",
-        relay_c.url(),
-        relay_c.domain()
-    );
-
-    // relay_a - SUT, starts with relay_b as bootstrap
-    let relay_a = TestRelay::start_with_sync(Some(relay_b.url().to_string())).await;
-    println!(
-        "relay_a (SUT) started at {} (domain: {})",
-        relay_a.url(),
-        relay_a.domain()
-    );
-
-    // 2. Create test keys (one for each announcement)
-    let keys_x = Keys::generate();
-    let keys_y = Keys::generate();
-
-    // 3. Set up announcement_x on relay_b (lists all three relays: A+B+C) with git data
-    let domains_x = vec![relay_a.domain(), relay_b.domain(), relay_c.domain()];
-    let domain_refs_x: Vec<&str> = domains_x.iter().map(|s| s.as_str()).collect();
-
-    let (announcement_x, _git_dir_b) =
-        setup_announcement_on_relay(&relay_b, &keys_x, &domain_refs_x, "repo-x-all-relays").await;
-    let announcement_x_id = announcement_x.id;
-    println!("announcement_x {} set up on relay_b with git data (listing A+B+C)", announcement_x_id);
-
-    // 4. Set up announcement_y on relay_c (lists only A+C, NOT B) with git data
-    let domains_y = vec![relay_a.domain(), relay_c.domain()];
-    let domain_refs_y: Vec<&str> = domains_y.iter().map(|s| s.as_str()).collect();
-
-    let (announcement_y, _git_dir_c) =
-        setup_announcement_on_relay(&relay_c, &keys_y, &domain_refs_y, "repo-y-ac-only").await;
-    let announcement_y_id = announcement_y.id;
-    println!("announcement_y {} set up on relay_c with git data (listing A+C only)", announcement_y_id);
-
-    // 7. Wait for relay_a to:
-    //    - Sync from bootstrap relay_b (gets announcement_x)
-    //    - Discover relay_c from announcement_x's relays tag
-    //    - Connect to relay_c and sync announcement_y
-    // With purgatory, each relay needs to: sync announcement → purgatory → sync state event →
-    // immediate purgatory sync → fetch git data → promote. Allow extra time for this.
-    println!("Waiting 12s for recursive relay discovery (with purgatory flow)...");
-    tokio::time::sleep(Duration::from_secs(12)).await;
-
-    // 8. Verify announcement_x was synced to relay_a (from bootstrap relay_b)
-    let filter_x = Filter::new()
-        .kind(Kind::GitRepoAnnouncement)
-        .author(keys_x.public_key());
-
-    let announcement_x_synced =
-        wait_for_event_on_relay(relay_a.url(), filter_x, Duration::from_secs(5)).await;
-
-    println!(
-        "announcement_x {} synced to relay_a: {}",
-        announcement_x_id, announcement_x_synced
-    );
-
-    // 9. Verify announcement_y was synced to relay_a (from discovered relay_c)
-    let filter_y = Filter::new()
-        .kind(Kind::GitRepoAnnouncement)
-        .author(keys_y.public_key());
-
-    let announcement_y_synced =
-        wait_for_event_on_relay(relay_a.url(), filter_y, Duration::from_secs(5)).await;
-
-    println!(
-        "announcement_y {} synced to relay_a: {}",
-        announcement_y_id, announcement_y_synced
-    );
-
-    // 10. Cleanup
-    relay_a.stop().await;
-    relay_b.stop().await;
-    relay_c.stop().await;
-
-    // 11. Assertions
-    assert!(
-        announcement_x_synced,
-        "announcement_x {} should have synced from bootstrap relay_b to relay_a",
-        announcement_x_id
-    );
-
-    assert!(
-        announcement_y_synced,
-        "announcement_y {} should have synced from discovered relay_c to relay_a (recursive discovery)",
-        announcement_y_id
-    );
-}
diff --git a/tests/sync/mod.rs b/tests/sync/mod.rs
index 400341f..70c6981 100644
--- a/tests/sync/mod.rs
+++ b/tests/sync/mod.rs
@@ -82,14 +82,12 @@
 //! **Example from `discovery.rs`:**
 //! ```rust
 //! #[tokio::test]
-//! async fn test_recursive_relay_discovery() {
+//! async fn test_discovers_layer3_via_layer2() {
 //!     // Multi-relay orchestration
-//!     let relay1 = TestRelay::start().await;
-//!     let relay2 = TestRelay::start().await;
-//!     let relay3 = TestRelay::start().await;
+//!     let relay_a = TestRelay::start().await;
+//!     let relay_b = TestRelay::start_with_sync(None).await;
 //!
-//!     // relay1 announces relay2, relay2 announces relay3
-//!     // Verify relay1 discovers relay3 through chain
+//!     // relay_b receives announcement listing relay_a, discovers and syncs from it
 //! }
 //! ```
 //!