From b4da09689ee0bd6ac327a6ed7ffb01e2175e2596 Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Fri, 5 Dec 2025 16:37:09 +0000 Subject: remove stupid tests and methods --- tests/proactive_sync_catchup.rs | 169 ++++++----------------- tests/proactive_sync_dynamic.rs | 287 ++++++++++++++-------------------------- 2 files changed, 143 insertions(+), 313 deletions(-) (limited to 'tests') diff --git a/tests/proactive_sync_catchup.rs b/tests/proactive_sync_catchup.rs index 944ae50..d8a2ef9 100644 --- a/tests/proactive_sync_catchup.rs +++ b/tests/proactive_sync_catchup.rs @@ -16,89 +16,6 @@ use ngit_grasp::sync::SubscriptionManager; -// ============================================================================ -// Configuration Constants Tests -// ============================================================================ - -/// Test that default startup delay is 30 seconds -#[test] -fn test_default_startup_delay_is_30_seconds() { - // The spec requires 30s warm-up before startup catchup - const EXPECTED_STARTUP_DELAY: u64 = 30; - - // This is defined in negentropy.rs as DEFAULT_STARTUP_DELAY_SECS - // We verify the expected value matches the spec - assert_eq!(EXPECTED_STARTUP_DELAY, 30); -} - -/// Test that default reconnect delay is 10 seconds -#[test] -fn test_default_reconnect_delay_is_10_seconds() { - // The spec requires 10s delay after reconnection before catchup - const EXPECTED_RECONNECT_DELAY: u64 = 10; - assert_eq!(EXPECTED_RECONNECT_DELAY, 10); -} - -/// Test that reconnect lookback is 3 days -#[test] -fn test_reconnect_lookback_is_3_days() { - // The spec requires 3 days lookback for reconnect catchup - const EXPECTED_LOOKBACK_DAYS: u64 = 3; - const EXPECTED_LOOKBACK_SECS: u64 = 3 * 24 * 60 * 60; // 259,200 seconds - - assert_eq!(EXPECTED_LOOKBACK_DAYS, 3); - assert_eq!(EXPECTED_LOOKBACK_SECS, 259200); -} - -/// Test daily catchup interval is 24 hours -#[test] -fn test_daily_catchup_interval_is_24_hours() { - // The spec requires daily catchup once per 24 hours - const EXPECTED_DAILY_INTERVAL_SECS: u64 = 86400; // 24 * 60 * 60 - assert_eq!(EXPECTED_DAILY_INTERVAL_SECS, 86400); -} - -/// Test relay stagger delay is 5 minutes -#[test] -fn test_relay_stagger_is_5_minutes() { - // The spec requires 5-minute stagger between relays for catchup - const EXPECTED_STAGGER_SECS: u64 = 300; // 5 * 60 - assert_eq!(EXPECTED_STAGGER_SECS, 300); -} - -// ============================================================================ -// Filter Compatibility Tests -// ============================================================================ - -/// Test that catchup uses announcement kinds (30617, 30618) -#[test] -fn test_catchup_uses_announcement_kinds() { - // Layer 1 filters should include announcement kinds - assert!(SubscriptionManager::is_announcement_kind(30617)); - assert!(SubscriptionManager::is_announcement_kind(30618)); -} - -/// Test that catchup uses PR/Issue kinds for Layer 3 -#[test] -fn test_catchup_uses_pr_issue_kinds() { - // Layer 3 should track PR and Issue kinds - assert!(SubscriptionManager::is_pr_issue_kind(1617)); // Patch proposal - assert!(SubscriptionManager::is_pr_issue_kind(1618)); // PR - assert!(SubscriptionManager::is_pr_issue_kind(1619)); // PR Update - assert!(SubscriptionManager::is_pr_issue_kind(1621)); // Issue - assert!(SubscriptionManager::is_pr_issue_kind(1622)); // Reply -} - -/// Test that non-sync kinds are not included in catchup -#[test] -fn test_catchup_excludes_non_sync_kinds() { - // Regular text notes and other kinds should not be included - assert!(!SubscriptionManager::is_announcement_kind(1)); // Text note - assert!(!SubscriptionManager::is_announcement_kind(4)); // DM - assert!(!SubscriptionManager::is_pr_issue_kind(1)); // Text note - assert!(!SubscriptionManager::is_pr_issue_kind(30617)); // Announcement (wrong layer) -} - // ============================================================================ // Catchup State Machine Tests // ============================================================================ @@ -108,17 +25,17 @@ fn test_catchup_excludes_non_sync_kinds() { fn test_startup_catchup_runs_once() { // After startup catchup completes, should_run_startup_catchup should return false // This is handled by the startup_catchup_completed flag in NegentropyService - + // Simulating the state machine: let mut startup_completed = false; - + // Before running, should return true (if delay elapsed) let should_run_before = !startup_completed; assert!(should_run_before); - + // After running, mark as completed startup_completed = true; - + // Now should return false let should_run_after = !startup_completed; assert!(!should_run_after); @@ -128,12 +45,12 @@ fn test_startup_catchup_runs_once() { #[test] fn test_daily_catchup_interval_check() { use std::time::{Duration, Instant}; - + const DAILY_INTERVAL_SECS: u64 = 86400; - + // Simulate last catchup time let last_catchup = Instant::now(); - + // Immediately after, should not run let should_run_immediately = last_catchup.elapsed() >= Duration::from_secs(DAILY_INTERVAL_SECS); assert!(!should_run_immediately); @@ -144,10 +61,10 @@ fn test_daily_catchup_interval_check() { fn test_new_relay_should_run_daily_catchup() { use std::collections::HashMap; use std::time::Instant; - + let last_daily_catchup: HashMap = HashMap::new(); let relay_url = "wss://test-relay.example.com"; - + // No previous catchup recorded, should return true let should_run = !last_daily_catchup.contains_key(relay_url); assert!(should_run); @@ -159,14 +76,14 @@ fn test_reconnect_catchup_after_reconnection() { // Reconnect catchup should only trigger when: // 1. Connection was previously successful (had_previous_connection = true) // 2. Connection was lost and restored - + let mut had_previous_connection = false; - + // First connection - should NOT trigger reconnect catchup let is_reconnection_first = had_previous_connection; assert!(!is_reconnection_first); had_previous_connection = true; - + // Second connection (after disconnection) - SHOULD trigger let is_reconnection_second = had_previous_connection; assert!(is_reconnection_second); @@ -185,10 +102,10 @@ fn test_gap_events_validated_through_policy() { // 2. Check if event exists locally // 3. Validate through Nip34WritePolicy // 4. Store if accepted - + // This is verified by the implementation in negentropy.rs:run_catchup() // where PolicyResult::Accept leads to storage and PolicyResult::Reject is logged - + assert!(true); // Flow verification - actual validation tested in other tests } @@ -197,14 +114,14 @@ fn test_gap_events_validated_through_policy() { fn test_gap_events_logged_at_warn_level() { // The spec requires gap events to be logged at WARN level // to distinguish them from live events (which are logged at INFO) - + // This is implemented in negentropy.rs with: // tracing::warn!("Gap event filled via {} catchup: {} (kind {})", ...) - + // We verify the logging pattern exists by testing the catchup types let catchup_types = ["startup", "reconnect", "daily"]; assert_eq!(catchup_types.len(), 3); - + for catchup_type in catchup_types { assert!(!catchup_type.is_empty()); } @@ -218,21 +135,21 @@ fn test_gap_events_logged_at_warn_level() { #[test] fn test_stagger_delay_for_multiple_relays() { const STAGGER_SECS: u64 = 300; // 5 minutes - + let _relay_urls = vec![ "wss://relay1.example.com", - "wss://relay2.example.com", + "wss://relay2.example.com", "wss://relay3.example.com", ]; - + // First relay (index 0) should have no stagger let stagger_0 = 0 * STAGGER_SECS; assert_eq!(stagger_0, 0); - + // Second relay (index 1) should have 5 minute stagger let stagger_1 = 1 * STAGGER_SECS; assert_eq!(stagger_1, 300); - + // Third relay (index 2) should have 10 minute stagger let stagger_2 = 2 * STAGGER_SECS; assert_eq!(stagger_2, 600); @@ -242,15 +159,15 @@ fn test_stagger_delay_for_multiple_relays() { #[test] fn test_startup_catchup_waits_for_warmup() { use std::time::{Duration, Instant}; - + const STARTUP_DELAY_SECS: u64 = 30; - + let startup_time = Instant::now(); - + // Immediately after startup, should not run (delay not elapsed) let elapsed = startup_time.elapsed(); let should_run = elapsed >= Duration::from_secs(STARTUP_DELAY_SECS); - + // This should be false since we just created startup_time assert!(!should_run); } @@ -265,7 +182,7 @@ fn test_reconnect_lookback_calculation() { // 3 days = 3 * 24 * 60 * 60 = 259,200 seconds let lookback_days: u64 = 3; let lookback_secs = lookback_days * 24 * 60 * 60; - + assert_eq!(lookback_secs, 259200); } @@ -290,10 +207,10 @@ fn test_startup_catchup_scenario() { // 2. Run full reconciliation (no time limit) // 3. Mark as completed (runs only once) // 4. Stagger between relays (5 minutes) - + const STARTUP_DELAY: u64 = 30; const STAGGER: u64 = 300; - + assert_eq!(STARTUP_DELAY, 30); assert_eq!(STAGGER, 300); } @@ -306,10 +223,10 @@ fn test_reconnect_catchup_scenario() { // 2. Wait 10s reconnect delay // 3. Only fetch last 3 days of events // 4. Runs in background (doesn't block connection) - + const RECONNECT_DELAY: u64 = 10; const LOOKBACK_DAYS: u64 = 3; - + assert_eq!(RECONNECT_DELAY, 10); assert_eq!(LOOKBACK_DAYS, 3); } @@ -322,11 +239,11 @@ fn test_daily_catchup_scenario() { // 2. Run if 24h elapsed since last catchup for that relay // 3. Full reconciliation (no time limit) // 4. Stagger between relays (5 minutes) - + const CHECK_INTERVAL: u64 = 3600; // 1 hour const DAILY_INTERVAL: u64 = 86400; // 24 hours const STAGGER: u64 = 300; // 5 minutes - + assert_eq!(CHECK_INTERVAL, 3600); assert_eq!(DAILY_INTERVAL, 86400); assert_eq!(STAGGER, 300); @@ -343,10 +260,10 @@ fn test_existing_events_skipped() { // 1. Fetch events from relay // 2. For each event, check if it exists locally // 3. Skip if exists, validate and store if not - + // This is implemented in negentropy.rs:event_exists_locally() // which queries the database for the event by ID - + const SKIP_EXISTING: bool = true; assert!(SKIP_EXISTING); } @@ -355,15 +272,15 @@ fn test_existing_events_skipped() { #[test] fn test_duplicate_prevention() { use std::collections::HashSet; - + let mut processed_ids: HashSet = HashSet::new(); let event_id = "abc123def456".to_string(); - + // First time seeing this event - should process let is_new = !processed_ids.contains(&event_id); assert!(is_new); processed_ids.insert(event_id.clone()); - + // Second time - should skip let is_duplicate = processed_ids.contains(&event_id); assert!(is_duplicate); @@ -380,18 +297,18 @@ fn test_config_fields_for_catchup() { // - sync_startup_delay_secs (default: 30) // - sync_reconnect_delay_secs (default: 10) // - sync_reconnect_lookback_days (default: 3) - + // Environment variables: // - NGIT_SYNC_STARTUP_DELAY_SECS // - NGIT_SYNC_RECONNECT_DELAY_SECS // - NGIT_SYNC_RECONNECT_LOOKBACK_DAYS - + let expected_defaults = vec![ ("startup_delay_secs", 30u64), ("reconnect_delay_secs", 10u64), ("reconnect_lookback_days", 3u64), ]; - + assert_eq!(expected_defaults.len(), 3); assert_eq!(expected_defaults[0].1, 30); assert_eq!(expected_defaults[1].1, 10); @@ -405,9 +322,9 @@ fn test_catchup_respects_config() { let custom_startup_delay: u64 = 60; let custom_reconnect_delay: u64 = 20; let custom_lookback_days: u64 = 7; - + // All should be configurable to non-default values assert_ne!(custom_startup_delay, 30); assert_ne!(custom_reconnect_delay, 10); assert_ne!(custom_lookback_days, 3); -} \ No newline at end of file +} diff --git a/tests/proactive_sync_dynamic.rs b/tests/proactive_sync_dynamic.rs index 8a3cb88..2d3232f 100644 --- a/tests/proactive_sync_dynamic.rs +++ b/tests/proactive_sync_dynamic.rs @@ -116,69 +116,6 @@ fn create_test_reply_event(keys: &Keys, event_id: &str) -> Event { .expect("Failed to sign event") } -// ============================================================================ -// Kind Detection Tests -// ============================================================================ - -/// Test that announcement kinds are correctly identified -#[test] -fn test_is_announcement_kind_30617() { - assert!(SubscriptionManager::is_announcement_kind(30617)); -} - -/// Test that maintainer list kind is correctly identified -#[test] -fn test_is_announcement_kind_30618() { - assert!(SubscriptionManager::is_announcement_kind(30618)); -} - -/// Test that non-announcement kinds are not identified as announcements -#[test] -fn test_is_announcement_kind_negative() { - assert!(!SubscriptionManager::is_announcement_kind(1)); // Text note - assert!(!SubscriptionManager::is_announcement_kind(1617)); // PR - assert!(!SubscriptionManager::is_announcement_kind(1621)); // Issue - assert!(!SubscriptionManager::is_announcement_kind(0)); // Unknown -} - -/// Test that PR/Issue kinds are correctly identified -#[test] -fn test_is_pr_issue_kind_1617() { - assert!(SubscriptionManager::is_pr_issue_kind(1617)); // Patch proposal -} - -/// Test that PR kind 1618 is correctly identified -#[test] -fn test_is_pr_issue_kind_1618() { - assert!(SubscriptionManager::is_pr_issue_kind(1618)); // PR -} - -/// Test that PR update kind is correctly identified -#[test] -fn test_is_pr_issue_kind_1619() { - assert!(SubscriptionManager::is_pr_issue_kind(1619)); // PR Update -} - -/// Test that Issue kind is correctly identified -#[test] -fn test_is_pr_issue_kind_1621() { - assert!(SubscriptionManager::is_pr_issue_kind(1621)); // Issue -} - -/// Test that Reply kind is correctly identified -#[test] -fn test_is_pr_issue_kind_1622() { - assert!(SubscriptionManager::is_pr_issue_kind(1622)); // Reply -} - -/// Test that non-PR/Issue kinds are not identified -#[test] -fn test_is_pr_issue_kind_negative() { - assert!(!SubscriptionManager::is_pr_issue_kind(30617)); // Announcement - assert!(!SubscriptionManager::is_pr_issue_kind(1)); // Text note - assert!(!SubscriptionManager::is_pr_issue_kind(0)); // Unknown -} - // ============================================================================ // Filter Count Tests // ============================================================================ @@ -188,19 +125,19 @@ fn test_is_pr_issue_kind_negative() { fn test_initial_filter_count() { // Create a minimal SubscriptionManager-like state for testing // We test the logic without needing a full FilterService - + // Initial state: 0 announcements, 0 events, not consolidated // Filter count should be: 1 (Layer 1) + 0 + 0 = 1 let announcement_count = 0; let event_count = 0; let is_consolidated = false; - + let filter_count = if is_consolidated { 1 } else { 1 + announcement_count + event_count }; - + assert_eq!(filter_count, 1); } @@ -210,13 +147,13 @@ fn test_filter_count_with_announcements() { let announcement_count = 5; let event_count = 0; let is_consolidated = false; - + let filter_count = if is_consolidated { 1 } else { 1 + announcement_count + event_count }; - + // 1 (Layer 1) + 5 (announcements) = 6 assert_eq!(filter_count, 6); } @@ -227,13 +164,13 @@ fn test_filter_count_with_events() { let announcement_count = 0; let event_count = 10; let is_consolidated = false; - + let filter_count = if is_consolidated { 1 } else { 1 + announcement_count + event_count }; - + // 1 (Layer 1) + 10 (events) = 11 assert_eq!(filter_count, 11); } @@ -244,13 +181,13 @@ fn test_filter_count_mixed() { let announcement_count = 50; let event_count = 30; let is_consolidated = false; - + let filter_count = if is_consolidated { 1 } else { 1 + announcement_count + event_count }; - + // 1 + 50 + 30 = 81 assert_eq!(filter_count, 81); } @@ -261,13 +198,13 @@ fn test_filter_count_consolidated() { let announcement_count = 100; // These would be cleared on consolidation let event_count = 100; let is_consolidated = true; - + let filter_count = if is_consolidated { 1 } else { 1 + announcement_count + event_count }; - + assert_eq!(filter_count, 1); } @@ -280,9 +217,9 @@ fn test_filter_count_consolidated() { fn test_should_consolidate_below_threshold() { let filter_count = 100; let is_consolidated = false; - + let should_consolidate = !is_consolidated && filter_count > CONSOLIDATION_THRESHOLD; - + assert!(!should_consolidate); } @@ -291,9 +228,9 @@ fn test_should_consolidate_below_threshold() { fn test_should_consolidate_at_threshold() { let filter_count = 151; // > 150 let is_consolidated = false; - + let should_consolidate = !is_consolidated && filter_count > CONSOLIDATION_THRESHOLD; - + assert!(should_consolidate); } @@ -302,9 +239,9 @@ fn test_should_consolidate_at_threshold() { fn test_should_consolidate_above_threshold() { let filter_count = 200; let is_consolidated = false; - + let should_consolidate = !is_consolidated && filter_count > CONSOLIDATION_THRESHOLD; - + assert!(should_consolidate); } @@ -313,9 +250,9 @@ fn test_should_consolidate_above_threshold() { fn test_should_consolidate_already_consolidated() { let filter_count = 200; // Would trigger, but already consolidated let is_consolidated = true; - + let should_consolidate = !is_consolidated && filter_count > CONSOLIDATION_THRESHOLD; - + assert!(!should_consolidate); } @@ -323,11 +260,11 @@ fn test_should_consolidate_already_consolidated() { #[test] fn test_consolidation_threshold_boundary() { let is_consolidated = false; - + // 150 should NOT trigger (> 150, not >= 150) let should_consolidate_at_150 = !is_consolidated && 150 > CONSOLIDATION_THRESHOLD; assert!(!should_consolidate_at_150); - + // 151 should trigger let should_consolidate_at_151 = !is_consolidated && 151 > CONSOLIDATION_THRESHOLD; assert!(should_consolidate_at_151); @@ -341,14 +278,14 @@ fn test_consolidation_threshold_boundary() { #[test] fn test_duplicate_announcement_prevention() { let mut subscribed_announcements: HashSet = HashSet::new(); - + let event_id = "abc123".to_string(); - + // First add should succeed let is_new = !subscribed_announcements.contains(&event_id); assert!(is_new); subscribed_announcements.insert(event_id.clone()); - + // Second add should fail (duplicate) let is_new_again = !subscribed_announcements.contains(&event_id); assert!(!is_new_again); @@ -358,14 +295,14 @@ fn test_duplicate_announcement_prevention() { #[test] fn test_duplicate_event_prevention() { let mut subscribed_events: HashSet = HashSet::new(); - + let event_id = "def456".to_string(); - + // First add should succeed let is_new = !subscribed_events.contains(&event_id); assert!(is_new); subscribed_events.insert(event_id.clone()); - + // Second add should fail (duplicate) let is_new_again = !subscribed_events.contains(&event_id); assert!(!is_new_again); @@ -375,14 +312,14 @@ fn test_duplicate_event_prevention() { #[test] fn test_multiple_unique_items_tracked() { let mut subscribed_announcements: HashSet = HashSet::new(); - + // Add multiple unique announcements for i in 0..10 { let id = format!("announcement_{}", i); assert!(!subscribed_announcements.contains(&id)); subscribed_announcements.insert(id); } - + assert_eq!(subscribed_announcements.len(), 10); } @@ -395,12 +332,12 @@ fn test_multiple_unique_items_tracked() { fn test_announcement_has_d_tag() { let keys = Keys::generate(); let event = create_test_announcement(&keys, "my-repo"); - + let has_d_tag = event.tags.iter().any(|tag| { let tag_vec = tag.clone().to_vec(); tag_vec.len() >= 2 && tag_vec[0] == "d" }); - + assert!(has_d_tag); } @@ -409,7 +346,7 @@ fn test_announcement_has_d_tag() { fn test_announcement_correct_kind() { let keys = Keys::generate(); let event = create_test_announcement(&keys, "my-repo"); - + assert_eq!(event.kind.as_u16(), KIND_REPOSITORY_ANNOUNCEMENT); } @@ -418,7 +355,7 @@ fn test_announcement_correct_kind() { fn test_maintainer_list_correct_kind() { let keys = Keys::generate(); let event = create_test_maintainer_list(&keys, "maintainers"); - + assert_eq!(event.kind.as_u16(), KIND_MAINTAINER_LIST); } @@ -428,12 +365,12 @@ fn test_pr_event_has_a_tag() { let keys = Keys::generate(); let coord = "30617:pubkey123:my-repo"; let event = create_test_pr_event(&keys, coord); - + let has_a_tag = event.tags.iter().any(|tag| { let tag_vec = tag.clone().to_vec(); tag_vec.len() >= 2 && tag_vec[0] == "a" }); - + assert!(has_a_tag); } @@ -443,12 +380,12 @@ fn test_issue_event_has_a_tag() { let keys = Keys::generate(); let coord = "30617:pubkey123:my-repo"; let event = create_test_issue_event(&keys, coord); - + let has_a_tag = event.tags.iter().any(|tag| { let tag_vec = tag.clone().to_vec(); tag_vec.len() >= 2 && tag_vec[0] == "a" }); - + assert!(has_a_tag); } @@ -458,12 +395,12 @@ fn test_reply_event_has_e_tag() { let keys = Keys::generate(); let event_id = "abc123def456"; let event = create_test_reply_event(&keys, event_id); - + let has_e_tag = event.tags.iter().any(|tag| { let tag_vec = tag.clone().to_vec(); tag_vec.len() >= 2 && tag_vec[0] == "e" }); - + assert!(has_e_tag); } @@ -477,50 +414,55 @@ fn test_subscription_lifecycle() { let mut subscribed_announcements: HashSet = HashSet::new(); let mut subscribed_events: HashSet = HashSet::new(); let mut is_consolidated = false; - + // Initial state let initial_count = 1 + subscribed_announcements.len() + subscribed_events.len(); assert_eq!(initial_count, 1); - + // Add some announcements for i in 0..50 { subscribed_announcements.insert(format!("ann_{}", i)); } - + let after_announcements = 1 + subscribed_announcements.len() + subscribed_events.len(); assert_eq!(after_announcements, 51); - + // Add some events for i in 0..50 { subscribed_events.insert(format!("evt_{}", i)); } - + let after_events = 1 + subscribed_announcements.len() + subscribed_events.len(); assert_eq!(after_events, 101); - + // Add more to exceed threshold for i in 50..100 { subscribed_announcements.insert(format!("ann_{}", i)); } - + let before_consolidation = 1 + subscribed_announcements.len() + subscribed_events.len(); assert_eq!(before_consolidation, 151); - + // Should trigger consolidation let should_consolidate = !is_consolidated && before_consolidation > CONSOLIDATION_THRESHOLD; assert!(should_consolidate); - + // Consolidate subscribed_announcements.clear(); subscribed_events.clear(); is_consolidated = true; - + // After consolidation - let after_consolidation = if is_consolidated { 1 } else { 1 + subscribed_announcements.len() + subscribed_events.len() }; + let after_consolidation = if is_consolidated { + 1 + } else { + 1 + subscribed_announcements.len() + subscribed_events.len() + }; assert_eq!(after_consolidation, 1); - + // Should not trigger consolidation again - let should_consolidate_again = !is_consolidated && after_consolidation > CONSOLIDATION_THRESHOLD; + let should_consolidate_again = + !is_consolidated && after_consolidation > CONSOLIDATION_THRESHOLD; assert!(!should_consolidate_again); } @@ -528,11 +470,11 @@ fn test_subscription_lifecycle() { #[test] fn test_consolidated_blocks_additions() { let is_consolidated = true; - + // When consolidated, add_announcement should return None (simulated) // The logic is: if is_consolidated, return None let should_add = !is_consolidated; - + assert!(!should_add); } @@ -542,12 +484,12 @@ fn test_non_consolidated_allows_additions() { let is_consolidated = false; let mut subscribed_announcements: HashSet = HashSet::new(); let event_id = "new_announcement"; - + // When not consolidated and event not in set, should add let should_add = !is_consolidated && !subscribed_announcements.contains(event_id); - + assert!(should_add); - + subscribed_announcements.insert(event_id.to_string()); assert!(subscribed_announcements.contains(event_id)); } @@ -562,7 +504,7 @@ fn test_announcement_coordinate_format() { let keys = Keys::generate(); let identifier = "my-repo"; let event = create_test_announcement(&keys, identifier); - + // Extract d tag let d_tag = event.tags.iter().find_map(|tag| { let tag_vec = tag.clone().to_vec(); @@ -572,13 +514,18 @@ fn test_announcement_coordinate_format() { None } }); - + assert!(d_tag.is_some()); assert_eq!(d_tag.unwrap(), identifier); - + // Build coordinate: kind:pubkey:identifier - let coord = format!("{}:{}:{}", KIND_REPOSITORY_ANNOUNCEMENT, event.pubkey.to_hex(), identifier); - + let coord = format!( + "{}:{}:{}", + KIND_REPOSITORY_ANNOUNCEMENT, + event.pubkey.to_hex(), + identifier + ); + // Verify format let parts: Vec<&str> = coord.split(':').collect(); assert_eq!(parts.len(), 3); @@ -590,16 +537,21 @@ fn test_announcement_coordinate_format() { #[test] fn test_multiple_announcement_coordinates_unique() { let keys = Keys::generate(); - + let identifiers = vec!["repo1", "repo2", "repo3"]; let mut coords: HashSet = HashSet::new(); - + for id in identifiers { let event = create_test_announcement(&keys, id); - let coord = format!("{}:{}:{}", KIND_REPOSITORY_ANNOUNCEMENT, event.pubkey.to_hex(), id); + let coord = format!( + "{}:{}:{}", + KIND_REPOSITORY_ANNOUNCEMENT, + event.pubkey.to_hex(), + id + ); coords.insert(coord); } - + assert_eq!(coords.len(), 3); } @@ -614,30 +566,34 @@ fn test_workflow_announcement_then_pr() { let mut subscribed_announcements: HashSet = HashSet::new(); let mut subscribed_events: HashSet = HashSet::new(); let is_consolidated = false; - + // Step 1: Receive announcement let announcement = create_test_announcement(&keys, "my-repo"); let ann_id = announcement.id.to_hex(); - + // Should add to tracking (simulating add_announcement) let should_add_ann = !is_consolidated && !subscribed_announcements.contains(&ann_id); assert!(should_add_ann); subscribed_announcements.insert(ann_id.clone()); - + // Filter count should increase let filter_count = 1 + subscribed_announcements.len() + subscribed_events.len(); assert_eq!(filter_count, 2); - + // Step 2: Receive PR for that repo - let coord = format!("{}:{}:my-repo", KIND_REPOSITORY_ANNOUNCEMENT, keys.public_key().to_hex()); + let coord = format!( + "{}:{}:my-repo", + KIND_REPOSITORY_ANNOUNCEMENT, + keys.public_key().to_hex() + ); let pr = create_test_pr_event(&keys, &coord); let pr_id = pr.id.to_hex(); - + // Should add to tracking (simulating add_event) let should_add_pr = !is_consolidated && !subscribed_events.contains(&pr_id); assert!(should_add_pr); subscribed_events.insert(pr_id.clone()); - + // Filter count should increase again let filter_count = 1 + subscribed_announcements.len() + subscribed_events.len(); assert_eq!(filter_count, 3); @@ -651,16 +607,16 @@ fn test_stress_many_items_triggers_consolidation() { let mut subscribed_events: HashSet = HashSet::new(); let mut is_consolidated = false; let mut consolidation_triggered = false; - + // Add 100 announcements for i in 0..100 { let event = create_test_announcement(&keys, &format!("repo-{}", i)); let event_id = event.id.to_hex(); - + if !is_consolidated && !subscribed_announcements.contains(&event_id) { subscribed_announcements.insert(event_id); } - + // Check consolidation after each add let filter_count = 1 + subscribed_announcements.len() + subscribed_events.len(); if !is_consolidated && filter_count > CONSOLIDATION_THRESHOLD { @@ -671,18 +627,18 @@ fn test_stress_many_items_triggers_consolidation() { break; } } - + // If we didn't consolidate yet, add events if !consolidation_triggered { for i in 0..100 { let coord = format!("30617:pubkey:repo-{}", i); let event = create_test_pr_event(&keys, &coord); let event_id = event.id.to_hex(); - + if !is_consolidated && !subscribed_events.contains(&event_id) { subscribed_events.insert(event_id); } - + // Check consolidation after each add let filter_count = 1 + subscribed_announcements.len() + subscribed_events.len(); if !is_consolidated && filter_count > CONSOLIDATION_THRESHOLD { @@ -694,55 +650,12 @@ fn test_stress_many_items_triggers_consolidation() { } } } - + // Consolidation should have been triggered assert!(consolidation_triggered); assert!(is_consolidated); - + // After consolidation, counts should be reset assert_eq!(subscribed_announcements.len(), 0); assert_eq!(subscribed_events.len(), 0); } - -/// Test that all PR/Issue kinds are handled consistently -#[test] -fn test_all_pr_issue_kinds_handled() { - let keys = Keys::generate(); - let coord = "30617:pubkey:repo"; - - // All these kinds should be identified as PR/Issue - let pr_kinds = vec![1617, 1618, 1619, 1621, 1622]; - - for kind in pr_kinds { - assert!( - SubscriptionManager::is_pr_issue_kind(kind), - "Kind {} should be identified as PR/Issue", - kind - ); - } -} - -/// Test that announcement and PR/Issue kinds are mutually exclusive -#[test] -fn test_kind_categories_mutually_exclusive() { - let announcement_kinds = vec![30617, 30618]; - let pr_issue_kinds = vec![1617, 1618, 1619, 1621, 1622]; - - // No announcement kind should be a PR/Issue kind - for kind in &announcement_kinds { - assert!( - !SubscriptionManager::is_pr_issue_kind(*kind), - "Announcement kind {} should not be PR/Issue", - kind - ); - } - - // No PR/Issue kind should be an announcement kind - for kind in &pr_issue_kinds { - assert!( - !SubscriptionManager::is_announcement_kind(*kind), - "PR/Issue kind {} should not be announcement", - kind - ); - } -} \ No newline at end of file -- cgit v1.2.3