Handle sending messages to rooms.

client/src/control/request.rs

@@ -18,6 +18,12 @@ pub enum Request {
   UserListRequest,
 }
 
+impl From<RoomMessageRequest> for Request {
+  fn from(request: RoomMessageRequest) -> Self {
+    Self::RoomMessageRequest(request)
+  }
+}
+
 /// This structure contains the chat room message request from the controller.
 #[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct RoomMessageRequest {

client/src/dispatcher.rs

@@ -9,7 +9,8 @@ use crate::context::Context;
 use crate::control::Request as ControlRequest;
 use crate::executor::Job;
 use crate::handlers::{
-  RoomListRequestHandler, SetPrivilegedUsersHandler, SetRoomListHandler,
+  RoomListRequestHandler, RoomMessageRequestHandler, SetPrivilegedUsersHandler,
+  SetRoomListHandler,
 };
 use crate::message_handler::MessageHandler;
 
@@ -26,6 +27,12 @@ impl From<ServerResponse> for Message {
   }
 }
 
+impl From<ControlRequest> for Message {
+  fn from(request: ControlRequest) -> Self {
+    Self::ControlRequest(request)
+  }
+}
+
 /// Pairs together a message and its handler as chosen by the dispatcher.
 /// Implements Job so as to be scheduled on an executor.
 struct DispatchedMessage<M, H> {
@@ -84,6 +91,12 @@ impl Dispatcher {
           handler: RoomListRequestHandler::default(),
         }))
       }
+      Message::ControlRequest(ControlRequest::RoomMessageRequest(request)) => {
+        Some(Box::new(DispatchedMessage {
+          message: request,
+          handler: RoomMessageRequestHandler::default(),
+        }))
+      }
       Message::ControlRequest(request) => {
         warn!("Unhandled control request: {:?}", request);
         None
@@ -101,10 +114,6 @@ mod tests {
 
   use super::*;
 
-  fn into_message<T: Into<ServerResponse>>(t: T) -> Message {
-    t.into().into()
-  }
-
   #[test]
   fn does_not_dispatch_unhandled_response() {
     assert!(Dispatcher::new()
@@ -144,6 +153,19 @@ mod tests {
       .is_some());
   }
 
+  #[test]
+  fn dispatches_room_message_request() {
+    assert!(Dispatcher::new()
+      .dispatch(Message::ControlRequest(
+        control::RoomMessageRequest {
+          room_name: "bleep".to_string(),
+          message: "yo!".to_string(),
+        }
+        .into()
+      ))
+      .is_some());
+  }
+
   #[test]
   fn dispatches_room_list_request() {
     assert!(Dispatcher::new()

client/src/handlers/mod.rs

@@ -1,7 +1,9 @@
 mod room_list_request_handler;
+mod room_message_request_handler;
 mod set_privileged_users_handler;
 mod set_room_list_handler;
 
 pub use room_list_request_handler::RoomListRequestHandler;
+pub use room_message_request_handler::RoomMessageRequestHandler;
 pub use set_privileged_users_handler::SetPrivilegedUsersHandler;
 pub use set_room_list_handler::SetRoomListHandler;

client/src/handlers/room_message_request_handler.rs

@@ -0,0 +1,71 @@
+use std::io;
+
+use solstice_proto::server;
+use solstice_proto::ServerRequest;
+
+use crate::context::Context;
+use crate::control;
+use crate::message_handler::MessageHandler;
+
+#[derive(Debug, Default)]
+pub struct RoomMessageRequestHandler;
+
+impl MessageHandler<control::RoomMessageRequest> for RoomMessageRequestHandler {
+  fn run(
+    self,
+    context: &Context,
+    message: &control::RoomMessageRequest,
+  ) -> io::Result<()> {
+    context
+      .server_request_tx
+      .blocking_send(ServerRequest::RoomMessageRequest(
+        server::RoomMessageRequest {
+          room_name: message.room_name.clone(),
+          message: message.message.clone(),
+        },
+      ));
+    Ok(())
+  }
+
+  fn name() -> String {
+    "RoomMessageRequestHandler".to_string()
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use solstice_proto::server;
+  use solstice_proto::ServerRequest;
+
+  use crate::context::ContextBundle;
+  use crate::control;
+  use crate::message_handler::MessageHandler;
+
+  use super::RoomMessageRequestHandler;
+
+  #[test]
+  fn run_forwards_request() {
+    let mut bundle = ContextBundle::default();
+
+    RoomMessageRequestHandler::default()
+      .run(
+        &bundle.context,
+        &control::RoomMessageRequest {
+          room_name: "bleep".to_string(),
+          message: "yo!".to_string(),
+        }
+        .into(),
+      )
+      .unwrap();
+
+    let request = bundle.server_request_rx.blocking_recv().unwrap();
+
+    assert_eq!(
+      request,
+      ServerRequest::RoomMessageRequest(server::RoomMessageRequest {
+        room_name: "bleep".to_string(),
+        message: "yo!".to_string(),
+      })
+    );
+  }
+}