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