rama-http 0.3.0-rc1

rama http layers, services and other utilities
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
130
131
132
133
134
135
136
137
138

use crate::layer::har::service::HARExportService;
use crate::layer::har::toggle::Toggle;
use rama_core::Layer;

#[non_exhaustive]
#[derive(Debug, Clone)]
pub struct HARExportLayer<R, T> {
    recorder: R,
    toggle: T,

    preserve_sensitive: bool,
}

impl<R, T> HARExportLayer<R, T> {
    pub fn new(recorder: R, toggle: T) -> Self {
        Self {
            recorder,
            toggle,
            preserve_sensitive: false,
        }
    }

    pub fn recorder(&self) -> &R {
        &self.recorder
    }

    pub fn toggle(&self) -> &T {
        &self.toggle
    }

    rama_utils::macros::generate_set_and_with! {
        /// Sets whether to preserve sensitive headers (false by default).
        pub fn preserve_sensitive(mut self) -> Self {
            self.preserve_sensitive = true;
            self
        }
    }
}

impl<R, S, T> Layer<S> for HARExportLayer<R, T>
where
    R: Clone + Send + Sync + 'static,
    T: Toggle + Clone + Send + Sync + 'static,
{
    type Service = HARExportService<R, S, T>;

    fn layer(&self, service: S) -> Self::Service {
        HARExportService {
            service,
            toggle: self.toggle.clone(),
            recorder: self.recorder.clone(),
            preserve_sensitive: self.preserve_sensitive,
        }
    }

    fn into_layer(self, service: S) -> Self::Service {
        HARExportService {
            service,
            toggle: self.toggle,
            recorder: self.recorder,
            preserve_sensitive: self.preserve_sensitive,
        }
    }
}

#[cfg(test)]
mod tests {
    use rama_core::extensions::Extensions;

    use super::*;
    use crate::layer::har::recorder::Recorder;
    use crate::layer::har::spec::Log;
    use crate::layer::har::toggle::mpsc_unbounded_toggle;
    use parking_lot::Mutex;
    use std::future::ready;
    use std::sync::{Arc, atomic::Ordering};

    // simple alternative implementation

    #[derive(Clone, Default)]
    pub struct InMemoryRecorder {
        logs: Arc<Mutex<Vec<Log>>>,
    }

    impl InMemoryRecorder {
        #[must_use]
        #[inline]
        pub fn new() -> Self {
            Self::default()
        }
    }

    impl Recorder for InMemoryRecorder {
        async fn record(&self, log: Log) -> Option<Extensions> {
            let mut lock = self.logs.lock();
            lock.push(log);
            None
        }

        fn stop_record(&self) -> impl Future<Output = ()> + Send {
            ready(())
        }
    }

    impl<T: Toggle> HARExportLayer<InMemoryRecorder, T> {
        pub fn new_test(toggle: T) -> Self {
            Self::new(InMemoryRecorder::new(), toggle)
        }
    }

    #[tokio::test]
    // Test showing flag on/off working with a manual recorder
    async fn in_memory_recorder_records_logs() {
        let (flag, tx) = mpsc_unbounded_toggle(std::future::pending::<()>());
        let layer = HARExportLayer::new_test(flag.clone());
        // initially the flag is set false
        assert!(!flag.load(Ordering::Relaxed));

        // flip once
        tx.send(()).unwrap();
        tokio::task::yield_now().await;
        assert!(flag.load(Ordering::Relaxed));

        layer.recorder.record(Log::default()).await;

        // flip it manually
        tx.send(()).unwrap();
        tokio::task::yield_now().await;
        assert!(!flag.load(Ordering::Relaxed));

        // Check that the recorder captured something
        let data = layer.recorder.logs.lock();
        assert!(
            !data.is_empty(),
            "Expected recorder to have recorded at least one HAR log"
        );
    }
}