ormer 0.2.7

A minimalist ORM framework that supports SQLite, PostgreSQL, MySQL, and SqlServer
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

#![cfg(feature = "sqlite")]

use ormer::{Database, DbType, Model, Value};
use std::sync::{Arc, Mutex};
use std::time::Duration;

static TRACE_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());

#[derive(Debug, Model)]
#[table = "sql_trace_users"]
struct SqlTraceUser {
    #[primary]
    id: i32,
    name: String,
}

fn is_trace_test_sql(sql: &str) -> bool {
    sql.contains("sql_trace_users") || sql.contains("missing_sql_trace_table")
}

#[tokio::test]
async fn sql_trace_records_callbacks_and_parameter_view() -> ormer::Result<()> {
    let _guard = TRACE_TEST_LOCK.lock().await;

    let db = Database::connect(DbType::Sqlite, ":memory:").await?;
    let before_sql = Arc::new(Mutex::new(Vec::<String>::new()));
    let after_sql = Arc::new(Mutex::new(Vec::<String>::new()));
    let error_sql = Arc::new(Mutex::new(Vec::<String>::new()));
    let slow_sql = Arc::new(Mutex::new(Vec::<String>::new()));
    let seen_params = Arc::new(Mutex::new(Vec::<Vec<Value>>::new()));

    db.sql_trace()
        .clear()
        .redact_params(|params| {
            params
                .iter()
                .map(|_| Value::Text("***".to_string()))
                .collect()
        })
        .rewrite(|sql| {
            if is_trace_test_sql(sql) {
                format!("{sql} /* traced */")
            } else {
                sql.to_string()
            }
        })
        .before_with({
            let before_sql = Arc::clone(&before_sql);
            let seen_params = Arc::clone(&seen_params);
            move |event| {
                if is_trace_test_sql(event.sql()) {
                    before_sql.lock().unwrap().push(event.sql().to_string());
                    seen_params.lock().unwrap().push(event.params().to_vec());
                }
            }
        })
        .after({
            let after_sql = Arc::clone(&after_sql);
            move |sql, _elapsed| {
                if is_trace_test_sql(sql) {
                    after_sql.lock().unwrap().push(sql.to_string());
                }
            }
        })
        .on_error({
            let error_sql = Arc::clone(&error_sql);
            move |sql, _err| {
                if is_trace_test_sql(sql) {
                    error_sql.lock().unwrap().push(sql.to_string());
                }
            }
        })
        .slow_sql_threshold(Duration::ZERO)
        .slow({
            let slow_sql = Arc::clone(&slow_sql);
            move |sql, _elapsed| {
                if is_trace_test_sql(sql) {
                    slow_sql.lock().unwrap().push(sql.to_string());
                }
            }
        });

    db.create_table::<SqlTraceUser>().execute().await?;
    db.insert(&SqlTraceUser {
        id: 1,
        name: "Alice".to_string(),
    })
    .execute()
    .await?;
    let users: Vec<SqlTraceUser> = db
        .select::<SqlTraceUser>()
        .filter(|user| user.name.eq("Alice".to_string()))
        .collect()
        .await?;

    assert_eq!(users.len(), 1);

    let err = db
        .execute_sql("INSERT INTO missing_sql_trace_table (id) VALUES (1)")
        .await
        .unwrap_err();
    assert!(err.to_string().contains("missing_sql_trace_table"));

    db.sql_trace().clear();

    let before_sql = before_sql.lock().unwrap();
    let after_sql = after_sql.lock().unwrap();
    let error_sql = error_sql.lock().unwrap();
    let slow_sql = slow_sql.lock().unwrap();
    let seen_params = seen_params.lock().unwrap();

    assert!(before_sql.iter().any(|sql| sql.contains("CREATE TABLE")));
    assert!(before_sql.iter().any(|sql| sql.contains("INSERT INTO")));
    assert!(before_sql.iter().any(|sql| sql.contains("SELECT")));
    assert!(before_sql.iter().all(|sql| sql.contains("/* traced */")));
    assert!(after_sql.iter().any(|sql| sql.contains("SELECT")));
    assert_eq!(error_sql.len(), 1);
    assert!(error_sql[0].contains("missing_sql_trace_table"));
    assert!(!slow_sql.is_empty());
    assert!(
        seen_params
            .iter()
            .flatten()
            .any(|value| matches!(value, Value::Text(value) if value == "***"))
    );

    Ok(())
}