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
119
120
121
122
123
124
125
126
127

mod common;

use tokio_postgres::Row;
use tokio_postgres::error::SqlState;

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

    ctx.client
        .execute("create table t(v float8)", &[])
        .await
        .expect("create");

    // insert constants only: 1, 2, NaN, 3, NaN
    ctx.client
        .execute(
            "insert into t values (1.0),(2.0),(float8 'NaN'),(3.0),(float8 'NaN')",
            &[],
        )
        .await
        .expect("insert");

    // v = v should be true even for NaN with our postgres-like rule
    let rows: Vec<Row> = ctx
        .client
        .query("select v from t where v = v", &[])
        .await
        .expect("select v=v");
    assert_eq!(rows.len(), 5);

    // compare against a param in where (extended protocol)
    let stmt = ctx
        .client
        .prepare("select v from t where v > $1")
        .await
        .expect("prepare with param");
    let rows: Vec<Row> = ctx
        .client
        .query(&stmt, &[&123.0_f64])
        .await
        .expect("v > param");
    assert_eq!(rows.len(), 2, "only the two NaNs are > 123.0");
    for row in rows {
        let v: Option<f64> = row.get(0);
        assert!(v.map(|x| x.is_nan()).unwrap_or(false));
    }

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

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

    ctx.client
        .execute("create table t(v float8)", &[])
        .await
        .expect("create");

    // constants: 2.0, null, NaN, 1.0
    ctx.client
        .execute(
            "insert into t values (2.0),(null),(float8 'NaN'),(1.0)",
            &[],
        )
        .await
        .expect("insert");

    // asc: expect 1.0, 2.0, NaN, NULL (nulls last)
    let asc_rows: Vec<Row> = ctx
        .client
        .query("select v from t order by 1 asc", &[])
        .await
        .expect("asc");
    let asc_vals: Vec<Option<f64>> = asc_rows
        .iter()
        .map(|r| r.get::<_, Option<f64>>(0))
        .collect();

    assert!(asc_vals[0] == Some(1.0));
    assert!(asc_vals[1] == Some(2.0));
    assert!(asc_vals[2].map(|x| x.is_nan()).unwrap_or(false));
    assert!(asc_vals[3].is_none());

    // desc: default nulls first, then NaN, then numbers
    let desc_rows: Vec<Row> = ctx
        .client
        .query("select v from t order by 1 desc", &[])
        .await
        .expect("desc");
    let desc_vals: Vec<Option<f64>> = desc_rows
        .iter()
        .map(|r| r.get::<_, Option<f64>>(0))
        .collect();

    assert!(desc_vals[0].is_none());
    assert!(desc_vals[1].map(|x| x.is_nan()).unwrap_or(false));
    assert!(desc_vals[2] == Some(2.0));
    assert!(desc_vals[3] == Some(1.0));

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

#[tokio::test(flavor = "multi_thread")]
async fn insert_nan_requires_explicit_literal() {
    let ctx = common::start().await;
    ctx.client
        .execute("create table nan_insert(v float8)", &[])
        .await
        .expect("create table");

    ctx.client
        .execute("insert into nan_insert values (float8 'NaN')", &[])
        .await
        .expect("literal NaN insert");

    let err = ctx
        .client
        .execute("insert into nan_insert values (nan)", &[])
        .await
        .expect_err("bare identifier nan should fail");
    assert_eq!(err.code(), Some(&SqlState::INTERNAL_ERROR));
    common::assert_db_error_contains(&err, "INSERT expressions cannot reference columns");

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