s3ql 0.1.3

Query Language for S3
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
121
122
123
124
125
126

use s3ql::{bucket::*, read::*, region, s3_client, transact::*};
use std::collections::HashMap;

pub const BUCKET: &'static str = "readObjectsBucket";

async fn client() -> rusoto_s3::S3Client {
    let region = region("us-east-1".to_owned(), "http://localhost:4566".to_owned());
    let s3 = s3_client(region);
    let _ = s3.create_s3_bucket(BUCKET.to_string(), None).await;

    s3
}

async fn insert(s3: &rusoto_s3::S3Client) {
    if !s3
        .has_s3_object(BUCKET.to_string(), "key1".to_string(), None, None, None)
        .await
        .is_ok()
    {
        let mut map = HashMap::new();
        map.insert("tx-time".to_string(), "2007-19-01T11:12:00-000".to_string());
        let body = "{\"hello\": \"world\"}";
        let _ = s3
            .insert_s3_object(
                BUCKET.to_string(),
                Some(map),
                "key1".to_string(),
                Some(body.to_string()),
                None,
            )
            .await;
    }

    if !s3
        .has_s3_object(BUCKET.to_string(), "key2".to_string(), None, None, None)
        .await
        .is_ok()
    {
        let mut map = HashMap::new();
        map.insert("tx-time".to_string(), "2008-19-01T11:12:00-000".to_string());
        let body = "{\"hello\": \"india\"}";
        let _ = s3
            .insert_s3_object(
                BUCKET.to_string(),
                Some(map),
                "key2".to_string(),
                Some(body.to_string()),
                None,
            )
            .await;
    }

    if !s3
        .has_s3_object(BUCKET.to_string(), "key3".to_string(), None, None, None)
        .await
        .is_ok()
    {
        let mut map = HashMap::new();
        map.insert("tx-time".to_string(), "2009-19-01T11:12:00-000".to_string());
        let body = "{\"hello\": \"brasil\"}";
        let _ = s3
            .insert_s3_object(
                BUCKET.to_string(),
                Some(map),
                "key3".to_string(),
                Some(body.to_string()),
                None,
            )
            .await;
    }
}

#[tokio::test]
async fn has_object() {
    let s3 = client().await;
    insert(&s3).await;

    let has_obj1 = s3
        .has_s3_object(BUCKET.to_string(), "key1".to_string(), None, None, None)
        .await;
    assert!(has_obj1.is_ok());

    let has_obj2 = s3
        .has_s3_object(BUCKET.to_string(), "key2".to_string(), None, None, None)
        .await;
    assert!(has_obj2.is_ok());

    let has_obj3 = s3
        .has_s3_object(BUCKET.to_string(), "key3".to_string(), None, None, None)
        .await;
    assert!(has_obj3.is_ok());
}

#[tokio::test]
async fn read_object_body() {
    let s3 = client().await;
    insert(&s3).await;

    let read_obj = s3
        .read_s3_object_body(BUCKET.to_string(), "key1".to_string(), None, None, None)
        .await;
    assert!(read_obj.is_some());
    assert_eq!(read_obj.unwrap(), "{\"hello\": \"world\"}");
}

#[tokio::test]
async fn show_objects() {
    let s3 = client().await;
    insert(&s3).await;

    let objs = s3.show_s3_objects(BUCKET.to_string(), None).await;
    assert!(objs.is_ok());
    assert!(objs.unwrap().contents.unwrap().len() == 3);
}

#[tokio::test]
async fn read_object() {
    let s3 = client().await;
    insert(&s3).await;

    let read_obj = s3
        .read_s3_object(BUCKET.to_string(), "key2".to_string(), None, None, None)
        .await;

    assert!(read_obj.unwrap().e_tag.is_some());
}