capy-cli 0.10.0

The command-line interface for the Capy web framework.
Documentation
//! Behavioral integration tests.
use capy_cli::{find_project, generate, new_project, Generator};
use std::fs;

#[test]
fn projects_and_generators_preserve_user_code() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("blog");
    new_project(&root, "blog").unwrap();
    assert_eq!(find_project(root.join("app/controllers")).unwrap(), root);
    let manifest = fs::read_to_string(root.join("Cargo.toml")).unwrap();
    assert!(manifest.contains(&format!(
        "capy = {{ package = \"capy-framework\", version = \"{}\" }}",
        env!("CARGO_PKG_VERSION")
    )));
    assert!(manifest.contains(&format!(
        "rust-version = \"{}\"",
        env!("CARGO_PKG_RUST_VERSION")
    )));
    assert!(!manifest.contains("{{"));
    assert!(new_project(&root, "blog").is_err());
    for (kind, name, relative) in [
        (Generator::Model, "Post", "app/models/post.rs"),
        (
            Generator::Controller,
            "PostController",
            "app/controllers/post_controller.rs",
        ),
        (
            Generator::Request,
            "CreatePostRequest",
            "app/requests/create_post_request.rs",
        ),
    ] {
        assert_eq!(generate(&root, kind, name).unwrap(), root.join(relative));
        fs::write(root.join(relative), "// manual changes\n").unwrap();
        assert!(generate(&root, kind, name).is_err());
        assert_eq!(
            fs::read_to_string(root.join(relative)).unwrap(),
            "// manual changes\n"
        );
    }
    let migration = generate(&root, Generator::Migration, "create_posts_table").unwrap();
    let registry = fs::read_to_string(root.join("database/migrations/mod.rs")).unwrap();
    assert!(registry.contains(migration.file_stem().unwrap().to_str().unwrap()));
    assert!(fs::read_to_string(migration)
        .unwrap()
        .contains("Alias::new(\"posts\")"));
    generate(&root, Generator::Migration, "add_post_index").unwrap();
}

#[test]
fn invalid_names_and_missing_markers_do_not_write_files() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("blog");
    new_project(&root, "blog").unwrap();
    for name in [
        "../escape",
        "bad/name",
        "bad-name",
        "type",
        "self",
        "Mod",
        "9post",
        "",
    ] {
        assert!(generate(&root, Generator::Model, name).is_err(), "{name}");
    }
    for name in ["../escape", "bad/name", "type", "9blog", "", "MyBlog"] {
        assert!(new_project(&temp.path().join("invalid"), name).is_err());
    }
    let registry = root.join("database/migrations/mod.rs");
    fs::write(&registry, "// customized registry\n").unwrap();
    assert!(generate(&root, Generator::Migration, "create_posts_table").is_err());
    assert_eq!(fs::read_dir(registry.parent().unwrap()).unwrap().count(), 1);
    assert_eq!(
        fs::read_to_string(registry).unwrap(),
        "// customized registry\n"
    );
}

fn snapshot(root: &std::path::Path) -> std::collections::BTreeMap<std::path::PathBuf, Vec<u8>> {
    fn visit(
        path: &std::path::Path,
        result: &mut std::collections::BTreeMap<std::path::PathBuf, Vec<u8>>,
    ) {
        for entry in fs::read_dir(path).unwrap() {
            let path = entry.unwrap().path();
            if path.is_dir() {
                visit(&path, result);
            } else {
                result.insert(path.clone(), fs::read(path).unwrap());
            }
        }
    }
    let mut result = Default::default();
    visit(root, &mut result);
    result
}

#[test]
fn naming_matrix_and_export_collisions_are_atomic() {
    let temp = tempfile::tempdir().unwrap();
    for name in [
        "blog",
        "blog-api",
        "routes",
        "app",
        "config",
        "application",
        "database",
    ] {
        new_project(&temp.path().join(name), name).unwrap();
    }
    for name in [
        "build",
        "deps",
        "examples",
        "incremental",
        "Self",
        "crate",
        "capy",
        "std",
        "nul",
        "com1",
        "Routes",
    ] {
        let path = temp.path().join(format!("invalid_{name}"));
        let error = new_project(&path, name).unwrap_err();
        assert!(!path.exists(), "{name}: {error}");
        if name == "build" {
            assert!(error.to_string().contains("reserved by Cargo"));
        }
    }
    let root = temp.path().join("blog");
    for (first, second) in [
        ("Post", "post"),
        ("blog_post", "BlogPost"),
        ("Post", "PostModel"),
    ] {
        let root = root.join(format!("{first}_{second}"));
        new_project(&root, "sample").unwrap();
        generate(&root, Generator::Model, first).unwrap();
        let before = snapshot(&root);
        assert!(generate(&root, Generator::Model, second).is_err());
        assert_eq!(snapshot(&root), before);
    }
    for (first, second) in [
        ("PostModel", "Post"),
        ("JSON", "Json"),
        ("Blog_Post", "blog_post"),
    ] {
        let root = temp.path().join(format!("case_{first}"));
        new_project(&root, "sample").unwrap();
        generate(&root, Generator::Model, first).unwrap();
        let before = snapshot(&root);
        assert!(generate(&root, Generator::Model, second).is_err());
        assert_eq!(snapshot(&root), before);
    }
    for kind in [Generator::Controller, Generator::Request, Generator::Model] {
        for name in [
            "Json",
            "Routes",
            "build",
            "String",
            "Vec",
            "Value",
            "Result",
            "Deserialize",
            "Validate",
        ] {
            generate(&root, kind, name).unwrap();
        }
        for name in ["Self", "self", "crate", "Mod", "Type"] {
            let before = snapshot(&root);
            assert!(generate(&root, kind, name).is_err());
            assert_eq!(snapshot(&root), before);
        }
    }
}

#[test]
fn user_defined_registry_symbols_are_checked() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("blog");
    new_project(&root, "blog").unwrap();
    for (registry, name) in [
        ("pub type PostModel = ();\n", "Post"),
        ("use crate::app::{self as PostModel};\n", "Post"),
        ("mod post {}\n", "Post"),
        ("mod r#post {}\n", "Post"),
        ("use crate::app::{self};\n", "App"),
        ("use crate::app::*;\n", "Post"),
    ] {
        fs::write(root.join("app/models/mod.rs"), registry).unwrap();
        let before = snapshot(&root);
        assert!(generate(&root, Generator::Model, name).is_err());
        assert_eq!(snapshot(&root), before);
    }
}

#[test]
fn concurrent_cli_generators_preserve_every_registration() {
    use std::process::{Command, Stdio};
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("blog");
    new_project(&root, "blog").unwrap();
    for (command, directory) in [
        ("make:model", "app/models"),
        ("make:controller", "app/controllers"),
        ("make:request", "app/requests"),
        ("make:migration", "database/migrations"),
    ] {
        for round in 0..4 {
            let children: Vec<_> = ["First", "Second"]
                .iter()
                .map(|name| {
                    Command::new(env!("CARGO_BIN_EXE_capy"))
                        .args([command, &format!("{name}{round}")])
                        .current_dir(&root)
                        .stdout(Stdio::piped())
                        .stderr(Stdio::piped())
                        .spawn()
                        .unwrap()
                })
                .collect();
            for child in children {
                let output = child.wait_with_output().unwrap();
                assert!(
                    output.status.success(),
                    "{}",
                    String::from_utf8_lossy(&output.stderr)
                );
            }
        }
        let registry = fs::read_to_string(root.join(directory).join("mod.rs")).unwrap();
        let paths: Vec<_> = fs::read_dir(root.join(directory))
            .unwrap()
            .map(|e| e.unwrap().path())
            .filter(|p| p.file_name().unwrap() != "mod.rs")
            .collect();
        assert_eq!(paths.len(), 8);
        for path in paths {
            let module = path.file_stem().unwrap().to_str().unwrap();
            assert_eq!(registry.matches(&format!("mod {module};")).count(), 1);
            if command == "make:migration" {
                assert_eq!(
                    registry
                        .matches(&format!("Box::new({module}::Migration)"))
                        .count(),
                    1
                );
            }
        }
    }
}

#[cfg(unix)]
#[test]
fn registry_write_failure_exits_without_success_or_partial_files() {
    use std::os::unix::fs::PermissionsExt;
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path().join("blog");
    new_project(&root, "blog").unwrap();
    let before = snapshot(&root);
    let directory = root.join("app/models");
    let permissions = fs::metadata(&directory).unwrap().permissions();
    fs::set_permissions(&directory, fs::Permissions::from_mode(0o555)).unwrap();
    let output = std::process::Command::new(env!("CARGO_BIN_EXE_capy"))
        .args(["make:model", "Post"])
        .current_dir(&root)
        .output()
        .unwrap();
    fs::set_permissions(directory, permissions).unwrap();
    assert!(!output.status.success());
    assert!(!String::from_utf8_lossy(&output.stdout).contains("Created"));
    assert_eq!(snapshot(&root), before);
}

#[test]
fn version_comes_from_cargo_metadata() {
    let output = std::process::Command::new(env!("CARGO_BIN_EXE_capy"))
        .arg("--version")
        .output()
        .unwrap();
    assert!(output.status.success());
    assert_eq!(
        String::from_utf8(output.stdout).unwrap(),
        format!("capy {}\n", env!("CARGO_PKG_VERSION"))
    );
}

#[test]
fn controller_output_gives_exact_explicit_routes_and_preserves_every_route_shape() {
    use std::process::Command;
    for source in [
        "use capy::prelude::*;\npub fn routes() -> Routes { Routes::new() }\n",
        "// retain formatting\nuse capy::Routes;\npub fn routes() -> Routes {\n  Routes::new().get(\"/custom\", capy::health)\n}\n",
        "mod nested { pub fn custom() {} } // arbitrary user-owned routing\n",
    ] {
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path().join("sample");
        new_project(&root, "sample").unwrap();
        let routes = root.join("routes/api.rs");
        fs::write(&routes, source).unwrap();
        for name in ["PostController", "PostsController", "BlogPostController"] {
            let output = Command::new(env!("CARGO_BIN_EXE_capy")).args(["make:controller", name]).current_dir(&root).output().unwrap();
            assert!(output.status.success());
            let output = String::from_utf8(output.stdout).unwrap();
            assert!(output.contains("Routing is explicit"));
            assert!(output.contains(&capy_cli::controller_route(name).unwrap()));
            assert_eq!(fs::read_to_string(&routes).unwrap(), source);
            let before = snapshot(&root);
            assert!(!Command::new(env!("CARGO_BIN_EXE_capy")).args(["make:controller", name]).current_dir(&root).output().unwrap().status.success());
            assert_eq!(snapshot(&root), before);
        }
        assert!(capy_cli::controller_route("admin/PostController").is_err());
    }
    assert_eq!(
        capy_cli::controller_route("PostController").unwrap(),
        ".get(\"/post\", crate::app::controllers::post_controller::PostController::index)"
    );
}