leptos-shadcn-ui/tests/performance_test_runner.rs

//! Performance Test Runner
//! 
//! This is the proper Rust-based way to run performance tests

use leptos::prelude::*;
use wasm_bindgen_test::*;
use web_sys;
use std::time::{Duration, Instant};

wasm_bindgen_test_configure!(run_in_browser);

#[derive(Debug, Clone)]
pub struct PerformanceMetrics {
    pub component_name: String,
    pub render_time: Duration,
    pub memory_usage: f64,
    pub interaction_time: Duration,
    pub timestamp: u64,
}

pub struct PerformanceTestRunner {
    metrics: Vec<PerformanceMetrics>,
    thresholds: std::collections::HashMap<String, f64>,
}

impl PerformanceTestRunner {
    pub fn new() -> Self {
        let mut thresholds = std::collections::HashMap::new();
        thresholds.insert("render_time_ms".to_string(), 50.0); // 50ms threshold
        thresholds.insert("memory_usage_kb".to_string(), 100.0); // 100KB threshold
        thresholds.insert("interaction_time_ms".to_string(), 10.0); // 10ms threshold
        
        Self {
            metrics: Vec::new(),
            thresholds,
        }
    }

    pub fn run_performance_tests(&mut self) -> bool {
        println!("🚀 Running Performance Tests");
        println!("============================");
        
        let components = vec![
            "button", "input", "card", "table", "form", "navigation"
        ];
        
        let mut all_passed = true;
        
        for component in components {
            println!("🧪 Testing performance for: {}", component);
            let passed = self.test_component_performance(component);
            if !passed {
                all_passed = false;
                println!("❌ Performance test failed for {}", component);
            } else {
                println!("✅ Performance test passed for {}", component);
            }
        }
        
        self.generate_performance_report();
        all_passed
    }

    fn test_component_performance(&mut self, component_name: &str) -> bool {
        let start_time = Instant::now();
        
        // Test render performance
        let render_time = self.measure_render_time(component_name);
        
        // Test memory usage
        let memory_usage = self.measure_memory_usage(component_name);
        
        // Test interaction performance
        let interaction_time = self.measure_interaction_time(component_name);
        
        let total_time = start_time.elapsed();
        
        let metrics = PerformanceMetrics {
            component_name: component_name.to_string(),
            render_time,
            memory_usage,
            interaction_time,
            timestamp: current_timestamp(),
        };
        
        self.metrics.push(metrics.clone());
        
        // Check thresholds
        let render_threshold = self.thresholds.get("render_time_ms").unwrap();
        let memory_threshold = self.thresholds.get("memory_usage_kb").unwrap();
        let interaction_threshold = self.thresholds.get("interaction_time_ms").unwrap();
        
        let render_passed = render_time.as_millis() as f64 <= *render_threshold;
        let memory_passed = memory_usage <= *memory_threshold;
        let interaction_passed = interaction_time.as_millis() as f64 <= *interaction_threshold;
        
        println!("  📊 Render Time: {:?} (threshold: {}ms)", render_time, render_threshold);
        println!("  💾 Memory Usage: {:.2}KB (threshold: {}KB)", memory_usage, memory_threshold);
        println!("  ⚡ Interaction Time: {:?} (threshold: {}ms)", interaction_time, interaction_threshold);
        println!("  ⏱️  Total Test Time: {:?}", total_time);
        
        render_passed && memory_passed && interaction_passed
    }

    fn measure_render_time(&self, component_name: &str) -> Duration {
        let start_time = Instant::now();
        
        // Simulate component rendering
        match component_name {
            "button" => self.render_button_component(),
            "input" => self.render_input_component(),
            "card" => self.render_card_component(),
            "table" => self.render_table_component(),
            "form" => self.render_form_component(),
            "navigation" => self.render_navigation_component(),
            _ => self.render_generic_component(component_name),
        }
        
        start_time.elapsed()
    }

    fn measure_memory_usage(&self, _component_name: &str) -> f64 {
        // Simulate memory usage measurement
        // In a real implementation, this would use web_sys to measure actual memory
        match _component_name {
            "button" => 15.5,
            "input" => 25.3,
            "card" => 45.7,
            "table" => 120.8,
            "form" => 80.2,
            "navigation" => 35.1,
            _ => 20.0,
        }
    }

    fn measure_interaction_time(&self, component_name: &str) -> Duration {
        let start_time = Instant::now();
        
        // Simulate user interaction
        match component_name {
            "button" => self.simulate_button_click(),
            "input" => self.simulate_input_typing(),
            "card" => self.simulate_card_hover(),
            "table" => self.simulate_table_sort(),
            "form" => self.simulate_form_submission(),
            "navigation" => self.simulate_navigation_click(),
            _ => self.simulate_generic_interaction(),
        }
        
        start_time.elapsed()
    }

    fn render_button_component(&self) {
        // Simulate button rendering
        std::thread::sleep(Duration::from_millis(5));
    }

    fn render_input_component(&self) {
        // Simulate input rendering
        std::thread::sleep(Duration::from_millis(8));
    }

    fn render_card_component(&self) {
        // Simulate card rendering
        std::thread::sleep(Duration::from_millis(12));
    }

    fn render_table_component(&self) {
        // Simulate table rendering
        std::thread::sleep(Duration::from_millis(25));
    }

    fn render_form_component(&self) {
        // Simulate form rendering
        std::thread::sleep(Duration::from_millis(18));
    }

    fn render_navigation_component(&self) {
        // Simulate navigation rendering
        std::thread::sleep(Duration::from_millis(10));
    }

    fn render_generic_component(&self, _name: &str) {
        // Simulate generic component rendering
        std::thread::sleep(Duration::from_millis(7));
    }

    fn simulate_button_click(&self) {
        // Simulate button click interaction
        std::thread::sleep(Duration::from_millis(2));
    }

    fn simulate_input_typing(&self) {
        // Simulate input typing interaction
        std::thread::sleep(Duration::from_millis(3));
    }

    fn simulate_card_hover(&self) {
        // Simulate card hover interaction
        std::thread::sleep(Duration::from_millis(1));
    }

    fn simulate_table_sort(&self) {
        // Simulate table sort interaction
        std::thread::sleep(Duration::from_millis(5));
    }

    fn simulate_form_submission(&self) {
        // Simulate form submission interaction
        std::thread::sleep(Duration::from_millis(8));
    }

    fn simulate_navigation_click(&self) {
        // Simulate navigation click interaction
        std::thread::sleep(Duration::from_millis(2));
    }

    fn simulate_generic_interaction(&self) {
        // Simulate generic interaction
        std::thread::sleep(Duration::from_millis(3));
    }

    fn generate_performance_report(&self) {
        println!("\n📊 Performance Test Report");
        println!("==========================");
        
        let total_components = self.metrics.len();
        let avg_render_time: Duration = self.metrics.iter()
            .map(|m| m.render_time)
            .sum::<Duration>() / total_components as u32;
        let avg_memory_usage: f64 = self.metrics.iter()
            .map(|m| m.memory_usage)
            .sum::<f64>() / total_components as f64;
        let avg_interaction_time: Duration = self.metrics.iter()
            .map(|m| m.interaction_time)
            .sum::<Duration>() / total_components as u32;
        
        println!("📦 Total Components Tested: {}", total_components);
        println!("⏱️  Average Render Time: {:?}", avg_render_time);
        println!("💾 Average Memory Usage: {:.2}KB", avg_memory_usage);
        println!("⚡ Average Interaction Time: {:?}", avg_interaction_time);
        
        println!("\n📋 Component Performance Details:");
        for metric in &self.metrics {
            println!("  📦 {}:", metric.component_name);
            println!("    ⏱️  Render: {:?}", metric.render_time);
            println!("    💾 Memory: {:.2}KB", metric.memory_usage);
            println!("    ⚡ Interaction: {:?}", metric.interaction_time);
        }
        
        // Performance recommendations
        println!("\n💡 Performance Recommendations:");
        for metric in &self.metrics {
            if metric.render_time.as_millis() > 30 {
                println!("  ⚠️  {}: Consider optimizing render performance", metric.component_name);
            }
            if metric.memory_usage > 80.0 {
                println!("  ⚠️  {}: Consider reducing memory usage", metric.component_name);
            }
            if metric.interaction_time.as_millis() > 5 {
                println!("  ⚠️  {}: Consider optimizing interaction performance", metric.component_name);
            }
        }
    }
}

fn current_timestamp() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs()
}

#[wasm_bindgen_test]
fn test_performance_test_runner() {
    let mut runner = PerformanceTestRunner::new();
    let success = runner.run_performance_tests();
    assert!(success, "All performance tests should pass");
}

#[wasm_bindgen_test]
fn test_button_performance() {
    let mut runner = PerformanceTestRunner::new();
    let passed = runner.test_component_performance("button");
    assert!(passed, "Button performance test should pass");
}

#[wasm_bindgen_test]
fn test_large_dataset_performance() {
    let start_time = Instant::now();
    
    // Simulate rendering a large dataset
    let num_items = 1000;
    let mut total_render_time = Duration::new(0, 0);
    
    for i in 0..num_items {
        let item_start = Instant::now();
        
        // Simulate rendering each item
        std::thread::sleep(Duration::from_micros(100));
        
        total_render_time += item_start.elapsed();
    }
    
    let total_time = start_time.elapsed();
    let avg_render_time = total_render_time / num_items as u32;
    
    println!("📊 Large Dataset Performance Test");
    println!("  📦 Items: {}", num_items);
    println!("  ⏱️  Total Time: {:?}", total_time);
    println!("  ⏱️  Average Render Time: {:?}", avg_render_time);
    
    // Assert performance thresholds
    assert!(total_time < Duration::from_secs(5), "Total render time should be under 5 seconds");
    assert!(avg_render_time < Duration::from_millis(1), "Average render time should be under 1ms");
}

#[wasm_bindgen_test]
fn test_memory_usage_performance() {
    let initial_memory = measure_memory_usage();
    
    // Simulate creating many components
    let num_components = 100;
    for _ in 0..num_components {
        // Simulate component creation
        let _component = create_test_component();
    }
    
    let final_memory = measure_memory_usage();
    let memory_increase = final_memory - initial_memory;
    
    println!("💾 Memory Usage Performance Test");
    println!("  📦 Components Created: {}", num_components);
    println!("  💾 Memory Increase: {:.2}KB", memory_increase);
    println!("  💾 Per Component: {:.2}KB", memory_increase / num_components as f64);
    
    // Assert memory usage thresholds
    assert!(memory_increase < 1000.0, "Memory increase should be under 1MB");
    assert!(memory_increase / num_components as f64 < 10.0, "Per-component memory should be under 10KB");
}

fn measure_memory_usage() -> f64 {
    // Simulate memory measurement
    // In a real implementation, this would use web_sys to measure actual memory
    50.0 + (std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_millis() % 100) as f64
}

fn create_test_component() -> String {
    // Simulate component creation
    "test_component".to_string()
}