xacli_testing/testing/

execute.rs

use std::collections::VecDeque;

use indexmap::IndexMap;

use super::{ctx::MockContext, test::TestCase};
use crate::{
    report::xacli::{
        TestCaseConfig, TestCaseResult, TestCaseStatus, TestError, TestFailure, TestSuiteResult,
        TestSuitesResult,
    },
    spec, TestingApp,
};

pub struct ExecuteResult {
    pub start_time: std::time::Instant,
    pub duration: std::time::Duration,
    pub code: i64,
    pub stdout: String,
    pub stderr: String,
}

impl TestingApp {
    /// Execute a test case and return the test result
    ///
    /// This method parses the arguments, runs the application with a mock context,
    /// and validates all assertions.
    pub fn execute(&self, test_case: TestCase) -> TestCaseResult {
        let start_time = std::time::Instant::now();
        let timestamp = std::time::SystemTime::now();

        // Extract test config from test case
        let config = TestCaseConfig {
            commands: test_case.commands.clone(),
            args: test_case.args.clone(),
        };

        // Build full args: [app_name, ...commands, ...args]
        let mut full_args = vec![self.app.info.name.clone()];
        full_args.extend(test_case.commands.clone());
        full_args.extend(test_case.args.clone());

        let ctx_info = match self.app.parse(full_args) {
            Ok(info) => info,
            Err(e) => {
                return TestCaseResult {
                    config,
                    timestamp,
                    duration: std::time::Duration::new(0, 0),
                    stdout: String::new(),
                    stderr: e.to_string(),
                    status: TestCaseStatus::Error {
                        error: TestError {
                            message: "Failed to parse arguments".to_string(),
                        },
                    },
                };
            }
        };

        let mut ctx = MockContext::new(
            ctx_info,
            VecDeque::from(test_case.input_events.clone()),
            self.config.tty,
        );

        let result = self.app.execute_with_ctx(&mut ctx);
        let code = match &result {
            Ok(_) => 0,
            Err(_) => 1,
        };

        let end_time = std::time::Instant::now();
        let duration = end_time.duration_since(start_time);

        let stdout = ctx.stdout_plain();
        let stderr = ctx.stderr_plain();

        // Build ExecuteResult for assertions
        let execute_result = ExecuteResult {
            start_time,
            duration,
            code,
            stdout: stdout.clone(),
            stderr: stderr.clone(),
        };

        // If execution failed, return Error status immediately
        if let Err(e) = result {
            return TestCaseResult {
                config,
                timestamp,
                duration,
                stdout,
                stderr: format!("{}\n{}", stderr, e),
                status: TestCaseStatus::Error {
                    error: TestError {
                        message: e.to_string(),
                    },
                },
            };
        }

        // Run all assertions
        let mut all_success = true;
        let mut error_messages = Vec::new();

        for asserter in &test_case.assertions {
            if let Ok(result) = asserter.validate(&execute_result) {
                if !result.success {
                    all_success = false;
                    error_messages.extend(result.messages);
                }
            }
        }

        // Determine status based on assertions
        let status = if all_success {
            TestCaseStatus::Passed
        } else {
            TestCaseStatus::Failed {
                failure: TestFailure {
                    message: error_messages.join("\n"),
                },
            }
        };

        TestCaseResult {
            config,
            timestamp,
            duration,
            stdout,
            stderr,
            status,
        }
    }

    /// Execute all tests in a spec file and return results
    ///
    /// This method iterates through all suites and tests in the spec file,
    /// converts each test case, executes it, and collects results.
    pub fn execute_spec(&self, spec: &spec::SpecFile) -> TestSuitesResult {
        let mut suites_result = IndexMap::new();

        for (suite_name, suite) in &spec.suite {
            // Skip suite if marked as skip
            if suite.features.skip {
                continue;
            }

            let mut suite_result = IndexMap::new();

            for (test_name, test_case) in &suite.test {
                // Skip test if marked as skip
                if test_case.features.skip {
                    continue;
                }

                // Convert and execute test case
                let test_result = match TestCase::try_from((test_name.as_str(), test_case)) {
                    Ok(testing_case) => {
                        let mut result = self.execute(testing_case);
                        // Update config with commands from spec
                        result.config.commands = test_case.commands.clone();
                        result
                    }
                    Err(e) => TestCaseResult {
                        config: TestCaseConfig {
                            commands: test_case.commands.clone(),
                            args: test_case.args.clone(),
                        },
                        timestamp: std::time::SystemTime::now(),
                        duration: std::time::Duration::default(),
                        stdout: String::new(),
                        stderr: e.to_string(),
                        status: TestCaseStatus::Error {
                            error: TestError {
                                message: format!("Failed to convert test case: {}", e),
                            },
                        },
                    },
                };

                suite_result.insert(test_name.clone(), test_result);
            }

            if !suite_result.is_empty() {
                suites_result.insert(
                    suite_name.clone(),
                    TestSuiteResult {
                        tests: suite_result,
                    },
                );
            }
        }

        TestSuitesResult {
            suites: suites_result,
        }
    }
}