Introduce SetPrivilegedUsersHandler.

This is the first message handler to be defined.

src/context.rs

@@ -38,6 +38,6 @@ mod tests {
 
     #[test]
     fn context_is_sync() {
-        let sync: &dyn Sync = &Context::new();
+        let _sync: &dyn Sync = &Context::new();
     }
 }

src/dispatcher.rs

@@ -4,6 +4,7 @@ use std::fmt::Debug;
 
 use crate::context::Context;
 use crate::executor::Job;
+use crate::handlers::SetPrivilegedUsersHandler;
 use crate::message_handler::MessageHandler;
 use crate::proto::server::ServerResponse;
 
@@ -53,7 +54,30 @@ impl Dispatcher {
     }
 
     /// Dispatches the given message by wrapping it with a handler.
-    pub fn dispatch(message: Message) -> Box<dyn Job> {
-        panic!("Unimplemented")
+    pub fn dispatch(&self, message: Message) -> Box<dyn Job> {
+        let dispatched = match message {
+            Message::ServerResponse(ServerResponse::PrivilegedUsersResponse(response)) => {
+                DispatchedMessage::new(response, SetPrivilegedUsersHandler::default())
+            }
+            _ => panic!("Unimplemented"),
+        };
+
+        Box::new(dispatched)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::proto::server;
+
+    use super::*;
+
+    #[test]
+    fn dispatcher_privileged_users_response() {
+        Dispatcher::new().dispatch(Message::ServerResponse(
+            server::ServerResponse::PrivilegedUsersResponse(server::PrivilegedUsersResponse {
+                users: vec!["foo".to_string(), "bar".to_string(), "baz".to_string()],
+            }),
+        ));
     }
 }

src/executor.rs

@@ -77,7 +77,7 @@ mod tests {
     }
 
     impl Job for Waiter {
-        fn execute(self: Box<Self>, context: &Context) {
+        fn execute(self: Box<Self>, _context: &Context) {
             self.barrier.wait();
         }
     }

src/handlers/mod.rs

@@ -0,0 +1,3 @@
+mod set_privileged_users_handler;
+
+pub use set_privileged_users_handler::SetPrivilegedUsersHandler;

src/handlers/set_privileged_users_handler.rs

@@ -0,0 +1,51 @@
+use std::io;
+
+use crate::context::Context;
+use crate::message_handler::MessageHandler;
+use crate::proto::server::PrivilegedUsersResponse;
+
+#[derive(Debug, Default)]
+pub struct SetPrivilegedUsersHandler;
+
+impl MessageHandler<PrivilegedUsersResponse> for SetPrivilegedUsersHandler {
+    fn run(self, context: &Context, message: &PrivilegedUsersResponse) -> io::Result<()> {
+        let users = message.users.clone();
+        context.users.lock().set_all_privileged(users);
+        Ok(())
+    }
+
+    fn name() -> String {
+        "SetPrivilegedUsersHandler".to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::context::Context;
+    use crate::message_handler::MessageHandler;
+    use crate::proto::server::PrivilegedUsersResponse;
+
+    use super::SetPrivilegedUsersHandler;
+
+    #[test]
+    fn run_sets_privileged_users() {
+        let context = Context::new();
+
+        let response = PrivilegedUsersResponse {
+            users: vec![
+                "aomame".to_string(),
+                "billybob".to_string(),
+                "carlos".to_string(),
+            ],
+        };
+
+        SetPrivilegedUsersHandler::default()
+            .run(&context, &response)
+            .unwrap();
+
+        let mut privileged = context.users.lock().get_all_privileged();
+        privileged.sort();
+
+        assert_eq!(privileged, response.users);
+    }
+}

src/main.rs

@@ -13,6 +13,7 @@ mod context;
 mod control;
 mod dispatcher;
 mod executor;
+mod handlers;
 mod message_handler;
 mod proto;
 mod room;

src/user.rs

@@ -93,6 +93,11 @@ impl UserMap {
         }
     }
 
+    /// Returns a copy of the set of privileged users.
+    pub fn get_all_privileged(&self) -> Vec<String> {
+        self.privileged.iter().map(|s| s.to_string()).collect()
+    }
+
     /// Marks the given user as privileged.
     pub fn insert_privileged(&mut self, user_name: String) {
         self.privileged.insert(user_name);