added test for manager state machine

src/dilation/events.rs

@@ -4,7 +4,6 @@ use serde_derive::Deserialize;
 use crate::{
     core::TheirSide,
     dilation::api::{IOEvent, ManagerCommand},
-    transit,
     transit::{DirectHint, Hints, RelayHint},
 };
 
@@ -42,7 +41,7 @@ pub enum ManagerEvent {
     },
     #[serde(rename = "connection-hints")]
     RxHints {
-        hints: transit::Hints,
+        hints: Hints,
     },
     RxReconnect,
     RxReconnecting,
@@ -52,33 +51,39 @@ pub enum ManagerEvent {
     Stop,
 }
 
-#[test]
-fn test_display_please_event() {
-    let event = ManagerEvent::RxPlease {
-        side: TheirSide::from("f91dcdaccc7cc336"),
-    };
-    assert_eq!(format!("{}", event), "TheirSide(f91dcdaccc7cc336)");
-}
+// XXX: for Connector fsm events
+// ...
+// XXX
 
-#[test]
-fn test_manager_event_deserialisation_start() {
-    let result: ManagerEvent = serde_json::from_str(r#"{"type": "start"}"#).expect("parse error");
-    assert_eq!(result, ManagerEvent::Start);
-}
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_display_please_event() {
+        let event = ManagerEvent::RxPlease {
+            side: TheirSide::from("f91dcdaccc7cc336"),
+        };
+        assert_eq!(format!("{}", event), "TheirSide(f91dcdaccc7cc336)");
+    }
 
-#[test]
-fn test_manager_event_deserialisation_rxplease() {
-    let result: ManagerEvent =
-        serde_json::from_str(r#"{"type": "please", "side": "f91dcdaccc7cc336"}"#)
-            .expect("parse error");
-    assert_eq!(
-        result,
-        ManagerEvent::RxPlease {
-            side: TheirSide::from("f91dcdaccc7cc336")
-        }
-    );
+    #[test]
+    fn test_manager_event_deserialisation_start() {
+        let result: ManagerEvent = serde_json::from_str(r#"{"type": "start"}"#).expect("parse error");
+        assert_eq!(result, ManagerEvent::Start);
+    }
+
+    #[test]
+    fn test_manager_event_deserialisation_rxplease() {
+        let result: ManagerEvent =
+            serde_json::from_str(r#"{"type": "please", "side": "f91dcdaccc7cc336"}"#)
+                .expect("parse error");
+        assert_eq!(
+            result,
+            ManagerEvent::RxPlease {
+                side: TheirSide::from("f91dcdaccc7cc336")
+            }
+        );
+    }
 }
 
-// XXX: for Connector fsm events
-// ...
-// XXX

src/dilation/manager.rs

@@ -1,3 +1,4 @@
+use std::panic::UnwindSafe;
 use derive_more::Display;
 #[cfg(test)]
 use mockall::automock;
@@ -19,12 +20,6 @@ pub enum Role {
     Follower,
 }
 
-pub struct ManagerMachine {
-    pub side: MySide,
-    pub role: Role,
-    pub state: Option<State>,
-}
-
 #[derive(Debug, PartialEq, Clone, Copy, Display)]
 pub enum State {
     Waiting,
@@ -38,6 +33,12 @@ pub enum State {
     Stopped,
 }
 
+pub struct ManagerMachine {
+    pub side: MySide,
+    pub role: Role,
+    pub state: Option<State>,
+}
+
 #[cfg_attr(test, automock)]
 impl ManagerMachine {
     pub fn new(side: MySide) -> Self {
@@ -66,10 +67,6 @@ impl ManagerMachine {
         actions
     }
 
-    pub fn get_current_state(&self) -> Option<State> {
-        self.state
-    }
-
     fn choose_role(&self, theirside: &TheirSide) -> Role {
         let myside: TheirSide = self.side.clone().into();
         if myside > *theirside {
@@ -223,6 +220,7 @@ impl ManagerMachine {
 #[cfg(test)]
 mod test {
     use crate::core::{MySide, TheirSide};
+    use crate::transit::Hints;
 
     use super::*;
 
@@ -248,7 +246,7 @@ mod test {
             ManagerMachine::new(MySide::unchecked_from_string("test123".to_string()));
         let side = MySide::generate(8);
 
-        assert_eq!(manager_fsm.get_current_state(), Some(State::Wanting));
+        assert_eq!(manager_fsm.current_state(), Some(State::Wanting));
 
         let mut handler = TestHandler::new();
 
@@ -261,12 +259,32 @@ mod test {
             &mut |cmd| handler.handle_command(cmd),
         );
 
-        assert_eq!(manager_fsm.get_current_state(), Some(State::Connecting));
+        assert_eq!(manager_fsm.current_state(), Some(State::Connecting));
         assert_eq!(
             handler.command,
             Some(ManagerCommand::Protocol(ProtocolCommand::SendPlease {
                 side: side,
             }))
         )
     }
+
+    #[test]
+    #[should_panic(expected = "Protocol error: foo")]
+    fn test_manager_machine_handle_error() {
+        let side = MySide::generate(8);
+        let mut manager_fsm = ManagerMachine {
+            side: side.clone(),
+            role: Role::Follower,
+            state: Some(State::Waiting),
+        };
+
+        assert_eq!(manager_fsm.current_state(), Some(State::Waiting));
+
+        manager_fsm.process(
+            ManagerEvent::Start,
+            &side,
+            &mut |cmd| {
+                Err(WormholeError::Protocol("foo".into()))
+            });
+    }
 }