appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::{SystemTime, UNIX_EPOCH};

#[test]
fn database_pull_requires_database_url_without_creating_a_draft() {
    let project = copied_fixture("m2-project");
    let output = Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .arg("--project")
        .arg(project.path())
        .args(["db", "pull"])
        .env_remove("DATABASE_URL")
        .output()
        .unwrap();

    assert_eq!(output.status.code(), Some(3));
    assert!(String::from_utf8_lossy(&output.stderr).contains("AS6304"));
    assert!(!project.path().join("spec/imported.yaml").exists());
}

#[test]
fn database_pull_review_requires_a_terminal_before_connecting() {
    let project = copied_fixture("m2-project");
    let output = Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .arg("--project")
        .arg(project.path())
        .args(["db", "pull", "--review"])
        .env_remove("DATABASE_URL")
        .output()
        .unwrap();
    assert_eq!(output.status.code(), Some(2));
    assert!(String::from_utf8_lossy(&output.stderr).contains("AS6310"));
    assert!(!project.path().join("spec/imported.yaml").exists());
}

#[test]
fn database_pull_introspects_postgres_when_configured() {
    let Ok(database_url) = std::env::var("APPSTRUCT_E2E_DATABASE_URL") else {
        return;
    };
    let nonce = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    let schema = format!("appstruct_pull_{}_{}", std::process::id(), nonce);
    let mut client = appstruct_migrate::connect_database(&database_url).unwrap();
    client
        .batch_execute(&format!(
            r"CREATE SCHEMA {schema};
CREATE TYPE {schema}.project_state AS ENUM ('planned', 'active');
CREATE DOMAIN {schema}.short_code AS varchar(12) CHECK (VALUE <> '');
CREATE TABLE {schema}.projects (
  id uuid PRIMARY KEY,
  name varchar(80) NOT NULL UNIQUE,
  code {schema}.short_code NOT NULL,
  state {schema}.project_state NOT NULL DEFAULT 'planned',
  created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
  search_name text GENERATED ALWAYS AS (lower(name)) STORED
);
CREATE TABLE {schema}.tasks (
  id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
  project_id uuid NOT NULL REFERENCES {schema}.projects(id) ON DELETE CASCADE,
  title text NOT NULL,
  tags text[],
  payload bytea
);"
        ))
        .unwrap();
    let guard = SchemaGuard {
        client,
        schema: schema.clone(),
    };
    let project = copied_fixture("m2-project");
    let output = Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .arg("--project")
        .arg(project.path())
        .args([
            "db",
            "pull",
            "--schema",
            &schema,
            "--output",
            "spec/pulled.yaml",
            "--format",
            "json",
        ])
        .env("DATABASE_URL", &database_url)
        .output()
        .unwrap();
    drop(guard);

    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let report: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(report["ok"], true);
    assert_eq!(report["result"]["command"], "db");
    assert_eq!(report["result"]["action"], "pull");
    assert_eq!(report["result"]["entity_count"], 2);
    let source = fs::read_to_string(project.path().join("spec/pulled.yaml")).unwrap();
    assert!(source.contains("  Project:\n"));
    assert!(source.contains("        values: [\"planned\", \"active\"]\n"));
    assert!(source.contains("        target: Project\n"));
    assert!(source.contains("        generated: auto_increment\n"));
    assert!(source.contains("      code:\n        type: string\n"));
    assert!(!source.contains("      search_name:\n"));
    assert!(!source.contains("      tags:\n"));
    assert!(!source.contains("      payload:\n"));
    assert!(
        report["result"]["warnings"]
            .as_array()
            .unwrap()
            .iter()
            .any(|warning| warning
                .as_str()
                .is_some_and(|value| value.contains("bytea")))
    );
    assert!(
        report["result"]["warnings"]
            .as_array()
            .unwrap()
            .iter()
            .any(|warning| warning
                .as_str()
                .is_some_and(|value| value.contains("short_code") && value.contains("base type")))
    );
}

struct SchemaGuard {
    client: postgres::Client,
    schema: String,
}

#[test]
fn database_pull_preflight_reports_structure_before_adoption_without_changing_config_or_data() {
    let Ok(database_url) = std::env::var("APPSTRUCT_E2E_DATABASE_URL") else {
        return;
    };
    let schema = format!(
        "appstruct_preflight_{}",
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    );
    let mut client = appstruct_migrate::connect_database(&database_url).unwrap();
    client.batch_execute(&format!("CREATE SCHEMA {schema}; CREATE TABLE {schema}.notes (id uuid PRIMARY KEY, title text NOT NULL, payload bytea); INSERT INTO {schema}.notes (id, title) VALUES ('00000000-0000-4000-8000-000000000001', 'keep');")).unwrap();
    let mut guard = SchemaGuard {
        client,
        schema: schema.clone(),
    };
    let project = tempfile::tempdir().unwrap();
    let root = "version: 1\napp: { name: preflight-demo }\ndatabase: { provider: postgres, dev: { mode: external } }\nincludes: []\n";
    fs::write(project.path().join("appstruct.yaml"), root).unwrap();
    let output = Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .arg("--project")
        .arg(project.path())
        .args([
            "db", "pull", "--schema", &schema, "--access", "public", "--format", "json",
        ])
        .env("DATABASE_URL", &database_url)
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let report: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    let preflight = &report["result"]["preflight"];
    assert_eq!(preflight["status"], "blocked");
    assert_eq!(preflight["history_checked"], false);
    assert_eq!(preflight["missing_revision"], serde_json::json!(["notes"]));
    assert!(
        preflight["structure_issues"]
            .as_array()
            .unwrap()
            .iter()
            .any(|issue| issue.as_str().unwrap().contains("revision"))
    );
    assert!(
        preflight["structure_issues"]
            .as_array()
            .unwrap()
            .iter()
            .any(|issue| issue.as_str().unwrap().contains("payload"))
    );
    assert_eq!(preflight["include"]["requires_confirmation"], true);
    assert_eq!(
        fs::read_to_string(project.path().join("appstruct.yaml")).unwrap(),
        root
    );
    assert!(!project.path().join("migrations").exists());
    let count: i64 = guard
        .client
        .query_one(
            &format!("SELECT count(*) FROM {schema}.notes WHERE title = 'keep'"),
            &[],
        )
        .unwrap()
        .get(0);
    assert_eq!(count, 1);
}

impl Drop for SchemaGuard {
    fn drop(&mut self) {
        let _ = self
            .client
            .batch_execute(&format!("DROP SCHEMA {} CASCADE", self.schema));
    }
}

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();
        }
    }
}