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(®istry, "// 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)"
);
}