Function test_result_cache_for_identical_queries

tests/result_cache_test.rs:5–63

()

#[tokio::test]
async fn test_result_cache_for_identical_queries() {
    let test_server = setup_test_server_with_init(|db| {
        Box::pin(async move {
            // Create a test table
            db.execute("CREATE TABLE cache_test (id INTEGER PRIMARY KEY, name TEXT, value REAL)").await?;
            
            // Insert test data
            for i in 1..=100 {
                let query = format!("INSERT INTO cache_test VALUES ({}, 'name_{}', {})", i, i, i as f64 * 1.5);
                db.execute(&query).await?;
            }
            
            Ok(())
        })
    }).await;
    
    let client = &test_server.client;
    
    // Execute a query that should be cached (takes more than 1ms or returns > 10 rows)
    let query = "SELECT id, name, value FROM cache_test WHERE id > 90 ORDER BY id";
    
    // First execution - should be slower
    let start1 = std::time::Instant::now();
    let rows1 = client.query(query, &[]).await.unwrap();
    let duration1 = start1.elapsed();
    
    // Verify results
    assert_eq!(rows1.len(), 10);
    assert_eq!(rows1[0].get::<_, i32>(0), 91);
    assert_eq!(rows1[9].get::<_, i32>(0), 100);
    
    // Second execution - should be cached and faster
    let start2 = std::time::Instant::now();
    let rows2 = client.query(query, &[]).await.unwrap();
    let duration2 = start2.elapsed();
    
    // Verify same results
    assert_eq!(rows2.len(), 10);
    assert_eq!(rows2[0].get::<_, i32>(0), 91);
    assert_eq!(rows2[9].get::<_, i32>(0), 100);
    
    // Third execution to ensure cache is working
    let start3 = std::time::Instant::now();
    let rows3 = client.query(query, &[]).await.unwrap();
    let duration3 = start3.elapsed();
    
    assert_eq!(rows3.len(), 10);
    
    // Log durations for debugging
    eprintln!("First execution: {duration1:?}");
    eprintln!("Second execution (cached): {duration2:?}");
    eprintln!("Third execution (cached): {duration3:?}");
    
    // With the test harness overhead, we can't reliably test timing
    // Just verify that subsequent executions return the same results
    // In production, the cache would provide significant benefits
    
    test_server.abort();