swarm-engine-eval 0.1.6

//! Report generation

pub mod json;

pub use json::JsonReporter;

use std::path::Path;

use serde::{Deserialize, Serialize};

use crate::aggregator::AggregatedResults;
use crate::error::Result;
use crate::run::EvalRun;

/// Reporter trait
pub trait Reporter {
    /// Generate report
    fn generate(&self, report: &EvalReport) -> Result<String>;

    /// Write report to file
    fn write_to_file(&self, report: &EvalReport, path: impl AsRef<Path>) -> Result<()> {
        let content = self.generate(report)?;
        std::fs::write(path, content)?;
        Ok(())
    }
}

/// Configuration summary for reports
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ConfigSummary {
    /// Scenario name
    pub scenario_name: String,
    /// Scenario ID
    pub scenario_id: String,
    /// Number of workers
    pub worker_count: usize,
    /// Max ticks
    pub max_ticks: u64,
    /// Number of runs
    pub run_count: usize,
}

/// Seed information
#[derive(Debug, Clone, Default)]
pub struct SeedInfo {
    /// Base seed
    pub base_seed: u64,
    /// Seeds used for each run
    pub run_seeds: Vec<u64>,
}

/// Assertion result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AssertionResult {
    /// Assertion name
    pub name: String,
    /// Whether it passed
    pub passed: bool,
    /// Expected value
    pub expected: String,
    /// Actual value
    pub actual: String,
    /// Message
    pub message: Option<String>,
}

/// Evaluation report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvalReport {
    /// Configuration summary
    pub config_summary: ConfigSummary,

    /// Seed information
    #[serde(skip)]
    pub seed_info: SeedInfo,

    /// Individual run results
    pub runs: Vec<EvalRun>,

    /// Aggregated results
    pub aggregated: AggregatedResults,

    /// Assertion results
    pub assertion_results: Vec<AssertionResult>,
}

impl EvalReport {
    /// Check if all assertions passed
    pub fn all_assertions_passed(&self) -> bool {
        self.assertion_results.iter().all(|r| r.passed)
    }

    /// Write to JSON file
    pub fn to_json_file(&self, path: impl AsRef<Path>) -> Result<()> {
        JsonReporter::new().write_to_file(self, path)
    }
}