Use sort_by() instead of sort_by_key().

client/src/handlers/mod.rs

@@ -2,9 +2,6 @@ mod login_status_request_handler;
 mod peer_address_response_handler;
 mod peer_connect_request_handler;
 mod privileged_users_response_handler;
-mod room_join_request_handler;
-mod room_join_response_handler;
-mod room_list_request_handler;
 mod room_list_response_handler;
 mod room_message_request_handler;
 mod room_message_response_handler;
@@ -14,9 +11,6 @@ pub use login_status_request_handler::LoginStatusRequestHandler;
 pub use peer_address_response_handler::PeerAddressResponseHandler;
 pub use peer_connect_request_handler::PeerConnectRequestHandler;
 pub use privileged_users_response_handler::PrivilegedUsersResponseHandler;
-pub use room_join_request_handler::RoomJoinRequestHandler;
-pub use room_join_response_handler::RoomJoinResponseHandler;
-pub use room_list_request_handler::RoomListRequestHandler;
 pub use room_list_response_handler::RoomListResponseHandler;
 pub use room_message_request_handler::RoomMessageRequestHandler;
 pub use room_message_response_handler::RoomMessageResponseHandler;

client/src/handlers/room_join_request_handler.rs

@@ -1,161 +0,0 @@
-use anyhow::Context as AnyhowContext;
-use log::error;
-use solstice_proto::server::RoomJoinRequest;
-use solstice_proto::ServerRequest;
-
-use crate::context::Context;
-use crate::control;
-use crate::message_handler::MessageHandler;
-
-#[derive(Debug, Default)]
-pub struct RoomJoinRequestHandler;
-
-fn start_joining(context: &mut Context, room_name: &str) -> anyhow::Result<()> {
-  let room = context.state.rooms.get_mut_strict(room_name)?;
-
-  room.start_joining().map_err(|err| {
-    let response =
-      control::Response::RoomJoinResponse(control::RoomJoinResponse {
-        room_name: room_name.to_string(),
-        room: room.clone_state(),
-      });
-
-    if let Err(err) = context.control_response_tx.blocking_send(response) {
-      error!(
-        "Failed to send RoomJoinResponse for room {}: {}",
-        room_name, err
-      );
-    }
-
-    err.into()
-  })
-}
-
-impl MessageHandler for RoomJoinRequestHandler {
-  type Message = String;
-
-  fn run(
-    self,
-    context: &mut Context,
-    room_name: &Self::Message,
-  ) -> anyhow::Result<()> {
-    start_joining(context, room_name).context("joining room")?;
-    context
-      .server_request_tx
-      .blocking_send(ServerRequest::RoomJoinRequest(RoomJoinRequest {
-        room_name: room_name.clone(),
-      }))
-      .context("sending server request")?;
-    Ok(())
-  }
-
-  fn name() -> String {
-    "RoomJoinRequestHandler".to_string()
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use anyhow::Context;
-  use solstice_proto::server::RoomJoinRequest;
-  use solstice_proto::ServerRequest;
-
-  use crate::context::{ContextBundle, ContextOptions};
-  use crate::control;
-  use crate::message_handler::MessageHandler;
-  use crate::room::{RoomMembership, RoomState, RoomVisibility};
-
-  use super::RoomJoinRequestHandler;
-
-  #[test]
-  fn run_failure() -> anyhow::Result<()> {
-    let mut bundle = ContextBundle::default();
-
-    RoomJoinRequestHandler::default()
-      .run(&mut bundle.context, &"bleep".to_string())
-      .unwrap_err();
-
-    // Room state has not changed.
-    assert_eq!(bundle.context.state.rooms.get_room_list(), vec![]);
-
-    // Close the channel, so we can observe it was empty without hanging.
-    drop(bundle.context.server_request_tx);
-    assert_eq!(bundle.server_request_rx.blocking_recv(), None);
-
-    Ok(())
-  }
-
-  #[test]
-  fn run_already_joined_responds_immediately() -> anyhow::Result<()> {
-    let mut room = RoomState::new(RoomVisibility::Public, 3);
-    room.membership = RoomMembership::Member;
-
-    let mut options = ContextOptions::default();
-    options
-      .initial_state
-      .rooms
-      .insert("bleep".to_string(), room.clone());
-    let mut bundle = ContextBundle::new(options);
-
-    RoomJoinRequestHandler::default()
-      .run(&mut bundle.context, &"bleep".to_string())
-      .unwrap_err();
-
-    // Room state has not changed.
-    assert_eq!(
-      bundle.context.state.rooms.get_room_list(),
-      vec![("bleep".to_string(), room.clone())]
-    );
-
-    assert_eq!(
-      bundle.control_response_rx.blocking_recv(),
-      Some(control::Response::RoomJoinResponse(
-        control::RoomJoinResponse {
-          room_name: "bleep".to_string(),
-          room,
-        }
-      ))
-    );
-
-    Ok(())
-  }
-
-  #[test]
-  fn run_success() -> anyhow::Result<()> {
-    let mut options = ContextOptions::default();
-    options.initial_state.rooms.insert(
-      "bleep".to_string(),
-      RoomState::new(RoomVisibility::Public, 3),
-    );
-    let mut bundle = ContextBundle::new(options);
-
-    RoomJoinRequestHandler::default()
-      .run(&mut bundle.context, &"bleep".to_string())
-      .context("running handler")?;
-
-    let request = bundle.server_request_rx.blocking_recv().unwrap();
-
-    // Room state has been altered to reflect the request.
-    assert_eq!(
-      bundle
-        .context
-        .state
-        .rooms
-        .get_strict("bleep")
-        .context("getting room")?
-        .clone_state()
-        .membership,
-      RoomMembership::Joining
-    );
-
-    // The request is forwarded onwards.
-    assert_eq!(
-      request,
-      ServerRequest::RoomJoinRequest(RoomJoinRequest {
-        room_name: "bleep".to_string(),
-      })
-    );
-
-    Ok(())
-  }
-}

client/src/handlers/room_join_response_handler.rs

@@ -1,99 +0,0 @@
-use anyhow::Context as AnyhowContext;
-use solstice_proto::server::RoomJoinResponse;
-
-use crate::context::Context;
-use crate::control;
-use crate::message_handler::MessageHandler;
-
-#[derive(Debug, Default)]
-pub struct RoomJoinResponseHandler;
-
-impl MessageHandler for RoomJoinResponseHandler {
-  type Message = RoomJoinResponse;
-
-  fn run(
-    self,
-    context: &mut Context,
-    response: &RoomJoinResponse,
-  ) -> anyhow::Result<()> {
-    {
-      let room = context.state.rooms.get_mut_strict(&response.room_name)?;
-
-      room.join(
-        response.owner.clone(),
-        response.operators.clone(),
-        &response.users,
-      );
-
-      // Send under lock to avoid out-of-order sends.
-      let control_response =
-        control::Response::RoomJoinResponse(control::RoomJoinResponse {
-          room_name: response.room_name.clone(),
-          room: room.clone_state(),
-        });
-
-      context
-        .control_response_tx
-        .blocking_send(control_response)
-        .context("sending control response")?;
-    }
-    Ok(())
-  }
-
-  fn name() -> String {
-    "RoomJoinResponseHandler".to_string()
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use solstice_proto::server::RoomJoinResponse;
-
-  use crate::context::{ContextBundle, ContextOptions};
-  use crate::control;
-  use crate::message_handler::MessageHandler;
-  use crate::room::{RoomMembership, RoomState, RoomVisibility};
-
-  use super::RoomJoinResponseHandler;
-
-  #[test]
-  fn run_updates_room_state_and_forwards_response() {
-    let mut room = RoomState::new(RoomVisibility::Public, 42);
-
-    let mut options = ContextOptions::default();
-    options
-      .initial_state
-      .rooms
-      .insert("apple".to_string(), room.clone());
-    let mut bundle = ContextBundle::new(options);
-
-    let response = RoomJoinResponse {
-      room_name: "apple".to_string(),
-      operators: vec!["shruti".to_string()],
-      owner: Some("kim".to_string()),
-      users: vec![],
-    };
-
-    RoomJoinResponseHandler::default()
-      .run(&mut bundle.context, &response)
-      .unwrap();
-
-    room.membership = RoomMembership::Member;
-    room.user_count = 0;
-    room.operators = ["shruti"].iter().map(|s| s.to_string()).collect();
-    room.owner = Some("kim".to_string());
-
-    let rooms = bundle.context.state.rooms.get_room_list();
-
-    assert_eq!(rooms, vec![("apple".to_string(), room.clone())]);
-
-    let response = bundle.control_response_rx.blocking_recv().unwrap();
-    assert_eq!(
-      response,
-      control::Response::RoomJoinResponse(control::RoomJoinResponse {
-        room_name: "apple".to_string(),
-        room,
-      })
-    );
-  }
-}

client/src/handlers/room_list_request_handler.rs

@@ -1,111 +0,0 @@
-use anyhow::Context as AnyhowContext;
-use solstice_proto::ServerRequest;
-
-use crate::context::Context;
-use crate::control;
-use crate::message_handler::MessageHandler;
-
-#[derive(Debug, Default)]
-pub struct RoomListRequestHandler;
-
-impl MessageHandler for RoomListRequestHandler {
-  type Message = ();
-
-  fn run(self, context: &mut Context, _message: &()) -> anyhow::Result<()> {
-    {
-      let rooms = context.state.rooms.get_room_list();
-      let control_response =
-        control::Response::RoomListResponse(control::RoomListResponse {
-          rooms,
-        });
-
-      context
-        .control_response_tx
-        .blocking_send(control_response)
-        .context("sending control response")?;
-    }
-
-    context
-      .server_request_tx
-      .blocking_send(ServerRequest::RoomListRequest)
-      .context("sending server request")?;
-    Ok(())
-  }
-
-  fn name() -> String {
-    "RoomListRequestHandler".to_string()
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use solstice_proto::server::RoomListResponse;
-  use solstice_proto::ServerRequest;
-
-  use crate::context::{ContextBundle, ContextOptions};
-  use crate::control;
-  use crate::message_handler::MessageHandler;
-  use crate::room::{RoomState, RoomVisibility};
-
-  use super::RoomListRequestHandler;
-
-  // Cannot get the compiler to be satisfied when borrowing the name...
-  fn room_name(pair: &(String, RoomState)) -> String {
-    pair.0.clone()
-  }
-
-  #[test]
-  fn run_forwards_request() {
-    let mut bundle = ContextBundle::default();
-
-    RoomListRequestHandler::default()
-      .run(&mut bundle.context, &())
-      .unwrap();
-
-    let request = bundle.server_request_rx.blocking_recv().unwrap();
-
-    assert_eq!(request, ServerRequest::RoomListRequest);
-  }
-
-  #[test]
-  fn run_sends_immediate_response() {
-    let mut options = ContextOptions::default();
-    options.initial_state.rooms.set_room_list(RoomListResponse {
-      rooms: vec![("potato".to_string(), 123), ("apple".to_string(), 42)],
-      owned_private_rooms: vec![],
-      other_private_rooms: vec![],
-      operated_private_room_names: vec![],
-    });
-
-    let mut bundle = ContextBundle::new(options);
-
-    RoomListRequestHandler::default()
-      .run(&mut bundle.context, &())
-      .unwrap();
-
-    let response = bundle.control_response_rx.blocking_recv().unwrap();
-
-    let mut rooms = match response {
-      control::Response::RoomListResponse(control::RoomListResponse {
-        rooms,
-      }) => rooms,
-      _ => panic!("Unexpected control response: {:?}", response),
-    };
-
-    rooms.sort_by_key(room_name);
-
-    assert_eq!(
-      rooms,
-      vec![
-        (
-          "apple".to_string(),
-          RoomState::new(RoomVisibility::Public, 42)
-        ),
-        (
-          "potato".to_string(),
-          RoomState::new(RoomVisibility::Public, 123)
-        ),
-      ]
-    );
-  }
-}

client/src/room/event.rs

@@ -1,13 +1,13 @@
 //! This module defines events affecting the room module and their handling.
 
-use solstice_proto::server::{
-  RoomJoinResponse, RoomListResponse, RoomMessageResponse,
-};
+use anyhow::Context as AnyhowContext;
+use log::error;
+use solstice_proto::server;
+use solstice_proto::ServerRequest;
 
 use crate::context::Context;
-use crate::control::RoomMessageRequest;
+use crate::control;
 use crate::handlers::{
-  RoomJoinRequestHandler, RoomJoinResponseHandler, RoomListRequestHandler,
   RoomListResponseHandler, RoomMessageRequestHandler,
   RoomMessageResponseHandler,
 };
@@ -17,11 +17,11 @@ use crate::message_handler::MessageHandler;
 #[derive(Debug, PartialEq, Eq)]
 pub enum RoomEvent {
   JoinRequest(String),
-  JoinResponse(RoomJoinResponse),
+  JoinResponse(server::RoomJoinResponse),
   ListRequest,
-  ListResponse(RoomListResponse),
-  MessageRequest(RoomMessageRequest),
-  MessageResponse(RoomMessageResponse),
+  ListResponse(server::RoomListResponse),
+  MessageRequest(control::RoomMessageRequest),
+  MessageResponse(server::RoomMessageResponse),
 }
 
 /// An interface for room event handlers.
@@ -40,6 +40,81 @@ pub trait HandleRoomEvent {
 #[derive(Default)]
 pub struct RoomEventHandler;
 
+fn start_joining(context: &mut Context, room_name: &str) -> anyhow::Result<()> {
+  let room = context.state.rooms.get_mut_strict(room_name)?;
+
+  room.start_joining().map_err(|err| {
+    let response =
+      control::Response::RoomJoinResponse(control::RoomJoinResponse {
+        room_name: room_name.to_string(),
+        room: room.clone_state(),
+      });
+
+    if let Err(err) = context.control_response_tx.blocking_send(response) {
+      error!(
+        "Failed to send RoomJoinResponse for room {}: {}",
+        room_name, err
+      );
+    }
+
+    err.into()
+  })
+}
+
+fn handle_join_request(
+  context: &mut Context,
+  room_name: String,
+) -> anyhow::Result<()> {
+  start_joining(context, &room_name).context("joining room")?;
+
+  context
+    .server_request_tx
+    .blocking_send(ServerRequest::RoomJoinRequest(server::RoomJoinRequest {
+      room_name,
+    }))
+    .context("sending server request")?;
+
+  Ok(())
+}
+
+fn handle_join_response(
+  context: &mut Context,
+  response: server::RoomJoinResponse,
+) -> anyhow::Result<()> {
+  let room = context.state.rooms.get_mut_strict(&response.room_name)?;
+
+  room.join(response.owner, response.operators, &response.users);
+
+  let control_response =
+    control::Response::RoomJoinResponse(control::RoomJoinResponse {
+      room_name: response.room_name,
+      room: room.clone_state(),
+    });
+
+  context
+    .control_response_tx
+    .blocking_send(control_response)
+    .context("sending control response")?;
+  Ok(())
+}
+
+fn handle_list_request(context: &mut Context) -> anyhow::Result<()> {
+  let rooms = context.state.rooms.get_room_list();
+  let control_response =
+    control::Response::RoomListResponse(control::RoomListResponse { rooms });
+
+  context
+    .control_response_tx
+    .blocking_send(control_response)
+    .context("sending control response")?;
+
+  context
+    .server_request_tx
+    .blocking_send(ServerRequest::RoomListRequest)
+    .context("sending server request")?;
+  Ok(())
+}
+
 impl HandleRoomEvent for RoomEventHandler {
   fn handle(
     &mut self,
@@ -49,14 +124,12 @@ impl HandleRoomEvent for RoomEventHandler {
     // TODO: Remove individual handlers, move code into RoomEventHandler.
     match event {
       RoomEvent::JoinRequest(room_name) => {
-        RoomJoinRequestHandler::default().run(context, &room_name)
+        handle_join_request(context, room_name)
       }
       RoomEvent::JoinResponse(response) => {
-        RoomJoinResponseHandler::default().run(context, &response)
-      }
-      RoomEvent::ListRequest => {
-        RoomListRequestHandler::default().run(context, &())
+        handle_join_response(context, response)
       }
+      RoomEvent::ListRequest => handle_list_request(context),
       RoomEvent::ListResponse(response) => {
         RoomListResponseHandler::default().run(context, &response)
       }
@@ -95,5 +168,212 @@ pub mod testing {
 
 #[cfg(test)]
 mod tests {
-  // TODO
+  use solstice_proto::server;
+
+  use crate::context::{ContextBundle, ContextOptions};
+  use crate::room::{RoomMembership, RoomState, RoomVisibility};
+
+  use super::*;
+
+  #[test]
+  fn handle_room_join_request_failure() {
+    let mut bundle = ContextBundle::default();
+
+    RoomEventHandler
+      .handle(
+        &mut bundle.context,
+        RoomEvent::JoinRequest("bleep".to_string()),
+      )
+      .unwrap_err();
+
+    // Room state has not changed.
+    assert_eq!(bundle.context.state.rooms.get_room_list(), vec![]);
+
+    // Close the channel, so we can observe it was empty without hanging.
+    drop(bundle.context.server_request_tx);
+    assert_eq!(bundle.server_request_rx.blocking_recv(), None);
+  }
+
+  #[test]
+  fn handle_room_join_request_already_joined() {
+    let mut room = RoomState::new(RoomVisibility::Public, 3);
+    room.membership = RoomMembership::Member;
+
+    let mut options = ContextOptions::default();
+    options
+      .initial_state
+      .rooms
+      .insert("bleep".to_string(), room.clone());
+    let mut bundle = ContextBundle::new(options);
+
+    RoomEventHandler
+      .handle(
+        &mut bundle.context,
+        RoomEvent::JoinRequest("bleep".to_string()),
+      )
+      .unwrap_err();
+
+    // Room state has not changed.
+    assert_eq!(
+      bundle.context.state.rooms.get_room_list(),
+      vec![("bleep".to_string(), room.clone())]
+    );
+
+    assert_eq!(
+      bundle.control_response_rx.blocking_recv(),
+      Some(control::Response::RoomJoinResponse(
+        control::RoomJoinResponse {
+          room_name: "bleep".to_string(),
+          room,
+        }
+      ))
+    );
+  }
+
+  #[test]
+  fn handle_room_join_request_success() {
+    let mut options = ContextOptions::default();
+    options.initial_state.rooms.insert(
+      "bleep".to_string(),
+      RoomState::new(RoomVisibility::Public, 3),
+    );
+    let mut bundle = ContextBundle::new(options);
+
+    RoomEventHandler
+      .handle(
+        &mut bundle.context,
+        RoomEvent::JoinRequest("bleep".to_string()),
+      )
+      .expect("handling request");
+
+    let request = bundle.server_request_rx.blocking_recv().unwrap();
+
+    // Room state has been altered to reflect the request.
+    assert_eq!(
+      bundle
+        .context
+        .state
+        .rooms
+        .get_strict("bleep")
+        .expect("getting room")
+        .clone_state()
+        .membership,
+      RoomMembership::Joining
+    );
+
+    // The request is forwarded onwards.
+    assert_eq!(
+      request,
+      ServerRequest::RoomJoinRequest(server::RoomJoinRequest {
+        room_name: "bleep".to_string(),
+      })
+    );
+  }
+
+  #[test]
+  fn handle_join_response_updates_room_state_and_forwards_response() {
+    let mut room = RoomState::new(RoomVisibility::Public, 42);
+
+    let mut options = ContextOptions::default();
+    options
+      .initial_state
+      .rooms
+      .insert("apple".to_string(), room.clone());
+    let mut bundle = ContextBundle::new(options);
+
+    let response = server::RoomJoinResponse {
+      room_name: "apple".to_string(),
+      operators: vec!["shruti".to_string()],
+      owner: Some("kim".to_string()),
+      users: vec![],
+    };
+
+    RoomEventHandler
+      .handle(&mut bundle.context, RoomEvent::JoinResponse(response))
+      .expect("handling response");
+
+    room.membership = RoomMembership::Member;
+    room.user_count = 0;
+    room.operators = ["shruti"].iter().map(|s| s.to_string()).collect();
+    room.owner = Some("kim".to_string());
+
+    let rooms = bundle.context.state.rooms.get_room_list();
+
+    assert_eq!(rooms, vec![("apple".to_string(), room.clone())]);
+
+    let response = bundle
+      .control_response_rx
+      .blocking_recv()
+      .expect("receiving response");
+    assert_eq!(
+      response,
+      control::Response::RoomJoinResponse(control::RoomJoinResponse {
+        room_name: "apple".to_string(),
+        room,
+      })
+    );
+  }
+
+  #[test]
+  fn handle_list_request_forwards_request() {
+    let mut bundle = ContextBundle::default();
+
+    RoomEventHandler
+      .handle(&mut bundle.context, RoomEvent::ListRequest)
+      .unwrap();
+
+    let request = bundle.server_request_rx.blocking_recv().unwrap();
+
+    assert_eq!(request, ServerRequest::RoomListRequest);
+  }
+
+  #[test]
+  fn handle_list_request_sends_immediate_response() {
+    let mut options = ContextOptions::default();
+    options
+      .initial_state
+      .rooms
+      .set_room_list(server::RoomListResponse {
+        rooms: vec![("potato".to_string(), 123), ("apple".to_string(), 42)],
+        owned_private_rooms: vec![],
+        other_private_rooms: vec![],
+        operated_private_room_names: vec![],
+      });
+
+    let mut bundle = ContextBundle::new(options);
+
+    RoomEventHandler
+      .handle(&mut bundle.context, RoomEvent::ListRequest)
+      .unwrap();
+
+    let response = bundle.control_response_rx.blocking_recv().unwrap();
+
+    let mut rooms = match response {
+      control::Response::RoomListResponse(control::RoomListResponse {
+        rooms,
+      }) => rooms,
+      _ => panic!("Unexpected control response: {:?}", response),
+    };
+
+    // `sort_by_key()` cannot handle an extractor function that returns
+    // references, so we use `sort_by()` instead.
+    // See: https://github.com/rust-lang/rust/issues/34162
+    rooms.sort_unstable_by(|(ref lhs_name, _), (ref rhs_name, _)| {
+      lhs_name.cmp(rhs_name)
+    });
+
+    assert_eq!(
+      rooms,
+      vec![
+        (
+          "apple".to_string(),
+          RoomState::new(RoomVisibility::Public, 42)
+        ),
+        (
+          "potato".to_string(),
+          RoomState::new(RoomVisibility::Public, 123)
+        ),
+      ]
+    );
+  }
 }