appstruct-cli 0.1.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_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 TABLE {schema}.projects (
  id uuid PRIMARY KEY,
  name varchar(80) NOT NULL UNIQUE,
  state {schema}.project_state NOT NULL DEFAULT 'planned',
  created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP
);
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,
  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!(
        report["result"]["warnings"]
            .as_array()
            .unwrap()
            .iter()
            .any(|warning| warning
                .as_str()
                .is_some_and(|value| value.contains("bytea")))
    );
}

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

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