toolu-orm-core 0.2.0

Schema definitions, migrations and driver traits for toolu-orm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Renaming a virtual table is an ordinary `RenameTable`, and it is not a way
//! to smuggle an in-place change past the refusals.

use toolu_orm_core::column::ColumnType;
use toolu_orm_core::diff::{diff_with_resolver, Operation};
use toolu_orm_core::fts5::Fts5Table;
use toolu_orm_core::index::IndexDef;

use super::test_helpers::{col, table};
use super::virtual_table_fixture::{
  memory_fts, registry, snapshot_of, RenameMemoryFts, NO_INDEXES_REASON,
};

#[test]
fn renaming_a_virtual_table_renames_it_without_recreating() {
  let old = snapshot_of(vec![memory_fts()]);
  let mut renamed = memory_fts();
  renamed.name = "note_fts".to_owned();
  let ops = diff_with_resolver(&old, &registry(vec![renamed]), &RenameMemoryFts)
    .expect("diff should succeed");
  assert_eq!(
    ops,
    vec![Operation::RenameTable {
      old: "memory_fts".to_owned(),
      new: "note_fts".to_owned()
    }]
  );
}

/// The rename path reaches the same checks as the unrenamed one.
#[test]
fn renaming_a_virtual_table_while_changing_it_is_refused() {
  let old = snapshot_of(vec![memory_fts()]);
  let retokenized = Fts5Table::new("note_fts")
    .unindexed_column("memory_id", ColumnType::Text)
    .column("body", ColumnType::Text)
    .tokenize("unicode61")
    .build();
  let error = diff_with_resolver(&old, &registry(vec![retokenized]), &RenameMemoryFts)
    .expect_err("expected the change to be refused");
  assert!(
    error
      .to_string()
      .contains("note_fts\" in place: its module arguments changed"),
    "unexpected error: {error}"
  );
}

#[test]
fn renaming_a_virtual_table_onto_an_index_is_refused() {
  let old = snapshot_of(vec![memory_fts()]);
  let mut indexed = memory_fts();
  indexed.name = "note_fts".to_owned();
  indexed.indexes.push(IndexDef {
    name: "idx_note_fts_body".to_owned(),
    columns: vec!["body".to_owned()],
    unique: false,
  });
  let error = diff_with_resolver(&old, &registry(vec![indexed]), &RenameMemoryFts)
    .expect_err("expected the change to be refused");
  assert!(
    error.to_string().contains(NO_INDEXES_REASON),
    "unexpected error: {error}"
  );
}

/// Renaming an ordinary table onto a virtual one is still a kind change.
#[test]
fn renaming_an_ordinary_table_into_a_virtual_one_is_refused() {
  let ordinary = table(
    "memory_fts",
    vec![col("body", ColumnType::Text, false, false)],
  );
  let old = snapshot_of(vec![ordinary]);
  let mut renamed = memory_fts();
  renamed.name = "note_fts".to_owned();
  let error = diff_with_resolver(&old, &registry(vec![renamed]), &RenameMemoryFts)
    .expect_err("expected the change to be refused");
  assert!(
    error
      .to_string()
      .contains("it became a virtual table using fts5"),
    "unexpected error: {error}"
  );
}