sqlite-requests 0.0.2

Represent SQLite queries and executes as request objects
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

use integration_test::indexed_test_cases;
use integration_test::named_test_cases;
use rusqlite::Connection;
use rusqlite::types::ToSql;
use sqlite_requests::connection::AccessConnection;
use sqlite_requests::connection::ReadWrite;
use sqlite_requests::execute::BulkExecute;
use sqlite_requests::execute::Execute;
use utils::temp_db::with_test_dbs;
use integration_test::queued_params_as_arg;

#[test]
fn test_execute_indexed() {
    fn test_execute_indexed_parameters(sql: &str, queued_params: &[&[&(ToSql)]]) {
        with_test_dbs(ReadWrite, |mut test_conn: AccessConnection<ReadWrite>, expected_conn: Connection| {
            let execute = Execute::new_indexed(&sql, queued_params).unwrap();
            let execute_results = test_conn.run(&execute).unwrap();
            let mapped_execute_results: Vec<_> = execute_results.into_iter().map(|execute_result| execute_result.changes()).collect();

            let mut expected_stmt = expected_conn.prepare(&sql).unwrap();
            let expected_results = queued_params.iter().map(|params| {
                expected_stmt.execute(params).unwrap()
            }).collect::<Vec<_>>();

            assert_eq!(expected_results, mapped_execute_results);
        });
    }

    let no_param =
        include_str!("../res/sql/test_execute_no_param.sql");
    let indexed_param =
        include_str!("../res/sql/test_execute_indexed_param.sql");
    let indexed_params =
        include_str!("../res/sql/test_execute_indexed_params.sql");

    for (sql, queued_params) in indexed_test_cases(no_param, indexed_param, indexed_params) {
        let queued_params_slices: Vec<_> = queued_params_as_arg(&queued_params);

        test_execute_indexed_parameters(sql, &queued_params_slices);
    }
}

#[test]
fn test_execute_named() {
    fn test_execute_named_parameters(sql: &str, queued_params: &[&[(&str, &ToSql)]]) {
        with_test_dbs(ReadWrite, |mut test_conn: AccessConnection<ReadWrite>, expected_conn: Connection| {
            let execute = Execute::new_named(&sql, queued_params).unwrap();
            let execute_results = test_conn.run(&execute).unwrap();
            let mapped_execute_results: Vec<_> = execute_results.into_iter().map(|execute_result| execute_result.changes()).collect();

            let mut expected_stmt = expected_conn.prepare(&sql).unwrap();
            let expected_results = queued_params.iter().map(|params| {
                expected_stmt.execute_named(params).unwrap()
            }).collect::<Vec<_>>();

            assert_eq!(expected_results, mapped_execute_results);
        });
    }

    let no_param =
        include_str!("../res/sql/test_execute_no_param.sql");
    let named_param =
        include_str!("../res/sql/test_execute_named_param.sql");
    let named_params =
        include_str!("../res/sql/test_execute_named_params.sql");

    for (sql, queued_params) in named_test_cases(no_param, named_param, named_params) {
        let queued_params_slices: Vec<_> = queued_params_as_arg(&queued_params);;

        test_execute_named_parameters(sql, &queued_params_slices);
    }
}

#[test]
fn test_bulk_execute() {
    with_test_dbs(ReadWrite, |mut test_conn: AccessConnection<ReadWrite>, expected_conn: Connection| {
        let no_param =
            include_str!("../res/sql/test_execute_no_param.sql");
        let indexed_param =
            include_str!("../res/sql/test_execute_indexed_param.sql");
        let indexed_params =
            include_str!("../res/sql/test_execute_indexed_params.sql");


        // Test
        let test_queries = indexed_test_cases(no_param, indexed_param, indexed_params).iter().map(|(sql, queued_params)| {
            let queued_params_slices: Vec<_> = queued_params_as_arg(&queued_params);;

            Execute::new_indexed(&sql, &queued_params_slices).unwrap()
        }).collect();

        let bulk_execute = BulkExecute::new(test_queries);

        let bulk_execute_results = test_conn.run(&bulk_execute).unwrap();

        let mapped_bulk_execute_results: Vec<_> = bulk_execute_results.into_iter().map(|execute_results| {
            let mapped_execute_results: Vec<_> = execute_results.into_iter().map(|execute_result| {
                execute_result.changes()
            }).collect();
            mapped_execute_results
        }).collect();


        //Expected
        let bulk_expected_results: Vec<_> = indexed_test_cases(no_param, indexed_param, indexed_params).iter().map(|(sql, queued_params)| {
            let mut expected_stmt = expected_conn.prepare(&sql).unwrap();
            let expected_results = queued_params.iter().map(|params| {
                let changes = expected_stmt.execute(params).unwrap();
                changes
            }).collect::<Vec<_>>();
            expected_results
        }).collect();

        assert_eq!(mapped_bulk_execute_results, bulk_expected_results);
    });
}


// Negative tests:

// TODO: test_execute_err
// TODO: test_bulk_execute_err (middle of transaction)