test: add a "raw" test

this is really just an example

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>

Author: rvolosatovs

Cargo.lock

@@ -99,6 +99,7 @@ futures = { workspace = true }
 tempfile = { workspace = true }
 test-log = { workspace = true, features = ["color", "log", "trace"] }
 tokio = { workspace = true, features = ["process", "rt-multi-thread"] }
+tokio-util = { workspace = true }
 wasmtime = { workspace = true }
 wasmtime-wasi = { workspace = true }
 wasmtime-cli-flags = { workspace = true, features = [

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wrpc-pack"
-version = "0.3.1"
+version = "0.4.0"
 description = "Temporary stopgap solution for encoding fully-synchronous wRPC values"
 
 authors.workspace = true

crates/pack/Cargo.toml

@@ -1327,6 +1327,53 @@ where
     Ok(())
 }
 
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+#[instrument(ret)]
+async fn rust_oneshot_raw() -> anyhow::Result<()> {
+    let (clt, mut srv) = tokio::io::duplex(1024);
+
+    join!(
+        async {
+            let (a,) = Oneshot::from(clt)
+                .invoke_values_blocking::<_, _, (String,)>((), "foo", "bar", (42,), &[[]; 0])
+                .await
+                .expect("failed to invoke `foo.bar`");
+            assert_eq!(a, "test");
+        },
+        async {
+            use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
+            use tokio_util::codec::Encoder as _;
+            use wrpc_transport::Encode as _;
+
+            let mut req = Vec::default();
+            _ = srv.read_to_end(&mut req).await;
+            eprintln!("request: `{:?}`", Bytes::from(req));
+
+            let mut data = bytes::BytesMut::default();
+            let deferred: Option<wrpc_transport::DeferredFn<wrpc_transport::frame::Outgoing>> =
+                ("test",)
+                    .encode(&mut Default::default(), &mut data)
+                    .expect("failed to encode");
+            assert!(deferred.is_none());
+
+            let mut res = bytes::BytesMut::default();
+            wrpc_transport::FrameEncoder
+                .encode(
+                    &wrpc_transport::Frame {
+                        path: Arc::default(),
+                        data: data.freeze(),
+                    },
+                    &mut res,
+                )
+                .expect("failed to encode response frame");
+            eprintln!("response: `{res:?}`");
+
+            srv.write_all(&res).await.expect("failed to write response");
+        }
+    );
+    Ok(())
+}
+
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[instrument(ret)]
 async fn rust_oneshot_duplex() -> anyhow::Result<()> {