slave 0.2.0

//! End-to-end tests that drive the compiled `slave` binary.

use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Output};
use std::sync::atomic::{AtomicUsize, Ordering};

/// A scratch directory removed when the test finishes.
struct TempDir(PathBuf);

impl TempDir {
    fn new() -> Self {
        static COUNTER: AtomicUsize = AtomicUsize::new(0);
        let n = COUNTER.fetch_add(1, Ordering::Relaxed);
        let dir = std::env::temp_dir().join(format!("slave-test-{}-{n}", std::process::id()));
        let _ = fs::remove_dir_all(&dir);
        fs::create_dir_all(&dir).expect("create temp dir");
        Self(dir)
    }

    /// Creates an application named `app` and returns its path.
    fn new_app(&self) -> PathBuf {
        let out = slave(
            &self.0,
            &["new", "app", "--framework-path", &framework_path()],
        );
        assert!(out.status.success(), "{}", stderr(&out));
        self.0.join("app")
    }
}

impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.0);
    }
}

fn framework_path() -> String {
    format!("{}/framework", env!("CARGO_MANIFEST_DIR"))
}

fn slave(dir: &Path, args: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_slave"))
        .args(args)
        .current_dir(dir)
        .output()
        .expect("run slave")
}

fn stderr(output: &Output) -> String {
    String::from_utf8_lossy(&output.stderr).into_owned()
}

fn read(path: impl AsRef<Path>) -> String {
    fs::read_to_string(path.as_ref())
        .unwrap_or_else(|err| panic!("read {}: {err}", path.as_ref().display()))
}

/// Files every new application starts with.
const SKELETON: &[&str] = &[
    "Cargo.toml",
    ".env.example",
    ".env",
    "src/main.rs",
    "src/app.rs",
    "src/base/mod.rs",
    "src/base/auth.rs",
    "src/base/config.rs",
    "src/base/error.rs",
    "src/base/state.rs",
    "src/modules/mod.rs",
    "src/modules/user/mod.rs",
    "src/modules/user/routes.rs",
    "src/modules/user/models/user.rs",
    "src/modules/user/repositories/user_repository.rs",
    "src/modules/user/services/user_service.rs",
    "src/modules/user/controllers/user_controller.rs",
    "src/modules/user/dto/user.rs",
    "src/modules/role/mod.rs",
    "src/modules/role/routes.rs",
    "src/modules/role/models/role.rs",
    "src/modules/role/repositories/role_repository.rs",
    "src/modules/role/services/role_service.rs",
    "src/modules/role/controllers/role_controller.rs",
    "src/modules/role/dto/role.rs",
    "src/modules/auth/mod.rs",
    "src/modules/auth/routes.rs",
    "src/modules/auth/repositories/token_repository.rs",
    "src/modules/auth/services/auth_service.rs",
    "src/modules/auth/controllers/auth_controller.rs",
    "src/modules/auth/dto/auth.rs",
    "src/bin/migrate.rs",
    "database/migrations/mod.rs",
    "tests/http.rs",
];

/// Migrations every new application starts with, in run order.
const INITIAL_MIGRATIONS: &[&str] = &[
    "create_users_table",
    "create_roles_tables",
    "create_auth_tokens_table",
];

#[test]
fn new_creates_core_application() {
    let tmp = TempDir::new();
    let app = tmp.new_app();

    for file in SKELETON {
        assert!(app.join(file).is_file(), "missing {file}");
    }
    let manifest = read(app.join("Cargo.toml"));
    assert!(manifest.contains("name = \"app\""));
    assert!(manifest.contains("[package.metadata.slave]"));
    assert!(manifest.contains("slave-framework = { path = "));
    assert!(manifest.contains("default-run = \"app\""));

    let modules = read(app.join("src/modules/mod.rs"));
    for module in ["auth", "role", "user"] {
        assert!(modules.contains(&format!("pub mod {module};")), "{modules}");
        assert!(
            modules.contains(&format!("{module}::routes(),")),
            "{modules}"
        );
    }
    assert!(read(app.join(".env")).contains("DATABASE_PATH="));
}

#[test]
fn new_defaults_to_crates_io_framework() {
    let tmp = TempDir::new();
    assert!(slave(&tmp.0, &["new", "app"]).status.success());
    assert!(read(tmp.0.join("app/Cargo.toml")).contains("slave-framework = \"0.1\""));
}

#[test]
fn new_refuses_existing_directory_and_bad_input() {
    let tmp = TempDir::new();
    fs::create_dir(tmp.0.join("taken")).unwrap();
    assert!(!slave(&tmp.0, &["new", "taken"]).status.success());
    assert!(!slave(&tmp.0, &["new", "../escape"]).status.success());
    assert!(!slave(&tmp.0, &["new", "has space"]).status.success());
    let out = slave(&tmp.0, &["new", "x", "--framework-path", "/nonexistent"]);
    assert!(!out.status.success());
    assert!(!tmp.0.join("x").exists());
}

#[test]
fn make_model_creates_domain_with_default_module() {
    let tmp = TempDir::new();
    let app = tmp.new_app();

    let out = slave(&app, &["make:model", "BlogPost"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let domain = app.join("src/modules/blog_post");
    assert!(read(domain.join("models/blog_post.rs")).contains("pub struct BlogPost"));
    assert!(read(domain.join("models/mod.rs")).contains("pub mod blog_post;"));
    assert!(read(domain.join("mod.rs")).contains("mod models;"));
    assert!(read(app.join("src/modules/mod.rs")).contains("pub mod blog_post;"));
}

#[test]
fn make_model_supports_several_models_per_module() {
    let tmp = TempDir::new();
    let app = tmp.new_app();

    let out = slave(&app, &["make:model", "Profile", "--module", "user"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let models = read(app.join("src/modules/user/models/mod.rs"));
    assert_eq!(models, "pub mod profile;\npub mod user;\n");
    assert!(app.join("src/modules/user/models/profile.rs").is_file());
    assert_eq!(
        read(app.join("src/modules/user/mod.rs"))
            .matches("mod models;")
            .count(),
        1
    );
}

#[test]
fn make_controller_creates_and_registers_routes() {
    let tmp = TempDir::new();
    let app = tmp.new_app();

    assert!(slave(&app, &["make:model", "Post"]).status.success());
    let out = slave(&app.join("src"), &["make:controller", "PostController"]);
    assert!(out.status.success(), "{}", stderr(&out));

    let domain = read(app.join("src/modules/post/mod.rs"));
    for line in [
        "mod controllers;",
        "mod models;",
        "mod routes;",
        "pub use routes::routes;",
    ] {
        assert!(domain.contains(line), "missing `{line}` in:\n{domain}");
    }
    assert!(
        app.join("src/modules/post/controllers/post_controller.rs")
            .is_file()
    );
    let routes = read(app.join("src/modules/post/routes.rs"));
    assert!(
        routes.contains("use super::controllers::post_controller;"),
        "{routes}"
    );
    assert!(routes.contains("\"/post\""), "{routes}");

    let modules = read(app.join("src/modules/mod.rs"));
    assert_eq!(modules.matches("pub mod post;").count(), 1, "{modules}");
    assert_eq!(modules.matches("post::routes(),").count(), 1, "{modules}");
}

#[test]
fn make_accepts_explicit_module() {
    let tmp = TempDir::new();
    let app = tmp.new_app();

    let args = [
        "make:controller",
        "AdminController",
        "--module",
        "admin_panel",
    ];
    let out = slave(&app, &args);
    assert!(out.status.success(), "{}", stderr(&out));
    let domain = app.join("src/modules/admin_panel");
    assert!(domain.join("controllers/admin_controller.rs").is_file());
    assert!(read(domain.join("routes.rs")).contains("\"/admin-panel\""));
}

#[test]
fn make_refuses_to_overwrite_without_force() {
    let tmp = TempDir::new();
    let app = tmp.new_app();
    let model = app.join("src/modules/user/models/user.rs");
    let original = read(&model);
    let modules_before = read(app.join("src/modules/mod.rs"));

    let out = slave(&app, &["make:model", "User"]);
    assert!(!out.status.success());
    assert!(stderr(&out).contains("already exists"));
    assert_eq!(read(&model), original);
    assert_eq!(read(app.join("src/modules/mod.rs")), modules_before);

    let out = slave(&app, &["make:model", "User", "--force"]);
    assert!(out.status.success(), "{}", stderr(&out));
    assert_ne!(read(&model), original);
    let models = read(app.join("src/modules/user/models/mod.rs"));
    assert_eq!(models.matches("pub mod user;").count(), 1);
}

#[test]
fn make_requires_a_project() {
    let tmp = TempDir::new();
    let out = slave(&tmp.0, &["make:model", "User"]);
    assert!(!out.status.success());
    assert!(stderr(&out).contains("not inside a slave application"));
}

#[test]
fn make_rejects_invalid_names() {
    let tmp = TempDir::new();
    let app = tmp.new_app();
    for args in [
        &["make:model", "user"][..],
        &["make:model", "User-Model"],
        &["make:model", "../User"],
        &["make:model", "Type"],
        &["make:controller", "Controller"],
        &["make:model", "Post", "--module", "Post"],
        &["make:model", "Post", "--module", "../post"],
    ] {
        assert!(!slave(&app, args).status.success(), "{args:?}");
    }
}

/// Returns migration file names in `database/migrations`, sorted.
fn migration_files(app: &Path) -> Vec<String> {
    let mut files: Vec<String> = fs::read_dir(app.join("database/migrations"))
        .unwrap()
        .map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned())
        .filter(|name| name != "mod.rs")
        .collect();
    files.sort();
    files
}

/// Migration names (file names without timestamp and extension), in file order.
fn migration_names(files: &[String]) -> Vec<&str> {
    files.iter().map(|f| &f[15..f.len() - 3]).collect()
}

#[test]
fn new_includes_core_migrations_in_order() {
    let tmp = TempDir::new();
    let app = tmp.new_app();
    let files = migration_files(&app);
    assert_eq!(migration_names(&files), INITIAL_MIGRATIONS);

    let registry = read(app.join("database/migrations/mod.rs"));
    for file in &files {
        assert!(
            registry.contains(&format!("#[path = \"{file}\"]")),
            "{registry}"
        );
    }
}

#[test]
fn make_migration_creates_and_registers_in_order() {
    let tmp = TempDir::new();
    let app = tmp.new_app();

    // Created within the same second as `slave new`: order must still follow creation.
    let added = [
        "create_posts_table",
        "add_phone_to_users",
        "add_index_to_posts",
    ];
    for name in added {
        let out = slave(&app, &["make:migration", name]);
        assert!(out.status.success(), "{}", stderr(&out));
    }

    let files = migration_files(&app);
    let expected: Vec<&str> = INITIAL_MIGRATIONS.iter().copied().chain(added).collect();
    assert_eq!(migration_names(&files), expected);

    let registry = read(app.join("database/migrations/mod.rs"));
    let mut last = 0;
    for file in &files {
        let module = format!("        m{},", &file[..file.len() - 3]);
        let at = registry
            .find(&module)
            .unwrap_or_else(|| panic!("{module} in {registry}"));
        assert!(at > last, "registry out of order:\n{registry}");
        last = at;
    }

    let dir = app.join("database/migrations");
    let posts = read(dir.join(&files[3]));
    assert!(posts.contains("pub struct CreatePostsTable;"));
    assert!(posts.contains("CREATE TABLE posts"));
    assert!(posts.contains("DROP TABLE posts"));
    let blank = read(dir.join(&files[4]));
    assert!(blank.contains("pub struct AddPhoneToUsers;"));
    assert!(
        blank.contains("None"),
        "blank migrations start irreversible"
    );
}

#[test]
fn make_migration_rejects_duplicates_and_bad_names() {
    let tmp = TempDir::new();
    let app = tmp.new_app();
    let out = slave(&app, &["make:migration", "create_users_table"]);
    assert!(!out.status.success());
    assert!(stderr(&out).contains("already exists"), "{}", stderr(&out));

    for name in ["CreatePosts", "create-posts", "1_init", "migration", ""] {
        let out = slave(&app, &["make:migration", name]);
        assert!(!out.status.success(), "{name}");
    }
    assert_eq!(migration_files(&app).len(), INITIAL_MIGRATIONS.len());
}

#[test]
fn migrate_commands_require_a_project() {
    let tmp = TempDir::new();
    for command in [
        "migrate",
        "migrate:status",
        "migrate:rollback",
        "make:migration",
    ] {
        let mut args = vec![command];
        if command == "make:migration" {
            args.push("create_users_table");
        }
        let out = slave(&tmp.0, &args);
        assert!(!out.status.success(), "{command}");
        assert!(
            stderr(&out).contains("not inside a slave application"),
            "{command}"
        );
    }
}

/// Generates an application, then checks formatting, runs its own HTTP test
/// suite, and drives `slave migrate*` against it. Slow (full dependency
/// build), so run with `cargo test -- --ignored`.
#[test]
#[ignore]
fn generated_application_builds_migrates_and_passes_its_tests() {
    let tmp = TempDir::new();
    let app = tmp.new_app();
    for args in [
        &["make:model", "Post"][..],
        &["make:controller", "PostController"],
        &["make:migration", "create_posts_table"],
    ] {
        let out = slave(&app, args);
        assert!(out.status.success(), "{args:?}: {}", stderr(&out));
    }

    let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target/generated-app");
    let run = |program: &str, args: &[&str]| {
        let out = Command::new(program)
            .args(args)
            .env("CARGO_TARGET_DIR", &target)
            .current_dir(&app)
            .output()
            .expect("run command");
        let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
        assert!(
            out.status.success(),
            "{program} {args:?}\n{stdout}\n{}",
            stderr(&out)
        );
        stdout
    };
    let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
    run(&cargo, &["fmt", "--check"]);
    run(&cargo, &["test", "--quiet"]);

    let slave_bin = env!("CARGO_BIN_EXE_slave");
    let total = INITIAL_MIGRATIONS.len() + 1;
    let migrated = run(slave_bin, &["migrate"]);
    assert!(
        migrated.contains(&format!("Batch 1: {total} applied")),
        "{migrated}"
    );
    let again = run(slave_bin, &["migrate"]);
    assert!(
        again.contains(&format!("Nothing to migrate ({total} already applied)")),
        "{again}"
    );
    let status = run(slave_bin, &["migrate:status"]);
    assert_eq!(status.matches("Ran ").count(), total, "{status}");
    let rolled_back = run(slave_bin, &["migrate:rollback"]);
    assert!(
        rolled_back.contains("Rolling back batch 1"),
        "{rolled_back}"
    );
    let status = run(slave_bin, &["migrate:status"]);
    assert_eq!(status.matches("Pending").count(), total, "{status}");
}