Dispatch to user event handler.

client/src/dispatcher.rs

@@ -9,17 +9,22 @@ use crate::event::{Event, EventHandler};
 use crate::handlers::*;
 use crate::message_handler::MessageHandler;
 use crate::room::{RoomEvent, RoomEventHandler};
+use crate::user::{UserEvent, UserEventHandler};
 
 /// Subsystem event handlers to which the `Dispatcher` dispatches events.
 pub trait DispatcherHandlers {
   type RoomEventHandler: EventHandler<Event = RoomEvent>;
   fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler;
+
+  type UserEventHandler: EventHandler<Event = UserEvent>;
+  fn user_event_handler(&mut self) -> &mut Self::UserEventHandler;
 }
 
 /// Default event handlers implementing real behavior.
 #[derive(Default)]
 pub struct DefaultDispatcherHandlers {
   room_event_handler: RoomEventHandler,
+  user_event_handler: UserEventHandler,
 }
 
 impl DispatcherHandlers for DefaultDispatcherHandlers {
@@ -27,6 +32,11 @@ impl DispatcherHandlers for DefaultDispatcherHandlers {
   fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler {
     &mut self.room_event_handler
   }
+
+  type UserEventHandler = UserEventHandler;
+  fn user_event_handler(&mut self) -> &mut Self::UserEventHandler {
+    &mut self.user_event_handler
+  }
 }
 
 /// Parts that make up a `Dispatcher`.
@@ -68,8 +78,10 @@ impl<H: DispatcherHandlers> Dispatcher<H> {
       }
       Event::ServerResponse(ServerResponse::PrivilegedUsersResponse(
         response,
-      )) => PrivilegedUsersResponseHandler::default()
-        .run(&mut self.context, &response),
+      )) => self.handlers.user_event_handler().handle(
+        &mut self.context,
+        UserEvent::PrivilegedUsersResponse(response),
+      ),
       Event::ServerResponse(ServerResponse::RoomJoinResponse(response)) => self
         .handlers
         .room_event_handler()
@@ -108,9 +120,10 @@ impl<H: DispatcherHandlers> Dispatcher<H> {
         .handlers
         .room_event_handler()
         .handle(&mut self.context, RoomEvent::JoinRequest(room_name)),
-      Event::ControlRequest(ControlRequest::UserListRequest) => {
-        UserListRequestHandler::default().run(&mut self.context, &())
-      }
+      Event::ControlRequest(ControlRequest::UserListRequest) => self
+        .handlers
+        .user_event_handler()
+        .handle(&mut self.context, UserEvent::ListRequest),
       Event::ControlRequest(request) => {
         warn!("Unhandled control request: {:?}", request);
         Ok(())
@@ -133,30 +146,66 @@ mod tests {
 
   use solstice_proto::server;
 
-  use crate::context::ContextBundle;
+  use crate::context::{Context, ContextBundle};
   use crate::control;
-  use crate::dispatcher::Event;
-  use crate::room::testing::FakeRoomEventHandler;
+  use crate::event::{Event, EventHandler};
+  use crate::room::RoomEvent;
+  use crate::user::UserEvent;
+
+  use super::{Dispatcher, DispatcherHandlers, DispatcherParts};
+
+  /// A fake event handler that just records the events passed to it.
+  struct FakeEventHandler<E> {
+    pub events: Vec<E>,
+  }
+
+  // `Default` derivation seems not to work with generic vectors? Implementing
+  // it by hand works just fine, however.
+  impl<E> Default for FakeEventHandler<E> {
+    fn default() -> Self {
+      Self {
+        events: Vec::default(),
+      }
+    }
+  }
 
-  use super::*;
+  impl<E> EventHandler for FakeEventHandler<E> {
+    type Event = E;
+
+    fn handle(
+      &mut self,
+      _context: &mut Context,
+      event: E,
+    ) -> anyhow::Result<()> {
+      self.events.push(event);
+      Ok(())
+    }
+  }
 
   #[derive(Default)]
   struct FakeDispatcherHandlers {
-    room_event_handler: FakeRoomEventHandler,
+    room_event_handler: FakeEventHandler<RoomEvent>,
+    user_event_handler: FakeEventHandler<UserEvent>,
   }
 
   impl FakeDispatcherHandlers {
     // Defined here for better maintainability as new handlers are added.
     fn has_events(&self) -> bool {
       !self.room_event_handler.events.is_empty()
+        || !self.user_event_handler.events.is_empty()
     }
   }
 
   impl DispatcherHandlers for FakeDispatcherHandlers {
-    type RoomEventHandler = FakeRoomEventHandler;
+    type RoomEventHandler = FakeEventHandler<RoomEvent>;
     fn room_event_handler(&mut self) -> &mut Self::RoomEventHandler {
       &mut self.room_event_handler
     }
+
+    type UserEventHandler = FakeEventHandler<UserEvent>;
+    fn user_event_handler(&mut self) -> &mut Self::UserEventHandler {
+      &mut self.user_event_handler
+    }
   }
 
   /// Dispatches `event` to fake handlers using a new `Dispatcher` and
@@ -222,9 +271,12 @@ mod tests {
       users: vec!["foo".to_string(), "bar".to_string(), "baz".to_string()],
     };
 
-    let _handlers = dispatch(Event::ServerResponse(response.into()));
+    let handlers = dispatch(Event::ServerResponse(response.clone().into()));
 
-    // TODO: Check that event is dispatched to a new user event handler.
+    assert_eq!(
+      handlers.user_event_handler.events,
+      &[UserEvent::PrivilegedUsersResponse(response)],
+    );
   }
 
   #[test]
@@ -318,8 +370,11 @@ mod tests {
   fn dispatches_user_list_request() {
     let request = control::Request::UserListRequest;
 
-    let _handlers = dispatch(request.into());
+    let handlers = dispatch(request.into());
 
-    // TODO: Check that event is dispatched to a new user event handler.
+    assert_eq!(
+      handlers.user_event_handler.events,
+      &[UserEvent::ListRequest],
+    );
   }
 }

client/src/room/event.rs

@@ -187,32 +187,6 @@ impl EventHandler for RoomEventHandler {
   }
 }
 
-#[cfg(test)]
-pub mod testing {
-  use crate::context::Context;
-  use crate::event::EventHandler;
-
-  use super::RoomEvent;
-
-  #[derive(Default)]
-  pub struct FakeRoomEventHandler {
-    pub events: Vec<RoomEvent>,
-  }
-
-  impl EventHandler for FakeRoomEventHandler {
-    type Event = RoomEvent;
-
-    fn handle(
-      &mut self,
-      _context: &mut Context,
-      event: Self::Event,
-    ) -> anyhow::Result<()> {
-      self.events.push(event);
-      Ok(())
-    }
-  }
-}
-
 #[cfg(test)]
 mod tests {
   use std::cmp::Ordering;

client/src/user/event.rs

@@ -1,12 +1,21 @@
 //! This module defines events affecting the user module and their handling.
 
+use solstice_proto::server;
+
 use crate::context::Context;
 use crate::event::EventHandler;
+use crate::handlers::{PrivilegedUsersResponseHandler, UserListRequestHandler};
+use crate::message_handler::MessageHandler;
 
 /// An event affecting the user module.
 #[derive(Debug, PartialEq, Eq)]
-pub enum UserEvent {}
+pub enum UserEvent {
+  ListRequest,
+  PrivilegedUsersResponse(server::PrivilegedUsersResponse),
+}
 
+/// The default user event handler.
+#[derive(Debug, Default)]
 pub struct UserEventHandler;
 
 impl EventHandler for UserEventHandler {
@@ -14,9 +23,16 @@ impl EventHandler for UserEventHandler {
 
   fn handle(
     &mut self,
-    _context: &mut Context,
-    _event: Self::Event,
+    context: &mut Context,
+    event: Self::Event,
   ) -> anyhow::Result<()> {
-    Ok(())
+    match event {
+      UserEvent::ListRequest => {
+        UserListRequestHandler::default().run(context, &())
+      }
+      UserEvent::PrivilegedUsersResponse(response) => {
+        PrivilegedUsersResponseHandler::default().run(context, &response)
+      }
+    }
   }
 }