xert 0.2.0

A professional Rust project scaffolding tool for Web, CLI, and Embedded projects.
Documentation
use std::path::Path;
use std::sync::{Arc, Mutex};
use xert::{
    scaffold::{create_project, ProgressHandler},
    Template,
};

// Mock progress handler for testing
struct TestProgressHandler {
    phases: Arc<Mutex<Vec<String>>>,
}

impl TestProgressHandler {
    fn new() -> Self {
        Self {
            phases: Arc::new(Mutex::new(Vec::new())),
        }
    }

    fn get_phases(&self) -> Vec<String> {
        self.phases.lock().unwrap().clone()
    }
}

impl ProgressHandler for TestProgressHandler {
    fn start_phase(&self, phase: &str) {
        self.phases
            .lock()
            .unwrap()
            .push(format!("START: {}", phase));
    }

    fn finish_phase(&self, phase: &str) {
        self.phases
            .lock()
            .unwrap()
            .push(format!("FINISH: {}", phase));
    }
}

// Silent handler for tests that don't need output
struct SilentHandler;

impl ProgressHandler for SilentHandler {
    fn start_phase(&self, _phase: &str) {}
    fn finish_phase(&self, _phase: &str) {}
}

#[tokio::test]
async fn test_create_cli_project() {
    let handler = TestProgressHandler::new();
    let project_name = "test_cli_project";

    if Path::new(project_name).exists() {
        std::fs::remove_dir_all(project_name).ok();
    }

    let result = create_project(&Template::Cli, project_name, &handler).await;
    assert!(
        result.is_ok(),
        "Project creation failed: {:?}",
        result.err()
    );

    assert!(
        Path::new(project_name).exists(),
        "Project directory not created"
    );
    assert!(
        Path::new(project_name).join("Cargo.toml").exists(),
        "Cargo.toml not created"
    );
    assert!(
        Path::new(project_name).join("src").join("main.rs").exists(),
        "main.rs not created"
    );

    let phases = handler.get_phases();
    assert!(
        phases.len() >= 4,
        "Progress handler should have been called at least 4 times"
    );
    assert!(
        phases
            .iter()
            .any(|p| p.contains("Dependencies") || p.contains("dependencies")),
        "Should track dependency resolution"
    );
    assert!(
        phases.iter().any(|p| p.to_lowercase().contains("scaffold")),
        "Should track scaffolding"
    );

    std::fs::remove_dir_all(project_name).ok();
}

#[tokio::test]
async fn test_create_web_project() {
    let handler = SilentHandler;
    let project_name = "test_web_project";

    if Path::new(project_name).exists() {
        std::fs::remove_dir_all(project_name).ok();
    }

    let result = create_project(&Template::Web, project_name, &handler).await;
    assert!(
        result.is_ok(),
        "Web project creation failed: {:?}",
        result.err()
    );
    assert!(
        Path::new(project_name).exists(),
        "Project directory not created"
    );

    let cargo_toml = std::fs::read_to_string(Path::new(project_name).join("Cargo.toml")).unwrap();
    assert!(
        cargo_toml.contains("axum"),
        "Cargo.toml should contain axum dependency"
    );
    assert!(
        cargo_toml.contains("tokio"),
        "Cargo.toml should contain tokio dependency"
    );

    std::fs::remove_dir_all(project_name).ok();
}

#[tokio::test]
async fn test_create_embedded_project() {
    let handler = SilentHandler;
    let project_name = "test_embedded_project";

    if Path::new(project_name).exists() {
        std::fs::remove_dir_all(project_name).ok();
    }

    let result = create_project(&Template::Embedded, project_name, &handler).await;
    assert!(
        result.is_ok(),
        "Embedded project creation failed: {:?}",
        result.err()
    );
    assert!(
        Path::new(project_name).exists(),
        "Project directory not created"
    );

    let cargo_toml = std::fs::read_to_string(Path::new(project_name).join("Cargo.toml")).unwrap();
    assert!(
        cargo_toml.contains("cortex-m"),
        "Cargo.toml should contain cortex-m dependency"
    );

    std::fs::remove_dir_all(project_name).ok();
}

#[tokio::test]
async fn test_duplicate_project_error() {
    let handler = SilentHandler;
    let project_name = "test_duplicate_project";

    if Path::new(project_name).exists() {
        std::fs::remove_dir_all(project_name).ok();
    }

    let result1 = create_project(&Template::Cli, project_name, &handler).await;
    assert!(result1.is_ok(), "First project creation should succeed");

    let result2 = create_project(&Template::Cli, project_name, &handler).await;
    assert!(result2.is_err(), "Creating duplicate project should fail");
    assert!(
        result2.unwrap_err().to_string().contains("already exists"),
        "Error should mention that directory already exists"
    );

    std::fs::remove_dir_all(project_name).ok();
}

#[tokio::test]
async fn test_dependency_resolution() {
    use xert::deps::resolve_dependencies;

    let crates = vec!["serde", "tokio", "anyhow"];
    let versions = resolve_dependencies(&crates).await;

    assert!(
        !versions.is_empty(),
        "Should resolve at least some dependencies"
    );

    if let Some(version) = versions.get("serde") {
        assert!(!version.is_empty(), "Version should not be empty");
        assert!(
            version.contains('.'),
            "Version should contain dots (e.g., 1.0.0)"
        );
    }
}

#[tokio::test]
async fn test_template_equality() {
    // Test Template enum comparison
    assert_eq!(Template::Web, Template::Web);
    assert_eq!(Template::Cli, Template::Cli);
    assert_eq!(Template::Embedded, Template::Embedded);
    assert_ne!(Template::Web, Template::Cli);
}

#[tokio::test]
async fn test_all_templates_create_projects() {
    let handler = SilentHandler;
    let templates = vec![
        (Template::Web, "test_all_web"),
        (Template::Cli, "test_all_cli"),
        (Template::Embedded, "test_all_embedded"),
    ];

    for (template, name) in templates {
        if Path::new(name).exists() {
            std::fs::remove_dir_all(name).ok();
        }

        let result = create_project(&template, name, &handler).await;
        assert!(result.is_ok(), "Failed to create {:?} project", template);
        assert!(Path::new(name).exists());
        assert!(Path::new(name).join("Cargo.toml").exists());

        std::fs::remove_dir_all(name).ok();
    }
}

#[tokio::test]
async fn test_security_audit_file_created() {
    let handler = SilentHandler;
    let project_name = "test_security_audit";

    if Path::new(project_name).exists() {
        std::fs::remove_dir_all(project_name).ok();
    }

    create_project(&Template::Cli, project_name, &handler)
        .await
        .unwrap();

    let audit_path = Path::new(project_name)
        .join(".github")
        .join("workflows")
        .join("audit.yml");
    assert!(
        audit_path.exists(),
        "Security audit workflow should be created"
    );

    let audit_content = std::fs::read_to_string(&audit_path).unwrap();
    assert!(
        audit_content.contains("Security Audit"),
        "Audit file should contain workflow name"
    );

    std::fs::remove_dir_all(project_name).ok();
}

#[tokio::test]
async fn test_concurrent_project_creation() {
    use tokio::task::JoinSet;

    let mut set = JoinSet::new();

    for i in 0..3 {
        set.spawn(async move {
            let handler = SilentHandler;
            let name = format!("test_concurrent_{}", i);

            if Path::new(&name).exists() {
                std::fs::remove_dir_all(&name).ok();
            }

            let result = create_project(&Template::Cli, &name, &handler).await;

            if Path::new(&name).exists() {
                std::fs::remove_dir_all(&name).ok();
            }

            result.is_ok()
        });
    }

    while let Some(res) = set.join_next().await {
        assert!(res.unwrap(), "Concurrent project creation should succeed");
    }
}

#[test]
fn test_template_debug_format() {
    let web = Template::Web;
    let debug_str = format!("{:?}", web);
    assert_eq!(debug_str, "Web");
}