a3s-orm 0.3.1

A type-safe, executor-neutral SQL query builder for Rust
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#![cfg(feature = "sqlite")]

use a3s_orm::{
    orm_table, select_from, Database, Migration, MigrationError, Migrator, SqliteDialect,
    SqliteExecutor,
};

orm_table! {
    struct Widget => "widget" {
        id: i64 => "id",
    }
}

orm_table! {
    struct RollbackProbe => "rollback_probe" {
        id: i64 => "id",
    }
}

fn migrations() -> Vec<Migration> {
    vec![
        Migration::new(
            "001",
            "create widgets",
            "create table widget (id integer primary key)",
        ),
        Migration::new("002", "seed widgets", "insert into widget (id) values (1)"),
    ]
}

#[tokio::test]
async fn applies_once_and_reports_up_to_date() {
    let executor = SqliteExecutor::open_in_memory().await.unwrap();
    let migrator = Migrator::new(executor.clone());
    let first = migrator.run(migrations()).await.unwrap();
    assert_eq!(first.applied, ["001", "002"]);
    let second = migrator.run(migrations()).await.unwrap();
    assert!(second.is_up_to_date());

    let database = Database::new(SqliteDialect, executor);
    let rows = database
        .fetch_all_as(select_from::<Widget>().select(Widget::id()))
        .await
        .unwrap()
        .rows;
    assert_eq!(rows, vec![1]);
}

#[tokio::test]
async fn serving_admission_reads_the_ledger_without_creating_it() {
    let executor = SqliteExecutor::open_in_memory().await.unwrap();
    let migrator = Migrator::new(executor);

    let absent = migrator.verify_required(migrations()).await.unwrap_err();
    assert!(matches!(
        absent,
        a3s_orm::migration::MigrationRunError::Backend(a3s_orm::SqliteMigrationError::Driver(_))
    ));

    let applied = migrator.run(migrations()).await.unwrap();
    assert_eq!(applied.applied, ["001", "002"]);
    migrator.verify_required(migrations()).await.unwrap();
}

#[tokio::test]
async fn detects_changed_and_missing_source_migrations() {
    let executor = SqliteExecutor::open_in_memory().await.unwrap();
    let migrator = Migrator::new(executor);
    migrator.run(migrations()).await.unwrap();

    let changed = migrator
        .run([
            Migration::new(
                "001",
                "create widgets",
                "create table widget (id integer primary key, changed text)",
            ),
            migrations().remove(1),
        ])
        .await
        .unwrap_err();
    assert!(matches!(
        changed,
        a3s_orm::migration::MigrationRunError::Backend(a3s_orm::SqliteMigrationError::Migration(
            MigrationError::ChecksumMismatch { .. }
        ))
    ));

    let missing = migrator.run([migrations().remove(1)]).await.unwrap_err();
    assert!(matches!(
        missing,
        a3s_orm::migration::MigrationRunError::Backend(
            a3s_orm::SqliteMigrationError::Migration(
                MigrationError::MissingSourceMigration(version)
            )
        ) if version == "001"
    ));
}

#[tokio::test]
async fn failed_migration_rolls_back_schema_and_history() {
    let executor = SqliteExecutor::open_in_memory().await.unwrap();
    let migrator = Migrator::new(executor.clone());
    let error = migrator
        .run([Migration::new(
            "001",
            "broken migration",
            "create table rollback_probe (id integer); invalid sql",
        )])
        .await;
    let error = error.unwrap_err();
    assert!(error.to_string().contains("001"));

    let database = Database::new(SqliteDialect, executor.clone());
    assert!(database
        .fetch_all(select_from::<RollbackProbe>().select(RollbackProbe::id()))
        .await
        .is_err());

    let repaired = migrator
        .run([Migration::new(
            "001",
            "broken migration",
            "create table rollback_probe (id integer)",
        )])
        .await
        .unwrap();
    assert_eq!(repaired.applied, ["001"]);
}

#[tokio::test]
async fn concurrent_migrators_serialize_on_the_shared_connection() {
    let executor = SqliteExecutor::open_in_memory().await.unwrap();
    let left = Migrator::new(executor.clone());
    let right = Migrator::new(executor);
    let (left, right) = tokio::join!(left.run(migrations()), right.run(migrations()));
    let applied = left.unwrap().applied.len() + right.unwrap().applied.len();
    assert_eq!(applied, 2);
}