appstruct-migrate 0.2.0

PostgreSQL schema diffing and migration execution for AppStruct
Documentation
use super::*;
use crate::{ColumnSchema, ForeignKeySchema, IndexSchema, TableSchema, UniqueConstraintSchema};
use appstruct_ir::{DatabaseProvider, GeneratedValueIr, OnDeleteIr};
use std::collections::BTreeMap;

#[test]
fn postgres_worker_partial_index_syntax_does_not_report_drift() {
    let cases: &[(&str, &[&str], &str)] = &[
        ("_appstruct_jobs", &["run_at", "id"], "queued"),
        ("_appstruct_jobs", &["locked_until", "id"], "running"),
        (
            "_appstruct_webhook_deliveries",
            &["next_attempt_at", "id"],
            "pending",
        ),
        (
            "_appstruct_webhook_deliveries",
            &["locked_until", "id"],
            "delivering",
        ),
    ];
    for &(table, columns, status) in cases {
        let expected =
            schema_with_index(table, columns, false, Some(&format!("status = '{status}'")));
        let actual = BTreeSet::from([index_shape(
            table,
            columns,
            false,
            Some(&format!("((status = '{status}'::text))")),
        )]);
        let mut issues = Vec::new();
        compare_indexes(&expected, &actual, &mut issues);
        assert_eq!(issues, Vec::<String>::new(), "status {status}: {issues:?}");
    }
}

#[test]
fn real_index_shape_changes_still_report_drift() {
    let expected = schema_with_index(
        "_appstruct_jobs",
        &["run_at", "id"],
        false,
        Some("status = 'queued'"),
    );
    let mut cases = Vec::new();

    let mut table = matching_index();
    table.table = "_appstruct_other_jobs".to_owned();
    cases.push(("table", table));

    let mut columns = matching_index();
    columns.columns.reverse();
    cases.push(("column order", columns));

    let mut unique = matching_index();
    unique.unique = true;
    cases.push(("uniqueness", unique));

    let mut predicate = matching_index();
    predicate.predicate = Some("(status = 'running'::text)".to_owned());
    cases.push(("predicate value", predicate));

    let mut missing_predicate = matching_index();
    missing_predicate.predicate = None;
    cases.push(("missing predicate", missing_predicate));

    for (label, actual) in cases {
        let mut issues = Vec::new();
        compare_indexes(&expected, &BTreeSet::from([actual]), &mut issues);
        assert_eq!(issues.len(), 2, "{label}: {issues:?}");
        assert!(
            issues.iter().any(|issue| issue.starts_with("missing ")),
            "{label}: {issues:?}"
        );
        assert!(
            issues.iter().any(|issue| issue.starts_with("unexpected ")),
            "{label}: {issues:?}"
        );
    }
}

fn schema_with_index(
    table: &str,
    columns: &[&str],
    unique: bool,
    predicate: Option<&str>,
) -> DatabaseSchema {
    DatabaseSchema {
        schema_version: crate::SCHEMA_VERSION,
        provider: DatabaseProvider::Postgres,
        tables: Vec::new(),
        unique_constraints: Vec::new(),
        indexes: vec![IndexSchema {
            id: "test::index".to_owned(),
            table: table.to_owned(),
            columns: columns.iter().map(|column| (*column).to_owned()).collect(),
            unique,
            method: appstruct_ir::IndexMethod::Btree,
            operator_class: None,
            predicate: predicate.map(str::to_owned),
        }],
        seeds: Vec::new(),
        foreign_keys: Vec::new(),
    }
}

fn index_shape(table: &str, columns: &[&str], unique: bool, predicate: Option<&str>) -> IndexShape {
    IndexShape {
        table: table.to_owned(),
        columns: columns.iter().map(|column| (*column).to_owned()).collect(),
        unique,
        method: "btree".to_owned(),
        operator_class: None,
        predicate: predicate.map(str::to_owned),
    }
}

fn matching_index() -> IndexShape {
    index_shape(
        "_appstruct_jobs",
        &["run_at", "id"],
        false,
        Some("(status = 'queued'::text)"),
    )
}

#[test]
fn unique_index_messages_include_the_unique_prefix() {
    let expected = schema_with_index("notes", &["id"], true, None);
    let mut issues = Vec::new();
    compare_indexes(&expected, &BTreeSet::new(), &mut issues);
    assert_eq!(issues, ["missing unique index on `notes` (id)"]);

    issues.clear();
    compare_indexes(
        &empty_schema(),
        &BTreeSet::from([index_shape("notes", &["id"], true, None)]),
        &mut issues,
    );
    assert_eq!(issues, ["unexpected unique index on `notes` (id)"]);
}

#[test]
fn compare_unique_constraints_reports_missing_and_unexpected_shapes() {
    let expected = DatabaseSchema {
        unique_constraints: vec![UniqueConstraintSchema {
            id: "notes::email".to_owned(),
            table: "notes".to_owned(),
            columns: vec!["email".to_owned()],
        }],
        ..empty_schema()
    };
    let mut issues = Vec::new();
    compare_unique_constraints(&expected, &BTreeSet::new(), &mut issues);
    assert_eq!(issues, ["missing unique constraint `notes(email)`"]);

    issues.clear();
    compare_unique_constraints(
        &empty_schema(),
        &BTreeSet::from([UniqueConstraintShape {
            table: "notes".to_owned(),
            columns: vec!["email".to_owned()],
        }]),
        &mut issues,
    );
    assert_eq!(issues, ["unexpected unique constraint `notes(email)`"]);
}

#[test]
fn compare_foreign_keys_covers_on_delete_variants() {
    let expected = DatabaseSchema {
        foreign_keys: vec![
            foreign_key("notes", "author_id", "users", "id", OnDeleteIr::Restrict),
            foreign_key("notes", "org_id", "orgs", "id", OnDeleteIr::Cascade),
            foreign_key("notes", "parent_id", "notes", "id", OnDeleteIr::SetNull),
        ],
        ..empty_schema()
    };
    let actual = BTreeSet::from([
        ForeignKeyShape {
            source_table: "notes".to_owned(),
            source_columns: vec!["author_id".to_owned()],
            target_table: "users".to_owned(),
            target_columns: vec!["id".to_owned()],
            on_delete: "RESTRICT".to_owned(),
        },
        ForeignKeyShape {
            source_table: "notes".to_owned(),
            source_columns: vec!["org_id".to_owned()],
            target_table: "orgs".to_owned(),
            target_columns: vec!["id".to_owned()],
            on_delete: "CASCADE".to_owned(),
        },
        ForeignKeyShape {
            source_table: "notes".to_owned(),
            source_columns: vec!["parent_id".to_owned()],
            target_table: "notes".to_owned(),
            target_columns: vec!["id".to_owned()],
            on_delete: "SET NULL".to_owned(),
        },
    ]);
    let mut issues = Vec::new();
    compare_foreign_keys(&expected, &actual, &mut issues);
    assert_eq!(issues, Vec::<String>::new(), "{issues:?}");

    issues.clear();
    compare_foreign_keys(&expected, &BTreeSet::new(), &mut issues);
    assert_eq!(issues.len(), 3);
    assert!(issues.iter().all(|issue| issue.starts_with("missing ")));

    issues.clear();
    compare_foreign_keys(&empty_schema(), &actual, &mut issues);
    assert_eq!(issues.len(), 3);
    assert!(issues.iter().all(|issue| issue.starts_with("unexpected ")));
}

#[test]
fn compare_columns_reports_missing_unexpected_and_attribute_drift() {
    let table = TableSchema {
        id: "notes".to_owned(),
        name: "notes".to_owned(),
        columns: vec![
            column("id", DatabaseType::Uuid, true, false, None, None),
            column(
                "status",
                DatabaseType::Enum {
                    values: vec!["draft".to_owned(), "active".to_owned()],
                },
                false,
                false,
                None,
                None,
            ),
        ],
    };
    let mut actual = BTreeMap::new();
    actual.insert(
        ("notes".to_owned(), "id".to_owned()),
        ActualColumn {
            data_type: "uuid".to_owned(),
            nullable: false,
            default: None,
            identity: false,
        },
    );
    actual.insert(
        ("notes".to_owned(), "extra".to_owned()),
        ActualColumn {
            data_type: "text".to_owned(),
            nullable: true,
            default: None,
            identity: false,
        },
    );
    let mut constraints = BTreeMap::new();
    constraints.insert(
        ("notes".to_owned(), "id".to_owned()),
        BTreeSet::from(["PRIMARY KEY".to_owned()]),
    );
    let mut issues = Vec::new();
    compare_columns(&table, &actual, &constraints, &BTreeMap::new(), &mut issues);
    assert!(
        issues
            .iter()
            .any(|issue| issue.contains("missing column `notes.status`")),
        "{issues:?}"
    );
    assert!(
        issues
            .iter()
            .any(|issue| issue.contains("unexpected column `notes.extra`")),
        "{issues:?}"
    );
}

#[test]
fn compare_column_reports_type_nullability_key_identity_and_default_drift() {
    let table = TableSchema {
        id: "items".to_owned(),
        name: "items".to_owned(),
        columns: Vec::new(),
    };
    let expected = column(
        "count",
        DatabaseType::Integer,
        true,
        false,
        Some("0"),
        Some(GeneratedValueIr::AutoIncrement),
    );
    let actual = ActualColumn {
        data_type: "bigint".to_owned(),
        nullable: true,
        default: Some("'1'::integer".to_owned()),
        identity: false,
    };
    let mut issues = Vec::new();
    compare_column(&table, &expected, &actual, None, &mut issues);
    assert!(issues.iter().any(|issue| issue.contains("has type")));
    assert!(issues.iter().any(|issue| issue.contains("nullability")));
    assert!(issues.iter().any(|issue| issue.contains("primary-key")));
    assert!(issues.iter().any(|issue| issue.contains("identity")));
    assert!(issues.iter().any(|issue| issue.contains("default")));

    issues.clear();
    let unique = column("email", DatabaseType::Text, false, true, None, None);
    compare_column(
        &table,
        &unique,
        &ActualColumn {
            data_type: "text".to_owned(),
            nullable: false,
            default: None,
            identity: false,
        },
        None,
        &mut issues,
    );
    assert!(issues.iter().any(|issue| issue.contains("unique status")));
}

#[test]
fn compare_enum_check_accepts_matching_literals_and_rejects_drift() {
    let mut checks = BTreeMap::new();
    checks.insert(
        "notes".to_owned(),
        vec!["CHECK ((status = ANY (ARRAY['draft'::text, 'active'::text])))".to_owned()],
    );
    let mut issues = Vec::new();
    compare_enum_check(
        "notes",
        "status",
        &["draft".to_owned(), "active".to_owned()],
        &checks,
        &mut issues,
    );
    assert_eq!(issues, Vec::<String>::new(), "{issues:?}");

    compare_enum_check(
        "notes",
        "status",
        &["draft".to_owned(), "archived".to_owned()],
        &checks,
        &mut issues,
    );
    assert!(
        issues
            .iter()
            .any(|issue| issue.contains("enum check for `notes.status`")),
        "{issues:?}"
    );
}

fn empty_schema() -> DatabaseSchema {
    DatabaseSchema {
        schema_version: crate::SCHEMA_VERSION,
        provider: DatabaseProvider::Postgres,
        tables: Vec::new(),
        unique_constraints: Vec::new(),
        indexes: Vec::new(),
        seeds: Vec::new(),
        foreign_keys: Vec::new(),
    }
}

fn column(
    name: &str,
    data_type: DatabaseType,
    primary_key: bool,
    unique: bool,
    default: Option<&str>,
    generated: Option<GeneratedValueIr>,
) -> ColumnSchema {
    ColumnSchema {
        id: format!("test::{name}"),
        name: name.to_owned(),
        data_type,
        nullable: false,
        primary_key,
        unique,
        default: default.map(str::to_owned),
        generated,
    }
}

fn foreign_key(
    source_table: &str,
    source_column: &str,
    target_table: &str,
    target_column: &str,
    on_delete: OnDeleteIr,
) -> ForeignKeySchema {
    ForeignKeySchema {
        id: format!("{source_table}::{source_column}"),
        source_table: source_table.to_owned(),
        source_columns: vec![source_column.to_owned()],
        target_table: target_table.to_owned(),
        target_columns: vec![target_column.to_owned()],
        unique: false,
        on_delete,
    }
}