Send message timestamp to controller client.

client/src/client.rs

@@ -620,17 +620,18 @@ impl Client {
       }
     };
 
-    room.messages.insert(room::Message {
+    let message = room::Message {
       received_at: std::time::SystemTime::now(),
       user_name: response.user_name.clone(),
       message: response.message.clone(),
-    });
+    };
+
+    room.messages.insert(message.clone());
 
     self.send_to_controller(control::Response::RoomMessageResponse(
       control::RoomMessageResponse {
         room_name: response.room_name,
-        user_name: response.user_name,
-        message: response.message,
+        message,
       },
     ));
   }

client/src/control/response.rs

@@ -1,7 +1,8 @@
-use crate::room::Room;
 use serde::{Deserialize, Serialize};
 use solstice_proto::User;
 
+use crate::room::{Message, Room};
+
 /// This enumeration is the list of possible control responses from the client
 /// to the controller.
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -70,10 +71,8 @@ pub struct RoomListResponse {
 pub struct RoomMessageResponse {
   /// The name of the room in which the message was said.
   pub room_name: String,
-  /// The name of the user who said the message.
-  pub user_name: String,
   /// The message itself.
-  pub message: String,
+  pub message: Message,
 }
 
 /// This struct describes the fact that the given user joined the given room.
@@ -106,10 +105,11 @@ pub struct UserListResponse {
 #[cfg(test)]
 mod tests {
   use std::collections::HashSet;
+  use std::time::{Duration, SystemTime};
 
   use solstice_proto::{User, UserStatus};
 
-  use crate::room::{Membership, MessageHistory, Room, Visibility};
+  use crate::room::{Membership, Message, MessageHistory, Room, Visibility};
 
   use super::{
     LoginStatusResponse, RoomJoinResponse, RoomLeaveResponse, RoomListResponse,
@@ -224,15 +224,21 @@ mod tests {
       serde_json::from_str::<RoomMessageResponse>(
         r#"{
           "room_name": "bleep",
-          "user_name": "karandeep",
-          "message": "namaste"
+          "message": {
+            "user_name": "karandeep",
+            "message": "namaste",
+            "received_at": { "secs_since_epoch": 42, "nanos_since_epoch": 0 }
+          }
         }"#
       )
       .unwrap(),
       RoomMessageResponse {
         room_name: "bleep".to_string(),
-        user_name: "karandeep".to_string(),
-        message: "namaste".to_string(),
+        message: Message {
+          user_name: "karandeep".to_string(),
+          message: "namaste".to_string(),
+          received_at: SystemTime::UNIX_EPOCH + Duration::from_secs(42),
+        },
       }
     );
   }

client/src/handlers/room_message_response_handler.rs

@@ -1,5 +1,4 @@
 use anyhow::Context as AnyhowContext;
-use log::warn;
 use solstice_proto::server;
 
 use crate::context::Context;
@@ -10,42 +9,34 @@ use crate::room::Message as RoomMessage;
 #[derive(Debug, Default)]
 pub struct RoomMessageResponseHandler;
 
-fn add_message(
-  context: &mut Context,
-  response: &server::RoomMessageResponse,
-) -> anyhow::Result<()> {
-  let room = context
-    .state
-    .rooms
-    .get_mut_strict(&response.room_name)
-    .context("looking up room")?;
-  room.messages.insert(RoomMessage {
-    received_at: context.system_clock.now(),
-    user_name: response.user_name.clone(),
-    message: response.message.clone(),
-  });
-  Ok(())
-}
-
 impl MessageHandler for RoomMessageResponseHandler {
   type Message = server::RoomMessageResponse;
 
   fn run(
     self,
     context: &mut Context,
-    message: &server::RoomMessageResponse,
+    response: &server::RoomMessageResponse,
   ) -> anyhow::Result<()> {
-    if let Err(err) = add_message(context, message) {
-      warn!("Error storing room message: {:#}", err);
-    }
+    let room = context
+      .state
+      .rooms
+      .get_mut_strict(&response.room_name)
+      .context("looking up room")?;
+
+    let message = RoomMessage {
+      received_at: context.system_clock.now(),
+      user_name: response.user_name.clone(),
+      message: response.message.clone(),
+    };
+
+    room.messages.insert(message.clone());
 
     context
       .control_response_tx
       .blocking_send(control::Response::RoomMessageResponse(
         control::RoomMessageResponse {
-          room_name: message.room_name.clone(),
-          user_name: message.user_name.clone(),
-          message: message.message.clone(),
+          room_name: response.room_name.clone(),
+          message,
         },
       ))
       .context("sending control response")?;
@@ -67,7 +58,7 @@ mod tests {
   use crate::context::{ContextBundle, ContextOptions};
   use crate::control;
   use crate::message_handler::MessageHandler;
-  use crate::room::{Message as RoomMessage, Room, Visibility};
+  use crate::room::{Message, Room, Visibility};
 
   use super::RoomMessageResponseHandler;
 
@@ -77,13 +68,21 @@ mod tests {
 
   #[test]
   fn run_forwards_response() {
-    let mut bundle = ContextBundle::default();
+    let mut options = ContextOptions::default();
+    options
+      .initial_state
+      .rooms
+      .insert("apple".to_string(), Room::new(Visibility::Public, 1));
+    options.simulated_clock =
+      Some(SimulatedSystemClock::new(system_time_from_secs(42)));
+
+    let mut bundle = ContextBundle::new(options);
 
     RoomMessageResponseHandler::default()
       .run(
         &mut bundle.context,
         &server::RoomMessageResponse {
-          room_name: "bleep".to_string(),
+          room_name: "apple".to_string(),
           user_name: "shruti".to_string(),
           message: "yo!".to_string(),
         },
@@ -98,9 +97,12 @@ mod tests {
     assert_eq!(
       response,
       control::Response::RoomMessageResponse(control::RoomMessageResponse {
-        room_name: "bleep".to_string(),
-        user_name: "shruti".to_string(),
-        message: "yo!".to_string(),
+        room_name: "apple".to_string(),
+        message: Message {
+          user_name: "shruti".to_string(),
+          message: "yo!".to_string(),
+          received_at: SystemTime::UNIX_EPOCH + Duration::from_secs(42),
+        },
       })
     );
   }
@@ -108,7 +110,7 @@ mod tests {
   #[test]
   fn run_stores_message() {
     let mut room = Room::new(Visibility::Public, 42);
-    room.messages.insert(RoomMessage {
+    room.messages.insert(Message {
       received_at: system_time_from_secs(42),
       user_name: "karandeep".to_string(),
       message: "namaste!".to_string(),
@@ -145,12 +147,12 @@ mod tests {
     assert_eq!(
       room.messages.to_vec(),
       vec![
-        RoomMessage {
+        Message {
           received_at: system_time_from_secs(42),
           user_name: "karandeep".to_string(),
           message: "namaste!".to_string(),
         },
-        RoomMessage {
+        Message {
           received_at: system_time_from_secs(43),
           user_name: "shruti".to_string(),
           message: "yo!".to_string(),