appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use serde_json::Value;
use std::{
    fs,
    path::{Path, PathBuf},
    process::{Command, Output},
};

#[test]
fn project_commands_emit_success_envelopes() {
    let project = copied_fixture("m2-project");

    let generated = run(project.path(), &["generate", "--format", "json"]);
    assert_success(&generated, "generate");
    let result = parse(&generated)["result"].clone();
    assert_eq!(result["mode"], "write");
    assert!(result["artifact_count"].as_u64().unwrap() > 0);

    let migration = run(project.path(), &["migrate", "plan", "--format", "json"]);
    assert_success(&migration, "migrate");
    assert_eq!(parse(&migration)["result"]["action"], "plan");

    let preset = copied_fixture("m6-preset-project");
    let shown = run(preset.path(), &["preset", "show", "--format", "json"]);
    assert_success(&shown, "preset");
    assert_eq!(parse(&shown)["result"]["name"], "appstruct/saas");
}

#[test]
fn new_emits_a_success_envelope_without_a_project() {
    let parent = tempfile::tempdir().unwrap();
    let output = Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .current_dir(parent.path())
        .args([
            "new",
            "json-app",
            "--template",
            "minimal",
            "--format",
            "json",
        ])
        .output()
        .unwrap();

    assert_success(&output, "new");
    assert_eq!(parse(&output)["result"]["template"], "minimal");
    assert!(parent.path().join("json-app/appstruct.yaml").is_file());
}

#[test]
fn project_events_and_diagnostics_emit_redacted_reports() {
    let project = copied_fixture("m2-project");
    let events = run(
        project.path(),
        &["project", "events", "--limit", "5", "--format", "json"],
    );
    assert_success(&events, "project events");

    let diagnostics = run(
        project.path(),
        &[
            "project",
            "diagnose",
            "--output",
            "diagnostics.json",
            "--format",
            "json",
        ],
    );
    assert_success(&diagnostics, "project diagnose");
    let bundle: Value =
        serde_json::from_slice(&fs::read(project.path().join("diagnostics.json")).unwrap())
            .unwrap();
    assert_eq!(bundle["appstruct_version"], env!("CARGO_PKG_VERSION"));
    assert!(bundle["status"]["compile"]["valid"].as_bool().unwrap());
    assert!(
        bundle["configuration"]
            .as_array()
            .unwrap()
            .iter()
            .all(|file| {
                file["sha256"]
                    .as_str()
                    .is_some_and(|value| value.starts_with("sha256:"))
            })
    );
    assert!(
        bundle["environment"]
            .as_array()
            .unwrap()
            .iter()
            .all(|entry| {
                entry.get("name").is_some()
                    && entry.get("configured").is_some()
                    && entry.as_object().is_some_and(|value| value.len() == 2)
            })
    );
}

fn assert_success(output: &Output, command: &str) {
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let report = parse(output);
    assert_eq!(report["ok"], true);
    assert_eq!(report["result"]["command"], command);
}

fn parse(output: &Output) -> Value {
    serde_json::from_slice(&output.stdout).unwrap()
}

fn copied_fixture(name: &str) -> tempfile::TempDir {
    let source = Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../tests/fixtures")
        .join(name);
    let temporary = tempfile::tempdir().unwrap();
    copy_directory(&source, temporary.path());
    temporary
}

fn copy_directory(source: &Path, destination: &Path) {
    fs::create_dir_all(destination).unwrap();
    for entry in fs::read_dir(source).unwrap() {
        let entry = entry.unwrap();
        let target: PathBuf = destination.join(entry.file_name());
        if entry.path().is_dir() {
            copy_directory(&entry.path(), &target);
        } else {
            fs::copy(entry.path(), target).unwrap();
        }
    }
}

fn run(project: &Path, arguments: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .arg("--project")
        .arg(project)
        .args(arguments)
        .env_remove("DATABASE_URL")
        .output()
        .unwrap()
}