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

mod common;

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

    ctx.client
        .execute(
            "create table pk_demo(a int, b int, primary key (a, b))",
            &[],
        )
        .await
        .expect("create pk_demo");

    ctx.client
        .execute("insert into pk_demo values (1, 2)", &[])
        .await
        .expect("insert first row");

    let err = ctx
        .client
        .execute("insert into pk_demo values (1, 2)", &[])
        .await
        .expect_err("duplicate composite key");
    common::assert_db_error_contains(&err, "duplicate key");

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

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

    ctx.client
        .execute(
            "create table parents(a int, b int, primary key (a, b))",
            &[],
        )
        .await
        .expect("create parents");
    ctx.client
        .execute(
            "create table children(x int, y int, foreign key (x, y) references parents(a, b))",
            &[],
        )
        .await
        .expect("create children");

    let err = ctx
        .client
        .execute("insert into children values (1, 1)", &[])
        .await
        .expect_err("insert without parent");
    common::assert_db_error_contains(&err, "foreign key");

    ctx.client
        .execute("insert into parents values (1, 1)", &[])
        .await
        .expect("insert parent");
    ctx.client
        .execute("insert into children values (1, 1)", &[])
        .await
        .expect("insert child");

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

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

    ctx.client
        .execute(
            "create table pk_updates(a int, b int, primary key (a, b))",
            &[],
        )
        .await
        .expect("create pk_updates");
    ctx.client
        .execute("insert into pk_updates values (1, 1), (2, 2)", &[])
        .await
        .expect("insert initial rows");

    let err = ctx
        .client
        .execute("update pk_updates set a = 1, b = 1 where a = 2", &[])
        .await
        .expect_err("update into duplicate key");
    common::assert_db_error_contains(&err, "duplicate key");

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

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

    ctx.client
        .execute(
            "create table updates_parent(a int, b int, primary key (a, b))",
            &[],
        )
        .await
        .expect("create parents");
    ctx.client
        .execute(
            "create table updates_child(id int primary key, x int, y int, foreign key (x, y) references updates_parent(a, b))",
            &[],
        )
        .await
        .expect("create child");
    ctx.client
        .execute("insert into updates_parent values (1, 1)", &[])
        .await
        .expect("insert parent");
    ctx.client
        .execute("insert into updates_child values (1, 1, 1)", &[])
        .await
        .expect("insert child");

    let err = ctx
        .client
        .execute("update updates_child set x = 2 where id = 1", &[])
        .await
        .expect_err("update to missing parent");
    common::assert_db_error_contains(&err, "foreign key");

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

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

    ctx.client
        .execute(
            "create table del_parent(a int, b int, primary key (a, b))",
            &[],
        )
        .await
        .expect("create parent");
    ctx.client
        .execute(
            "create table del_child(id int primary key, x int, y int, foreign key (x, y) references del_parent(a, b))",
            &[],
        )
        .await
        .expect("create child");
    ctx.client
        .execute("insert into del_parent values (1, 1)", &[])
        .await
        .expect("insert parent");
    ctx.client
        .execute("insert into del_child values (1, 1, 1)", &[])
        .await
        .expect("insert child");

    let err = ctx
        .client
        .execute("delete from del_parent where a = 1 and b = 1", &[])
        .await
        .expect_err("delete referenced parent");
    common::assert_db_error_contains(&err, "foreign key");

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