arangoq 0.3.4

An AQL query builder layer and ArangoDb client 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
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

#[cfg(feature = "actors")]
use actix::{Actor, System};
#[cfg(feature = "actors")]
use actix_rt::spawn;
use arangoq::*;
#[cfg(feature = "actors")]
use futures::future::FutureExt;
use lazy_static::*;
use proptest::prelude::*;
use proptest_derive::Arbitrary;
use serde::{Deserialize, Serialize};

lazy_static! {
    static ref DATABASE: ArangoConnection = {
        std::env::set_var("RUST_LOG", "debug,hyper=info,tokio_reactor=info");
        let _res = env_logger::try_init();
        //set db password
        std::env::set_var("ARANGO_USER_NAME", "arangoq");
        std::env::set_var("ARANGO_PASSWORD", "arangoq");
        let db_host = "http://localhost:8529/".to_owned();
        let db_name = "evt_test".to_owned();
        // create new connection to local db
        ArangoConnection::new(
            db_host,
            db_name,
            reqwest::Client::new(),
        )
    };
}

#[cfg(feature = "actors")]
proptest! {
#![proptest_config(ProptestConfig::with_cases(1))]
#[ignore]
#[test]
/// These tests verify that generated query objects and responses work well
/// with a real arangodb instance.
/// Create a db called arangoq with user arangoq, and password arangoq
/// for these tests to work.
fn test_live_queries(test_data: TestData) {
    // fn test_live_queries() {
    // let test_data = TestData::default();
    let _res = System::run(move || {
        // start actor
        let addr = ArangoActorAsync { connection: DATABASE.clone() }.start();

        // add test data with insert
        debug!("{:?}", test_data);

        // create an insert query
        let coll = Collection::new("testdocs", CollectionType::Document);
        let query = coll.insert(&test_data);
        let dbq = DbQuery(query, std::marker::PhantomData::<TestData>);
        // send message and get future for result
        let res = addr.send(dbq);
        // handle() returns tokio handle
        spawn(
            res.map(|res| {
                let ar = res.unwrap().unwrap();
                assert!(!ar.error);
                let inserted_data = ar.result.first().unwrap();
                debug!("{:?}", inserted_data);
                assert!(!inserted_data._key.is_empty());
                // Last one alive, lock the door!
                // System::current().stop();
            }),
        );

        // create a replace query
        let coll = Collection::new("testdocs", CollectionType::Document);
        let query = coll.insert(&test_data);
        let dbq = DbQuery(query, std::marker::PhantomData::<TestData>);
        // send message and get future for result
        let res = addr.send(dbq);
        // handle() returns tokio handle
        spawn(
            res.map(|res| {
                let ar = res.unwrap().unwrap();
                assert!(!ar.error);
                let inserted_data = ar.result.first().unwrap();
                debug!("{:?}", inserted_data);
                assert!(!inserted_data._key.is_empty());
                System::current().stop();
            }),
        );
    });
}
}

#[derive(Serialize, Deserialize, Debug, Default, Arbitrary, ArangoBuilder)]
pub struct TestData {
    #[proptest(value = "String::new()")]
    #[serde(skip_serializing_if = "String::is_empty", default)]
    pub(crate) _key: String,
    #[proptest(strategy = "any::<String>()")]
    name: String,
    // Error("i128 is not supported", line: 0, column: 0)
    // #[proptest(strategy = "any::<u128>()")]
    // u128data: u128,
    #[proptest(strategy = "any::<u64>()")]
    u64data: u64,
    #[proptest(strategy = "any::<u32>()")]
    u32data: u32,
    #[proptest(strategy = "any::<u16>()")]
    u16data: u16,
    #[proptest(strategy = "any::<u8>()")]
    u8data: u8,
    // Error("i128 is not supported", line: 0, column: 0)
    // #[proptest(strategy = "any::<i128>()")]
    // i128data: i128,
    #[proptest(strategy = "any::<i16>()")]
    i16data: i16,
    // TODO: figure out how to tag these
    // #[proptest(strategy = "proptest::option::of::<String>(String::default())")]
    // an_option: Option<String>,
    // #[proptest(strategy = "any::<Vec<String>>()")]
    // a_vec: Vec<String>,
    // #[proptest(strategy = "any::<HashMap<String, String>>()")]
    // a_map: HashMap<String, String>,
}