xacli_testing/report/

xacli.rs

use std::{fmt::Debug, time::Duration};

use indexmap::IndexMap;
use serde::{Deserialize, Serialize};

/// Result of running tests
#[derive(Clone, Serialize, Deserialize)]
pub struct TestSuitesResult {
    /// Test suites results (ordered)
    pub suites: IndexMap<String, TestSuiteResult>,
}

impl Debug for TestSuitesResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TestSuitesResult")
            .field("suites", &self.suites.keys().collect::<Vec<&String>>())
            .finish()
    }
}

impl TestSuitesResult {
    /// Create empty result
    pub fn new() -> Self {
        Self {
            suites: IndexMap::new(),
        }
    }

    /// Read report from JSON file
    pub fn from_file(path: impl AsRef<std::path::Path>) -> Result<Self, std::io::Error> {
        let content = std::fs::read_to_string(path)?;
        serde_json::from_str(&content)
            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
    }

    /// Write report to JSON file
    pub fn to_file(&self, path: impl AsRef<std::path::Path>) -> Result<(), std::io::Error> {
        let json = serde_json::to_string_pretty(self)
            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
        std::fs::write(path, json)
    }

    /// Serialize to JSON string
    pub fn to_json(&self) -> Result<String, serde_json::Error> {
        serde_json::to_string_pretty(self)
    }

    /// Count total tests
    pub fn total(&self) -> usize {
        self.suites.values().map(|s| s.tests.len()).sum()
    }

    /// Count passed tests
    pub fn passed(&self) -> usize {
        self.suites
            .values()
            .flat_map(|s| s.tests.values())
            .filter(|t| matches!(t.status, TestCaseStatus::Passed))
            .count()
    }

    /// Count failed tests
    pub fn failed(&self) -> usize {
        self.suites
            .values()
            .flat_map(|s| s.tests.values())
            .filter(|t| matches!(t.status, TestCaseStatus::Failed { .. }))
            .count()
    }
}

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

/// Result of running a test suite
#[derive(Clone, Serialize, Deserialize)]
pub struct TestSuiteResult {
    /// Test cases results (ordered)
    pub tests: IndexMap<String, TestCaseResult>,
}

impl Debug for TestSuiteResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TestSuiteResult")
            .field("tests", &self.tests.keys().collect::<Vec<&String>>())
            .finish()
    }
}

/// Result of running a test case
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestCaseResult {
    /// Test case configuration
    pub config: TestCaseConfig,

    /// Timestamp when the test started (milliseconds since UNIX epoch)
    #[serde(with = "system_time_serde")]
    pub timestamp: std::time::SystemTime,

    /// Duration of the test execution
    #[serde(with = "duration_serde")]
    pub duration: Duration,

    /// Captured standard output
    pub stdout: String,

    /// Captured standard error
    pub stderr: String,

    /// Test case status
    pub status: TestCaseStatus,
}

/// Test case configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestCaseConfig {
    /// Commands to execute (subcommand path)
    pub commands: Vec<String>,

    /// Command-line arguments
    pub args: Vec<String>,
}

/// Test case status variants
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum TestCaseStatus {
    /// Test passed (no child element)
    Passed,

    /// Test failed
    Failed { failure: TestFailure },

    /// Test had an error (e.g., exception, crash)
    Error { error: TestError },

    /// Test was skipped
    Skipped { skipped: TestSkipped },
}

/// Failure information for a failed test
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestFailure {
    /// Failure message
    pub message: String,
}

/// Error information for a test with an error
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestError {
    /// Error message
    pub message: String,
}

/// Skipped test information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestSkipped {
    /// Reason for skipping
    pub message: Option<String>,
}

/// Custom serialization for Duration (as milliseconds)
mod duration_serde {
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
    use std::time::Duration;

    #[derive(Serialize, Deserialize)]
    struct DurationMs {
        ms: u128,
    }

    pub fn serialize<S>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        DurationMs {
            ms: duration.as_millis(),
        }
        .serialize(serializer)
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<Duration, D::Error>
    where
        D: Deserializer<'de>,
    {
        let d = DurationMs::deserialize(deserializer)?;
        Ok(Duration::from_millis(d.ms as u64))
    }
}

/// Custom serialization for SystemTime (as milliseconds since UNIX epoch)
mod system_time_serde {
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
    use std::time::{Duration, SystemTime, UNIX_EPOCH};

    #[derive(Serialize, Deserialize)]
    struct TimestampMs {
        epoch_ms: u128,
    }

    pub fn serialize<S>(time: &SystemTime, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let epoch_ms = time
            .duration_since(UNIX_EPOCH)
            .unwrap_or(Duration::ZERO)
            .as_millis();
        TimestampMs { epoch_ms }.serialize(serializer)
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<SystemTime, D::Error>
    where
        D: Deserializer<'de>,
    {
        let t = TimestampMs::deserialize(deserializer)?;
        Ok(UNIX_EPOCH + Duration::from_millis(t.epoch_ms as u64))
    }
}