agdb 0.12.10

Agnesoft Graph Database
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
105
106
107
108
109
110
111
112
113
114

#[path = "../../src/test_utilities/test_file.rs"]
pub mod test_file;

use agdb::Db;
use agdb::DbElement;
use agdb::DbError;
use agdb::DbTransactionMut;
use agdb::Query;
use agdb::QueryMut;
use agdb::QueryResult;

pub use test_file::TestFile;

pub struct TestDb {
    #[allow(dead_code)]
    test_file: TestFile,
    pub db: Db,
}

#[allow(dead_code)]
impl TestDb {
    #[track_caller]
    pub fn new() -> Self {
        let test_file = TestFile::new();
        let db = Db::new(test_file.file_name()).unwrap();

        Self { test_file, db }
    }

    #[track_caller]
    pub fn exec<T: Query>(&self, query: T, result: i64) {
        assert_eq!(self.db.exec(query).unwrap().result, result);
    }

    #[track_caller]
    pub fn exec_ids<T: Query>(&self, query: T, ids: &[i64]) {
        assert_eq!(
            self.db
                .exec(query)
                .unwrap()
                .elements
                .into_iter()
                .map(|e| e.id.0)
                .collect::<Vec<i64>>(),
            ids
        );
    }

    #[track_caller]
    pub fn exec_elements<T: Query>(&self, query: T, elements: &[DbElement]) {
        let res = self.db.exec(query).unwrap();
        assert_eq!(res.result, elements.len() as i64);
        assert_eq!(res.elements, elements);
    }

    #[track_caller]
    pub fn exec_result<T: Query>(&self, query: T) -> QueryResult {
        self.db.exec(query).unwrap()
    }

    #[track_caller]
    pub fn exec_error<T: Query>(&self, query: T, error: &str) {
        assert_eq!(self.db.exec(query).unwrap_err().description, error);
    }

    #[track_caller]
    pub fn exec_mut<T: QueryMut>(&mut self, query: T, result: i64) {
        assert_eq!(self.db.exec_mut(query).unwrap().result, result);
    }

    #[track_caller]
    pub fn exec_mut_result<T: QueryMut>(&mut self, query: T) -> QueryResult {
        self.db.exec_mut(query).unwrap()
    }

    #[track_caller]
    pub fn exec_mut_ids<T: QueryMut>(&mut self, query: T, ids: &[i64]) {
        assert_eq!(
            self.db
                .exec_mut(query)
                .unwrap()
                .elements
                .into_iter()
                .map(|e| e.id.0)
                .collect::<Vec<i64>>(),
            ids
        );
    }

    #[track_caller]
    pub fn exec_mut_error<T: QueryMut>(&mut self, query: T, error: &str) {
        assert_eq!(self.db.exec_mut(query).unwrap_err().description, error);
    }

    #[track_caller]
    pub fn transaction_mut<T, E: From<DbError> + std::fmt::Debug>(
        &mut self,
        f: impl FnMut(&mut DbTransactionMut) -> Result<T, E>,
    ) {
        self.db.transaction_mut(f).unwrap();
    }

    #[track_caller]
    pub fn transaction_mut_error<
        T: std::fmt::Debug,
        E: From<DbError> + std::fmt::Debug + PartialEq,
    >(
        &mut self,
        f: impl FnMut(&mut DbTransactionMut) -> Result<T, E>,
        error: E,
    ) {
        assert_eq!(self.db.transaction_mut(f).unwrap_err(), error);
    }
}