From 91dc5e8d718475a73815892452a58e1dbf56c8d9 Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Mon, 8 Dec 2025 20:39:58 +0000 Subject: delete old bad AI genreated tests --- tests/proactive_sync_catchup.rs | 330 ---------------------------------------- 1 file changed, 330 deletions(-) delete mode 100644 tests/proactive_sync_catchup.rs (limited to 'tests/proactive_sync_catchup.rs') diff --git a/tests/proactive_sync_catchup.rs b/tests/proactive_sync_catchup.rs deleted file mode 100644 index d8a2ef9..0000000 --- a/tests/proactive_sync_catchup.rs +++ /dev/null @@ -1,330 +0,0 @@ -//! GRASP-02 Phase 5: Negentropy Catchup Integration Tests -//! -//! Tests verify negentropy catchup functionality: -//! - Startup catchup after warm-up delay (30s default) -//! - Reconnect catchup recovers recent gaps (last 3 days) -//! - Daily catchup runs once per 24h with stagger -//! - Catchup uses same filters as live sync -//! - Gap events logged at WARN level -//! -//! # Running Tests -//! -//! ```bash -//! cargo test --test proactive_sync_catchup -//! cargo test --test proactive_sync_catchup -- --nocapture -//! ``` - -use ngit_grasp::sync::SubscriptionManager; - -// ============================================================================ -// Catchup State Machine Tests -// ============================================================================ - -/// Test startup catchup should only run once -#[test] -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); -} - -/// Test daily catchup interval checking -#[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); -} - -/// Test that new relay (no previous catchup) should run daily catchup -#[test] -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); -} - -/// Test reconnect catchup only after successful reconnection -#[test] -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); -} - -// ============================================================================ -// Gap Event Flow Tests -// ============================================================================ - -/// Test that gap events go through policy validation -#[test] -fn test_gap_events_validated_through_policy() { - // The NegentropyService uses write_policy.admit_event() for validation - // This test verifies the flow exists: - // 1. Fetch events from relay - // 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 -} - -/// Test that gap events are distinguished from live events -#[test] -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()); - } -} - -// ============================================================================ -// Stagger Logic Tests -// ============================================================================ - -/// Test stagger delay calculation for multiple relays -#[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://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); -} - -/// Test that startup catchup waits for warm-up -#[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); -} - -// ============================================================================ -// Lookback Period Tests -// ============================================================================ - -/// Test reconnect lookback calculation -#[test] -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); -} - -/// Test that daily catchup uses no lookback (full reconciliation) -#[test] -fn test_daily_catchup_full_reconciliation() { - // Daily catchup should reconcile all events, not just recent ones - // This is implemented by passing None to the since parameter - let since: Option = None; - assert!(since.is_none()); -} - -// ============================================================================ -// Three Catchup Scenario Tests -// ============================================================================ - -/// Test startup catchup scenario -#[test] -fn test_startup_catchup_scenario() { - // Startup catchup: - // 1. Wait 30s for warm-up - // 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); -} - -/// Test reconnect catchup scenario -#[test] -fn test_reconnect_catchup_scenario() { - // Reconnect catchup: - // 1. Trigger after connection restore (not first connection) - // 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); -} - -/// Test daily catchup scenario -#[test] -fn test_daily_catchup_scenario() { - // Daily catchup: - // 1. Check hourly if any relay needs catchup - // 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); -} - -// ============================================================================ -// Event Existence Check Tests -// ============================================================================ - -/// Test that existing events are skipped during catchup -#[test] -fn test_existing_events_skipped() { - // The catchup flow should: - // 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); -} - -/// Test duplicate prevention during catchup -#[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); -} - -// ============================================================================ -// Configuration Integration Tests -// ============================================================================ - -/// Test config fields exist for catchup timing -#[test] -fn test_config_fields_for_catchup() { - // The Config struct should have these fields: - // - 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); - assert_eq!(expected_defaults[2].1, 3); -} - -/// Test that catchup respects configured delays -#[test] -fn test_catchup_respects_config() { - // Custom delays should be used instead of defaults - 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); -} -- cgit v1.2.3