Tests skeleton

src/main.rs

@@ -65,7 +65,8 @@ fn main() {
         (
             module: services::packet_processor::start_inbound,
             name: inbound_packet_processor,
-            dependencies: [messenger, player_state, block_state, patchwork_state]
+            dependencies: [messenger, player_state, block_state, patchwork_state],
+            extras: [None]
         ),
         (
             module: services::connection::start,
@@ -96,3 +97,88 @@ fn main() {
         messenger.sender(),
     );
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+
+    fn start_trace() {
+        let logger_config = ConfigBuilder::new()
+            .set_max_level(LevelFilter::Off)
+            .set_thread_level(LevelFilter::Off)
+            .set_target_level(LevelFilter::Off)
+            .build();
+        SimpleLogger::init(LevelFilter::Trace, logger_config).unwrap();
+    }
+
+    #[test]
+    fn test() {
+        start_trace();
+
+        // Since servers handle connection in their own thread, create a channel
+        // to retrieve information
+        let (router_sender, router_receiver) = std::sync::mpsc::channel();
+        let optional_router_sender = Some(router_sender.clone());
+
+        define_services!(
+            (
+                module: services::player::start,
+                name: player_state,
+                dependencies: [messenger]
+            ),
+            (
+                module: services::block::start,
+                name: block_state,
+                dependencies: [messenger]
+            ),
+            (
+                module: services::patchwork::start,
+                name: patchwork_state,
+                dependencies: [messenger, inbound_packet_processor, player_state]
+            ),
+            (
+                module: services::messenger::start,
+                name: messenger,
+                dependencies: []
+            ),
+            (
+                module: services::packet_processor::start_inbound,
+                name: inbound_packet_processor,
+                dependencies: [messenger, player_state, block_state, patchwork_state],
+                extras: [optional_router_sender]
+            ),
+            (
+                module: services::connection::start,
+                name: connection_service,
+                dependencies: [messenger, player_state, patchwork_state, inbound_packet_processor]
+            ),
+            (
+                module: services::keep_alive::start,
+                name: keep_alive,
+                dependencies: [messenger]
+            )
+        );
+        trace!("Services Started");
+
+        // the stuff below this should also probably be moved to a service model
+        let peer_address = String::from("127.0.0.1");
+        let peer_port = std::env::var("PEER_PORT").unwrap().parse::<u16>().unwrap();
+
+        patchwork_state.sender().new_map(models::map::Peer {
+            port: peer_port,
+            address: peer_address,
+        });
+
+        std::thread::spawn(move || {
+            server::listen(
+                inbound_packet_processor.sender(),
+                connection_service.sender(),
+                messenger.sender(),
+            );
+        });
+
+        while let Ok((state, packet)) = router_receiver.recv() {
+            trace!("==[Received]== {:?}, {:?}", state, packet);
+        }
+    }
+}

src/services/instance.rs

@@ -32,15 +32,16 @@ impl<O> ServiceInstance<O> {
 // 1. Create the service instance struct (which creates a channel for you)
 // 2. Run the service event loop method with a clone of the sender of all services it depends on
 macro_rules! define_services {
-    ($( (module: $service:path, name: $service_instance:ident, dependencies: [$($dependency:ident),*])),*) => (
+    ($( (module: $service:path, name: $service_instance:ident, dependencies: [$($dependency:ident),*] $(, extras: [$($extra:ident),*])?)),*) => (
         $(let mut $service_instance = ServiceInstance::new();)*
         $(
             paste::expr! {
-                $(let [<$dependency _clone>] = $dependency.sender(););*
+                $(let [<$dependency _clone>] = $dependency.sender();)*
+                $($(let [<$extra _clone>] = $extra.clone();)*)?
                 let sender = $service_instance.sender();
                 let receiver = $service_instance.receiver();
-                thread::spawn(move || $service(receiver, sender, $({[<$dependency _clone>]}),*));
+                thread::spawn(move || $service(receiver, sender $(, {[<$dependency _clone>]})* $(, $({[<$extra _clone>]})*)? ));
             }
         )*
-    )
+    );
 }

src/services/packet_processor.rs

@@ -4,7 +4,7 @@ use super::interfaces::packet_processor::Operations;
 use super::interfaces::patchwork::PatchworkState;
 use super::interfaces::player::PlayerState;
 
-use super::packet::{read, translate};
+use super::packet::{read, translate, Packet};
 use super::packet_handlers::packet_router;
 use super::translation::{TranslationInfo, TranslationUpdates};
 use std::collections::HashMap;
@@ -24,6 +24,7 @@ pub fn start_inbound<
     player_state: P,
     block_state: B,
     patchwork_state: PA,
+    test_sender: Option<std::sync::mpsc::Sender<(i32, Packet)>>,
 ) {
     let mut translation_data = HashMap::<Uuid, TranslationInfo>::new();
 
@@ -37,6 +38,15 @@ pub fn start_inbound<
 
                 let packet = read(&mut msg.cursor.clone(), translation_data.state);
                 let packet = translate(packet, translation_data.clone());
+
+                // Send raw packet info if we provided a channel
+                let test_sender_clone = test_sender.clone();
+                if let Some(test_sender_clone) = test_sender_clone {
+                    test_sender_clone
+                        .send((translation_data.state, packet.clone()))
+                        .expect("Failed to send packet to channel");
+                }
+
                 let translation_update = packet_router::route_packet(
                     packet,
                     translation_data.state,