mockgres 0.0.26

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

mod common;

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

    ctx.client
        .execute("create table partitions(id int primary key)", &[])
        .await
        .expect("create partitions");
    ctx.client
        .execute(
            "create table wal_file_offsets(
                partition_id int not null references partitions(id),
                base_offset int not null
            )",
            &[],
        )
        .await
        .expect("create wal_file_offsets");

    ctx.client
        .execute(
            "alter table wal_file_offsets drop constraint wal_file_offsets_partition_id_fkey",
            &[],
        )
        .await
        .expect("drop foreign key constraint by default name");

    ctx.client
        .execute("alter table wal_file_offsets drop column partition_id", &[])
        .await
        .expect("drop non-last column after dropping FK");

    ctx.client
        .execute("insert into wal_file_offsets values (123)", &[])
        .await
        .expect("insert without parent after dropping FK");

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

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

    ctx.client
        .execute(
            "create table partitions(
                topic_name text not null,
                partition_number int not null,
                id int primary key,
                unique(topic_name, partition_number)
            )",
            &[],
        )
        .await
        .expect("create partitions");
    ctx.client
        .execute(
            "create table wal_file_offsets(
                topic_name text not null,
                partition_number int not null
            )",
            &[],
        )
        .await
        .expect("create wal_file_offsets");
    ctx.client
        .execute("insert into partitions values ('topic-a', 0, 1)", &[])
        .await
        .expect("insert partition");
    ctx.client
        .execute("insert into wal_file_offsets values ('topic-a', 0)", &[])
        .await
        .expect("insert child row before FK");

    ctx.client
        .execute(
            "alter table wal_file_offsets add constraint wal_file_offsets_topic_name_partition_number_fkey \
             foreign key (topic_name, partition_number) references partitions(topic_name, partition_number) on delete cascade",
            &[],
        )
        .await
        .expect("add foreign key");

    let err = ctx
        .client
        .execute("insert into wal_file_offsets values ('missing', 0)", &[])
        .await
        .expect_err("insert without parent should fail");
    let db_err = err.as_db_error().expect("expected db error");
    assert!(
        db_err.message().contains("foreign key"),
        "unexpected error: {:?}",
        db_err.message()
    );

    ctx.client
        .execute("insert into wal_file_offsets values ('topic-a', 0)", &[])
        .await
        .expect("insert child row after FK");

    ctx.client
        .execute("delete from partitions where id = 1", &[])
        .await
        .expect("delete parent should cascade");

    let row = ctx
        .client
        .query_one("select count(*) from wal_file_offsets", &[])
        .await
        .expect("count child rows");
    let count: i64 = row.get(0);
    assert_eq!(count, 0);

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