edgedb-query 0.2.2

Crate that provide a bunch of traits and structs used by edgedb-query-derive crate
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


#[cfg(test)]
mod select_tests {
    use edgedb_query::queries::select::{OrderDir, OrderOptions, PageOptions, parse_options, SelectOptions};

    #[test]
    fn parse_with_no_options() {

        let options = SelectOptions {
            order_options: None,
            page_options: None
        };

        let stmt = parse_options(&options, "default::User",vec![]);

        assert_eq!(String::default(), stmt);
    }

    #[test]
    fn parse_with_no_module_specified_and_order_by_options() {

        let options = SelectOptions {
            order_options: Some(OrderOptions {
                order_by: "name".to_string(),
                order_direction: None
            }),
            page_options: None
        };

        let stmt = parse_options(&options, "default::User",vec!["name"]);

        assert_eq!(String::from(" order by default::User.name asc"), stmt);
    }

    #[test]
    fn parse_with_no_module_specified_and_order_options() {

        let options = SelectOptions {
            order_options: Some(OrderOptions {
                order_by: "name".to_string(),
                order_direction: Some(OrderDir::Desc)
            }),
            page_options: None
        };

        let stmt = parse_options(&options, "default::User", vec!["name"]);

        assert_eq!(String::from(" order by default::User.name desc"), stmt);
    }

    #[test]
    fn parse_with_module_specified_and_order_options() {

        let options = SelectOptions {
            order_options: Some(OrderOptions {
                order_by: "name".to_string(),
                order_direction: Some(OrderDir::Desc)
            }),
            page_options: None
        };

        let stmt = parse_options(&options, "users::User",vec!["name"]);

        assert_eq!(String::from(" order by users::User.name desc"), stmt);
    }

    #[test]
    fn parse_with_module_specified_and_order_options_and_limit_options() {

        let options = SelectOptions {
            order_options: Some(OrderOptions {
                order_by: "name".to_string(),
                order_direction: Some(OrderDir::Desc)
            }),
            page_options: Some(PageOptions {
                limit: 10,
                offset: None
            })
        };

        let stmt = parse_options(&options, "users::User", vec!["name"]);

        assert_eq!(String::from(" order by users::User.name desc limit 10"), stmt);
    }

    #[test]
    fn parse_with_module_specified_and_order_options_and_page_options() {

        let options = SelectOptions {
            order_options: Some(OrderOptions {
                order_by: "name".to_string(),
                order_direction: Some(OrderDir::Desc)
            }),
            page_options: Some(PageOptions {
                limit: 10,
                offset: Some(1)
            })
        };

        let stmt = parse_options(&options, "users::User", vec!["name"]);

        assert_eq!(String::from(" order by users::User.name desc limit 10 offset 1"), stmt);
    }
}