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

use crate::prelude::*;
use http_body_util::Full;
use hyper::Response;
use hyper::body::Bytes;
use std::path::PathBuf;
use std::pin::Pin;
use tokio::fs;
use tokio::fs::create_dir_all;

pub struct RecordReplayFileStore {
    path: PathBuf,
    records: RecordReplayRecords,
}

impl RecordReplayFileStore {
    pub async fn from<Str: Into<String>>(path: Str) -> Result<Self, CinemaError> {
        let path = PathBuf::from(path.into());

        let records = match fs::read_to_string(&path).await {
            Ok(content) => {
                // [TODO] Handle errors
                toml::from_str(&content).unwrap()
            }

            Err(_) => Default::default(),
        };

        Ok(RecordReplayFileStore { path, records })
    }
}

impl RecordReplayStore for RecordReplayFileStore {
    fn handle(
        &mut self,
        payload: ProxyHandlerPayload<'_>,
    ) -> Result<Option<Response<Full<Bytes>>>, CinemaError> {
        // [TODO] Handle error

        let record = self.records.requests.iter().find(|req| {
            req.method == payload.request.method
                && req.uri == payload.request.uri
                && req.body == payload.request.body
        });

        match record {
            Some(record) => {
                // [TODO] There can be multiple responses for the same request
                let response = &record.response;

                let mut builder = Response::builder().status(response.status);
                if let Some(headers) = &response.headers {
                    for (name, value) in headers.iter() {
                        builder = builder.header(name, value);
                    }
                }

                let body = Bytes::from(response.body.clone());
                let response = builder
                    .body(Full::new(body))
                    .map_err(|err| CinemaError::RestoreResponseBody(err))?;

                return Ok(Some(response));
            }

            None => Ok(None),
        }
    }

    fn commit<'a>(&'a self) -> Pin<Box<dyn Future<Output = Result<(), CinemaError>> + Send + 'a>> {
        Box::pin(async {
            if let Some(parent) = self.path.parent() {
                if !parent.exists() {
                    // [TODO] Handle errors
                    create_dir_all(parent).await.unwrap();
                }
            }

            let _ = fs::write(
                &self.path,
                toml::to_string(&self.records).map_err(|err| CinemaError::Serialize(err, ""))?,
            )
            .await;

            Ok(())
        })
    }

    fn record(&mut self, payload: RecordReplayRecord) -> Result<(), CinemaError> {
        self.records.requests.push(payload);
        Ok(())
    }
}