Add a network test for proxying server errors.

src/network.rs

@@ -292,7 +292,7 @@ impl Network {
         // too many pending RPCs to be served.
         let (tx, rx) = channel();
         Network {
-            reliable: false,
+            reliable: true,
             long_delays: false,
             long_reordering: false,
             clients: Default::default(),
@@ -310,8 +310,10 @@ impl Network {
 mod tests {
     use std::sync::MutexGuard;
 
-    use crate::test_utils::{junk_server::make_server, make_echo_rpc};
-    use crate::Result;
+    use crate::test_utils::{
+        junk_server::make_server, make_aborting_rpc, make_echo_rpc,
+    };
+    use crate::{ReplyMessage, Result};
 
     use super::*;
 
@@ -358,8 +360,10 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_proxy_rpc() -> Result<()> {
+    fn send_rpc(
+        rpc: RpcOnWire,
+        rx: futures::channel::oneshot::Receiver<Result<ReplyMessage>>,
+    ) -> Result<ReplyMessage> {
         let network = Network::run_daemon();
         let sender = {
             let mut network = unlock(&network);
@@ -371,8 +375,6 @@ mod tests {
             network.request_bus.clone()
         };
 
-        let (rpc, rx) =
-            make_echo_rpc("test-client", "test-server", &[0x09, 0x00]);
         let result = sender.send(rpc);
 
         assert!(
@@ -384,6 +386,15 @@ mod tests {
             Ok(reply) => reply,
             Err(e) => panic!("Future execution should not fail: {}", e),
         };
+
+        reply
+    }
+
+    #[test]
+    fn test_proxy_rpc() -> Result<()> {
+        let (rpc, rx) =
+            make_echo_rpc("test-client", "test-server", &[0x09u8, 0x00u8]);
+        let reply = send_rpc(rpc, rx);
         match reply {
             Ok(reply) => assert_eq!(reply.as_ref(), &[0x00u8, 0x09u8]),
             Err(e) => panic!("Expecting echo message, got {}", e),
@@ -391,4 +402,14 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_proxy_rpc_server_error() -> Result<()> {
+        let (rpc, rx) = make_aborting_rpc("test-client", "test-server");
+        let reply = send_rpc(rpc, rx);
+        let err = reply.expect_err("Network should proxy server errors");
+        assert_eq!(std::io::ErrorKind::ConnectionReset, err.kind());
+
+        Ok(())
+    }
 }

src/test_utils/mod.rs

@@ -4,17 +4,33 @@ use crate::{ReplyMessage, RequestMessage, Result, RpcOnWire};
 
 pub(crate) mod junk_server;
 
+pub(crate) fn make_aborting_rpc<C: Into<String>, S: Into<String>>(
+    client: C,
+    server: S,
+) -> (RpcOnWire, Receiver<Result<ReplyMessage>>) {
+    make_rpc(client, server, "aborting", &[])
+}
+
 pub(crate) fn make_echo_rpc<C: Into<String>, S: Into<String>>(
     client: C,
     server: S,
     data: &[u8],
+) -> (RpcOnWire, Receiver<Result<ReplyMessage>>) {
+    make_rpc(client, server, "echo", data)
+}
+
+pub(crate) fn make_rpc<C: Into<String>, S: Into<String>, M: Into<String>>(
+    client: C,
+    server: S,
+    service_method: M,
+    data: &[u8],
 ) -> (RpcOnWire, Receiver<Result<ReplyMessage>>) {
     let (tx, rx) = futures::channel::oneshot::channel();
     (
         RpcOnWire {
             client: client.into(),
             server: server.into(),
-            service_method: "echo".into(),
+            service_method: service_method.into(),
             request: RequestMessage::copy_from_slice(data),
             reply_channel: tx,
         },