rate-guard 0.1.0

//! Comprehensive tests for FixedWindowCounter rate limiter implementation.
//!
//! This module tests all aspects of the FixedWindowCounter rate limiter including
//! window behavior, resets, time progression, and edge cases.

use rate_guard::{Nanos, Millis, Secs, MockTimeSource, RateLimit};
use rate_guard::limits::FixedWindowCounterBuilder;
use rate_guard::error::{RateLimitError};
use std::time::Duration;

#[cfg(test)]
mod fixed_window_counter_basic_functionality {
    use super::*;

    #[test]
    fn test_initial_capacity() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        assert_eq!(counter.capacity_remaining().unwrap(), 100);
    }

    #[test]
    fn test_acquire_within_window() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Acquire some tokens within the window
        assert!(counter.try_acquire(30).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 70);

        // Acquire more tokens in the same window
        assert!(counter.try_acquire(20).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
    }

    #[test]
    fn test_acquire_all_tokens_in_window() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(50)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Use all tokens in the window
        assert!(counter.try_acquire(50).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 0);
    }

    #[test]
    fn test_insufficient_tokens_in_window() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Use all tokens
        assert!(counter.try_acquire(10).is_ok());
        
        // Try to acquire more than available in current window
        assert!(counter.try_acquire(5).is_err());
        assert_eq!(counter.capacity_remaining().unwrap(), 0);
    }

    #[test]
    fn test_acquire_beyond_capacity() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Try to acquire more than window capacity
        assert!(counter.try_acquire(15).is_err());
        assert_eq!(counter.capacity_remaining().unwrap(), 10); // Should remain unchanged
    }
}

#[cfg(test)]
mod fixed_window_counter_window_behavior {
    use super::*;

    #[test]
    fn test_window_reset() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Use tokens in first window
        assert!(counter.try_acquire(80).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 20);

        // Advance time to next window
        time_source.advance(Duration::from_secs(60));
        
        // Window should reset, full capacity available
        assert_eq!(counter.capacity_remaining().unwrap(), 100);
        assert!(counter.try_acquire(100).is_ok());
    }

    #[test]
    fn test_partial_window_progression() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Use tokens
        assert!(counter.try_acquire(50).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 50);

        // Advance time within the same window
        time_source.advance(Duration::from_secs(30));
        
        // Should still be in same window, capacity unchanged
        assert_eq!(counter.capacity_remaining().unwrap(), 50);

        // Use more tokens in same window
        assert!(counter.try_acquire(30).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 20);
    }

    #[test]
    fn test_multiple_window_cycles() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(50)
            .window_duration(Duration::from_secs(30))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // First window
        assert!(counter.try_acquire(40).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 10);

        // Move to second window
        time_source.advance(Duration::from_secs(30));
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
        assert!(counter.try_acquire(25).is_ok());

        // Move to third window
        time_source.advance(Duration::from_secs(30));
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
        assert!(counter.try_acquire(50).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 0);

        // Move to fourth window
        time_source.advance(Duration::from_secs(30));
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
    }

    #[test]
    fn test_large_time_skip() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Use tokens
        assert!(counter.try_acquire(90).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 10);

        // Skip many windows ahead
        time_source.advance(Duration::from_secs(600)); // 10 windows
        
        // Should be in a fresh window
        assert_eq!(counter.capacity_remaining().unwrap(), 100);
    }
}

#[cfg(test)]
mod fixed_window_counter_precision_tests {
    use super::*;

    #[test]
    fn test_millisecond_precision_windows() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_millis(1000))
            .with_time(time_source.clone())
            .with_precision::<Millis>()
            .build()
            .unwrap();

        assert!(counter.try_acquire(50).is_ok());
        
        // Advance by less than window duration
        time_source.advance(Duration::from_millis(999));
        assert_eq!(counter.capacity_remaining().unwrap(), 50); // Same window

        // Cross window boundary
        time_source.advance(Duration::from_millis(1));
        assert_eq!(counter.capacity_remaining().unwrap(), 100); // New window
    }

    #[test]
    fn test_nanosecond_precision_windows() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_nanos(1_000_000)) // 1ms
            .with_time(time_source.clone())
            .with_precision::<Nanos>()
            .build()
            .unwrap();

        assert!(counter.try_acquire(5).is_ok());
        
        // Advance by less than window duration
        time_source.advance(Duration::from_nanos(999_999));
        assert_eq!(counter.capacity_remaining().unwrap(), 5); // Same window

        // Cross window boundary
        time_source.advance(Duration::from_nanos(1));
        assert_eq!(counter.capacity_remaining().unwrap(), 10); // New window
    }

    #[test]
    fn test_second_precision_windows() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(5))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        assert!(counter.try_acquire(30).is_ok());
        
        // Advance within window
        time_source.advance(Duration::from_secs(4));
        assert_eq!(counter.capacity_remaining().unwrap(), 70); // Same window

        // Cross window boundary
        time_source.advance(Duration::from_secs(1));
        assert_eq!(counter.capacity_remaining().unwrap(), 100); // New window
    }
}

#[cfg(test)]
mod fixed_window_counter_verbose_errors {
    use super::*;

    #[test]
    fn test_verbose_insufficient_capacity() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Use all tokens in window
        assert!(counter.try_acquire(10).is_ok());

        // Try verbose acquire with insufficient tokens
        match counter.try_acquire_verbose(5) {
            Err(RateLimitError::InsufficientCapacity { acquiring, available, retry_after }) => {
                assert_eq!(acquiring, 5);
                assert_eq!(available, 0);
                assert!(retry_after > Duration::ZERO);
                // retry_after should be roughly the time until next window
            }
            _ => panic!("Expected InsufficientCapacity error"),
        }
    }

    #[test]
    fn test_verbose_beyond_capacity() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Try to acquire more than window capacity
        match counter.try_acquire_verbose(15) {
            Err(RateLimitError::BeyondCapacity { acquiring, capacity }) => {
                assert_eq!(acquiring, 15);
                assert_eq!(capacity, 10);
            }
            _ => panic!("Expected BeyondCapacity error"),
        }
    }

    #[test]
    fn test_verbose_success() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Successful verbose acquire
        assert!(counter.try_acquire_verbose(50).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
    }

    #[test]
    fn test_verbose_retry_after_timing() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_secs(60))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Advance into window
        time_source.advance(Duration::from_secs(20));
        
        // Use all tokens
        assert!(counter.try_acquire(10).is_ok());

        // Check retry timing
        match counter.try_acquire_verbose(1) {
            Err(RateLimitError::InsufficientCapacity { retry_after, .. }) => {
                // Should be approximately 40 seconds until next window
                assert!(retry_after >= Duration::from_secs(39));
                assert!(retry_after <= Duration::from_secs(40));
            }
            _ => panic!("Expected InsufficientCapacity error"),
        }
    }
}

#[cfg(test)]
mod fixed_window_counter_edge_cases {
    use super::*;

    #[test]
    fn test_zero_token_acquire() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Acquiring zero tokens should succeed
        assert!(counter.try_acquire(0).is_ok());
        assert_eq!(counter.capacity_remaining().unwrap(), 100); // Should remain unchanged
    }

    #[test]
    fn test_window_boundary_exact_timing() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_millis(1000))
            .with_time(time_source.clone())
            .with_precision::<Millis>()
            .build()
            .unwrap();

        // Use tokens
        assert!(counter.try_acquire(80).is_ok());
        
        // Advance to exact window boundary
        time_source.advance(Duration::from_millis(1000));
        
        // Should be new window
        assert_eq!(counter.capacity_remaining().unwrap(), 100);
    }

    #[test]
    fn test_rapid_consecutive_acquires() {
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(60))
            .with_time(MockTimeSource::new())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Multiple rapid acquires in same window
        for i in 1..=10 {
            assert!(counter.try_acquire(5).is_ok());
            assert_eq!(counter.capacity_remaining().unwrap(), 100 - (i * 5));
        }

        // Window should have 50 tokens left
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
        assert!(counter.try_acquire(50).is_ok());
        assert!(counter.try_acquire(1).is_err()); // Should fail
    }

    #[test]
    fn test_very_small_window_duration() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(10)
            .window_duration(Duration::from_nanos(1))
            .with_time(time_source.clone())
            .with_precision::<Nanos>()
            .build()
            .unwrap();

        assert!(counter.try_acquire(5).is_ok());
        
        // Advance by the tiny window duration
        time_source.advance(Duration::from_nanos(1));
        
        // Should be new window
        assert_eq!(counter.capacity_remaining().unwrap(), 10);
    }
}

#[cfg(test)]
mod fixed_window_counter_window_alignment {
    use super::*;

    #[test]
    fn test_window_alignment_from_start() {
        let time_source = MockTimeSource::new();
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(10))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Windows should align from time 0
        // Window 0: [0, 10), Window 1: [10, 20), etc.
        
        assert!(counter.try_acquire(50).is_ok());
        
        // At time 9, still in first window
        time_source.advance(Duration::from_secs(9));
        assert_eq!(counter.capacity_remaining().unwrap(), 50);
        
        // At time 10, new window starts
        time_source.advance(Duration::from_secs(1));
        assert_eq!(counter.capacity_remaining().unwrap(), 100);
        
        assert!(counter.try_acquire(30).is_ok());
        
        // At time 19, still in second window
        time_source.advance(Duration::from_secs(9));
        assert_eq!(counter.capacity_remaining().unwrap(), 70);
        
        // At time 20, third window starts
        time_source.advance(Duration::from_secs(1));
        assert_eq!(counter.capacity_remaining().unwrap(), 100);
    }

    #[test]
    fn test_non_aligned_start_time() {
        let time_source = MockTimeSource::new();
        
        // Start at non-zero time
        time_source.advance(Duration::from_secs(5));
        
        let counter = FixedWindowCounterBuilder::builder()
            .capacity(100)
            .window_duration(Duration::from_secs(10))
            .with_time(time_source.clone())
            .with_precision::<Secs>()
            .build()
            .unwrap();

        // Even though we start at time 5, windows should still align to [0,10), [10,20), etc.
        assert!(counter.try_acquire(50).is_ok());
        
        // Advance to time 10 (window boundary)
        time_source.advance(Duration::from_secs(5));
        assert_eq!(counter.capacity_remaining().unwrap(), 100); // New window
        
        assert!(counter.try_acquire(25).is_ok());
        
        // Advance to time 20 (next window boundary)  
        time_source.advance(Duration::from_secs(10));
        assert_eq!(counter.capacity_remaining().unwrap(), 100); // New window
    }
}