tiny-counter 0.1.0

//! Performance regression tests.
//!
//! Ensures that key operations complete within reasonable time bounds.

use std::time::Instant;
use tiny_counter::EventStore;

// ============================================================================
// Recording Performance
// ============================================================================

#[test]
fn record_performance_baseline() {
    let store = EventStore::new();
    let start = Instant::now();

    for _ in 0..10_000 {
        store.record("event");
    }

    let elapsed = start.elapsed();
    assert!(
        elapsed.as_millis() < 100,
        "Recording 10k events took {:?}, expected < 100ms",
        elapsed
    );
}

#[test]
fn record_multiple_events_performance() {
    let store = EventStore::new();
    let start = Instant::now();

    for i in 0..1_000 {
        let event_id = format!("event_{}", i % 100);
        store.record(&event_id);
    }

    let elapsed = start.elapsed();
    assert!(
        elapsed.as_millis() < 50,
        "Recording 1k events across 100 IDs took {:?}, expected < 50ms",
        elapsed
    );
}

#[test]
fn record_large_counts_performance() {
    let store = EventStore::new();
    let start = Instant::now();

    for _ in 0..1_000 {
        store.record_count("batch_event", 1000);
    }

    let elapsed = start.elapsed();
    assert!(
        elapsed.as_millis() < 50,
        "Recording 1k large counts took {:?}, expected < 50ms",
        elapsed
    );
}

// ============================================================================
// Query Performance
// ============================================================================

#[test]
fn query_performance_baseline() {
    let store = EventStore::new();

    // Pre-populate with data
    for _ in 0..100_000 {
        store.record("event");
    }

    let start = Instant::now();
    let _ = store.query("event").last_days(7).sum();
    let elapsed = start.elapsed();

    assert!(
        elapsed.as_millis() < 10,
        "Query took {:?}, expected < 10ms",
        elapsed
    );
}

#[test]
fn query_many_performance() {
    let store = EventStore::new();

    // Pre-populate with multiple events
    for i in 0..10_000 {
        store.record(format!("event_{}", i % 10));
    }

    let event_ids: Vec<String> = (0..10).map(|i| format!("event_{}", i)).collect();
    let event_refs: Vec<&str> = event_ids.iter().map(|s| s.as_str()).collect();

    let start = Instant::now();
    let _ = store.query_many(&event_refs).last_days(7).sum();
    let elapsed = start.elapsed();

    assert!(
        elapsed.as_millis() < 20,
        "Multi-query took {:?}, expected < 20ms",
        elapsed
    );
}

#[test]
fn aggregation_performance() {
    let store = EventStore::new();

    // Pre-populate with data
    for _ in 0..50_000 {
        store.record_count("event", 10);
    }

    let start = Instant::now();
    let _ = store.query("event").last_days(7).sum();
    let _ = store.query("event").last_days(7).average();
    let _ = store.query("event").last_days(7).average_nonzero();
    let _ = store.query("event").last_days(7).count_nonzero();
    let elapsed = start.elapsed();

    assert!(
        elapsed.as_millis() < 50,
        "Four aggregations took {:?}, expected < 50ms",
        elapsed
    );
}

// ============================================================================
// Special Query Performance
// ============================================================================

#[test]
fn ratio_query_performance() {
    let store = EventStore::new();

    // Pre-populate with data
    for _ in 0..50_000 {
        store.record_count("numerator", 5);
        store.record_count("denominator", 10);
    }

    let start = Instant::now();
    let _ = store.query_ratio("numerator", "denominator").last_days(7);
    let elapsed = start.elapsed();

    assert!(
        elapsed.as_millis() < 20,
        "Ratio query took {:?}, expected < 20ms",
        elapsed
    );
}

#[test]
fn delta_query_performance() {
    let store = EventStore::new();

    // Pre-populate with data
    for _ in 0..50_000 {
        store.record_count("additions", 15);
        store.record_count("deletions", 5);
    }

    let start = Instant::now();
    let _ = store
        .query_delta("additions", "deletions")
        .last_days(7)
        .sum();
    let elapsed = start.elapsed();

    assert!(
        elapsed.as_millis() < 20,
        "Delta query took {:?}, expected < 20ms",
        elapsed
    );
}