Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

17.8 KB
Raw Blame
//! Structural undo preserves net changes and later collaborators' work.

use super::*;
use models_databases::{ColumnId, ColumnKind, NewColumn, NewOption, OptionId, TableChange};
use uuid::Uuid;

async fn board(pool: &PgPool, wedding: &Wedding) -> ViewId {
    let view = ViewId::from_uuid(Uuid::now_v7());
    change_as(
        pool,
        wedding,
        WOLF,
        vec![DatabaseOp::View {
            table: wedding.table_id,
            view,
            change: ViewChange::Create {
                view: NewView {
                    name: "Board".into(),
                    query: ViewQuery::default(),
                    layout: RequestedLayout::Board {
                        group_by: wedding.rsvp,
                        title: Some(wedding.name),
                        lanes: vec![],
                        card_fields: vec![],
                        hide_empty_lanes: false,
                    },
                },
            },
        }],
    )
    .await;
    view
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn repeated_column_renames_including_a_final_noop_undo_the_net_change(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let change = change_as(
        &pool,
        &wedding,
        WOLF,
        ["First", "Second", "Second"]
            .into_iter()
            .map(|name| DatabaseOp::Column {
                table: wedding.table_id,
                column: wedding.name,
                change: ColumnChange::Rename {
                    name: name.into(),
                    previous_name: None,
                },
            })
            .collect(),
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, change).await,
        UndoOutcome::Reverted { .. }
    ));
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column: wedding.name,
            change: ColumnChange::Rename {
                name: "Verified".into(),
                previous_name: Some("Name".into()),
            },
        }],
    )
    .await;
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn repeated_reorders_undo_the_final_order(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let before = table_state(&pool, wedding.table_id).await;
    let change = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![
            DatabaseOp::Table {
                table: wedding.table_id,
                change: TableChange::ReorderColumns {
                    order: vec![wedding.rsvp, wedding.name, wedding.plus_ones],
                },
            },
            DatabaseOp::Table {
                table: wedding.table_id,
                change: TableChange::ReorderColumns {
                    order: vec![wedding.plus_ones, wedding.rsvp, wedding.name],
                },
            },
        ],
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, change).await,
        UndoOutcome::Reverted { .. }
    ));
    assert_eq!(table_state(&pool, wedding.table_id).await, before);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn undoing_column_creation_preserves_a_collaborators_rename(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let column = ColumnId::from_uuid(Uuid::now_v7());
    let change = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::Create {
                definition: NewColumn::New {
                    name: "Extra".into(),
                    kind: ColumnKind::Text,
                    options: vec![],
                    infer_type: false,
                },
                after: None,
            },
        }],
    )
    .await;
    change_as(
        &pool,
        &wedding,
        JULIA,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::Rename {
                name: "Important".into(),
                previous_name: None,
            },
        }],
    )
    .await;
    let before = table_state(&pool, wedding.table_id).await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, change).await,
        UndoOutcome::Refused {
            reason: UndoRefusal::ChangedSince,
            ..
        }
    ));
    assert_eq!(table_state(&pool, wedding.table_id).await, before);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn deleting_two_selected_options_restores_them_before_the_cell(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let (row, _) = insert_guests(&pool, &wedding).await;
    let column = ColumnId::from_uuid(Uuid::now_v7());
    let a = OptionId::from_uuid(Uuid::now_v7());
    let b = OptionId::from_uuid(Uuid::now_v7());
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::Create {
                definition: NewColumn::New {
                    name: "Tags".into(),
                    kind: ColumnKind::Select { multi: true },
                    options: vec![
                        NewOption {
                            id: a,
                            label: "A".into(),
                        },
                        NewOption {
                            id: b,
                            label: "B".into(),
                        },
                    ],
                    infer_type: false,
                },
                after: None,
            },
        }],
    )
    .await;
    change_as(
        &pool,
        &wedding,
        WOLF,
        set_cells(
            &wedding,
            row,
            vec![CellWrite {
                column,
                value: CellValue::Options(vec![OptionRef::Id(a), OptionRef::Id(b)]),
            }],
        ),
    )
    .await;
    let before = table_state(&pool, wedding.table_id).await;
    // First verify the surviving selection is a correct after-image.
    let one = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::DeleteOption { option: a },
        }],
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, one).await,
        UndoOutcome::Reverted { .. }
    ));
    assert_eq!(table_state(&pool, wedding.table_id).await, before);
    let both = change_as(
        &pool,
        &wedding,
        WOLF,
        [a, b]
            .into_iter()
            .map(|option| DatabaseOp::Column {
                table: wedding.table_id,
                column,
                change: ColumnChange::DeleteOption { option },
            })
            .collect(),
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, both).await,
        UndoOutcome::Reverted { .. }
    ));
    assert_eq!(table_state(&pool, wedding.table_id).await, before);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn a_deleted_relation_keeps_its_target_when_restored(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let column = ColumnId::from_uuid(Uuid::now_v7());
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::Create {
                definition: NewColumn::New {
                    name: "Related guests".into(),
                    kind: ColumnKind::Relation {
                        database: wedding.database_id,
                        table: wedding.table_id,
                    },
                    options: vec![],
                    infer_type: false,
                },
                after: None,
            },
        }],
    )
    .await;
    let repository = PgDatabasesRepo::new(pool.clone(), PropertiesPgRepo::new(pool.clone()));
    let before = repository
        .columns_for_tables(&[wedding.table_id])
        .await
        .unwrap()
        .into_iter()
        .find(|held| held.id == column)
        .unwrap();
    let change = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::Delete,
        }],
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, change).await,
        UndoOutcome::Reverted { .. }
    ));
    let after = repository
        .columns_for_tables(&[wedding.table_id])
        .await
        .unwrap()
        .into_iter()
        .find(|held| held.id == column)
        .unwrap();
    assert_eq!(after.config, before.config);
    assert_eq!(after.infer_type, before.infer_type);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn a_later_relation_protects_an_inserted_row_from_undo(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let (source, _) = insert_guests(&pool, &wedding).await;
    let column = ColumnId::from_uuid(Uuid::now_v7());
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column,
            change: ColumnChange::Create {
                definition: NewColumn::New {
                    name: "Relation".into(),
                    kind: ColumnKind::Relation {
                        database: wedding.database_id,
                        table: wedding.table_id,
                    },
                    options: vec![],
                    infer_type: false,
                },
                after: None,
            },
        }],
    )
    .await;
    let repository = PgDatabasesRepo::new(pool.clone(), PropertiesPgRepo::new(pool.clone()));
    let before = repository.row_refs(wedding.table_id).await.unwrap();
    let insertion = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Rows {
            table: wedding.table_id,
            change: RowsChange::Insert {
                rows: vec![vec![CellWrite {
                    column: wedding.name,
                    value: CellValue::Text("New guest".into()),
                }]],
            },
        }],
    )
    .await;
    let target = repository
        .row_refs(wedding.table_id)
        .await
        .unwrap()
        .into_iter()
        .find(|row| !before.iter().any(|old| old.id == row.id))
        .unwrap()
        .id;
    change_as(
        &pool,
        &wedding,
        JULIA,
        set_cells(
            &wedding,
            source,
            vec![CellWrite {
                column,
                value: CellValue::Rows(vec![target]),
            }],
        ),
    )
    .await;
    assert_eq!(
        undo_as(&pool, &wedding, WOLF, insertion).await,
        UndoOutcome::Refused {
            reason: UndoRefusal::RowInUse,
            by: None
        }
    );
    assert!(
        repository
            .row_refs(wedding.table_id)
            .await
            .unwrap()
            .iter()
            .any(|row| row.id == target)
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn a_filter_only_dependency_protects_a_new_option(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let option = OptionId::from_uuid(Uuid::now_v7());
    let addition = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column: wedding.rsvp,
            change: ColumnChange::AddOptions {
                options: vec![NewOption {
                    id: option,
                    label: "Later".into(),
                }],
            },
        }],
    )
    .await;
    change_as(
        &pool,
        &wedding,
        JULIA,
        vec![DatabaseOp::View {
            table: wedding.table_id,
            view: ViewId::from_uuid(Uuid::now_v7()),
            change: ViewChange::Create {
                view: NewView {
                    name: "Later guests".into(),
                    layout: RequestedLayout::Table { columns: vec![] },
                    query: ViewQuery {
                        filter: Some(FilterGroup {
                            conjunction: Conjunction::And,
                            conditions: vec![FilterNode::Condition(FilterCondition {
                                column: wedding.rsvp,
                                test: FilterTest::Options {
                                    operator: models_databases::views::SetOperator::IsAnyOf,
                                    options: vec![option],
                                },
                            })],
                        }),
                        sort: vec![],
                    },
                },
            },
        }],
    )
    .await;
    assert_eq!(
        undo_as(&pool, &wedding, WOLF, addition).await,
        UndoOutcome::Refused {
            reason: UndoRefusal::OptionInUse,
            by: None
        }
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn move_then_delete_restores_the_row_before_moving_it_back(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let (row, _) = insert_guests(&pool, &wedding).await;
    let view = board(&pool, &wedding).await;
    let before = table_state(&pool, wedding.table_id).await;
    let change = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![
            DatabaseOp::View {
                table: wedding.table_id,
                view,
                change: ViewChange::MoveCard {
                    row,
                    lane: models_databases::views::LaneKey::Option(wedding.no),
                    before: None,
                    after: None,
                },
            },
            DatabaseOp::Rows {
                table: wedding.table_id,
                change: RowsChange::Delete { rows: vec![row] },
            },
        ],
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, change).await,
        UndoOutcome::Reverted { .. }
    ));
    assert_eq!(table_state(&pool, wedding.table_id).await, before);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn deleting_a_positioned_card_does_not_claim_to_restore_its_position(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let (row, _) = insert_guests(&pool, &wedding).await;
    let view = board(&pool, &wedding).await;
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::View {
            table: wedding.table_id,
            view,
            change: ViewChange::MoveCard {
                row,
                lane: models_databases::views::LaneKey::Option(wedding.no),
                before: None,
                after: None,
            },
        }],
    )
    .await;
    let deletion = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Rows {
            table: wedding.table_id,
            change: RowsChange::Delete { rows: vec![row] },
        }],
    )
    .await;
    assert_eq!(
        undo_as(&pool, &wedding, WOLF, deletion).await,
        UndoOutcome::Refused {
            reason: UndoRefusal::NotUndoable,
            by: None
        }
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn deleting_a_lane_with_card_positions_does_not_claim_complete_restoration(pool: PgPool) {
    let wedding = wedding(&pool).await;
    let (row, _) = insert_guests(&pool, &wedding).await;
    let view = board(&pool, &wedding).await;
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::View {
            table: wedding.table_id,
            view,
            change: ViewChange::MoveCard {
                row,
                lane: models_databases::views::LaneKey::Option(wedding.no),
                before: None,
                after: None,
            },
        }],
    )
    .await;
    let deletion = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column: wedding.rsvp,
            change: ColumnChange::DeleteOption { option: wedding.no },
        }],
    )
    .await;
    assert_eq!(
        undo_as(&pool, &wedding, WOLF, deletion).await,
        UndoOutcome::Refused {
            reason: UndoRefusal::NotUndoable,
            by: None
        }
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn undo_restores_required_column_metadata_and_its_cells(pool: PgPool) {
    let wedding = wedding(&pool).await;
    change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Rows {
            table: wedding.table_id,
            change: RowsChange::Insert {
                rows: vec![vec![CellWrite {
                    column: wedding.name,
                    value: CellValue::Text("Sam".into()),
                }]],
            },
        }],
    )
    .await;
    sqlx::query!(
        "UPDATE database_columns SET nullable = false WHERE id = $1",
        wedding.name.into_uuid()
    )
    .execute(&pool)
    .await
    .unwrap();
    let change = change_as(
        &pool,
        &wedding,
        WOLF,
        vec![DatabaseOp::Column {
            table: wedding.table_id,
            column: wedding.name,
            change: ColumnChange::Delete,
        }],
    )
    .await;
    assert!(matches!(
        undo_as(&pool, &wedding, WOLF, change).await,
        UndoOutcome::Reverted { .. }
    ));
    assert!(
        !sqlx::query_scalar!(
            "SELECT nullable FROM database_columns WHERE id = $1",
            wedding.name.into_uuid()
        )
        .fetch_one(&pool)
        .await
        .unwrap()
    );
    let cells: i64 = sqlx::query_scalar!(r#"SELECT count(*) AS "count!" FROM entity_properties p JOIN database_columns c ON c.property_definition_id = p.property_definition_id WHERE c.id = $1 AND p.entity_type = 'DATABASE_ROW'"#, wedding.name.into_uuid()).fetch_one(&pool).await.unwrap();
    assert_eq!(cells, 1);
}