rusoto 0.24.2

AWS SDK 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

//! Mock request dispatcher and credentials for unit testing services
use std::fs::File;
use std::io::Read;
use std::collections::HashMap;

use super::{DispatchSignedRequest, HttpResponse, HttpDispatchError, SignedRequest};
use super::{ProvideAwsCredentials, CredentialsError, AwsCredentials};
use chrono::{Duration, UTC};
use hyper::status::StatusCode;

const ONE_DAY: i64 = 86400;

pub struct MockCredentialsProvider;

impl ProvideAwsCredentials for MockCredentialsProvider {
    fn credentials(&self) -> Result<AwsCredentials, CredentialsError> {
        Ok(AwsCredentials::new("mock_key",
                               "mock_secret",
                               None,
                               UTC::now() + Duration::seconds(ONE_DAY)))
    }
}

pub struct MockRequestDispatcher {
    mock_response: HttpResponse,
    request_checker: Option<Box<Fn(&SignedRequest)>>,
}

impl MockRequestDispatcher {
    pub fn with_status(status: u16) -> MockRequestDispatcher {
        let response = HttpResponse {
            status: StatusCode::from_u16(status),
            body: b"".to_vec(),
            headers: HashMap::new(),
        };

        MockRequestDispatcher {
            mock_response: response,
            request_checker: None,
        }
    }

    pub fn with_body(mut self, body: &str) -> MockRequestDispatcher {
        self.mock_response.body = body.as_bytes().to_vec();
        self
    }

    pub fn with_request_checker<F>(mut self, checker: F) -> MockRequestDispatcher
        where F: Fn(&SignedRequest) + 'static {
        self.request_checker = Some(Box::new(checker));
        self
    }

    pub fn with_header(mut self, key: String, value: String) -> MockRequestDispatcher {
        self.mock_response.headers.insert(key, value);
        self
    }
}

impl DispatchSignedRequest for MockRequestDispatcher {
    fn dispatch(&self, request: &SignedRequest) -> Result<HttpResponse, HttpDispatchError> {
        if self.request_checker.is_some() {
            self.request_checker.as_ref().unwrap()(request);
        }
        Ok(self.mock_response.clone())
    }
}

pub trait ReadMockResponse {
    fn read_response(dir_name: &str, file_name: &str) -> String;
}

pub struct MockResponseReader;

impl ReadMockResponse for MockResponseReader {
    fn read_response(dir_name: &str, response_name: &str) -> String {
        let file_name = format!("{}/{}", dir_name, response_name);

        let mut input_file = File::open(&file_name).expect("couldn't find file");

        let mut mock_response = String::new();

        input_file.read_to_string(&mut mock_response).expect(&format!(
	        "Failed to read {:?}",
	        file_name,
	    ));

        mock_response
    }
}