Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
//! Explicit literal tests of inverting each kind of op.
use models_databases::views::LaneKey;
use std::collections::BTreeMap;
use chrono::{DateTime, Utc};
use models_databases::position::{Position, key_between};
use models_databases::views::{
CardPosition, DatabaseView, NewView, RequestedLayout, ViewColumn, ViewId, ViewLayout, ViewQuery,
};
use models_databases::{
CellValue, CellWrite, ColumnChange, ColumnId, ColumnKind, DatabaseId, DatabaseOp, NewColumn,
NewOption, OptionId, OptionRef, PropertyId, RowChange, RowChanges, RowId, RowsChange,
TableChange, TableId, TableVersion, ViewChange,
};
use models_properties::service::property_option::PropertyOptionValue;
use models_properties::service::property_value::PropertyValue;
use uuid::Uuid;
use super::*;
use crate::domain::models::{Column, ColumnReplacement, NewDefinition, Write};
const DATABASE: DatabaseId = DatabaseId::from_uuid(Uuid::from_u128(0xd0));
const GUESTS: TableId = TableId::from_uuid(Uuid::from_u128(0x10));
const VENUES: TableId = TableId::from_uuid(Uuid::from_u128(0x11));
const NAME: ColumnId = ColumnId::from_uuid(Uuid::from_u128(0xc1));
const RSVP: ColumnId = ColumnId::from_uuid(Uuid::from_u128(0xc2));
const PLUS_ONES: ColumnId = ColumnId::from_uuid(Uuid::from_u128(0xc3));
const NAME_DEFINITION: Uuid = Uuid::from_u128(0xe1);
const RSVP_DEFINITION: Uuid = Uuid::from_u128(0xe2);
const PLUS_ONES_DEFINITION: Uuid = Uuid::from_u128(0xe3);
const YES: OptionId = OptionId::from_uuid(Uuid::from_u128(0xa1));
const NO: OptionId = OptionId::from_uuid(Uuid::from_u128(0xa2));
const MAYBE: OptionId = OptionId::from_uuid(Uuid::from_u128(0xa3));
const MARIA: RowId = RowId::from_uuid(Uuid::from_u128(0xb1));
const OMAR: RowId = RowId::from_uuid(Uuid::from_u128(0xb2));
const GRID: ViewId = ViewId::from_uuid(Uuid::from_u128(0xf1));
const BOARD: ViewId = ViewId::from_uuid(Uuid::from_u128(0xf2));
fn first_key() -> Position {
key_between(None, None).unwrap()
}
fn second_key() -> Position {
key_between(Some(&first_key()), None).unwrap()
}
fn written() -> DateTime<Utc> {
DateTime::UNIX_EPOCH
}
/// The guest list's views as stored: a grid sorted by Plus Ones, and a board
/// grouped by RSVP.
fn views() -> [DatabaseView; 2] {
[
DatabaseView {
id: GRID,
database_id: DATABASE,
table_id: GUESTS,
name: "Everyone".into(),
position: first_key(),
query: ViewQuery {
filter: None,
sort: vec![models_databases::views::SortKey {
column: PLUS_ONES,
direction: models_databases::views::SortDirection::Descending,
}],
},
layout: ViewLayout::Table {
columns: vec![ViewColumn {
column: PLUS_ONES,
width: Some(80),
}],
},
created_at: written(),
updated_at: written(),
},
DatabaseView {
id: BOARD,
database_id: DATABASE,
table_id: GUESTS,
name: "By RSVP".into(),
position: second_key(),
query: ViewQuery::default(),
layout: ViewLayout::Board {
group_by: RSVP,
title: NAME,
lanes: Vec::new(),
card_fields: Vec::new(),
hide_empty_lanes: false,
},
created_at: written(),
updated_at: written(),
},
]
}
/// The wedding database as its planner read it: Guests (Name, RSVP, Plus
/// Ones) and Venues.
fn schema() -> SchemaImage {
SchemaImage {
tables: vec![
TableImage {
id: GUESTS,
name: "Guests".into(),
version: TableVersion(7),
},
TableImage {
id: VENUES,
name: "Venues".into(),
version: TableVersion(2),
},
],
columns: vec![
ColumnImage {
nullable: true,
id: NAME,
infer_type: false,
table: GUESTS,
name: "Name".into(),
definition_name: "Name".into(),
definition: NAME_DEFINITION,
kind: Some(ColumnKind::Text),
options: Vec::new(),
formula: None,
},
ColumnImage {
nullable: true,
id: RSVP,
infer_type: false,
table: GUESTS,
name: "RSVP".into(),
definition_name: "RSVP".into(),
definition: RSVP_DEFINITION,
kind: Some(ColumnKind::Select { multi: false }),
options: vec![
OptionImage {
id: YES,
label: "Yes".into(),
color: Some("#00AA00".into()),
},
OptionImage {
id: NO,
label: "No".into(),
color: Some("#AA0000".into()),
},
OptionImage {
id: MAYBE,
label: "Maybe".into(),
color: None,
},
],
formula: None,
},
ColumnImage {
nullable: true,
id: PLUS_ONES,
infer_type: false,
table: GUESTS,
name: "Plus Ones".into(),
definition_name: "Extra guests".into(),
definition: PLUS_ONES_DEFINITION,
kind: Some(ColumnKind::Number),
options: Vec::new(),
formula: None,
},
],
views: views().to_vec(),
}
}
/// Maria (RSVP Yes, Plus Ones 1) and Omar (RSVP No) as they were.
fn guests() -> BTreeMap<RowId, RowImage> {
BTreeMap::from([
(
MARIA,
RowImage {
table: GUESTS,
position: first_key(),
cells: BTreeMap::from([
(NAME, CellValue::Text("Maria".into())),
(RSVP, CellValue::Options(vec![OptionRef::Id(YES)])),
(PLUS_ONES, CellValue::Number(1.0)),
]),
},
),
(
OMAR,
RowImage {
table: GUESTS,
position: second_key(),
cells: BTreeMap::from([
(NAME, CellValue::Text("Omar".into())),
(RSVP, CellValue::Options(vec![OptionRef::Id(NO)])),
]),
},
),
])
}
#[test]
fn a_row_insert_is_undone_by_deleting_the_rows_it_inserted() {
let op = DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Insert {
rows: vec![vec![CellWrite {
column: NAME,
value: CellValue::Text("Maria".into()),
}]],
},
};
let write = Write::InsertRows {
derivation: None,
table_id: GUESTS,
rows: vec![vec![(NAME_DEFINITION, PropertyValue::Str("Maria".into()))]],
restored: Vec::new(),
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[MARIA],
}],
&before,
);
assert_eq!(
inverse,
ChangeInverse {
ops: vec![DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Delete { rows: vec![MARIA] },
}],
..ChangeInverse::default()
}
);
}
#[test]
fn a_cell_update_is_undone_by_writing_back_the_old_value_or_clearing_an_empty_cell() {
let op = DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Update {
changes: RowChanges::Uniform {
rows: vec![MARIA, OMAR],
cells: vec![
CellWrite {
column: RSVP,
value: CellValue::Options(vec![OptionRef::Id(MAYBE)]),
},
CellWrite {
column: PLUS_ONES,
value: CellValue::Number(2.0),
},
],
},
},
};
let write = Write::UpdateRows {
derivation: None,
table_id: GUESTS,
rows: vec![
(
MARIA,
vec![
(
RSVP_DEFINITION,
Some(PropertyValue::SelectOption(vec![MAYBE.into_uuid()])),
),
(PLUS_ONES_DEFINITION, Some(PropertyValue::Num(2.0))),
],
),
(
OMAR,
vec![
(
RSVP_DEFINITION,
Some(PropertyValue::SelectOption(vec![MAYBE.into_uuid()])),
),
(PLUS_ONES_DEFINITION, Some(PropertyValue::Num(2.0))),
],
),
],
};
let before = Before {
schema: schema(),
rows: guests(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Update {
changes: RowChanges::PerRow {
rows: vec![
RowChange {
row: MARIA,
cells: vec![
CellWrite {
column: RSVP,
value: CellValue::Options(vec![OptionRef::Id(YES)]),
},
CellWrite {
column: PLUS_ONES,
value: CellValue::Number(1.0),
},
],
},
RowChange {
row: OMAR,
cells: vec![
CellWrite {
column: RSVP,
value: CellValue::Options(vec![OptionRef::Id(NO)]),
},
CellWrite {
column: PLUS_ONES,
value: CellValue::Clear,
},
],
},
],
},
},
}]
);
}
#[test]
fn a_row_delete_is_undone_by_reinserting_the_rows_under_their_ids_and_positions() {
let op = DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Delete { rows: vec![OMAR] },
};
let write = Write::DeleteRows {
only_if_unreferenced: false,
table_id: GUESTS,
rows: vec![OMAR],
};
let before = Before {
schema: schema(),
rows: guests(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse,
ChangeInverse {
ops: vec![DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Insert {
rows: vec![vec![
CellWrite {
column: NAME,
value: CellValue::Text("Omar".into()),
},
CellWrite {
column: RSVP,
value: CellValue::Options(vec![OptionRef::Id(NO)]),
},
]],
},
}],
restored_rows: BTreeMap::from([(
0,
vec![RestoredRow {
id: OMAR,
position: second_key(),
}],
)]),
..ChangeInverse::default()
}
);
}
#[test]
fn a_column_create_is_undone_by_deleting_the_column() {
let seats = ColumnId::from_uuid(Uuid::from_u128(0xc9));
let op = DatabaseOp::Column {
table: GUESTS,
column: seats,
change: ColumnChange::Create {
definition: NewColumn::New {
name: "Seats".into(),
kind: ColumnKind::Number,
options: Vec::new(),
infer_type: false,
},
after: None,
},
};
let write = Write::CreateColumn {
column: Column {
protections: vec![],
nullable: true,
id: seats,
table_id: GUESTS,
property_definition_id: Uuid::from_u128(0xe9),
position: second_key(),
config: None,
display_name: None,
infer_type: false,
},
definition: None,
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::Column {
table: GUESTS,
column: seats,
change: ColumnChange::Delete,
}]
);
}
#[test]
fn a_column_delete_is_undone_by_binding_its_definition_back_with_its_name_cells_views_and_place() {
let op = DatabaseOp::Column {
table: GUESTS,
column: PLUS_ONES,
change: ColumnChange::Delete,
};
let [grid, _] = views();
let grid_without = DatabaseView {
query: ViewQuery::default(),
layout: ViewLayout::Table {
columns: Vec::new(),
},
..grid.clone()
};
let write = Write::DeleteColumn {
table_id: GUESTS,
column_id: PLUS_ONES,
definition_id: PLUS_ONES_DEFINITION,
views: vec![grid_without],
related: None,
};
let before = Before {
schema: schema(),
column_cells: BTreeMap::from([(
PLUS_ONES,
BTreeMap::from([(MARIA, CellValue::Number(1.0))]),
)]),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![
DatabaseOp::Column {
table: GUESTS,
column: PLUS_ONES,
change: ColumnChange::Create {
definition: NewColumn::Existing {
property: PropertyId::from_uuid(PLUS_ONES_DEFINITION),
},
after: None,
},
},
DatabaseOp::Column {
table: GUESTS,
column: PLUS_ONES,
change: ColumnChange::Rename {
name: "Plus Ones".into(),
previous_name: None,
},
},
DatabaseOp::View {
table: GUESTS,
view: GRID,
change: ViewChange::Update {
name: Some("Everyone".into()),
query: Some(grid.query.clone()),
layout: Some(RequestedLayout::Table {
columns: vec![ViewColumn {
column: PLUS_ONES,
width: Some(80)
}],
}),
},
},
DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Update {
changes: RowChanges::PerRow {
rows: vec![RowChange {
row: MARIA,
cells: vec![CellWrite {
column: PLUS_ONES,
value: CellValue::Number(1.0),
}],
}],
},
},
},
DatabaseOp::Table {
table: GUESTS,
change: TableChange::ReorderColumns {
order: vec![NAME, RSVP, PLUS_ONES],
},
},
]
);
}
#[test]
fn a_column_rename_is_undone_by_renaming_it_back() {
let op = DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::Rename {
name: "Coming?".into(),
previous_name: Some("RSVP".into()),
},
};
let write = Write::RenameColumn {
table_id: GUESTS,
column_id: RSVP,
from: None,
name: "Coming?".into(),
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::Rename {
name: "RSVP".into(),
previous_name: Some("Coming?".into()),
},
}]
);
}
#[test]
fn a_column_reorder_is_undone_by_the_old_order() {
let op = DatabaseOp::Table {
table: GUESTS,
change: TableChange::ReorderColumns {
order: vec![PLUS_ONES, RSVP, NAME],
},
};
let write = Write::OrderColumns {
table_id: GUESTS,
positions: Vec::new(),
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::Table {
table: GUESTS,
change: TableChange::ReorderColumns {
order: vec![NAME, RSVP, PLUS_ONES],
},
}]
);
}
#[test]
fn a_type_change_is_undone_by_the_old_type_with_the_old_definition_and_cells() {
let op = DatabaseOp::Column {
table: GUESTS,
column: PLUS_ONES,
change: ColumnChange::ChangeType {
to: ColumnKind::Text,
},
};
let write = Write::ReplaceColumn {
table_id: GUESTS,
read_version: Some(TableVersion(7)),
definition: Some(NewDefinition {
id: Uuid::from_u128(0xe8),
name: "Extra guests".into(),
data_type: models_properties::shared::DataType::String,
is_multi_select: false,
specific_entity_type: None,
options: Vec::new(),
}),
replacement: ColumnReplacement {
column: Column {
protections: vec![],
nullable: true,
id: PLUS_ONES,
table_id: GUESTS,
property_definition_id: PLUS_ONES_DEFINITION,
position: second_key(),
config: None,
display_name: Some("Plus Ones".into()),
infer_type: false,
},
definition_id: Uuid::from_u128(0xe8),
config: None,
values: vec![(MARIA, PropertyValue::Str("1".into()))],
},
views: Vec::new(),
};
let before = Before {
schema: schema(),
column_cells: BTreeMap::from([(
PLUS_ONES,
BTreeMap::from([(MARIA, CellValue::Number(1.0))]),
)]),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse,
ChangeInverse {
ops: vec![
DatabaseOp::Column {
table: GUESTS,
column: PLUS_ONES,
change: ColumnChange::ChangeType {
to: ColumnKind::Number,
},
},
DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Update {
changes: RowChanges::PerRow {
rows: vec![RowChange {
row: MARIA,
cells: vec![CellWrite {
column: PLUS_ONES,
value: CellValue::Number(1.0),
}],
}],
},
},
},
],
rebinds: BTreeMap::from([(0, PLUS_ONES_DEFINITION)]),
..ChangeInverse::default()
}
);
}
#[test]
fn added_options_are_undone_by_deleting_the_options_actually_added() {
let late = OptionId::from_uuid(Uuid::from_u128(0xa4));
let op = DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::AddOptions {
options: vec![
NewOption {
id: OptionId::from_uuid(Uuid::from_u128(0xa9)),
label: "yes".into(),
},
NewOption {
id: late,
label: "Late".into(),
},
],
},
};
let write = Write::AddOptions {
table_id: GUESTS,
tables: vec![GUESTS],
definition_id: RSVP_DEFINITION,
options: vec![(late, PropertyOptionValue::String("Late".into()))],
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::DeleteOption { option: late },
}]
);
}
#[test]
fn an_option_update_is_undone_by_its_old_label_and_colour() {
let op = DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::UpdateOption {
option: YES,
label: Some("Coming".into()),
color: Some(None),
},
};
let write = Write::UpdateOption {
table_id: GUESTS,
tables: vec![GUESTS],
definition_id: RSVP_DEFINITION,
option_id: YES,
value: Some(PropertyOptionValue::String("Coming".into())),
color: Some(None),
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::UpdateOption {
option: YES,
label: Some("Yes".into()),
color: Some(Some("#00AA00".into())),
},
}]
);
}
#[test]
fn an_option_delete_is_undone_by_the_option_its_colour_and_the_cells_that_held_it() {
let op = DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::DeleteOption { option: NO },
};
let write = Write::DeleteOption {
only_if_unused: false,
table_id: GUESTS,
tables: vec![GUESTS],
definition_id: RSVP_DEFINITION,
option_id: NO,
views: Vec::new(),
};
let before = Before {
schema: schema(),
column_cells: BTreeMap::from([(
RSVP,
BTreeMap::from([
(MARIA, CellValue::Options(vec![OptionRef::Id(YES)])),
(OMAR, CellValue::Options(vec![OptionRef::Id(NO)])),
]),
)]),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![
DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::AddOptions {
options: vec![NewOption {
id: NO,
label: "No".into(),
}],
},
},
DatabaseOp::Column {
table: GUESTS,
column: RSVP,
change: ColumnChange::UpdateOption {
option: NO,
label: None,
color: Some(Some("#AA0000".into())),
},
},
DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Update {
changes: RowChanges::PerRow {
rows: vec![RowChange {
row: OMAR,
cells: vec![CellWrite {
column: RSVP,
value: CellValue::Options(vec![OptionRef::Id(NO)]),
}],
}],
},
},
},
]
);
}
#[test]
fn a_view_create_is_undone_by_deleting_the_view() {
let seating = ViewId::from_uuid(Uuid::from_u128(0xf9));
let op = DatabaseOp::View {
table: GUESTS,
view: seating,
change: ViewChange::Create {
view: NewView {
name: "Seating".into(),
query: ViewQuery::default(),
layout: RequestedLayout::Table {
columns: Vec::new(),
},
},
},
};
let write = Write::DeleteView {
table_id: GUESTS,
view_id: seating,
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::View {
table: GUESTS,
view: seating,
change: ViewChange::Delete,
}]
);
}
#[test]
fn a_view_update_is_undone_by_its_old_name_query_and_layout() {
let op = DatabaseOp::View {
table: GUESTS,
view: GRID,
change: ViewChange::Update {
name: Some("All guests".into()),
query: None,
layout: None,
},
};
let [grid, _] = views();
let write = Write::UpdateView {
view: DatabaseView {
name: "All guests".into(),
..grid.clone()
},
regrouped: false,
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::View {
table: GUESTS,
view: GRID,
change: ViewChange::Update {
name: Some("Everyone".into()),
query: Some(grid.query.clone()),
layout: Some(RequestedLayout::Table {
columns: vec![ViewColumn {
column: PLUS_ONES,
width: Some(80),
}],
}),
},
}]
);
}
#[test]
fn a_view_delete_is_undone_by_creating_it_again_under_its_id_in_its_place() {
let op = DatabaseOp::View {
table: GUESTS,
view: BOARD,
change: ViewChange::Delete,
};
let write = Write::DeleteView {
table_id: GUESTS,
view_id: BOARD,
};
let before = Before {
schema: schema(),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![
DatabaseOp::View {
table: GUESTS,
view: BOARD,
change: ViewChange::Create {
view: NewView {
name: "By RSVP".into(),
query: ViewQuery::default(),
layout: RequestedLayout::Board {
group_by: RSVP,
title: Some(NAME),
lanes: Vec::new(),
card_fields: Vec::new(),
hide_empty_lanes: false,
},
},
},
},
DatabaseOp::Table {
table: GUESTS,
change: TableChange::ReorderViews {
order: vec![GRID, BOARD],
},
},
]
);
}
#[test]
fn a_card_move_is_undone_by_moving_it_back_between_its_old_neighbours() {
let ana = RowId::from_uuid(Uuid::from_u128(0xb3));
let op = DatabaseOp::View {
table: GUESTS,
view: BOARD,
change: ViewChange::MoveCard {
row: MARIA,
lane: LaneKey::Option(NO),
before: None,
after: None,
},
};
let write = Write::MoveCard {
table_id: GUESTS,
view_id: BOARD,
row: MARIA,
positions: Vec::new(),
cell: (
RSVP_DEFINITION,
Some(PropertyValue::SelectOption(vec![NO.into_uuid()])),
),
};
let before = Before {
schema: schema(),
rows: guests(),
cards: BTreeMap::from([(
BOARD,
vec![
CardPosition {
row: ana,
lane: LaneKey::Option(YES),
position: first_key(),
},
CardPosition {
row: MARIA,
lane: LaneKey::Option(YES),
position: second_key(),
},
],
)]),
..Before::default()
};
let inverse = invert(
&[Planned {
op: &op,
write: &write,
inserted: &[],
}],
&before,
);
assert_eq!(
inverse.ops,
vec![DatabaseOp::View {
table: GUESTS,
view: BOARD,
change: ViewChange::MoveCard {
row: MARIA,
lane: LaneKey::Option(YES),
before: Some(ana),
after: None,
},
}]
);
}
#[test]
fn table_creates_renames_and_reorders_are_undone_and_a_table_delete_is_not() {
let gifts = TableId::from_uuid(Uuid::from_u128(0x12));
let ops = [
DatabaseOp::Table {
table: gifts,
change: TableChange::Create {
name: "Gifts".into(),
},
},
DatabaseOp::Table {
table: GUESTS,
change: TableChange::Rename {
name: "People".into(),
previous_name: None,
},
},
DatabaseOp::ReorderTables {
order: vec![gifts, VENUES, GUESTS],
},
DatabaseOp::Table {
table: VENUES,
change: TableChange::Delete,
},
];
let writes = [
Write::CreateTable {
table_id: gifts,
name: "Gifts".into(),
},
Write::RenameTable {
table_id: GUESTS,
from: "Guests".into(),
name: "People".into(),
},
Write::OrderTables {
tables: vec![gifts, VENUES, GUESTS],
positions: Vec::new(),
},
Write::DeleteTable {
table_id: VENUES,
version: TableVersion(2),
},
];
let before = Before {
schema: schema(),
..Before::default()
};
let planned: Vec<Planned<'_>> = ops
.iter()
.zip(&writes)
.map(|(op, write)| Planned {
op,
write,
inserted: &[],
})
.collect();
let inverse = invert(&planned, &before);
assert_eq!(
inverse.ops,
vec![
DatabaseOp::Table {
table: GUESTS,
change: TableChange::Rename {
name: "Guests".into(),
previous_name: Some("People".into()),
},
},
DatabaseOp::Table {
table: gifts,
change: TableChange::Delete,
},
DatabaseOp::ReorderTables {
order: vec![GUESTS],
},
]
);
}
#[test]
fn what_a_batch_creates_and_removes_again_needs_no_inverse() {
let walk_in = RowId::from_uuid(Uuid::from_u128(0xb9));
let seats = ColumnId::from_uuid(Uuid::from_u128(0xc9));
let ops = [
DatabaseOp::Column {
table: GUESTS,
column: seats,
change: ColumnChange::Create {
definition: NewColumn::New {
name: "Seats".into(),
kind: ColumnKind::Number,
options: Vec::new(),
infer_type: false,
},
after: None,
},
},
DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Insert {
rows: vec![Vec::new()],
},
},
DatabaseOp::Rows {
table: GUESTS,
change: RowsChange::Delete {
rows: vec![walk_in],
},
},
DatabaseOp::Column {
table: GUESTS,
column: seats,
change: ColumnChange::Delete,
},
];
let writes = [
Write::CreateColumn {
column: Column {
protections: vec![],
nullable: true,
id: seats,
table_id: GUESTS,
property_definition_id: Uuid::from_u128(0xe9),
position: second_key(),
config: None,
display_name: None,
infer_type: false,
},
definition: None,
},
Write::InsertRows {
derivation: None,
table_id: GUESTS,
rows: vec![Vec::new()],
restored: Vec::new(),
},
Write::DeleteRows {
only_if_unreferenced: false,
table_id: GUESTS,
rows: vec![walk_in],
},
Write::DeleteColumn {
table_id: GUESTS,
column_id: seats,
definition_id: Uuid::from_u128(0xe9),
views: Vec::new(),
related: None,
},
];
let before = Before {
schema: schema(),
..Before::default()
};
let inserted = [Vec::new(), vec![walk_in], Vec::new(), Vec::new()];
let planned: Vec<Planned<'_>> = ops
.iter()
.zip(&writes)
.zip(&inserted)
.map(|((op, write), inserted)| Planned {
op,
write,
inserted,
})
.collect();
let inverse = invert(&planned, &before);
assert_eq!(inverse, ChangeInverse::default());
}
#[test]
fn a_tables_changes_fold_each_row_once_as_it_stands_now() {
let walk_in = RowId::from_uuid(Uuid::from_u128(0xb9));
let versions = [
VersionTouches {
version: TableVersion(8),
rows: vec![
(MARIA, RowChangeKind::Insert),
(walk_in, RowChangeKind::Insert),
],
columns: Vec::new(),
},
VersionTouches {
version: TableVersion(9),
rows: vec![
(MARIA, RowChangeKind::Update),
(OMAR, RowChangeKind::Update),
],
columns: Vec::new(),
},
VersionTouches {
version: TableVersion(10),
rows: vec![
(walk_in, RowChangeKind::Delete),
(OMAR, RowChangeKind::Delete),
],
columns: vec![ColumnTouch {
column: PLUS_ONES,
kind: ColumnChangeKind::Delete,
}],
},
];
let changes = table_changes(TableVersion(7), &versions);
assert_eq!(
changes,
TableChanges {
version: TableVersion(10),
complete: true,
truncated: false,
rows: vec![
TouchedRow {
row: MARIA,
kind: RowChangeKind::Insert,
},
TouchedRow {
row: OMAR,
kind: RowChangeKind::Delete,
},
],
columns: vec![TouchedColumn {
column: PLUS_ONES,
kind: ColumnChangeKind::Delete,
}],
}
);
}
#[test]
fn a_gap_in_a_tables_journal_makes_its_changes_incomplete() {
let versions = [VersionTouches {
version: TableVersion(9),
rows: vec![(MARIA, RowChangeKind::Update)],
columns: Vec::new(),
}];
let changes = table_changes(TableVersion(7), &versions);
assert_eq!(
changes,
TableChanges {
version: TableVersion(9),
complete: false,
truncated: false,
rows: vec![TouchedRow {
row: MARIA,
kind: RowChangeKind::Update,
}],
columns: Vec::new(),
}
);
}