Add stub LoginHandler.

src/dispatcher.rs

@@ -4,7 +4,7 @@ use std::fmt::Debug;
 
 use crate::context::Context;
 use crate::executor::Job;
-use crate::handlers::SetPrivilegedUsersHandler;
+use crate::handlers::{LoginHandler, SetPrivilegedUsersHandler};
 use crate::message_handler::MessageHandler;
 use crate::proto::server::ServerResponse;
 
@@ -55,14 +55,15 @@ impl Dispatcher {
 
     /// Dispatches the given message by wrapping it with a handler.
     pub fn dispatch(&self, message: Message) -> Box<dyn Job> {
-        let dispatched = match message {
-            Message::ServerResponse(ServerResponse::PrivilegedUsersResponse(response)) => {
-                DispatchedMessage::new(response, SetPrivilegedUsersHandler::default())
+        match message {
+            Message::ServerResponse(ServerResponse::LoginResponse(response)) => {
+                Box::new(DispatchedMessage::new(response, LoginHandler::default()))
             }
+            Message::ServerResponse(ServerResponse::PrivilegedUsersResponse(response)) => Box::new(
+                DispatchedMessage::new(response, SetPrivilegedUsersHandler::default()),
+            ),
             _ => panic!("Unimplemented"),
-        };
-
-        Box::new(dispatched)
+        }
     }
 }
 
@@ -80,4 +81,13 @@ mod tests {
             }),
         ));
     }
+
+    #[test]
+    fn dispatcher_login_response() {
+        Dispatcher::new().dispatch(Message::ServerResponse(
+            server::ServerResponse::LoginResponse(server::LoginResponse::LoginFail {
+                reason: "bleep bloop".to_string(),
+            }),
+        ));
+    }
 }

src/handlers/login_handler.rs

@@ -0,0 +1,48 @@
+use std::io;
+
+use crate::context::Context;
+use crate::login::LoginStatus;
+use crate::message_handler::MessageHandler;
+use crate::proto::server::LoginResponse;
+
+#[derive(Debug, Default)]
+pub struct LoginHandler;
+
+impl MessageHandler<LoginResponse> for LoginHandler {
+    fn run(self, context: &Context, message: &LoginResponse) -> io::Result<()> {
+        let lock = context.login.lock();
+
+        match *lock {
+            LoginStatus::AwaitingResponse => (),
+            _ => {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("unexpected login response, status = {:?}", *lock),
+                ));
+            }
+        };
+
+        unimplemented!();
+    }
+
+    fn name() -> String {
+        "LoginHandler".to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn run_fails_on_wrong_status() {
+        let context = Context::new();
+
+        let response = LoginResponse::LoginFail {
+            reason: "bleep bloop".to_string(),
+        };
+
+        LoginHandler::default().run(&context, &response).unwrap();
+    }
+}

src/handlers/mod.rs

@@ -1,3 +1,5 @@
+mod login_handler;
 mod set_privileged_users_handler;
 
+pub use login_handler::LoginHandler;
 pub use set_privileged_users_handler::SetPrivilegedUsersHandler;