mockgres 0.0.29

An in-memory database that replicates a reasonable subset of Postgres functionality to make unit tests that rely on a database to run.
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

mod common;

use tokio_postgres::types::Type;

#[tokio::test(flavor = "multi_thread")]
async fn prepared_select_supports_multiple_portals() {
    let mut ctx = common::start().await;

    ctx.client
        .execute(
            "create table portal_demo(id int primary key, score int, active bool)",
            &[],
        )
        .await
        .expect("create table");
    ctx.client
        .execute(
            "insert into portal_demo values
                (1, 5, true),
                (2, 15, true),
                (3, 25, false),
                (4, 35, false)",
            &[],
        )
        .await
        .expect("insert rows");

    let stmt = ctx
        .client
        .prepare(
            "select id from portal_demo
             where score >= $1 and active = $2
             order by id",
        )
        .await
        .expect("prepare select");

    let txn = ctx.client.transaction().await.expect("start txn");
    let portal_active = txn.bind(&stmt, &[&10_i32, &true]).await.expect("bind 1");
    let portal_inactive = txn.bind(&stmt, &[&10_i32, &false]).await.expect("bind 2");

    let ids_active: Vec<i32> = txn
        .query_portal(&portal_active, 0)
        .await
        .expect("query portal 1")
        .into_iter()
        .map(|row| row.get(0))
        .collect();
    let ids_inactive: Vec<i32> = txn
        .query_portal(&portal_inactive, 0)
        .await
        .expect("query portal 2")
        .into_iter()
        .map(|row| row.get(0))
        .collect();

    assert_eq!(ids_active, vec![2]);
    assert_eq!(ids_inactive, vec![3, 4]);
    txn.commit().await.expect("commit txn");

    let _ = ctx.shutdown.send(());
}

#[tokio::test(flavor = "multi_thread")]
async fn prepared_update_behaves_inside_and_outside_transactions() {
    let ctx = common::start().await;

    ctx.client
        .execute(
            "create table prepared_stock(id int primary key, qty int)",
            &[],
        )
        .await
        .expect("create table");
    ctx.client
        .execute("insert into prepared_stock values (1, 10)", &[])
        .await
        .expect("seed row");

    let select_stmt = ctx
        .client
        .prepare("select qty from prepared_stock where id = $1")
        .await
        .expect("prepare select");
    let update_stmt = ctx
        .client
        .prepare("update prepared_stock set qty = qty + $1 where id = $2")
        .await
        .expect("prepare update");

    let original: i32 = ctx
        .client
        .query_one(&select_stmt, &[&1_i32])
        .await
        .expect("initial select")
        .get(0);
    assert_eq!(original, 10);

    ctx.client.execute("begin", &[]).await.expect("begin");
    ctx.client
        .execute(&update_stmt, &[&5_i32, &1_i32])
        .await
        .expect("update in txn");
    let mid: i32 = ctx
        .client
        .query_one(&select_stmt, &[&1_i32])
        .await
        .expect("select in txn")
        .get(0);
    assert_eq!(mid, original + 5);
    ctx.client.execute("rollback", &[]).await.expect("rollback");

    let after_rollback: i32 = ctx
        .client
        .query_one(&select_stmt, &[&1_i32])
        .await
        .expect("select after rollback")
        .get(0);
    assert_eq!(after_rollback, original);

    ctx.client
        .execute(&update_stmt, &[&3_i32, &1_i32])
        .await
        .expect("autocommit update");
    let final_qty: i32 = ctx
        .client
        .query_one(&select_stmt, &[&1_i32])
        .await
        .expect("select after commit")
        .get(0);
    assert_eq!(final_qty, original + 3);

    let _ = ctx.shutdown.send(());
}

#[tokio::test(flavor = "multi_thread")]
async fn prepared_bool_parameter_works_in_update_case_condition() {
    let ctx = common::start().await;
    ctx.client
        .batch_execute(
            "create table case_updates (
                 id text primary key,
                 state text not null
             );
             insert into case_updates values ('1', 'ARMED');",
        )
        .await
        .unwrap();

    let statement = ctx
        .client
        .prepare(
            "update case_updates
                set state = case when $1 then 'ACTIVE' else state end
              where id = '1'",
        )
        .await
        .unwrap();
    assert_eq!(statement.params(), &[Type::BOOL]);
    assert_eq!(ctx.client.execute(&statement, &[&true]).await.unwrap(), 1);

    let row = ctx
        .client
        .query_one("select state from case_updates where id = '1'", &[])
        .await
        .unwrap();
    assert_eq!(row.get::<_, String>(0), "ACTIVE");

    let _ = ctx.shutdown.send(());
}