tank-tests 0.36.0

Test suide for drivers of Tank: the Rust data layer. This is intended to be used by drivers to implement common unit tests.
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

#![allow(dead_code)]
#![allow(unused_imports)]
use std::{pin::pin, str::FromStr, sync::LazyLock};
use tank::{
    Driver, DynQuery, Entity, Executor, Interval, Query, QueryBuilder, QueryResult, RawQuery,
    SqlWriter,
    stream::{StreamExt, TryStreamExt},
};
use tokio::sync::Mutex;
use uuid::Uuid;

static MUTEX: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));

#[derive(Entity, Debug, PartialEq)]
struct Container {
    first: [[Interval; 2]; 1],
    second: [[[Uuid; 1]; 3]; 1],
}

pub async fn arrays2(executor: &mut impl Executor) {
    let _ = MUTEX.lock().await;

    // Multiple statements
    #[cfg(not(feature = "disable-multiple-statements"))]
    {
        let mut query = DynQuery::default();
        let writer = executor.driver().sql_writer();
        writer.write_drop_table::<Container>(&mut query, true);
        writer.write_create_table::<Container>(&mut query, true);
        let value = Container {
            first: [[
                Interval::from_years(500),
                Interval::from_micros(1) + Interval::from_months(4),
            ]],
            second: [[
                [Uuid::from_str("c1412337-cfce-444a-ac46-5e6edcc0bf23").unwrap()],
                [Uuid::from_str("00000000-0000-0000-0000-000000000000").unwrap()],
                [Uuid::from_str("9d7f0f5b-19d6-4298-a332-214fc85e2652").unwrap()],
            ]],
        };
        writer.write_insert(&mut query, &[value], false);
        writer.write_select(
            &mut query,
            &QueryBuilder::new()
                .select(Container::columns())
                .from(Container::table())
                .where_expr(true)
                .limit(Some(1)),
        );
        let rows = pin!(executor.run(query).try_filter_map(|v| async move {
            Ok(match v {
                QueryResult::Row(v) => Some(v),
                QueryResult::Affected(..) => None,
            })
        }));
        let rows = rows
            .map(|v| v.and_then(Container::from_row))
            .try_collect::<Vec<_>>()
            .await
            .expect("Coult not execute the query");
        assert_eq!(
            rows,
            [Container {
                first: [[
                    Interval::from_years(500),
                    Interval::from_micros(1) + Interval::from_months(4),
                ]],
                second: [[
                    [Uuid::from_str("c1412337-cfce-444a-ac46-5e6edcc0bf23").unwrap()],
                    [Uuid::from_str("00000000-0000-0000-0000-000000000000").unwrap()],
                    [Uuid::from_str("9d7f0f5b-19d6-4298-a332-214fc85e2652").unwrap()],
                ]],
            }]
        )
    }
}