Update tests with new wit-bindgen APIs

Author: alexcrichton

crates/test-programs/src/bin/api_0_3_proxy.rs

@@ -1,4 +1,4 @@
-use futures::{join, SinkExt as _};
+use futures::join;
 use test_programs::p3::wasi::http::types::{ErrorCode, Headers, Request, Response};
 use test_programs::p3::{wit_future, wit_stream};
 use wit_bindgen_rt::async_support::spawn;
@@ -39,10 +39,8 @@ impl test_programs::p3::proxy::exports::wasi::http::handler::Guest for T {
         spawn(async {
             join!(
                 async {
-                    contents_tx
-                        .send(b"hello, world!".to_vec())
-                        .await
-                        .expect("writing response");
+                    let remaining = contents_tx.write_all(b"hello, world!".to_vec()).await;
+                    assert!(remaining.is_empty());
                     drop(contents_tx);
                     trailers_tx.write(Ok(None));
                 },
@@ -51,7 +49,6 @@ impl test_programs::p3::proxy::exports::wasi::http::handler::Guest for T {
                         .await
                         .expect("failed to transmit response")
                         .unwrap()
-                        .unwrap()
                 }
             );
         });

crates/test-programs/src/bin/http_0_3_outbound_request_content_length.rs

@@ -1,4 +1,3 @@
-use futures::SinkExt as _;
 use test_programs::p3::wasi::http::types::{ErrorCode, Headers, Method, Request, Scheme, Trailers};
 use test_programs::p3::{wit_future, wit_stream};
 use wit_bindgen_rt::async_support::{FutureWriter, StreamWriter};
@@ -44,17 +43,19 @@ impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
         {
             println!("writing enough");
             let (_, mut contents_tx, trailers_tx) = make_request();
-            contents_tx.send(b"long enough".to_vec()).await.unwrap();
+            let remaining = contents_tx.write_all(b"long enough".to_vec()).await;
+            assert!(remaining.is_empty());
             drop(contents_tx);
-            trailers_tx.write(Ok(None)).await;
+            trailers_tx.write(Ok(None)).await.unwrap();
         }
 
         {
             println!("writing too little");
             let (_, mut contents_tx, trailers_tx) = make_request();
-            contents_tx.send(b"msg".to_vec()).await.unwrap();
+            let remaining = contents_tx.write_all(b"msg".to_vec()).await;
+            assert!(remaining.is_empty());
             drop(contents_tx);
-            trailers_tx.write(Ok(None)).await;
+            trailers_tx.write(Ok(None)).await.unwrap();
 
             // handle()
 
@@ -71,12 +72,10 @@ impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
         {
             println!("writing too much");
             let (_, mut contents_tx, trailers_tx) = make_request();
-            contents_tx
-                .send(b"more than 11 bytes".to_vec())
-                .await
-                .unwrap();
+            let remaining = contents_tx.write_all(b"more than 11 bytes".to_vec()).await;
+            assert!(remaining.is_empty());
             drop(contents_tx);
-            trailers_tx.write(Ok(None)).await;
+            trailers_tx.write(Ok(None)).await.unwrap();
 
             // TODO: Figure out how/if to represent this in wasip3
             //let e = request_body

crates/test-programs/src/bin/http_0_3_outbound_request_response_build.rs

@@ -1,4 +1,3 @@
-use futures::SinkExt as _;
 use test_programs::p3::wasi::http::types::{Fields, Headers, Method, Request, Response, Scheme};
 use test_programs::p3::{wit_future, wit_stream};
 
@@ -26,7 +25,8 @@ impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
             request
                 .set_authority(Some("www.example.com"))
                 .expect("setting authority");
-            contents_tx.send(b"request-body".to_vec()).await.unwrap();
+            let remaining = contents_tx.write_all(b"request-body".to_vec()).await;
+            assert!(remaining.is_empty());
         }
         {
             let headers = Headers::from_list(&[(
@@ -37,7 +37,8 @@ impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
             let (mut contents_tx, contents_rx) = wit_stream::new();
             let (_, trailers_rx) = wit_future::new();
             let _ = Response::new(headers, Some(contents_rx), trailers_rx);
-            contents_tx.send(b"response-body".to_vec()).await.unwrap();
+            let remaining = contents_tx.write_all(b"response-body".to_vec()).await;
+            assert!(remaining.is_empty());
         }
 
         {

crates/test-programs/src/p3/http.rs

@@ -1,7 +1,6 @@
-use core::fmt;
-
 use anyhow::{anyhow, Context as _, Result};
-use futures::{try_join, SinkExt as _, TryStreamExt as _};
+use core::fmt;
+use futures::try_join;
 
 use crate::p3::wasi::http::{handler, types};
 use crate::p3::{wit_future, wit_stream};
@@ -92,20 +91,17 @@ pub async fn request(
     let ((), (), response) = try_join!(
         async {
             if let Some(buf) = body {
-                contents_tx
-                    .send(buf.into())
-                    .await
-                    .expect("failed to send body content chunk");
+                let remaining = contents_tx.write_all(buf.into()).await;
+                assert!(remaining.is_empty());
             }
             drop(contents_tx);
-            trailers_tx.write(Ok(None)).await;
+            trailers_tx.write(Ok(None)).await.unwrap();
             anyhow::Ok(())
         },
         async {
             transmit
                 .await
                 .expect("transmit sender dropped")
-                .expect("failed to receive request transmit result")
                 .context("failed to transmit request")?;
             Ok(())
         },
@@ -115,12 +111,10 @@ pub async fn request(
             let headers = response.headers().entries();
 
             let (body, trailers) = response.body().expect("failed to get response body");
-            let body = body.try_collect::<Vec<_>>().await?;
-            let body = body.concat();
+            let body = body.collect().await;
             let trailers = trailers
                 .await
                 .expect("trailers sender dropped")
-                .expect("failed to receive response trailers result")
                 .context("failed to read body")?;
             let trailers = trailers.map(|trailers| trailers.entries());
             Ok(Response {