stubr 0.6.2

Wiremock implemented in 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

use std::net::SocketAddr;

use log::{error, info};
use tokio::sync::mpsc::Sender;

use logger::RecordLogger;
use proxy::Proxy;

use super::super::model::JsonStub;
use super::config::RecordConfig;
use super::writer::StubWriter;

pub mod http;
pub mod logger;
pub mod port;
pub mod proxy;
pub mod warp_exchange;

#[cfg(feature = "record-standalone")]
pub struct StubrRecord {
    addr: SocketAddr,
    tx: Sender<String>,
}

#[cfg(feature = "record-standalone")]
impl StubrRecord {
    /// Get recorder base uri.
    /// Use this to configure your http client proxy configuration.
    pub fn uri(&self) -> String {
        format!("http://{}", self.addr)
    }

    pub(crate) fn record(config: RecordConfig) -> Self {
        let (addr, tx) = Proxy::run(config, |(ex, cfg)| {
            let host = format!("http://{}", ex.host());
            let method = ex.req().method().to_string();
            let url = ex.req().url().clone();
            let status: u16 = ex.resp().status().into();
            let stub = JsonStub::from((ex, cfg));
            let writer = StubWriter { stub };
            writer
                .write(&host, cfg.output.as_ref())
                .map(|f| RecordLogger::success(f, status, &method, &url))
                .unwrap_or_else(|e| RecordLogger::error(e, status, &method, &url));
        });
        Self { addr, tx }
    }

    #[cfg(feature = "record-isahc")]
    pub fn isahc_client(&self) -> isahc::HttpClient {
        crate::isahc_client(self.uri())
    }

    #[cfg(feature = "record-reqwest")]
    pub fn reqwest_client(&self) -> reqwest::Client {
        crate::reqwest_client(self.uri())
    }
}

#[cfg(feature = "record-standalone")]
impl Drop for StubrRecord {
    fn drop(&mut self) {
        async_std::task::block_on(async {
            match self.tx.send(String::new()).await {
                Ok(_) => info!("Stopping stubr recorder on {}", self.addr),
                Err(e) => error!("Failed stopping stubr recorder on {} because {:?}", self.addr, e),
            }
        });
    }
}