sea-orm-spanner 0.1.0

Google Cloud Spanner backend for SeaORM
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

mod common;
mod entity;

use {
    common::setup_test_database,
    entity::numeric_types,
    rust_decimal::Decimal,
    rust_decimal_macros::dec,
    sea_orm::{ActiveModelTrait, EntityTrait, Set},
    serial_test::serial,
};

mod numeric_type_tests {
    use super::*;

    #[tokio::test]
    #[serial]
    async fn test_numeric_insert_and_select() {
        let db = setup_test_database().await;
        let id = uuid::Uuid::new_v4().to_string();

        let value = dec!(12345.6789);
        let model = numeric_types::ActiveModel {
            id: Set(id.clone()),
            numeric_val: Set(value),
            numeric_nullable: Set(Some(dec!(999.999))),
        };

        let inserted = model.insert(&db).await.expect("Insert failed");
        assert_eq!(inserted.numeric_val, value);
        assert_eq!(inserted.numeric_nullable, Some(dec!(999.999)));

        let selected = numeric_types::Entity::find_by_id(&id)
            .one(&db)
            .await
            .expect("Select failed")
            .expect("Entity not found");
        assert_eq!(selected.numeric_val, value);
        assert_eq!(selected.numeric_nullable, Some(dec!(999.999)));
    }

    #[tokio::test]
    #[serial]
    async fn test_numeric_negative() {
        let db = setup_test_database().await;
        let id = uuid::Uuid::new_v4().to_string();

        let negative = dec!(-12345.6789);
        let model = numeric_types::ActiveModel {
            id: Set(id.clone()),
            numeric_val: Set(negative),
            numeric_nullable: Set(Some(dec!(-0.001))),
        };

        let inserted = model.insert(&db).await.expect("Insert failed");
        assert_eq!(inserted.numeric_val, negative);
        assert_eq!(inserted.numeric_nullable, Some(dec!(-0.001)));

        let selected = numeric_types::Entity::find_by_id(&id)
            .one(&db)
            .await
            .expect("Select failed")
            .expect("Entity not found");
        assert_eq!(selected.numeric_val, negative);
    }

    #[tokio::test]
    #[serial]
    async fn test_numeric_high_precision() {
        let db = setup_test_database().await;
        let id = uuid::Uuid::new_v4().to_string();

        let large_val = dec!(9999999999999999999.999999999);
        let model = numeric_types::ActiveModel {
            id: Set(id.clone()),
            numeric_val: Set(large_val),
            numeric_nullable: Set(None),
        };

        let inserted = model.insert(&db).await.expect("Insert failed");
        assert_eq!(inserted.numeric_val, large_val);

        let selected = numeric_types::Entity::find_by_id(&id)
            .one(&db)
            .await
            .expect("Select failed")
            .expect("Entity not found");
        assert_eq!(selected.numeric_val, large_val);
    }

    #[tokio::test]
    #[serial]
    async fn test_numeric_from_string() {
        let db = setup_test_database().await;
        let id = uuid::Uuid::new_v4().to_string();

        let value: Decimal = "123456789.123456789".parse().unwrap();
        let model = numeric_types::ActiveModel {
            id: Set(id.clone()),
            numeric_val: Set(value),
            numeric_nullable: Set(Some(dec!(1.0))),
        };

        let inserted = model.insert(&db).await.expect("Insert failed");
        assert_eq!(inserted.numeric_val, value);

        let selected = numeric_types::Entity::find_by_id(&id)
            .one(&db)
            .await
            .expect("Select failed")
            .expect("Entity not found");
        assert_eq!(selected.numeric_val, value);
    }
}