toasty-driver-integration-suite 0.5.0

Integration test suite for Toasty database drivers
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

use crate::prelude::*;

use bigdecimal::BigDecimal;
use std::str::FromStr;

#[driver_test(id(ID))]
pub async fn ty_bigdecimal(test: &mut Test) -> Result<(), BoxError> {
    #[derive(Debug, toasty::Model)]
    struct Item {
        #[key]
        #[auto]
        id: ID,
        val: BigDecimal,
    }

    let mut db = test.setup_db(models!(Item)).await;

    let test_values = vec![
        BigDecimal::from_str("0")?,
        BigDecimal::from_str("1")?,
        BigDecimal::from_str("-1")?,
        BigDecimal::from_str("123.456")?,
        BigDecimal::from_str("-123.456")?,
        BigDecimal::from_str("0.0000000001")?, // Small positive
        BigDecimal::from_str("-0.0000000001")?, // Small negative
        BigDecimal::from_str("99999999999999999999.99999999999999999999")?, // Large with precision
        BigDecimal::from_str("-99999999999999999999.99999999999999999999")?, // Large negative with precision
        BigDecimal::from_str("3.141592653589793238462643383279")?,           // Pi approximation
    ];

    for val in &test_values {
        let created = Item::create().val(val.clone()).exec(&mut db).await?;
        let read = Item::get_by_id(&mut db, &created.id).await?;
        assert_eq!(read.val, *val, "Round-trip failed for: {}", val);
    }
    Ok(())
}

#[driver_test(id(ID))]
pub async fn ty_bigdecimal_as_text(test: &mut Test) -> Result<(), BoxError> {
    #[derive(Debug, toasty::Model)]
    struct Item {
        #[key]
        #[auto]
        id: ID,

        #[column(type = text)]
        val: BigDecimal,
    }

    let mut db = test.setup_db(models!(Item)).await;

    let test_values = vec![
        BigDecimal::from_str("0")?,
        BigDecimal::from_str("123.456")?,
        BigDecimal::from_str("-123.456")?,
        BigDecimal::from_str("99999999999999999999.99999999999999999999")?,
    ];

    for val in &test_values {
        let created = Item::create().val(val.clone()).exec(&mut db).await?;
        let read = Item::get_by_id(&mut db, &created.id).await?;
        assert_eq!(read.val, *val, "Round-trip failed for: {}", val);
    }
    Ok(())
}

#[driver_test(
    id(ID),
    requires(and(bigdecimal_implemented, decimal_arbitrary_precision))
)]
pub async fn ty_bigdecimal_as_numeric_arbitrary_precision(test: &mut Test) -> Result<(), BoxError> {
    #[derive(Debug, toasty::Model)]
    struct Item {
        #[key]
        #[auto]
        id: ID,
        #[column(type = numeric)]
        val: BigDecimal,
    }

    let mut db = test.setup_db(models!(Item)).await;

    let test_values = vec![
        BigDecimal::from_str("0")?,
        BigDecimal::from_str("123.456")?,
        BigDecimal::from_str("-123.456")?,
        BigDecimal::from_str("99999999999999999999.99999999999999999999")?,
        BigDecimal::from_str("3.141592653589793238462643383279")?,
    ];

    for val in &test_values {
        let created = Item::create().val(val.clone()).exec(&mut db).await?;
        let read = Item::get_by_id(&mut db, &created.id).await?;
        assert_eq!(read.val, *val, "Round-trip failed for: {}", val);
    }
    Ok(())
}

#[driver_test(id(ID), requires(and(native_decimal, bigdecimal_implemented)))]
pub async fn ty_bigdecimal_as_numeric_fixed_precision(test: &mut Test) -> Result<(), BoxError> {
    #[derive(Debug, toasty::Model)]
    struct Item {
        #[key]
        #[auto]
        id: ID,
        #[column(type = numeric(38, 20))]
        val: BigDecimal,
    }

    let mut db = test.setup_db(models!(Item)).await;

    let test_values = vec![
        BigDecimal::from_str("0")?,
        BigDecimal::from_str("123.456")?,
        BigDecimal::from_str("-123.456")?,
        BigDecimal::from_str("123456789012345678.12345678901234567890")?, // Within precision(38,20)
        BigDecimal::from_str("3.14159265358979323846")?,
    ];

    for val in &test_values {
        let created = Item::create().val(val.clone()).exec(&mut db).await?;
        let read = Item::get_by_id(&mut db, &created.id).await?;
        assert_eq!(read.val, *val, "Round-trip failed for: {}", val);
    }
    Ok(())
}