cinema 0.1.0

HTTP record-replay proxy for Rust tests
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

use crate::prelude::*;
use std::sync::{Arc, RwLock};

mod store;
pub use store::*;

pub struct RecordReplay {
    proxy: Proxy,
    store: Arc<RwLock<dyn RecordReplayStore + Send + Sync>>,
}

impl RecordReplay {
    pub async fn start<Store>(store: Store) -> Result<Self, CinemaError>
    where
        Store: RecordReplayStore + Send + Sync + 'static,
    {
        let store = Arc::new(RwLock::new(store));
        let proxy = {
            let store = store.clone();
            Proxy::start_with(Arc::new(move |payload| {
                let mut store = store
                    .write()
                    .map_err(|_| CinemaError::Lock("record replay store for writing"))?;
                store.handle(payload)
            }))
            .await?
        };

        Ok(RecordReplay { proxy, store })
    }

    pub fn add_origin<Str: Into<String> + Copy>(&mut self, origin: Str) -> String {
        let store = Arc::clone(&self.store);
        self.proxy.forward_with(
            origin,
            Arc::new(move |payload| {
                let record = RecordReplayRecord {
                    method: payload.request.method().clone(),
                    uri: payload.request.uri().clone(),
                    // [TODO] Record headers and body?
                    headers: None,
                    body: None,
                    response: RecordReplayRecordResponse {
                        status: payload.status,
                        headers: payload.headers.cloned(),
                        body: payload.body.clone(),
                    },
                };

                let mut store = store
                    .write()
                    .map_err(|_| CinemaError::Lock("record replay store for writing"))?;
                store.record(record)?;

                Ok(())
            }),
        )
    }

    pub async fn commit(&mut self) {
        let store = self.store.clone();
        let store = store
            .read()
            .map_err(|_| CinemaError::Lock("record replay store for reading"))
            .unwrap();
        store.commit().await.unwrap();
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;
    use reqwest::Client;
    use tokio::fs;

    #[tokio::test]
    async fn test_replay() {
        let store = RecordReplayFileStore::from("records/replay.toml")
            .await
            .unwrap();
        let mut replay = RecordReplay::start(store).await.unwrap();
        let mocked_origin = replay.add_origin("https://example.com");

        let client = Client::new();
        let response = client
            .get(mocked_origin)
            .send()
            .await
            .expect("Failed to send request");
        let text = response.text().await.expect("Failed to read response");
        assert_eq!(text, "<!doctype html><title>Hello, cruel world!</title>");
    }

    #[tokio::test]
    async fn test_record() {
        let fixture_name = "records/record.toml";
        let _ = fs::remove_file(fixture_name).await.unwrap_or_else(|_| ());
        let store = RecordReplayFileStore::from(fixture_name).await.unwrap();
        let mut replay = RecordReplay::start(store).await.unwrap();
        let mocked_origin = replay.add_origin("https://example.com");

        let client = Client::new();
        let response = client
            .get(mocked_origin)
            .send()
            .await
            .expect("Failed to send request");
        let text = response.text().await.expect("Failed to read response");

        replay.commit().await;

        let records_str = fs::read_to_string(fixture_name)
            .await
            .expect("Failed to read file");
        let records: RecordReplayRecords =
            toml::from_str(&records_str).expect("Failed to parse TOML");

        assert_eq!(records.requests.len(), 1);

        let request = records.requests.get(0).expect("Failed to find request");
        assert_eq!(request.method, "GET");
        assert_eq!(request.uri, "https://example.com/");
        assert_eq!(request.response.status, 200);
        assert_eq!(request.response.body, text);

        let _ = fs::remove_file(fixture_name).await.unwrap();
    }
}