Add spec to test invites from non DM rooms

assets/translations.yaml

@@ -77,7 +77,7 @@ en:
     connect_without_rocketchat_server_id: "You have to provide an id to connect to a Rocket.Chat server. It can contain any alphanumeric character and `_`. For example `connect https://rocketchat.example.com my_token rocketchat_example`"
     connect_with_invalid_rocketchat_server_id: "The provided Rocket.Chat server ID `${rocketchat_server_id}` is not valid, it can only contain lowercase alphanumeric characters and `_`. The maximum length is ${max_rocketchat_server_id_length} characters."
     internal: "An internal error occurred"
-    inviter_unknown: "The invite didn't contain a sender, the admin room could not be validated"
+    inviter_unknown: "Could not determine if the admin room is valid, because the inviter is unknown. Possibly because the bot user was invited into an existing room. Please invite the bot user ${bot_user_id} to a direct chat."
     no_rocketchat_server: "No Rocket.Chat server found when querying ${rocketchat_url} (version information is missing from the response)"
     other_user_joined: "Another user join the admin room, leaving, please create a new admin room."
     only_room_creator_can_invite_bot_user: "Only the room creator can invite the Rocket.Chat bot user, please create a new room and invite the Rocket.Chat user to create an admin room."

src/matrix-rocketchat/errors.rs

@@ -305,9 +305,10 @@ error_chain!{
             display("Room {} has more then two members and cannot be used as admin room", room_id)
         }
 
-        InviterUnknown(room_id: RoomId) {
+        InviterUnknown(room_id: RoomId, bot_user_id: UserId) {
             description("Inviter for join event was not found")
-            display("Could not determine if the admin room {} is valid, because the inviter is unknown", room_id)
+            display("Could not determine if the admin room {} is valid, because the inviter is unknown. \
+            Please invite the bot user {} to a direct chat.", room_id, bot_user_id)
         }
 
         OnlyRoomCreatorCanInviteBotUser(inviter_id: UserId, room_id: RoomId, creator_id: UserId) {

src/matrix-rocketchat/handlers/events/room_handler.rs

@@ -187,7 +187,14 @@ impl<'a> RoomHandler<'a> {
         let inviter_id = match inviter_id {
             Some(inviter_id) => inviter_id,
             None => {
-                bail_error!(ErrorKind::InviterUnknown(matrix_room_id.clone()), t!(["errors", "inviter_unknown"]));
+                info!(self.logger, "Inviter is unknown, bot will leave and forget the room {}", matrix_room_id);
+                let bot_user_id = self.config.matrix_bot_user_id()?;
+                let err = user_error!(
+                    ErrorKind::InviterUnknown(matrix_room_id.clone(), bot_user_id.clone()),
+                    t!(["errors", "inviter_unknown"]).with_vars(vec![("bot_user_id", bot_user_id.to_string())])
+                );
+                self.handle_admin_room_setup_error(&err, matrix_room_id, matrix_bot_user_id);
+                return Ok(());
             }
         };
 

tests/admin_room.rs

@@ -116,7 +116,7 @@ fn bot_leaves_and_forgets_the_admin_room_when_the_user_leaves_it() {
 }
 
 #[test]
-fn bot_ignoeres_when_a_user_leaves_a_room_that_is_not_in_the_database() {
+fn bot_ignoeres_when_a_user_leaves_a_room_that_is_not_bridged() {
     let test = Test::new();
     let (leave_message_forwarder, leave_receiver) = MessageForwarder::new();
     let (forget_message_forwarder, forget_receiver) = MessageForwarder::new();
@@ -783,3 +783,40 @@ fn join_events_for_rooms_that_are_not_accessible_by_the_bot_user_are_ignored() {
 
     assert!(receiver.recv_timeout(default_timeout()).is_err());
 }
+
+#[test]
+fn the_bot_user_leaves_the_admin_room_the_inviter_is_unknown() {
+    let test = Test::new();
+    let mut matrix_router = test.default_matrix_routes();
+    let (message_forwarder, receiver) = MessageForwarder::new();
+    matrix_router.put(SendMessageEventEndpoint::router_path(), message_forwarder, "send_message_event");
+    let (leave_room, leave_room_receiver) = handlers::MatrixLeaveRoom::with_forwarder(test.config.as_url.clone());
+    matrix_router.post(LeaveRoomEndpoint::router_path(), leave_room, "leave_room");
+    let (forget_forwarder, forget_receiver) = MessageForwarder::new();
+    matrix_router.post(ForgetRoomEndpoint::router_path(), forget_forwarder, "forget");
+    matrix_router.post(JoinEndpoint::router_path(), handlers::EmptyJson {}, "join_room");
+    let join_room_handler = handlers::MatrixJoinRoom {
+        as_url: test.config.as_url.clone(),
+        send_inviter: false,
+    };
+    matrix_router.post(JoinEndpoint::router_path(), join_room_handler, "join_room");
+
+    let test = test.with_matrix_routes(matrix_router).run();
+
+    helpers::create_room(
+        &test.config,
+        "admin_room",
+        UserId::try_from("@spec_user:localhost").unwrap(),
+        UserId::try_from("@rocketchat:localhost").unwrap(),
+    );
+
+    let message_received_by_matrix = receiver.recv_timeout(default_timeout()).unwrap();
+    assert!(message_received_by_matrix.contains(
+        "Could not determine if the admin room is valid, because the inviter is unknown. \
+        Possibly because the bot user was invited into an existing room. \
+        Please invite the bot user @rocketchat:localhost to a direct chat.",
+    ));
+
+    assert!(leave_room_receiver.recv_timeout(default_timeout()).is_ok());
+    assert!(forget_receiver.recv_timeout(default_timeout()).is_ok());
+}

tests/forward_rocketchat_channel_to_matrix.rs

@@ -35,7 +35,7 @@ fn successfully_forwards_a_text_message_from_rocketchat_to_matrix_when_the_user_
     let (message_forwarder, receiver) = MessageForwarder::new();
     let (register_forwarder, register_receiver) = handlers::MatrixRegister::with_forwarder();
     let (invite_forwarder, invite_receiver) = handlers::MatrixInviteUser::with_forwarder(test.config.as_url.clone());
-    let (join_forwarder, join_receiver) = handlers::MatrixJoinRoom::with_forwarder(test.config.as_url.clone());
+    let (join_forwarder, join_receiver) = handlers::MatrixJoinRoom::with_forwarder(test.config.as_url.clone(), true);
     let (set_display_name_forwarder, set_display_name_receiver) = handlers::MatrixSetDisplayName::with_forwarder();
     let mut matrix_router = test.default_matrix_routes();
     matrix_router.put(SendMessageEventEndpoint::router_path(), message_forwarder, "send_message_event");
@@ -139,7 +139,7 @@ fn successfully_forwards_a_text_message_from_rocketchat_to_matrix_when_the_user_
     let (message_forwarder, receiver) = MessageForwarder::new();
     let (register_forwarder, register_receiver) = handlers::MatrixRegister::with_forwarder();
     let (invite_forwarder, invite_receiver) = handlers::MatrixInviteUser::with_forwarder(test.config.as_url.clone());
-    let (join_forwarder, join_receiver) = handlers::MatrixJoinRoom::with_forwarder(test.config.as_url.clone());
+    let (join_forwarder, join_receiver) = handlers::MatrixJoinRoom::with_forwarder(test.config.as_url.clone(), true);
     let (set_display_name_forwarder, set_display_name_receiver) = handlers::MatrixSetDisplayName::with_forwarder();
     let mut matrix_router = test.default_matrix_routes();
     matrix_router.put(SendMessageEventEndpoint::router_path(), message_forwarder, "send_message_event");

tests/matrix-rocketchat-test/handlers.rs

@@ -731,12 +731,16 @@ impl Handler for RoomStateCreate {
 
 pub struct MatrixJoinRoom {
     pub as_url: String,
+    pub send_inviter: bool,
 }
 
 impl MatrixJoinRoom {
-    pub fn with_forwarder(as_url: String) -> (Chain, Receiver<String>) {
+    pub fn with_forwarder(as_url: String, send_inviter: bool) -> (Chain, Receiver<String>) {
         let (message_forwarder, receiver) = MessageForwarder::new();
-        let mut chain = Chain::new(MatrixJoinRoom { as_url: as_url });
+        let mut chain = Chain::new(MatrixJoinRoom {
+            as_url: as_url,
+            send_inviter: send_inviter,
+        });
         chain.link_before(message_forwarder);;
         (chain, receiver)
     }
@@ -794,7 +798,12 @@ impl Handler for MatrixJoinRoom {
             return Ok(Response::with((status::Conflict, payload.to_string())));
         }
 
-        helpers::send_join_event_from_matrix(&self.as_url, room_id, user_id, Some(inviter_id));
+        let join_inviter = if self.send_inviter {
+            Some(inviter_id)
+        } else {
+            None
+        };
+        helpers::send_join_event_from_matrix(&self.as_url, room_id, user_id, join_inviter);
 
         Ok(Response::with((status::Ok, "{}")))
     }

tests/matrix-rocketchat-test/lib.rs

@@ -477,7 +477,10 @@ impl Test {
     pub fn default_matrix_routes(&self) -> Router {
         let mut router = Router::new();
 
-        let join_room_handler = handlers::MatrixJoinRoom { as_url: self.config.as_url.clone() };
+        let join_room_handler = handlers::MatrixJoinRoom {
+            as_url: self.config.as_url.clone(),
+            send_inviter: true,
+        };
         router.post(JoinRoomByIdEndpoint::router_path(), join_room_handler, "join_room");
 
         let leave_room_handler = handlers::MatrixLeaveRoom { as_url: self.config.as_url.clone() };