textfsm-rust 0.3.1

//! CliTable test runner for ntc-templates compatibility testing.
//!
//! Uses parallel execution for faster testing.
//!
//! Usage:
//!   cargo run --release --features serde --example test_clitable -- \
//!     --ntc-templates /path/to/ntc-templates \
//!     --output results.json

use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Mutex;
use textfsm_rust::{CliTable, ListItem, Value};
use walkdir::WalkDir;

/// Test results output format.
#[derive(Debug, Serialize)]
struct TestResults {
    total: usize,
    passed: usize,
    failed: usize,
    skipped: usize,
    pass_rate: f64,
    failures: Vec<TestFailure>,
}

#[derive(Debug, Serialize, Clone)]
struct TestFailure {
    template: String,
    test_file: String,
    error: String,
}

/// Raw test data from YAML files in ntc-templates.
#[derive(Debug, Deserialize)]
struct RawTestCase {
    #[serde(default)]
    parsed_sample: Vec<HashMap<String, serde_yaml::Value>>,
}

/// A single test case to run.
struct TestCase {
    template_name: String,
    test_file: PathBuf,
    raw_file: PathBuf,
    platform: String,
    command: String,
}

struct Args {
    ntc_templates_dir: PathBuf,
    output_file: PathBuf,
    verbose: bool,
}

fn parse_args() -> Args {
    let args: Vec<String> = std::env::args().collect();

    let mut ntc_templates_dir = None;
    let mut output_file = None;
    let mut verbose = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--ntc-templates" => {
                ntc_templates_dir = Some(PathBuf::from(&args[i + 1]));
                i += 2;
            }
            "--output" => {
                output_file = Some(PathBuf::from(&args[i + 1]));
                i += 2;
            }
            "--verbose" | "-v" => {
                verbose = true;
                i += 1;
            }
            _ => {
                i += 1;
            }
        }
    }

    Args {
        ntc_templates_dir: ntc_templates_dir.expect("--ntc-templates is required"),
        output_file: output_file.expect("--output is required"),
        verbose,
    }
}

fn main() {
    let args = parse_args();

    let templates_dir = args.ntc_templates_dir.join("ntc_templates/templates");
    let tests_dir = args.ntc_templates_dir.join("tests");
    let index_path = templates_dir.join("index");

    println!("ntc-templates directory: {}", args.ntc_templates_dir.display());
    println!("Templates directory: {}", templates_dir.display());
    println!("Index file: {}", index_path.display());
    println!("Output file: {}", args.output_file.display());

    // Create CliTable
    let cli_table = match CliTable::new(&index_path, &templates_dir) {
        Ok(ct) => ct,
        Err(e) => {
            eprintln!("Error: Failed to create CliTable: {}", e);
            std::process::exit(1);
        }
    };

    // Collect all test cases
    let test_cases = collect_test_cases(&templates_dir, &tests_dir);
    let total = test_cases.len();

    println!("\nFound {} test cases, running in parallel...\n", total);

    // Thread-safe counters and failure collection
    let passed = AtomicUsize::new(0);
    let skipped = AtomicUsize::new(0);
    let failures: Mutex<Vec<TestFailure>> = Mutex::new(Vec::new());

    // Run tests in parallel
    test_cases.par_iter().for_each(|test_case| {
        match run_single_test(test_case, &cli_table) {
            Ok(()) => {
                passed.fetch_add(1, Ordering::Relaxed);
                if args.verbose {
                    println!("PASS: {}", test_case.template_name);
                }
            }
            Err(TestError::Skipped(_reason)) => {
                skipped.fetch_add(1, Ordering::Relaxed);
            }
            Err(TestError::Failed(e)) => {
                if args.verbose {
                    println!(
                        "FAIL: {} - {}: {}",
                        test_case.template_name,
                        test_case.test_file.display(),
                        e
                    );
                }
                let mut failures_guard = failures.lock().unwrap();
                failures_guard.push(TestFailure {
                    template: test_case.template_name.clone(),
                    test_file: test_case.test_file.display().to_string(),
                    error: e,
                });
            }
        }
    });

    let passed_count = passed.load(Ordering::Relaxed);
    let skipped_count = skipped.load(Ordering::Relaxed);
    let failures_list = failures.into_inner().unwrap();
    let failed = total - passed_count - skipped_count;
    let pass_rate = if total > skipped_count {
        (passed_count as f64 / (total - skipped_count) as f64) * 100.0
    } else {
        0.0
    };

    let results = TestResults {
        total,
        passed: passed_count,
        failed,
        skipped: skipped_count,
        pass_rate,
        failures: failures_list,
    };

    // Print summary
    println!("\n========================================");
    println!(" CliTable Test Results");
    println!("========================================");
    println!("Total:     {}", total);
    println!("Passed:    {}", passed_count);
    println!("Failed:    {}", failed);
    println!("Skipped:   {}", skipped_count);
    println!("Pass Rate: {:.2}%", pass_rate);
    println!("========================================\n");

    // Write results to JSON file
    let json = serde_json::to_string_pretty(&results).expect("failed to serialize results");
    fs::write(&args.output_file, json).expect("failed to write output file");

    println!("Results written to {}", args.output_file.display());
}

/// Collect all test cases from templates and tests directories.
fn collect_test_cases(templates_dir: &Path, tests_dir: &Path) -> Vec<TestCase> {
    let mut test_cases = Vec::new();

    for entry in WalkDir::new(templates_dir)
        .max_depth(1)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().is_some_and(|ext| ext == "textfsm"))
    {
        let template_path = entry.path();
        let template_name = template_path
            .file_stem()
            .and_then(|s| s.to_str())
            .unwrap_or("unknown")
            .to_string();

        // Parse template name to get platform and command
        // Format: {vendor}_{os}_{command}.textfsm
        let parts: Vec<&str> = template_name.splitn(3, '_').collect();
        if parts.len() < 3 {
            continue;
        }

        let platform = format!("{}_{}", parts[0], parts[1]);
        let command = parts[2].replace('_', " ");

        // Find test directory: tests/{platform}/{command}/
        let test_dir = tests_dir.join(&platform).join(parts[2]);

        if test_dir.exists() {
            for test_entry in WalkDir::new(&test_dir)
                .max_depth(1)
                .into_iter()
                .filter_map(|e| e.ok())
                .filter(|e| e.path().extension().is_some_and(|ext| ext == "yml" || ext == "yaml"))
            {
                let test_file = test_entry.path().to_path_buf();
                let raw_file = test_file.with_extension("raw");

                if raw_file.exists() {
                    test_cases.push(TestCase {
                        template_name: template_name.clone(),
                        test_file,
                        raw_file,
                        platform: platform.clone(),
                        command: command.clone(),
                    });
                }
            }
        }
    }

    test_cases
}

enum TestError {
    Skipped(String),
    Failed(String),
}

fn run_single_test(tc: &TestCase, cli_table: &CliTable) -> Result<(), TestError> {
    // Build attributes for template matching
    let mut attrs = HashMap::new();
    attrs.insert("Platform".to_string(), tc.platform.clone());
    attrs.insert("Command".to_string(), tc.command.clone());

    // Check if we can find a matching template
    cli_table
        .find_templates(&attrs)
        .map_err(|e| TestError::Skipped(format!("no matching template: {}", e)))?;

    // Read test YAML
    let test_content = fs::read_to_string(&tc.test_file)
        .map_err(|e| TestError::Failed(format!("failed to read test file: {}", e)))?;

    let test_data: RawTestCase = serde_yaml::from_str(&test_content)
        .map_err(|e| TestError::Failed(format!("failed to parse test YAML: {}", e)))?;

    // Read raw input
    let raw_input = fs::read_to_string(&tc.raw_file)
        .map_err(|e| TestError::Failed(format!("failed to read raw file: {}", e)))?;

    // Parse using CliTable
    let table = cli_table
        .parse_cmd(&raw_input, &attrs)
        .map_err(|e| TestError::Failed(format!("failed to parse: {}", e)))?;

    // Compare results
    compare_results(&table, &test_data.parsed_sample).map_err(TestError::Failed)
}

fn compare_results(
    table: &textfsm_rust::TextTable,
    expected: &[HashMap<String, serde_yaml::Value>],
) -> Result<(), String> {
    if table.len() != expected.len() {
        return Err(format!(
            "row count mismatch: got {} rows, expected {}",
            table.len(),
            expected.len()
        ));
    }

    let header = table.header();

    for (row_idx, (row, expected_row)) in table.iter().zip(expected.iter()).enumerate() {
        for col_name in header {
            let value = row.get(col_name).unwrap_or(&Value::Empty);

            // ntc-templates uses lowercase column names in YAML
            let expected_value = expected_row
                .get(&col_name.to_lowercase())
                .or_else(|| expected_row.get(col_name));

            if let Some(expected_val) = expected_value
                && !values_match(value, expected_val)
            {
                return Err(format!(
                    "row {}, column '{}': got {:?}, expected {:?}",
                    row_idx, col_name, value, expected_val
                ));
            }
        }
    }

    Ok(())
}

fn values_match(actual: &Value, expected: &serde_yaml::Value) -> bool {
    match (actual, expected) {
        (Value::Empty, serde_yaml::Value::Null) => true,
        (Value::Empty, serde_yaml::Value::String(s)) => s.is_empty(),
        (Value::Single(s), serde_yaml::Value::String(e)) => s == e,
        (Value::Single(s), serde_yaml::Value::Number(n)) => s == &n.to_string(),
        (Value::Single(s), serde_yaml::Value::Bool(b)) => {
            s == &b.to_string() || (s == "True" && *b) || (s == "False" && !*b)
        }
        (Value::List(items), serde_yaml::Value::Sequence(seq)) => {
            if items.len() != seq.len() {
                return false;
            }
            items.iter().zip(seq.iter()).all(|(item, exp)| match item {
                ListItem::String(s) => match exp {
                    serde_yaml::Value::String(e) => s == e,
                    serde_yaml::Value::Number(n) => s == &n.to_string(),
                    _ => false,
                },
                ListItem::Dict(d) => match exp {
                    serde_yaml::Value::Mapping(m) => m.iter().all(|(k, v)| {
                        if let (serde_yaml::Value::String(key), serde_yaml::Value::String(val)) =
                            (k, v)
                        {
                            d.get(key) == Some(val)
                        } else {
                            false
                        }
                    }),
                    _ => false,
                },
            })
        }
        (Value::List(_), serde_yaml::Value::Null) => false,
        (Value::Empty, serde_yaml::Value::Sequence(seq)) => seq.is_empty(),
        (Value::List(items), serde_yaml::Value::String(s)) => items.is_empty() && s.is_empty(),
        _ => false,
    }
}