rullst-orm 12.1.1

Fast, un-opinionated, database-agnostic ORM and query builder for Rust
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

use super::*;

#[test]
fn capabilities_include_the_bounded_typed_model_profile() {
    let capabilities = TursoStore::capabilities();
    assert!(capabilities.supports(Capability::EdgeSql));
    assert!(capabilities.supports(Capability::RelationalModels));
    assert!(!capabilities.supports(Capability::Documents));
}

fn statement(sql: &str, parameters: Vec<TursoValue>) -> TursoStatement {
    TursoStatement::new(sql, parameters).unwrap()
}

#[tokio::test]
async fn offline_fallback_executes_real_parameterized_sql() {
    let store = TursoStore::connect(TursoConfig::new("mock_local", ""))
        .await
        .unwrap();
    assert!(store.is_offline());
    store
        .execute(statement(
            "CREATE TABLE events (sequence INTEGER, label TEXT)",
            vec![],
        ))
        .await
        .unwrap();
    store
        .transaction(vec![
            statement(
                "INSERT INTO events VALUES (?1, ?2)",
                vec![TursoValue::Integer(1), TursoValue::Text("one".into())],
            ),
            statement(
                "INSERT INTO events VALUES (?1, ?2)",
                vec![TursoValue::Integer(2), TursoValue::Text("two".into())],
            ),
        ])
        .await
        .unwrap();
    let rows = store
        .query(
            statement(
                "SELECT sequence, label FROM events WHERE sequence >= ?1 ORDER BY sequence",
                vec![TursoValue::Integer(1)],
            ),
            TursoQueryLimit::new(1).unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    assert_eq!(rows[0].get("sequence"), Some(&TursoValue::Integer(1)));
    assert_eq!(rows[0].get("label"), Some(&TursoValue::Text("one".into())));
}

#[test]
fn validates_transport_tokens_statements_and_bounds() {
    assert!(
        TursoConfig::new("https://example.turso.io", "")
            .validate()
            .is_err()
    );
    assert!(
        TursoConfig::new("http://example.turso.io", "token")
            .validate()
            .is_err()
    );
    assert!(
        TursoConfig::new("ftp://127.0.0.1:8080", "")
            .allow_insecure_loopback()
            .validate()
            .is_err()
    );
    assert!(
        TursoConfig::new("http://127.0.0.1:8080", "")
            .allow_insecure_loopback()
            .validate()
            .is_ok()
    );
    assert!(TursoStatement::new("", vec![]).is_err());
    assert!(TursoStatement::new("SELECT 1", vec![TursoValue::Null; 1_025]).is_err());
    assert!(
        TursoStatement::new(
            "SELECT ?1",
            vec![TursoValue::Blob(vec![0; MAX_PARAMETER_BYTES + 1])],
        )
        .is_err()
    );
    assert!(TursoQueryLimit::new(0).is_err());
    assert!(TursoQueryLimit::new(10_001).is_err());
    assert!(!format!("{:?}", TursoConfig::new("mock_local", "secret")).contains("secret"));
}