.

distant-core/tests/manager_tests.rs

@@ -1,96 +0,0 @@
-use distant_core::{
-    net::{FramedTransport, InmemoryTransport, IntoSplit, OneshotListener, PlainCodec},
-    BoxedDistantReader, BoxedDistantWriter, Destination, DistantApiServer, DistantChannelExt,
-    DistantManager, DistantManagerClient, DistantManagerClientConfig, DistantManagerConfig, Map,
-};
-use std::io;
-
-/// Creates a client transport and server listener for our tests
-/// that are connected together
-async fn setup() -> (
-    FramedTransport<InmemoryTransport, PlainCodec>,
-    OneshotListener<FramedTransport<InmemoryTransport, PlainCodec>>,
-) {
-    let (t1, t2) = InmemoryTransport::pair(100);
-
-    let listener = OneshotListener::from_value(FramedTransport::new(t2, PlainCodec));
-    let transport = FramedTransport::new(t1, PlainCodec);
-    (transport, listener)
-}
-
-#[tokio::test]
-async fn should_be_able_to_establish_a_single_connection_and_communicate() {
-    let (transport, listener) = setup().await;
-
-    let config = DistantManagerConfig::default();
-    let manager_ref = DistantManager::start(config, listener).expect("Failed to start manager");
-
-    // NOTE: To pass in a raw function, we HAVE to specify the types of the parameters manually,
-    //       otherwise we get a compilation error about lifetime mismatches
-    manager_ref
-        .register_connect_handler("scheme", |_: &_, _: &_, _: &mut _| async {
-            use distant_core::net::ServerExt;
-            let (t1, t2) = FramedTransport::pair(100);
-
-            // Spawn a server on one end
-            let _ = DistantApiServer::local(Default::default())
-                .unwrap()
-                .start(OneshotListener::from_value(t2.into_split()))?;
-
-            // Create a reader/writer pair on the other end
-            let (writer, reader) = t1.into_split();
-            let writer: BoxedDistantWriter = Box::new(writer);
-            let reader: BoxedDistantReader = Box::new(reader);
-            Ok((writer, reader))
-        })
-        .await
-        .expect("Failed to register handler");
-
-    let config = DistantManagerClientConfig::with_empty_prompts();
-    let mut client =
-        DistantManagerClient::new(config, transport).expect("Failed to connect to manager");
-
-    // Test establishing a connection to some remote server
-    let id = client
-        .connect(
-            "scheme://host".parse::<Destination>().unwrap(),
-            "key=value".parse::<Map>().unwrap(),
-        )
-        .await
-        .expect("Failed to connect to a remote server");
-
-    // Test retrieving list of connections
-    let list = client
-        .list()
-        .await
-        .expect("Failed to get list of connections");
-    assert_eq!(list.len(), 1);
-    assert_eq!(list.get(&id).unwrap().to_string(), "scheme://host");
-
-    // Test retrieving information
-    let info = client
-        .info(id)
-        .await
-        .expect("Failed to get info about connection");
-    assert_eq!(info.id, id);
-    assert_eq!(info.destination.to_string(), "scheme://host");
-    assert_eq!(info.options, "key=value".parse::<Map>().unwrap());
-
-    // Create a new channel and request some data
-    let mut channel = client
-        .open_channel(id)
-        .await
-        .expect("Failed to open channel");
-    let _ = channel
-        .system_info()
-        .await
-        .expect("Failed to get system information");
-
-    // Test killing a connection
-    client.kill(id).await.expect("Failed to kill connection");
-
-    // Test getting an error to ensure that serialization of that data works,
-    // which we do by trying to access a connection that no longer exists
-    let err = client.info(id).await.unwrap_err();
-    assert_eq!(err.kind(), io::ErrorKind::NotConnected);
-}

distant-net/tests/manager_tests.rs

@@ -13,13 +13,13 @@ struct TestServerHandler;
 
 #[async_trait]
 impl ServerHandler for TestServerHandler {
-    type Request = u8;
-    type Response = u8;
+    type Request = String;
+    type Response = String;
     type LocalData = ();
 
     async fn on_request(&self, ctx: ServerCtx<Self::Request, Self::Response, Self::LocalData>) {
         ctx.reply
-            .send(ctx.request.payload)
+            .send(format!("echo {}", ctx.request.payload))
             .await
             .expect("Failed to send response")
     }
@@ -99,7 +99,7 @@ async fn should_be_able_to_establish_a_single_connection_and_communicate() {
 
     // Create a new channel and request some data
     info!("Submitting server channel open request to manager");
-    let mut channel_client: Client<u8, u8> = client
+    let mut channel_client: Client<String, String> = client
         .open_raw_channel(id)
         .await
         .expect("Failed to open channel")
@@ -107,10 +107,10 @@ async fn should_be_able_to_establish_a_single_connection_and_communicate() {
 
     info!("Verifying server channel can send and receive data");
     let res = channel_client
-        .send(123u8)
+        .send("hello".to_string())
         .await
         .expect("Failed to send request to server");
-    assert_eq!(res.payload, 123u8, "Invalid response payload");
+    assert_eq!(res.payload, "echo hello", "Invalid response payload");
 
     // Test killing a connection
     info!("Submitting connection kill request to manager");

distant-net/tests/typed_tests.rs

@@ -30,7 +30,6 @@ impl ServerHandler for TestServerHandler {
 async fn should_be_able_to_send_and_receive_typed_payloads_between_client_and_server() {
     let (t1, t2) = InmemoryTransport::pair(100);
 
-    // Spawn a server on one end and connect to it on the other
     let _ = Server::new()
         .handler(TestServerHandler)
         .verifier(Verifier::none())

distant-net/tests/untyped_tests.rs

@@ -30,7 +30,6 @@ impl ServerHandler for TestServerHandler {
 async fn should_be_able_to_send_and_receive_untyped_payloads_between_client_and_server() {
     let (t1, t2) = InmemoryTransport::pair(100);
 
-    // Spawn a server on one end and connect to it on the other
     let _ = Server::new()
         .handler(TestServerHandler)
         .verifier(Verifier::none())