wrpc 0.16.0

WebAssembly component-native RPC framework based on WIT
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

use anyhow::Context;
use bytes::Bytes;
use futures::{stream, StreamExt as _};
use tokio::join;
use tracing::info;

#[allow(dead_code)]
pub async fn assert_async<C: Default>(
    client: &impl wrpc_transport::Invoke<Context = C>,
) -> anyhow::Result<()> {
    wit_bindgen_wrpc::generate!({
        world: "async-client",
        path: "tests/wit",
    });

    info!("calling `wrpc-test:integration/async.with-streams`");
    let ((a, b), io) = wrpc_test::integration::async_::with_streams(client, C::default())
        .await
        .context("failed to call `wrpc-test:integration/async.with-streams`")?;
    join!(
        async {
            info!("receiving `a`");
            assert_eq!(a.collect::<Vec<Bytes>>().await.concat(), b"test");
        },
        async {
            info!("receiving `b`");
            assert_eq!(
                b.collect::<Vec<_>>().await.concat(),
                [["foo"].as_slice(), ["bar", "baz"].as_slice()]
            );
        },
        async {
            if let Some(io) = io {
                info!("performing I/O");
                io.await.expect("failed to complete async I/O");
            }
        }
    );

    info!("calling `wrpc-test:integration/async.with-future`");
    let (fut, io) = wrpc_test::integration::async_::with_future(
        client,
        C::default(),
        &wrpc_test::integration::async_::Something {
            foo: "bar".to_string(),
        },
        Box::pin(stream::iter(["foo".into(), "bar".into()])),
    )
    .await
    .context("failed to call `wrpc-test:integration/async.with-future`")?;
    join!(
        async {
            info!("receiving results");
            assert_eq!(fut.await.collect::<Vec<Bytes>>().await.concat(), b"foobar");
        },
        async {
            if let Some(io) = io {
                info!("performing I/O");
                io.await.expect("failed to complete async I/O");
            }
        }
    );

    Ok(())
}