use super::*;
#[test]
fn new_name_flag_sets_project_name() {
let dir = temp_dir("new_name_flag");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("explicit-name".into()), false, &dir).unwrap();
let content = fs::read_to_string(output.join("presentacion/api/Cargo.toml")).unwrap();
assert!(content.contains("name = \"explicit-name\""));
cleanup(&dir);
}
#[test]
fn new_db_flag_creates_db_files() {
let dir = temp_dir("new_db_flag");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("db-project".into()), true, &dir).unwrap();
assert!(output.join("docker-compose.yml").exists());
assert!(output.join(".env").exists());
assert!(output.join(".env.example").exists());
assert!(output.join(".cargo/config.toml").exists());
assert!(output.join("migraciones").is_dir());
assert!(output.join("migrador/src/lib.rs").exists());
cleanup(&dir);
}
#[test]
fn new_without_db_flag_has_no_db_files() {
let dir = temp_dir("new_no_db");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("plain-project".into()), false, &dir).unwrap();
assert!(!output.join(".env.example").exists());
assert!(!output.join(".cargo/config.toml").exists());
assert!(!output.join("migrador/src/lib.rs").exists());
cleanup(&dir);
}
#[test]
fn creates_project_structure() {
let dir = temp_dir("cg_structure");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("test-app", &dir).unwrap();
assert!(output.join("Cargo.toml").exists());
assert!(output.join("nucleo/src/lib.rs").exists());
for layer in ["dominio", "aplicacion", "infraestructura", "rest"] {
assert!(
output
.join(format!("contextos/saludo/{layer}/src/lib.rs"))
.exists()
);
assert!(
output
.join(format!("contextos/saludo/{layer}/Cargo.toml"))
.exists()
);
}
assert!(output.join("presentacion/cableado/Cargo.toml").exists());
assert!(output.join("presentacion/api/src/main.rs").exists());
assert!(output.join("presentacion/api/src/lib.rs").exists());
cleanup(&dir);
}
#[test]
fn presentation_cargo_toml_has_project_name() {
let dir = temp_dir("cg_cargo");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("my-puerto-app", &dir).unwrap();
let content = fs::read_to_string(output.join("presentacion/api/Cargo.toml")).unwrap();
assert!(content.contains("name = \"my-puerto-app\""));
cleanup(&dir);
}
#[test]
fn main_rs_is_minimal_entry_point() {
let dir = temp_dir("cg_main");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("cool-project", &dir).unwrap();
let content = fs::read_to_string(output.join("presentacion/api/src/main.rs")).unwrap();
assert!(content.contains("api::generado::bootstrap::construir_app"));
assert!(!content.contains("{{project-name}}"));
let lib = fs::read_to_string(output.join("presentacion/api/src/lib.rs")).unwrap();
assert!(lib.contains("pub mod generado"), "{lib}");
cleanup(&dir);
}
#[test]
fn bootstrap_rs_wires_ddd_layers() {
let dir = temp_dir("cg_bootstrap");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("api-test", &dir).unwrap();
let content = wiring(&output);
assert!(content.contains("ObtenerSaludoImpl"));
assert!(content.contains("RepositorioSaludoEnMemoria"));
assert!(content.contains("ApiSaludo"));
assert!(content.contains("OpenApiService"));
assert!(content.contains("puerto_web::rutas("));
cleanup(&dir);
}
#[test]
fn ddd_layers_exist() {
let dir = temp_dir("cg_ddd");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("ddd-app", &dir).unwrap();
assert!(
output
.join("contextos/saludo/dominio/src/modelo.rs")
.exists()
);
assert!(
output
.join("contextos/saludo/dominio/src/errores.rs")
.exists()
);
assert!(
output
.join("contextos/saludo/dominio/src/repositorio.rs")
.exists()
);
assert!(
output
.join("contextos/saludo/aplicacion/src/obtener_saludo.rs")
.exists()
);
assert!(
output
.join("contextos/saludo/aplicacion/src/obtener_saludo.rs")
.exists()
);
assert!(
output
.join("contextos/saludo/infraestructura/src/repositorio.rs")
.exists()
);
assert!(output.join("contextos/saludo/rest/src/rutas.rs").exists());
assert!(output.join("contextos/saludo/rest/src/dto.rs").exists());
assert!(output.join("contextos/saludo/rest/src/errores.rs").exists());
assert!(
output
.join("contextos/saludo/rest/src/respuestas.rs")
.exists()
);
assert!(output.join("puerto.toml").exists());
assert!(
output
.join("presentacion/api/src/generado/bootstrap.rs")
.exists()
);
assert!(output.join("presentacion/cableado/src/lib.rs").exists());
cleanup(&dir);
}
#[test]
fn puerto_toml_has_project_name_and_greeting_entity() {
let dir = temp_dir("cg_puerto_toml");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("my-app", &dir).unwrap();
let content = fs::read_to_string(output.join("puerto.toml")).unwrap();
assert!(content.contains("nombre = \"my-app\""));
assert!(content.contains("nombre = \"Saludo\""));
assert!(content.contains("obtener_saludo"));
cleanup(&dir);
}
#[test]
#[ignore = "slow: compiles and tests a full generated project"]
fn generated_project_compiles_and_tests_pass() {
let dir = temp_dir("cg_compile");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("compile-test", &dir).unwrap();
super::compile_matrix::patch_runtime_crates(&output);
let result = std::process::Command::new("cargo")
.args(["test", "--workspace"])
.current_dir(&output)
.output()
.expect("failed to run cargo test");
if !result.status.success() {
eprintln!("stdout:\n{}", String::from_utf8_lossy(&result.stdout));
eprintln!("stderr:\n{}", String::from_utf8_lossy(&result.stderr));
panic!("cargo test failed in generated project");
}
cleanup(&dir);
}
pub(super) fn new_project_non_interactive(
name: Option<String>,
db: bool,
destination: &Path,
) -> Result<PathBuf, Box<dyn std::error::Error>> {
let tmp = extract_template()?;
let args = GenerateArgs {
template_path: TemplatePath {
path: Some(tmp.path().to_string_lossy().into_owned()),
..Default::default()
},
name: name.clone(),
destination: Some(destination.to_path_buf()),
vcs: Some(Vcs::None),
no_workspace: true,
..Default::default()
};
let output = generate(args)?;
drop(tmp);
if db {
scaffold::apply_db_to_new_project(&output)?;
}
Ok(output)
}
fn generate_db_project(
name: &str,
destination: &Path,
) -> Result<PathBuf, Box<dyn std::error::Error>> {
let output = generate_project(name, destination)?;
scaffold::apply_db_to_new_project(&output)?;
Ok(output)
}
#[test]
fn db_project_has_env_example() {
let dir = temp_dir("db_env");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let content = fs::read_to_string(output.join(".env.example")).unwrap();
assert!(content.contains("DATABASE_URL"));
assert!(content.contains("db_app"));
cleanup(&dir);
}
#[test]
fn db_project_has_env_file_with_project_db_name() {
let dir = temp_dir("db_env_file");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("my-api", &dir).unwrap();
let content = fs::read_to_string(output.join(".env")).unwrap();
assert!(content.contains("DATABASE_URL"));
assert!(content.contains("my_api"));
cleanup(&dir);
}
#[test]
fn db_project_has_docker_compose_with_project_name() {
let dir = temp_dir("db_docker_compose");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("my-api", &dir).unwrap();
let content = fs::read_to_string(output.join("docker-compose.yml")).unwrap();
assert!(content.contains("postgres:16"));
assert!(content.contains("my-api-postgres"));
assert!(content.contains("my_api"));
assert!(content.contains("5432"));
cleanup(&dir);
}
#[test]
fn db_project_has_gitignore_with_env() {
let dir = temp_dir("db_gitignore");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let gitignore_path = output.join(".gitignore");
if gitignore_path.exists() {
let content = fs::read_to_string(&gitignore_path).unwrap();
assert!(content.contains(".env"));
}
cleanup(&dir);
}
#[test]
fn db_project_makefile_has_docker_and_sqlx_targets() {
let dir = temp_dir("db_makefile_targets");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let content = fs::read_to_string(output.join("Makefile")).unwrap();
assert!(content.contains("docker-compose/up"));
assert!(content.contains("docker-compose/down"));
assert!(content.contains("sqlx/migrate"));
assert!(content.contains("sqlx/prepare"));
assert!(content.contains("sqlx/check"));
assert!(content.contains("sqlx/online"));
assert!(content.contains("sqlx/offline"));
assert!(content.contains("db/reiniciar"));
assert!(content.contains("test/infraestructura"));
cleanup(&dir);
}
fn make(output: &Path, args: &[&str]) -> (bool, String) {
let result = std::process::Command::new("make")
.args(args)
.current_dir(output)
.output()
.expect("make not found");
let text = format!(
"{}{}",
String::from_utf8_lossy(&result.stdout),
String::from_utf8_lossy(&result.stderr)
);
(result.status.success(), text)
}
#[test]
fn should_define_each_db_make_target_once_when_the_project_has_a_database() {
let dir = temp_dir("db_makefile_once");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-make", &dir).unwrap();
let (ok, text) = make(&output, &["-n", "help"]);
assert!(ok, "{text}");
assert!(!text.contains("overriding recipe"), "{text}");
cleanup(&dir);
}
#[test]
fn should_start_postgres_and_wait_for_it_when_running_a_db_project() {
let dir = temp_dir("db_makefile_wait");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-wait", &dir).unwrap();
for target in ["sqlx/migrate", "run", "test/infraestructura"] {
let (ok, text) = make(&output, &["-n", target]);
assert!(ok, "{text}");
assert!(
text.contains("docker compose up -d --wait"),
"`make {target}` does not wait for the database:\n{text}"
);
}
cleanup(&dir);
}
#[test]
fn should_print_colors_not_escape_codes_when_make_echoes() {
let dir = temp_dir("makefile_colors");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("colors", &dir).unwrap();
let (ok, text) = make(&output, &["help"]);
assert!(ok, "{text}");
assert!(!text.contains("\\033"), "{text}");
cleanup(&dir);
}
#[test]
fn should_ask_for_web_install_when_the_frontend_dependencies_are_missing() {
let dir = temp_dir("web_not_installed");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("web-missing", &dir).unwrap();
for target in ["web/lint", "web/test", "web/dev"] {
let (ok, text) = make(&output, &[target]);
assert!(!ok, "`make {target}` should fail without node_modules");
assert!(
text.contains("make web/install"),
"`make {target}` does not say how to fix it:\n{text}"
);
}
cleanup(&dir);
}
#[test]
fn db_project_has_cargo_config_with_sqlx_offline() {
let dir = temp_dir("db_cargo_config");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let content = fs::read_to_string(output.join(".cargo/config.toml")).unwrap();
assert!(content.contains("SQLX_OFFLINE"));
cleanup(&dir);
}
#[test]
fn db_project_has_migrations_dir() {
let dir = temp_dir("db_migrations");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
assert!(output.join("migraciones").is_dir());
cleanup(&dir);
}
#[test]
fn db_project_has_the_migrador_crate() {
let dir = temp_dir("db_db_rs");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let content = fs::read_to_string(output.join("migrador/src/lib.rs")).unwrap();
assert!(content.contains("pub static MIGRADOR"));
assert!(output.join("migrador/build.rs").exists());
cleanup(&dir);
}
#[test]
fn should_declare_the_migrador_when_a_db_project_is_created() {
let dir = temp_dir("db_mod_declared");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let root = fs::read_to_string(output.join("Cargo.toml")).unwrap();
assert!(
root.contains("members = [\"nucleo\", \"migrador\", "),
"{root}"
);
assert_eq!(
root.matches("migrador = { path = \"migrador\" }").count(),
1,
"{root}"
);
cleanup(&dir);
}
#[test]
fn db_project_infrastructure_cargo_has_sqlx() {
let dir = temp_dir("db_infra_cargo");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let content = fs::read_to_string(output.join("Cargo.toml")).unwrap();
assert!(content.contains("sqlx = { version = \"0.8\""), "{content}");
assert!(content.contains("postgres"));
let migrador = fs::read_to_string(output.join("migrador/Cargo.toml")).unwrap();
assert!(
migrador.contains("sqlx = { workspace = true }"),
"{migrador}"
);
cleanup(&dir);
}
#[test]
fn db_project_puerto_toml_has_project_db_true() {
let dir = temp_dir("db_proj_toml");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_db_project("db-app", &dir).unwrap();
let config = puerto_toml::read(&output).unwrap();
assert!(
config.project.db,
"project.db should be true for --db projects"
);
cleanup(&dir);
}
#[test]
fn no_db_project_puerto_toml_omits_project_db() {
let dir = temp_dir("no_db_proj_toml");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("plain-app", &dir).unwrap();
let config = puerto_toml::read(&output).unwrap();
assert!(
!config.project.db,
"project.db should be false for non-db projects"
);
let content = fs::read_to_string(output.join("puerto.toml")).unwrap();
assert!(
!content.contains("db = true"),
"puerto.toml should not contain db = true for non-db projects"
);
cleanup(&dir);
}
#[test]
fn no_demo_has_no_greeting_files() {
let dir = temp_dir("no_demo_files");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("no-demo-app".into()), false, &dir).unwrap();
scaffold::apply_no_demo(&output).unwrap();
assert!(!output.join("contextos/saludo").exists());
cleanup(&dir);
}
#[test]
fn no_demo_puerto_toml_has_no_entity_block() {
let dir = temp_dir("no_demo_toml");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("no-demo-app".into()), false, &dir).unwrap();
scaffold::apply_no_demo(&output).unwrap();
let content = fs::read_to_string(output.join("puerto.toml")).unwrap();
assert!(
!content.contains("[[entidad]]"),
"puerto.toml should have no entity blocks"
);
assert!(
!content.contains("Saludo"),
"puerto.toml should not mention Saludo"
);
assert!(
content.starts_with("[proyecto]"),
"puerto.toml should open with [proyecto], without an empty `entidad = []` above it:\n{content}"
);
cleanup(&dir);
}
#[test]
fn no_demo_lib_files_have_no_greeting_modules() {
let dir = temp_dir("no_demo_lib");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("no-demo-app".into()), false, &dir).unwrap();
scaffold::apply_no_demo(&output).unwrap();
for manifest in [
"Cargo.toml",
"presentacion/api/Cargo.toml",
"presentacion/cableado/Cargo.toml",
] {
let content = fs::read_to_string(output.join(manifest)).unwrap();
assert!(
!content.contains("_saludo"),
"{manifest} should not name a saludo crate:\n{content}"
);
}
cleanup(&dir);
}
#[test]
fn no_demo_bootstrap_has_no_saludo() {
let dir = temp_dir("no_demo_bootstrap");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("no-demo-app".into()), false, &dir).unwrap();
scaffold::apply_no_demo(&output).unwrap();
let content = wiring(&output);
assert!(
!content.contains("Saludo"),
"bootstrap.rs should have no Saludo reference"
);
assert!(
!content.contains("saludo"),
"bootstrap.rs should have no saludo reference"
);
cleanup(&dir);
}
#[test]
fn default_project_still_has_greeting_files() {
let dir = temp_dir("con_demo");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("demo-app".into()), false, &dir).unwrap();
assert!(
output
.join("contextos/saludo/dominio/src/modelo.rs")
.exists()
);
assert!(output.join("contextos/saludo/rest/src/rutas.rs").exists());
cleanup(&dir);
}
#[test]
fn no_demo_then_scaffold_generates_new_entity() {
let dir = temp_dir("no_demo_then_scaffold");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = new_project_non_interactive(Some("no-demo-app".into()), false, &dir).unwrap();
scaffold::apply_no_demo(&output).unwrap();
scaffold::run_scaffold("Player", &output, &[], OverwritePolicy::Ask).unwrap();
assert!(
output
.join("contextos/player/dominio/src/modelo.rs")
.exists()
);
assert!(output.join("contextos/player/rest/src/rutas.rs").exists());
assert!(!output.join("contextos/saludo").exists());
cleanup(&dir);
}
#[test]
fn new_project_includes_the_web_frontend_by_default() {
let dir = temp_dir("new_web_default");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = crate::commands::new::new_project(
Some("web-app".into()),
crate::commands::new::NewOptions {
no_db: true,
..Default::default()
},
Some(dir.clone()),
)
.unwrap();
for file in [
"web/package.json",
"web/bunfig.toml",
"web/.dependency-cruiser.cjs",
"web/src/main.tsx",
"web/src/api/http.ts",
"web/src/generado/dependencias.ts",
"web/src/generado/rutas.tsx",
"web/AGENTS.md",
] {
assert!(output.join(file).exists(), "missing {file}");
}
assert!(puerto_toml::read(&output).unwrap().project.web);
let agents = fs::read_to_string(output.join("AGENTS.md")).unwrap();
assert!(agents.contains("web/AGENTS.md"), "{agents}");
cleanup(&dir);
}
#[test]
fn new_project_with_no_web_has_no_frontend_and_does_not_mention_one() {
let dir = temp_dir("new_no_web");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = crate::commands::new::new_project(
Some("api-only".into()),
crate::commands::new::NewOptions {
no_db: true,
no_web: true,
..Default::default()
},
Some(dir.clone()),
)
.unwrap();
assert!(!output.join("web").exists());
assert!(!puerto_toml::read(&output).unwrap().project.web);
let manifest = fs::read_to_string(output.join("puerto.toml")).unwrap();
assert!(!manifest.contains("web ="), "{manifest}");
let agents = fs::read_to_string(output.join("AGENTS.md")).unwrap();
assert!(!agents.contains("web/"), "{agents}");
assert!(agents.contains("## Convenciones"), "{agents}");
cleanup(&dir);
}
#[test]
fn web_index_html_is_titled_after_the_project() {
let dir = temp_dir("web_title");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("shop-front", &dir).unwrap();
let index = fs::read_to_string(output.join("web/index.html")).unwrap();
assert!(index.contains("<title>shop-front</title>"), "{index}");
cleanup(&dir);
}
#[test]
fn web_package_pins_exact_versions_and_runs_on_bun() {
let dir = temp_dir("web_pins");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("web-pins", &dir).unwrap();
let package = fs::read_to_string(output.join("web/package.json")).unwrap();
let json: serde_json::Value = serde_json::from_str(&package).unwrap();
assert!(json["packageManager"].as_str().unwrap().starts_with("bun@"));
for section in ["dependencies", "devDependencies"] {
for (name, version) in json[section].as_object().unwrap() {
let version = version.as_str().unwrap();
assert!(
version.chars().next().unwrap().is_ascii_digit(),
"{name} is not pinned: {version}"
);
}
}
cleanup(&dir);
}
#[test]
fn template_never_embeds_installed_web_dependencies() {
for path in ["web/node_modules", "web/dist"] {
assert!(
crate::TEMPLATE_DIR.get_dir(path).is_none(),
"{path} is embedded in the template"
);
}
}
#[test]
fn makefile_runs_the_frontend_checks_when_web_exists() {
let dir = temp_dir("web_makefile");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = generate_project("web-make", &dir).unwrap();
let makefile = fs::read_to_string(output.join("Makefile")).unwrap();
for target in ["web/install:", "web/dev:", "web/test:", "web/lint:"] {
assert!(makefile.contains(target), "Makefile misses {target}");
}
for recipe in ["$(MAKE) web/test", "$(MAKE) web/lint"] {
assert!(makefile.contains(recipe), "Makefile misses {recipe}");
}
cleanup(&dir);
}
#[test]
fn web_only_agent_rules_stay_in_a_web_project_without_their_markers() {
let dir = temp_dir("agents_web_blocks");
cleanup(&dir);
fs::create_dir_all(&dir).unwrap();
let output = crate::commands::new::new_project(
Some("with-web".into()),
crate::commands::new::NewOptions {
no_db: true,
..Default::default()
},
Some(dir.clone()),
)
.unwrap();
let agents = fs::read_to_string(output.join("AGENTS.md")).unwrap();
assert!(!agents.contains("<!--"), "{agents}");
assert!(agents.contains("puerto generar web <Nombre>"), "{agents}");
assert!(agents.contains("make web/sync"), "{agents}");
cleanup(&dir);
}