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

use std::future::{ready, Future, Ready};
use std::pin::Pin;

use actix_web::{
    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
    web::Data,
    Error,
};

pub struct ActixVerifyLifecycle<T>(pub fn(&T));

impl<S, B, T> Transform<S, ServiceRequest> for ActixVerifyLifecycle<T>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
    T: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Transform = ActixVerifyLifecycleMiddleware<S, T>;
    type InitError = ();
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(ActixVerifyLifecycleMiddleware {
            service,
            before_each: self.0,
        }))
    }
}

pub struct ActixVerifyLifecycleMiddleware<S, T> {
    service: S,
    before_each: fn(&T),
}

impl<S, B, T> Service<ServiceRequest> for ActixVerifyLifecycleMiddleware<S, T>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
    T: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + 'static>>;

    forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        let (http_req, payload) = req.into_parts();
        if let Some(data) = http_req.app_data::<Data<T>>() {
            (self.before_each)(data);
        }
        let fut = self.service.call(ServiceRequest::from_parts(http_req, payload));
        Box::pin(fut)
    }
}