kaccy-core 0.2.0

//! Integration Testing Framework
//!
//! This module provides integration testing utilities for testing multi-service
//! interactions and end-to-end scenarios.
//!
//! # Features
//!
//! - End-to-end test scenarios
//! - Multi-service integration
//! - Contract testing
//! - Test environment management
//!
//! # Examples
//!
//! ```
//! use kaccy_core::utils::integration_testing::{TestScenario, TestEnvironment};
//!
//! let mut env = TestEnvironment::new();
//! env.register_service("database");
//! env.start_service("database").unwrap();
//! env.register_service("api");
//! env.start_service("api").unwrap();
//!
//! let mut scenario = TestScenario::new("user_registration")
//!     .with_step("create_user")
//!     .with_step("verify_email")
//!     .with_step("login");
//!
//! let result = scenario.execute(&env);
//! ```

use crate::{CoreError as Error, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, Instant};

/// Test step status
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum StepStatus {
    /// Step is pending
    Pending,
    /// Step is running
    Running,
    /// Step passed
    Passed,
    /// Step failed
    Failed,
    /// Step was skipped
    Skipped,
}

/// Test scenario result
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TestResult {
    /// All steps passed
    Passed,
    /// One or more steps failed
    Failed,
    /// Test was skipped
    Skipped,
}

/// Test step
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestStep {
    /// Step name
    pub name: String,
    /// Step description
    pub description: String,
    /// Status
    pub status: StepStatus,
    /// Duration in milliseconds
    pub duration_ms: Option<u64>,
    /// Error message if failed
    pub error: Option<String>,
}

impl TestStep {
    /// Create a new test step
    pub fn new(name: &str, description: &str) -> Self {
        Self {
            name: name.to_string(),
            description: description.to_string(),
            status: StepStatus::Pending,
            duration_ms: None,
            error: None,
        }
    }

    /// Mark step as passed
    pub fn pass(&mut self, duration: Duration) {
        self.status = StepStatus::Passed;
        self.duration_ms = Some(duration.as_millis() as u64);
    }

    /// Mark step as failed
    pub fn fail(&mut self, error: &str, duration: Duration) {
        self.status = StepStatus::Failed;
        self.duration_ms = Some(duration.as_millis() as u64);
        self.error = Some(error.to_string());
    }
}

/// Test scenario
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestScenario {
    /// Scenario name
    pub name: String,
    /// Test steps
    pub steps: Vec<TestStep>,
    /// Overall result
    pub result: Option<TestResult>,
    /// Total duration
    pub total_duration_ms: Option<u64>,
}

impl TestScenario {
    /// Create a new test scenario
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            steps: Vec::new(),
            result: None,
            total_duration_ms: None,
        }
    }

    /// Add a test step
    pub fn with_step(mut self, name: &str) -> Self {
        self.steps.push(TestStep::new(name, ""));
        self
    }

    /// Add a test step with description
    pub fn with_step_desc(mut self, name: &str, description: &str) -> Self {
        self.steps.push(TestStep::new(name, description));
        self
    }

    /// Execute the test scenario
    pub fn execute(&mut self, env: &TestEnvironment) -> Result<TestResult> {
        let start = Instant::now();
        let mut all_passed = true;

        for step in &mut self.steps {
            if !env.is_service_running(&step.name) && env.services.contains_key(&step.name) {
                // Service needed but not running
                step.status = StepStatus::Skipped;
                continue;
            }

            step.status = StepStatus::Running;
            let step_start = Instant::now();

            // Simulate step execution
            if env.should_fail(&step.name) {
                step.fail("Step failed", step_start.elapsed());
                all_passed = false;
            } else {
                step.pass(step_start.elapsed());
            }
        }

        self.total_duration_ms = Some(start.elapsed().as_millis() as u64);
        self.result = Some(if all_passed {
            TestResult::Passed
        } else {
            TestResult::Failed
        });

        Ok(self.result.unwrap())
    }

    /// Get pass rate
    pub fn pass_rate(&self) -> f64 {
        if self.steps.is_empty() {
            return 0.0;
        }

        let passed = self
            .steps
            .iter()
            .filter(|s| s.status == StepStatus::Passed)
            .count();

        (passed as f64 / self.steps.len() as f64) * 100.0
    }
}

/// Test service
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestService {
    /// Service name
    pub name: String,
    /// Is service running?
    pub is_running: bool,
    /// Service port
    pub port: Option<u16>,
    /// Service health endpoint
    pub health_endpoint: Option<String>,
}

impl TestService {
    /// Create a new test service
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            is_running: false,
            port: None,
            health_endpoint: None,
        }
    }

    /// Start the service
    pub fn start(&mut self) {
        self.is_running = true;
    }

    /// Stop the service
    pub fn stop(&mut self) {
        self.is_running = false;
    }
}

/// Test environment
pub struct TestEnvironment {
    /// Services
    pub services: HashMap<String, TestService>,
    /// Environment variables
    pub env_vars: HashMap<String, String>,
    /// Failure injections (service name -> should fail)
    failure_injections: HashMap<String, bool>,
}

impl TestEnvironment {
    /// Create a new test environment
    pub fn new() -> Self {
        Self {
            services: HashMap::new(),
            env_vars: HashMap::new(),
            failure_injections: HashMap::new(),
        }
    }

    /// Register a service
    pub fn register_service(&mut self, name: &str) {
        self.services
            .insert(name.to_string(), TestService::new(name));
    }

    /// Start a service
    pub fn start_service(&mut self, name: &str) -> Result<()> {
        let service = self
            .services
            .get_mut(name)
            .ok_or_else(|| Error::Validation(format!("Service {} not found", name)))?;

        service.start();
        Ok(())
    }

    /// Stop a service
    pub fn stop_service(&mut self, name: &str) -> Result<()> {
        let service = self
            .services
            .get_mut(name)
            .ok_or_else(|| Error::Validation(format!("Service {} not found", name)))?;

        service.stop();
        Ok(())
    }

    /// Check if service is running
    pub fn is_service_running(&self, name: &str) -> bool {
        self.services
            .get(name)
            .map(|s| s.is_running)
            .unwrap_or(false)
    }

    /// Set environment variable
    pub fn set_env(&mut self, key: &str, value: &str) {
        self.env_vars.insert(key.to_string(), value.to_string());
    }

    /// Get environment variable
    pub fn get_env(&self, key: &str) -> Option<&str> {
        self.env_vars.get(key).map(|s| s.as_str())
    }

    /// Inject failure for a service/step
    pub fn inject_failure(&mut self, name: &str) {
        self.failure_injections.insert(name.to_string(), true);
    }

    /// Clear failure injection
    pub fn clear_failure(&mut self, name: &str) {
        self.failure_injections.remove(name);
    }

    /// Check if should fail
    fn should_fail(&self, name: &str) -> bool {
        self.failure_injections.get(name).copied().unwrap_or(false)
    }

    /// Stop all services
    pub fn cleanup(&mut self) {
        for service in self.services.values_mut() {
            service.stop();
        }
    }
}

impl Default for TestEnvironment {
    fn default() -> Self {
        Self::new()
    }
}

/// Contract definition for testing
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceContract {
    /// Service name
    pub service_name: String,
    /// Expected request format
    pub expected_request: String,
    /// Expected response format
    pub expected_response: String,
    /// API version
    pub version: String,
}

impl ServiceContract {
    /// Create a new service contract
    pub fn new(service_name: &str, version: &str) -> Self {
        Self {
            service_name: service_name.to_string(),
            expected_request: "{}".to_string(),
            expected_response: "{}".to_string(),
            version: version.to_string(),
        }
    }

    /// Validate a contract
    pub fn validate(&self) -> Result<()> {
        // In a real implementation, this would validate JSON schemas, etc.
        Ok(())
    }
}

/// Integration test suite
pub struct IntegrationTestSuite {
    /// Suite name
    pub name: String,
    /// Test scenarios
    pub scenarios: Vec<TestScenario>,
    /// Contracts to verify
    pub contracts: Vec<ServiceContract>,
}

impl IntegrationTestSuite {
    /// Create a new test suite
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            scenarios: Vec::new(),
            contracts: Vec::new(),
        }
    }

    /// Add a scenario to the suite
    pub fn add_scenario(&mut self, scenario: TestScenario) {
        self.scenarios.push(scenario);
    }

    /// Add a contract to verify
    pub fn add_contract(&mut self, contract: ServiceContract) {
        self.contracts.push(contract);
    }

    /// Execute all scenarios
    pub fn execute_all(&mut self, env: &TestEnvironment) -> SuiteResult {
        let start = Instant::now();
        let mut passed = 0;
        let mut failed = 0;

        for scenario in &mut self.scenarios {
            match scenario.execute(env) {
                Ok(TestResult::Passed) => passed += 1,
                _ => failed += 1,
            }
        }

        // Validate contracts
        let mut contract_failures = 0;
        for contract in &self.contracts {
            if contract.validate().is_err() {
                contract_failures += 1;
            }
        }

        SuiteResult {
            total_scenarios: self.scenarios.len(),
            passed_scenarios: passed,
            failed_scenarios: failed,
            contract_failures,
            duration_ms: start.elapsed().as_millis() as u64,
        }
    }
}

/// Test suite result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SuiteResult {
    /// Total number of scenarios
    pub total_scenarios: usize,
    /// Number of passed scenarios
    pub passed_scenarios: usize,
    /// Number of failed scenarios
    pub failed_scenarios: usize,
    /// Number of contract failures
    pub contract_failures: usize,
    /// Total duration in milliseconds
    pub duration_ms: u64,
}

impl SuiteResult {
    /// Get success rate
    pub fn success_rate(&self) -> f64 {
        if self.total_scenarios == 0 {
            return 0.0;
        }
        (self.passed_scenarios as f64 / self.total_scenarios as f64) * 100.0
    }

    /// Check if all tests passed
    pub fn all_passed(&self) -> bool {
        self.failed_scenarios == 0 && self.contract_failures == 0
    }
}

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

    #[test]
    fn test_test_environment_creation() {
        let env = TestEnvironment::new();
        assert_eq!(env.services.len(), 0);
    }

    #[test]
    fn test_register_and_start_service() {
        let mut env = TestEnvironment::new();
        env.register_service("database");
        assert!(env.start_service("database").is_ok());
        assert!(env.is_service_running("database"));
    }

    #[test]
    fn test_stop_service() {
        let mut env = TestEnvironment::new();
        env.register_service("api");
        env.start_service("api").unwrap();
        assert!(env.is_service_running("api"));

        env.stop_service("api").unwrap();
        assert!(!env.is_service_running("api"));
    }

    #[test]
    fn test_environment_variables() {
        let mut env = TestEnvironment::new();
        env.set_env("DATABASE_URL", "postgresql://localhost/test");

        assert_eq!(
            env.get_env("DATABASE_URL"),
            Some("postgresql://localhost/test")
        );
    }

    #[test]
    fn test_test_scenario_creation() {
        let scenario = TestScenario::new("user_flow")
            .with_step("register")
            .with_step("login")
            .with_step("logout");

        assert_eq!(scenario.steps.len(), 3);
    }

    #[test]
    fn test_scenario_execution() {
        let mut env = TestEnvironment::new();
        env.register_service("api");
        env.start_service("api").unwrap();

        let mut scenario = TestScenario::new("simple_test").with_step("test_step");

        let result = scenario.execute(&env).unwrap();
        assert_eq!(result, TestResult::Passed);
    }

    #[test]
    fn test_failure_injection() {
        let mut env = TestEnvironment::new();
        env.inject_failure("test_step");

        let mut scenario = TestScenario::new("failing_test").with_step("test_step");

        let result = scenario.execute(&env).unwrap();
        assert_eq!(result, TestResult::Failed);
    }

    #[test]
    fn test_integration_suite() {
        let mut env = TestEnvironment::new();
        env.register_service("api");
        env.start_service("api").unwrap();

        let mut suite = IntegrationTestSuite::new("Main Suite");
        suite.add_scenario(TestScenario::new("test1").with_step("step1"));
        suite.add_scenario(TestScenario::new("test2").with_step("step2"));

        let result = suite.execute_all(&env);
        assert_eq!(result.total_scenarios, 2);
        assert!(result.all_passed());
    }

    #[test]
    fn test_contract_validation() {
        let contract = ServiceContract::new("user_service", "v1");
        assert!(contract.validate().is_ok());
    }

    #[test]
    fn test_suite_success_rate() {
        let result = SuiteResult {
            total_scenarios: 10,
            passed_scenarios: 8,
            failed_scenarios: 2,
            contract_failures: 0,
            duration_ms: 1000,
        };

        assert_eq!(result.success_rate(), 80.0);
    }
}