rusqbin 0.2.3

Rusqbin is a web server that stashes your requests for later retrieval so you can do end-to-end testing of code that makes HTTP calls. It is available as both a binary and a library.
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
127
128
129

#[macro_use]
extern crate hyper;
extern crate rusqbin;
extern crate serde_json;

use self::rusqbin::models::BinSummary;

use hyper::header::{Headers, Header};
use hyper::Method;

use rusqbin::models::Request;
use rusqbin::storage::*;

#[cfg(test)]
mod common;
use common::*;

/// Internal tests: server is started and stopped and requests are made to
/// it, but internal state is checked from Rust using the bin server.
#[test]
fn test_list_empty() {
    run_with_server(|test_env| {
        let ref bins = test_env.server.storage.lock().unwrap().get_bin_summaries();
        assert!(bins.is_empty());
    })
}


#[test]
fn test_creating_bin() {
    run_with_server(|mut test_env| {
        let bin = test_env.create_bin().unwrap();
        let ref storage = test_env.server.storage.lock().unwrap();
        assert!(storage.get_bin_summary(&bin.id).is_some());
    })
}

#[test]
fn test_deleting_existing_bin() {
    run_with_server(|mut test_env| {
        let bin = test_env.create_bin().unwrap();
        let _deleted = test_env.delete_bin(&bin.id).unwrap();
        let ref storage = test_env.server.storage.lock().unwrap();
        assert!(storage.get_bin_summary(&bin.id).is_none());
    })
}

#[test]
fn test_requesting_bin_summary() {
    run_with_server(|mut test_env| {
        let new_bin = test_env.create_bin().unwrap();
        let bin_id = new_bin.id;

        let requests = vec![
            ServerRequest {
                method: Method::Get,
                headers: Headers::new(),
                path: "/",
                body: None,
            },
            ServerRequest {
                method: Method::Get,
                headers: Headers::new(),
                path: "/hello/world",
                body: None,
            },
            ServerRequest {
                method: Method::Post,
                headers: Headers::new(),
                path: "/boom/chicka/chicka",
                body: Some("{ id: 3 }"),
            },
        ];
        test_env.parallel_requests(&bin_id, &requests, 2);

        let ref storage = test_env.server.storage.lock().unwrap();
        let bin_summary: BinSummary = storage.get_bin_summary(&bin_id).unwrap();
        assert_eq!(bin_summary.request_count, requests.len() * 2);
    })
}


header! { (XFlubble, "X-Flubble") => [String] }
header! { (XDoodle, "X-Doodle") => [String] }

#[test]
fn test_requesting_bin_requests() {
    run_with_server(|mut test_env| {
        let new_bin = test_env.create_bin().unwrap();
        let bin_id = new_bin.id;

        let mut headers = Headers::new();
        headers.set(XFlubble("yep".to_owned()));
        headers.set(XDoodle("nope".to_owned()));

        let requests = vec![
            ServerRequest {
                method: Method::Post,
                headers: headers,
                path: "/",
                body: Some("hey there."),
            },
        ];
        test_env.parallel_requests(&bin_id, &requests, 1);

        let ref storage = test_env.server.storage.lock().unwrap();
        let requests: &Vec<Request> = storage.get_bin(&bin_id).unwrap();
        assert_eq!(requests.len(), 1);

        let req: &Request = &requests[0];
        println!("{:?}", req.headers);
        assert_eq!(req.headers.len(), 5); // includes content-length, host, XRusqbinId, and the 2 additional ones we sent.

        assert!(
            req.headers
                .get(<XFlubble as Header>::header_name())
                .is_some()
        );
        assert!(
            req.headers
                .get(<XDoodle as Header>::header_name())
                .is_some()
        );

        assert_eq!(req.body, Some("hey there.".to_owned()));
        assert_eq!(req.method, Method::Post.as_ref());

    })
}