Brummel
4da47cb919
The cargo-new mirror completed: a scaffold landing inside a tracked tree no longer nests a .git (the gitlink/submodule hazard that bit the fieldtest corpus); outside a work tree the best-effort init is unchanged. Oracle: git rev-parse --is-inside-work-tree in the target dir; any failure reads as not-in-a-work-tree so the init stays best-effort. RED-first (tdd-author handoff): the inside-a-work-tree pin observed failing on the nested .git; the outside guard pinned against over-removal. Gates: workspace 1003/0, clippy -D warnings clean. closes #204
228 lines
8.0 KiB
Rust
228 lines
8.0 KiB
Rust
//! E2E: the `aura new` scaffolder (cycle 0103). Proves the full authoring
|
|
//! loop — scaffold → cargo build → aura run — with zero hand-editing, plus
|
|
//! the refusal contract. Scaffolded projects live in per-test temp dirs;
|
|
//! their path-deps resolve into this checkout (the baked engine root).
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Command, Output};
|
|
|
|
fn aura(args: &[&str], cwd: &Path) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_aura"))
|
|
.args(args)
|
|
.current_dir(cwd)
|
|
.output()
|
|
.expect("run aura")
|
|
}
|
|
|
|
fn tmp(tag: &str) -> PathBuf {
|
|
let d = std::env::temp_dir().join(format!("aura-new-{tag}-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&d);
|
|
std::fs::create_dir_all(&d).unwrap();
|
|
d
|
|
}
|
|
|
|
#[test]
|
|
fn new_scaffold_builds_and_runs_the_authoring_loop() {
|
|
let base = tmp("loop");
|
|
let out = aura(&["new", "demo-lab"], &base);
|
|
assert!(
|
|
out.status.success(),
|
|
"aura new failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
let proj = base.join("demo-lab");
|
|
for f in [
|
|
"Cargo.toml",
|
|
"Aura.toml",
|
|
".gitignore",
|
|
"src/lib.rs",
|
|
"blueprints/signal.json",
|
|
"CLAUDE.md",
|
|
] {
|
|
assert!(proj.join(f).is_file(), "missing scaffolded file {f}");
|
|
}
|
|
let build = Command::new("cargo")
|
|
.arg("build")
|
|
.current_dir(&proj)
|
|
.output()
|
|
.expect("cargo build scaffolded project");
|
|
assert!(
|
|
build.status.success(),
|
|
"scaffolded build failed:\n{}",
|
|
String::from_utf8_lossy(&build.stderr)
|
|
);
|
|
let a = aura(&["run", "blueprints/signal.json"], &proj);
|
|
assert!(
|
|
a.status.success(),
|
|
"run failed: {}",
|
|
String::from_utf8_lossy(&a.stderr)
|
|
);
|
|
let b = aura(&["run", "blueprints/signal.json"], &proj);
|
|
assert_eq!(a.stdout, b.stdout, "two runs must be byte-identical (C1)");
|
|
let v: serde_json::Value = serde_json::from_slice(&a.stdout).expect("report is JSON");
|
|
assert_eq!(v["manifest"]["project"]["namespace"], "demo_lab");
|
|
let introspect = aura(&["graph", "introspect", "--vocabulary"], &proj);
|
|
assert!(introspect.status.success());
|
|
let text = String::from_utf8_lossy(&introspect.stdout);
|
|
assert!(text.contains("demo_lab::Identity"), "project id listed");
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
#[test]
|
|
fn new_refuses_an_existing_destination() {
|
|
let base = tmp("exists");
|
|
std::fs::create_dir_all(base.join("taken")).unwrap();
|
|
let out = aura(&["new", "taken"], &base);
|
|
assert_eq!(out.status.code(), Some(1), "runtime refusal");
|
|
let err = String::from_utf8_lossy(&out.stderr);
|
|
assert!(err.contains("already exists"), "stderr: {err}");
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
#[test]
|
|
fn new_rejects_invalid_names_as_usage_faults() {
|
|
let base = tmp("badname");
|
|
for bad in ["bad/name", "9lives"] {
|
|
let out = aura(&["new", bad], &base);
|
|
assert_eq!(out.status.code(), Some(2), "usage fault for {bad}");
|
|
let err = String::from_utf8_lossy(&out.stderr);
|
|
assert!(err.contains("invalid project name"), "stderr: {err}");
|
|
}
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
#[test]
|
|
fn new_refuses_a_missing_engine_path_with_hint() {
|
|
let base = tmp("noengine");
|
|
let out = aura(&["new", "x", "--engine-path", "/nonexistent-engine"], &base);
|
|
assert_eq!(out.status.code(), Some(1), "runtime refusal");
|
|
let err = String::from_utf8_lossy(&out.stderr);
|
|
assert!(err.contains("--engine-path"), "stderr: {err}");
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
/// Property: an explicit `--namespace` override actually reaches the
|
|
/// runtime vocabulary (not just the `ScaffoldSpec` struct field checked at
|
|
/// the unit layer) — a scaffolded, built, run project registers its node
|
|
/// under the caller-chosen namespace, and the manifest records it too.
|
|
#[test]
|
|
fn new_namespace_override_reaches_the_built_vocabulary() {
|
|
let base = tmp("customns");
|
|
let out = aura(&["new", "demo-lab", "--namespace", "custom_ns"], &base);
|
|
assert!(
|
|
out.status.success(),
|
|
"aura new failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
let proj = base.join("demo-lab");
|
|
let build = Command::new("cargo")
|
|
.arg("build")
|
|
.current_dir(&proj)
|
|
.output()
|
|
.expect("cargo build scaffolded project");
|
|
assert!(
|
|
build.status.success(),
|
|
"scaffolded build failed:\n{}",
|
|
String::from_utf8_lossy(&build.stderr)
|
|
);
|
|
let run = aura(&["run", "blueprints/signal.json"], &proj);
|
|
assert!(
|
|
run.status.success(),
|
|
"run failed: {}",
|
|
String::from_utf8_lossy(&run.stderr)
|
|
);
|
|
let v: serde_json::Value = serde_json::from_slice(&run.stdout).expect("report is JSON");
|
|
assert_eq!(v["manifest"]["project"]["namespace"], "custom_ns");
|
|
let introspect = aura(&["graph", "introspect", "--vocabulary"], &proj);
|
|
assert!(introspect.status.success());
|
|
let text = String::from_utf8_lossy(&introspect.stdout);
|
|
assert!(text.contains("custom_ns::Identity"), "overridden namespace listed: {text}");
|
|
assert!(!text.contains("demo_lab::Identity"), "default-derived namespace must not leak");
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
/// Property: `aura new` mirrors `cargo new` — when the target directory is
|
|
/// already inside a git work tree, the scaffolder does NOT initialize a
|
|
/// nested repo. A nested `.git` under a tracked tree is a gitlink/submodule
|
|
/// hazard (it bit the 0107 fieldtest corpus); the enclosing repo owns the
|
|
/// scaffold's history.
|
|
#[test]
|
|
fn new_inside_a_work_tree_skips_the_nested_git() {
|
|
let base = tmp("insidegit");
|
|
let init = Command::new("git")
|
|
.arg("init")
|
|
.current_dir(&base)
|
|
.output()
|
|
.expect("git init the enclosing work tree");
|
|
assert!(
|
|
init.status.success(),
|
|
"git init base failed: {}",
|
|
String::from_utf8_lossy(&init.stderr)
|
|
);
|
|
|
|
let out = aura(&["new", "demo-lab"], &base);
|
|
assert!(
|
|
out.status.success(),
|
|
"aura new failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
let proj = base.join("demo-lab");
|
|
// The full scaffold still lands unchanged...
|
|
for f in [
|
|
"Cargo.toml",
|
|
"Aura.toml",
|
|
".gitignore",
|
|
"src/lib.rs",
|
|
"blueprints/signal.json",
|
|
"CLAUDE.md",
|
|
] {
|
|
assert!(proj.join(f).is_file(), "missing scaffolded file {f}");
|
|
}
|
|
// ...but without a nested repo of its own.
|
|
assert!(
|
|
!proj.join(".git").exists(),
|
|
"scaffold nested a .git inside an existing work tree (gitlink hazard)"
|
|
);
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
/// Guard against over-removal of the git-init: OUTSIDE any work tree the
|
|
/// scaffold still initializes its own repo. `std::env::temp_dir()` is not
|
|
/// inside a git work tree (the e2e helpers here already rely on that), so the
|
|
/// scaffold's parent is genuinely detached from this checkout's tree.
|
|
#[test]
|
|
fn new_outside_a_work_tree_initializes_git() {
|
|
let base = tmp("outsidegit");
|
|
let out = aura(&["new", "demo-lab"], &base);
|
|
assert!(
|
|
out.status.success(),
|
|
"aura new failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
let proj = base.join("demo-lab");
|
|
assert!(
|
|
proj.join(".git").is_dir(),
|
|
"scaffold outside a work tree must initialize its own repo"
|
|
);
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|
|
|
|
#[test]
|
|
fn new_works_inside_an_unbuilt_project_tree() {
|
|
// Scaffold once (unbuilt), then scaffold AGAIN from inside that tree:
|
|
// the load-bypass guard must keep aura new from trying to load the
|
|
// enclosing project's (absent) dylib.
|
|
let base = tmp("nested");
|
|
let out = aura(&["new", "outer"], &base);
|
|
assert!(out.status.success());
|
|
let inner_cwd = base.join("outer");
|
|
let out = aura(&["new", "inner"], &inner_cwd);
|
|
assert!(
|
|
out.status.success(),
|
|
"aura new inside an unbuilt project tree must succeed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
assert!(inner_cwd.join("inner/Cargo.toml").is_file());
|
|
let _ = std::fs::remove_dir_all(&base);
|
|
}
|