Fix membership handler test

2014-12-12 14:32:39 +00:00 · 2014-12-12 14:32:39 +00:00 · ebf2ec3ce6
commit ebf2ec3ce6
parent 41ff21c907
1 changed files with 102 additions and 87 deletions
--- a/tests/handlers/test_room.py
+++ b/tests/handlers/test_room.py
@ -47,7 +47,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
                "get_room_member",
                "get_room",
                "store_room",
-                "snapshot_room",
+                "get_latest_events_in_room",
            ]),
            resource_for_federation=NonCallableMock(),
            http_client=NonCallableMock(spec_set=[]),
@ -63,7 +63,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
                "check_host_in_room",
            ]),
            state_handler=NonCallableMock(spec_set=[
-                "annotate_event_with_state",
+                "annotate_context_with_state",
                "get_current_state",
            ]),
            config=self.mock_config,
@ -91,9 +91,6 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
        self.handlers.profile_handler = ProfileHandler(self.hs)
        self.room_member_handler = self.handlers.room_member_handler

-        self.snapshot = Mock()
-        self.datastore.snapshot_room.return_value = self.snapshot
-
        self.ratelimiter = hs.get_ratelimiter()
        self.ratelimiter.send_message.return_value = (True, 0)

@ -104,50 +101,68 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
        target_user_id = "@red:blue"
        content = {"membership": Membership.INVITE}

-        event = self.hs.get_event_factory().create_event(
-            etype=RoomMemberEvent.TYPE,
-            user_id=user_id,
-            state_key=target_user_id,
-            room_id=room_id,
-            membership=Membership.INVITE,
-            content=content,
+        builder = self.hs.get_event_builder_factory().new({
+            "type": RoomMemberEvent.TYPE,
+            "sender": user_id,
+            "state_key": target_user_id,
+            "room_id": room_id,
+            "content": content,
+        })
+
+        self.datastore.get_latest_events_in_room.return_value = (
+            defer.succeed([])
        )

-        self.auth.check_host_in_room.return_value = defer.succeed(True)
+        def annotate(_, ctx):
+            ctx.current_state = {
+                (RoomMemberEvent.TYPE, "@alice:green"): self._create_member(
+                    user_id="@alice:green",
+                    room_id=room_id,
+                ),
+                (RoomMemberEvent.TYPE, "@bob:red"): self._create_member(
+                    user_id="@bob:red",
+                    room_id=room_id,
+                ),
+            }

-        store_id = "store_id_fooo"
-        self.datastore.persist_event.return_value = defer.succeed(store_id)
+            return defer.succeed(True)

-        self.datastore.get_room_member.return_value = defer.succeed(None)
+        self.state_handler.annotate_context_with_state.side_effect = annotate

-        event.old_state_events = {
-            (RoomMemberEvent.TYPE, "@alice:green"): self._create_member(
-                user_id="@alice:green",
-                room_id=room_id,
-            ),
-            (RoomMemberEvent.TYPE, "@bob:red"): self._create_member(
-                user_id="@bob:red",
-                room_id=room_id,
-            ),
-        }
+        def add_auth(_, ctx):
+            ctx.auth_events = ctx.current_state[
+                (RoomMemberEvent.TYPE, "@bob:red")
+            ]

-        event.state_events = event.old_state_events
-        event.state_events[(RoomMemberEvent.TYPE, target_user_id)] = event
+            return defer.succeed(True)
+        self.auth.add_auth_events.side_effect = add_auth

-        # Actual invocation
-        yield self.room_member_handler.change_membership(event)
+        def send_invite(domain, event):
+            return defer.succeed(event)

-        self.federation.handle_new_event.assert_called_once_with(
-            event, self.snapshot,
+        self.federation.send_invite.side_effect = send_invite
+
+        room_handler = self.room_member_handler
+        event, context = yield room_handler._create_new_client_event(
+            builder
        )

-        self.assertEquals(
-            set(["red", "green"]),
-            set(event.destinations)
+        yield room_handler.change_membership(event, context)
+
+        self.state_handler.annotate_context_with_state.assert_called_once_with(
+            builder, context
+        )
+
+        self.auth.add_auth_events.assert_called_once_with(
+            builder, context
+        )
+
+        self.federation.send_invite.assert_called_once_with(
+            "blue", event,
        )

        self.datastore.persist_event.assert_called_once_with(
-            event
+            event, context=context,
        )
        self.notifier.on_new_room_event.assert_called_once_with(
            event, extra_users=[self.hs.parse_userid(target_user_id)]
@ -162,57 +177,56 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
        user_id = "@bob:red"
        user = self.hs.parse_userid(user_id)

-        event = self._create_member(
-            user_id=user_id,
-            room_id=room_id,
-        )
-
-        self.auth.check_host_in_room.return_value = defer.succeed(True)
-
-        store_id = "store_id_fooo"
-        self.datastore.persist_event.return_value = defer.succeed(store_id)
-        self.datastore.get_room.return_value = defer.succeed(1)  # Not None.
-
-        prev_state = NonCallableMock()
-        prev_state.membership = Membership.INVITE
-        prev_state.sender = "@foo:red"
-        self.datastore.get_room_member.return_value = defer.succeed(prev_state)
-
        join_signal_observer = Mock()
        self.distributor.observe("user_joined_room", join_signal_observer)

-        event.state_events = {
-            (RoomMemberEvent.TYPE, "@alice:green"): self._create_member(
-                user_id="@alice:green",
-                room_id=room_id,
-            ),
-            (RoomMemberEvent.TYPE, user_id): event,
-        }
+        builder = self.hs.get_event_builder_factory().new({
+            "type": RoomMemberEvent.TYPE,
+            "sender": user_id,
+            "state_key": user_id,
+            "room_id": room_id,
+            "content": {"membership": Membership.JOIN},
+        })

-        event.old_state_events = {
-            (RoomMemberEvent.TYPE, "@alice:green"): self._create_member(
-                user_id="@alice:green",
-                room_id=room_id,
-            ),
-        }
-
-        event.state_events = event.old_state_events
-        event.state_events[(RoomMemberEvent.TYPE, user_id)] = event
-
-        # Actual invocation
-        yield self.room_member_handler.change_membership(event)
-
-        self.federation.handle_new_event.assert_called_once_with(
-            event, self.snapshot
+        self.datastore.get_latest_events_in_room.return_value = (
+            defer.succeed([])
        )

-        self.assertEquals(
-            set(["red", "green"]),
-            set(event.destinations)
+        def annotate(_, ctx):
+            ctx.current_state = {
+                (RoomMemberEvent.TYPE, "@bob:red"): self._create_member(
+                    user_id="@bob:red",
+                    room_id=room_id,
+                    membership=Membership.INVITE
+                ),
+            }
+
+            return defer.succeed(True)
+
+        self.state_handler.annotate_context_with_state.side_effect = annotate
+
+        def add_auth(_, ctx):
+            ctx.auth_events = ctx.current_state[
+                (RoomMemberEvent.TYPE, "@bob:red")
+            ]
+
+            return defer.succeed(True)
+        self.auth.add_auth_events.side_effect = add_auth
+
+        room_handler = self.room_member_handler
+        event, context = yield room_handler._create_new_client_event(
+            builder
+        )
+
+        # Actual invocation
+        yield room_handler.change_membership(event, context)
+
+        self.federation.handle_new_event.assert_called_once_with(
+            event, None, destinations=set()
        )

        self.datastore.persist_event.assert_called_once_with(
-            event
+            event, context=context
        )
        self.notifier.on_new_room_event.assert_called_once_with(
            event, extra_users=[user]
@ -222,15 +236,16 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
            user=user, room_id=room_id
        )

-    def _create_member(self, user_id, room_id):
-        return self.hs.get_event_factory().create_event(
-            etype=RoomMemberEvent.TYPE,
-            user_id=user_id,
-            state_key=user_id,
-            room_id=room_id,
-            membership=Membership.JOIN,
-            content={"membership": Membership.JOIN},
-        )
+    def _create_member(self, user_id, room_id, membership=Membership.JOIN):
+        builder = self.hs.get_event_builder_factory().new({
+            "type": RoomMemberEvent.TYPE,
+            "sender": user_id,
+            "state_key": user_id,
+            "room_id": room_id,
+            "content": {"membership": membership},
+        })
+
+        return builder.build()


 class RoomCreationTest(unittest.TestCase):