vox 0.4.0

Core Vox library crate
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

//! Tests for client middleware hook execution through the Caller pipeline.

use std::sync::{Arc, Mutex};

use vox::memory_link_pair;

#[vox::service]
trait Echo {
    async fn echo(&self, value: u32) -> u32;
}

#[derive(Clone)]
struct EchoService;

impl Echo for EchoService {
    async fn echo(&self, value: u32) -> u32 {
        value
    }
}

#[derive(Clone)]
struct RecordingMiddleware {
    name: &'static str,
    events: Arc<Mutex<Vec<String>>>,
}

impl vox::ClientMiddleware for RecordingMiddleware {
    fn pre<'a, 'call>(
        &'a self,
        context: &'a vox::ClientContext<'a>,
        _request: &'a mut vox::ClientRequest<'call, 'a>,
    ) -> vox::BoxMiddlewareFuture<'a> {
        let name = self.name;
        let method_name = context.method().map(|m| m.method_name).unwrap_or("unknown");
        let events = self.events.clone();
        Box::pin(async move {
            events
                .lock()
                .unwrap()
                .push(format!("{name}:pre:{method_name}"));
        })
    }

    fn post<'a>(
        &'a self,
        context: &'a vox::ClientContext<'a>,
        outcome: vox::ClientCallOutcome<'a>,
    ) -> vox::BoxMiddlewareFuture<'a> {
        let name = self.name;
        let method_name = context.method().map(|m| m.method_name).unwrap_or("unknown");
        let ok = outcome.is_ok();
        let events = self.events.clone();
        Box::pin(async move {
            events
                .lock()
                .unwrap()
                .push(format!("{name}:post:{method_name}:{ok}"));
        })
    }
}

#[tokio::test]
async fn middleware_hooks_fire_in_order() {
    let (client_link, server_link) = memory_link_pair(16);

    let server = tokio::spawn(async move {
        vox::acceptor_on(server_link)
            .on_connection(EchoDispatcher::new(EchoService))
            .establish::<vox::NoopClient>()
            .await
            .expect("server establish")
    });

    let client = vox::initiator_on(client_link, vox::TransportMode::Bare)
        .establish::<EchoClient>()
        .await
        .expect("client establish");

    let _server_guard = server.await.expect("server task");

    let events = Arc::new(Mutex::new(Vec::new()));

    let client = client
        .with_middleware(RecordingMiddleware {
            name: "first",
            events: events.clone(),
        })
        .with_middleware(RecordingMiddleware {
            name: "second",
            events: events.clone(),
        });

    let result = client.echo(42).await.expect("echo with middleware");
    assert_eq!(result, 42);

    let events = events.lock().unwrap();
    assert_eq!(
        &*events,
        &[
            "first:pre:echo",
            "second:pre:echo",
            // post hooks run in reverse order
            "second:post:echo:true",
            "first:post:echo:true",
        ]
    );
}

struct MetadataInjectingMiddleware;

impl vox::ClientMiddleware for MetadataInjectingMiddleware {
    fn pre<'a, 'call>(
        &'a self,
        _context: &'a vox::ClientContext<'a>,
        request: &'a mut vox::ClientRequest<'call, 'a>,
    ) -> vox::BoxMiddlewareFuture<'a> {
        Box::pin(async move {
            request.push_string_metadata(
                "x-test",
                "injected".to_string(),
                vox::MetadataFlags::NONE,
            );
        })
    }
}

#[vox::service]
trait MetadataProbe {
    #[vox::context]
    async fn check_metadata(&self) -> bool;
}

#[derive(Clone)]
struct MetadataProbeService;

impl MetadataProbe for MetadataProbeService {
    async fn check_metadata(&self, cx: &vox::RequestContext<'_>) -> bool {
        cx.metadata().iter().any(|e| {
            e.key == "x-test"
                && matches!(&e.value, vox::MetadataValue::String(s) if s == "injected")
        })
    }
}

#[tokio::test]
async fn middleware_can_inject_metadata() {
    let (client_link, server_link) = memory_link_pair(16);

    let server = tokio::spawn(async move {
        vox::acceptor_on(server_link)
            .on_connection(MetadataProbeDispatcher::new(MetadataProbeService))
            .establish::<vox::NoopClient>()
            .await
            .expect("server establish")
    });

    let client = vox::initiator_on(client_link, vox::TransportMode::Bare)
        .establish::<MetadataProbeClient>()
        .await
        .expect("client establish");

    let _server_guard = server.await.expect("server task");

    // Without middleware — no injected metadata.
    let has_meta = client.check_metadata().await.expect("probe without mw");
    assert!(
        !has_meta,
        "should not have x-test metadata without middleware"
    );

    // With middleware — metadata injected.
    let client = client.with_middleware(MetadataInjectingMiddleware);
    let has_meta = client.check_metadata().await.expect("probe with mw");
    assert!(has_meta, "middleware should inject x-test metadata");
}