Move protocol-specific test to protocol::, move Packet to network::.

src/network/client.rs

@@ -14,7 +14,7 @@ use tokio::sync::{mpsc, oneshot};
 use tokio::time::{delay_for, Delay};
 
 use super::idalloc::IdAllocator;
-use super::packet::{Packet, SERVER_EVENT_ID};
+use super::{Packet, SERVER_EVENT_ID};
 
 pub fn create<StreamType, ErrorType, PacketType>(
     stream: StreamType,

src/network/mod.rs

@@ -1,5 +1,44 @@
+//! Module which implements a low-level packet protocol over websockets.
+//!
+//! The low-level protocol needs to implement two basic pieces of functionality: It needs to be
+//! able to implement remote procedure calls from the client to the server, and it needs to
+//! provide a method for the server to send asynchronous events. A protocol for both cases is
+//! outlined below, where each packet is sent as one WebSocket message.
+//!
+//! Remote procedure call:
+//! - The client allocates an ID from the range between 0..2^31-1 that is not currently in use
+//!   for another RPC in progress.
+//! - The client prepares a packet with this ID, "response = false", and the appropriate
+//!   payload and sends the packet to the server.
+//! - The server receives the packet, processes the request and sends a packet back with the
+//!   identical ID and "response = true".
+//! - In case of an error, the payload has the type "Error" which in turn contains the error
+//!   type.
+//! - Unpon reception of the response, the client is free to reuse the ID for further RPCs.
+//! Note that this protocol does not allow the client to cancel an RPC that is currently in
+//! progress - implementing such functionality is difficult, error-prone, and most likely not
+//! worth the effort.
+//!
+//! Server-side event:
+//! - The server creates a packet with the ID 2^31 and the event content and sends it to the
+//!   client.
+//! Note that the client does not have any method to acknowledge event reception. As events are
+//! asynchronous compared to RPCs on the same connection, the event type needs to be designed in
+//! a way that no such temporal information is necessary to process the events.
+//! TODO: Example to demonstrate the problem.
+
 pub mod client;
 pub mod idalloc;
-pub mod packet;
 pub mod server;
 pub mod websocket;
+
+use serde::{Deserialize, Serialize};
+
+pub const SERVER_EVENT_ID: u32 = u32::max_value();
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
+pub struct Packet<Payload> {
+    pub id: u32,
+    pub response: bool, // TODO: Not really required.
+    pub payload: Payload,
+}

src/network/packet.rs

@@ -1,112 +0,0 @@
-//! Module which implements a low-level packet protocol over websockets.
-//!
-//! The low-level protocol needs to implement two basic pieces of functionality: It needs to be
-//! able to implement remote procedure calls from the client to the server, and it needs to
-//! provide a method for the server to send asynchronous events. A protocol for both cases is
-//! outlined below, where each packet is sent as one WebSocket message.
-//!
-//! Remote procedure call:
-//! - The client allocates an ID from the range between 0..2^31-1 that is not currently in use
-//!   for another RPC in progress.
-//! - The client prepares a packet with this ID, "response = false", and the appropriate
-//!   payload and sends the packet to the server.
-//! - The server receives the packet, processes the request and sends a packet back with the
-//!   identical ID and "response = true".
-//! - In case of an error, the payload has the type "Error" which in turn contains the error
-//!   type.
-//! - Unpon reception of the response, the client is free to reuse the ID for further RPCs.
-//! Note that this protocol does not allow the client to cancel an RPC that is currently in
-//! progress - implementing such functionality is difficult, error-prone, and most likely not
-//! worth the effort.
-//!
-//! Server-side event:
-//! - The server creates a packet with the ID 2^31 and the event content and sends it to the
-//!   client.
-//! Note that the client does not have any method to acknowledge event reception. As events are
-//! asynchronous compared to RPCs on the same connection, the event type needs to be designed in
-//! a way that no such temporal information is necessary to process the events.
-//! TODO: Example to demonstrate the problem.
-
-use serde::{Deserialize, Serialize};
-
-pub const SERVER_EVENT_ID: u32 = u32::max_value();
-
-#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
-pub struct Packet<Payload> {
-    pub id: u32,
-    pub response: bool, // TODO: Not really required.
-    pub payload: Payload,
-}
-
-#[cfg(test)]
-mod tests {
-    use rmps::Serializer;
-
-    use super::*;
-    use crate::protocol::{PacketPayload, ServerInfoResponse};
-
-    /// Test whether serialization of packets matches the expected values.
-    /// TODO: TGhese tests should be in protocol.rs.
-    #[test]
-    fn test_serde_compatibility() {
-        let tests = [
-            (
-                Packet {
-                    id: 42,
-                    response: false,
-                    payload: PacketPayload::ServerInfo,
-                },
-                vec![
-                    131, 162, 105, 100, 42, 168, 114, 101, 115, 112, 111, 110, 115, 101, 194, 167,
-                    112, 97, 121, 108, 111, 97, 100, 129, 170, 83, 101, 114, 118, 101, 114, 73,
-                    110, 102, 111, 192,
-                ],
-            ),
-            (
-                Packet {
-                    id: 42,
-                    response: true,
-                    payload: PacketPayload::ServerInfoResponse(ServerInfoResponse {
-                        version: "0.1".to_owned(),
-                    }),
-                },
-                vec![
-                    131, 162, 105, 100, 42, 168, 114, 101, 115, 112, 111, 110, 115, 101, 195, 167,
-                    112, 97, 121, 108, 111, 97, 100, 129, 178, 83, 101, 114, 118, 101, 114, 73,
-                    110, 102, 111, 82, 101, 115, 112, 111, 110, 115, 101, 129, 167, 118, 101, 114,
-                    115, 105, 111, 110, 163, 48, 46, 49,
-                ],
-            ),
-            (
-                Packet {
-                    id: 42,
-                    response: true,
-                    payload: PacketPayload::Error(crate::protocol::Error::InvalidParameter),
-                },
-                vec![
-                    131, 162, 105, 100, 42, 168, 114, 101, 115, 112, 111, 110, 115, 101, 195, 167,
-                    112, 97, 121, 108, 111, 97, 100, 129, 165, 69, 114, 114, 111, 114, 129, 176,
-                    73, 110, 118, 97, 108, 105, 100, 80, 97, 114, 97, 109, 101, 116, 101, 114, 192,
-                ],
-            ),
-        ];
-
-        for test in tests.iter() {
-            let mut serialized = Vec::new();
-            test.0
-                .serialize(
-                    &mut Serializer::new(&mut serialized)
-                        .with_struct_map()
-                        .with_string_variants(),
-                )
-                .unwrap();
-            let deserialized: Packet<PacketPayload> =
-                rmps::decode::from_slice(&serialized).unwrap();
-
-            // Test that serializing produces the expected binary results.
-            assert_eq!(serialized, test.1);
-            // Test that deserializing yields the original again.
-            assert_eq!(deserialized, test.0);
-        }
-    }
-}

src/protocol.rs

@@ -136,3 +136,76 @@ pub struct GetFileContent {
 pub struct GetFileContentResponse {
     // TODO
 }
+
+#[cfg(test)]
+mod tests {
+    use rmps::Serializer;
+
+    use super::*;
+    use crate::network::Packet;
+
+    /// Test whether serialization of packets matches the expected values.
+    /// TODO: These tests should be in protocol.rs.
+    #[test]
+    fn test_serde_compatibility() {
+        let tests = [
+            (
+                Packet {
+                    id: 42,
+                    response: false,
+                    payload: PacketPayload::ServerInfo,
+                },
+                vec![
+                    131, 162, 105, 100, 42, 168, 114, 101, 115, 112, 111, 110, 115, 101, 194, 167,
+                    112, 97, 121, 108, 111, 97, 100, 129, 170, 83, 101, 114, 118, 101, 114, 73,
+                    110, 102, 111, 192,
+                ],
+            ),
+            (
+                Packet {
+                    id: 42,
+                    response: true,
+                    payload: PacketPayload::ServerInfoResponse(ServerInfoResponse {
+                        version: "0.1".to_owned(),
+                    }),
+                },
+                vec![
+                    131, 162, 105, 100, 42, 168, 114, 101, 115, 112, 111, 110, 115, 101, 195, 167,
+                    112, 97, 121, 108, 111, 97, 100, 129, 178, 83, 101, 114, 118, 101, 114, 73,
+                    110, 102, 111, 82, 101, 115, 112, 111, 110, 115, 101, 129, 167, 118, 101, 114,
+                    115, 105, 111, 110, 163, 48, 46, 49,
+                ],
+            ),
+            (
+                Packet {
+                    id: 42,
+                    response: true,
+                    payload: PacketPayload::Error(crate::protocol::Error::InvalidParameter),
+                },
+                vec![
+                    131, 162, 105, 100, 42, 168, 114, 101, 115, 112, 111, 110, 115, 101, 195, 167,
+                    112, 97, 121, 108, 111, 97, 100, 129, 165, 69, 114, 114, 111, 114, 129, 176,
+                    73, 110, 118, 97, 108, 105, 100, 80, 97, 114, 97, 109, 101, 116, 101, 114, 192,
+                ],
+            ),
+        ];
+
+        for test in tests.iter() {
+            let mut serialized = Vec::new();
+            test.0
+                .serialize(
+                    &mut Serializer::new(&mut serialized)
+                        .with_struct_map()
+                        .with_string_variants(),
+                )
+                .unwrap();
+            let deserialized: Packet<PacketPayload> =
+                rmps::decode::from_slice(&serialized).unwrap();
+
+            // Test that serializing produces the expected binary results.
+            assert_eq!(serialized, test.1);
+            // Test that deserializing yields the original again.
+            assert_eq!(deserialized, test.0);
+        }
+    }
+}