diff options
author | Erik Johnston <erikj@matrix.org> | 2015-11-19 13:21:10 +0000 |
---|---|---|
committer | Erik Johnston <erikj@matrix.org> | 2015-11-19 13:21:10 +0000 |
commit | eb3677f58ffeddc534bc8ceb2adb060d0794b817 (patch) | |
tree | 4377eb0dc5e221862489bdcc802e50e2f1f41cb1 /tests/handlers/test_room.py |
Imported Upstream version 0.11.0
Diffstat (limited to 'tests/handlers/test_room.py')
-rw-r--r-- | tests/handlers/test_room.py | 404 |
1 files changed, 404 insertions, 0 deletions
diff --git a/tests/handlers/test_room.py b/tests/handlers/test_room.py new file mode 100644 index 00000000..2a7553f9 --- /dev/null +++ b/tests/handlers/test_room.py @@ -0,0 +1,404 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from twisted.internet import defer +from .. import unittest + +from synapse.api.constants import EventTypes, Membership +from synapse.handlers.room import RoomMemberHandler, RoomCreationHandler +from synapse.handlers.profile import ProfileHandler +from synapse.types import UserID +from ..utils import setup_test_homeserver + +from mock import Mock, NonCallableMock + + +class RoomMemberHandlerTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + self.hostname = "red" + hs = yield setup_test_homeserver( + self.hostname, + ratelimiter=NonCallableMock(spec_set=[ + "send_message", + ]), + datastore=NonCallableMock(spec_set=[ + "persist_event", + "get_room_member", + "get_room", + "store_room", + "get_latest_events_in_room", + "add_event_hashes", + ]), + resource_for_federation=NonCallableMock(), + http_client=NonCallableMock(spec_set=[]), + notifier=NonCallableMock(spec_set=["on_new_room_event"]), + handlers=NonCallableMock(spec_set=[ + "room_member_handler", + "profile_handler", + "federation_handler", + ]), + auth=NonCallableMock(spec_set=[ + "check", + "add_auth_events", + "check_host_in_room", + ]), + state_handler=NonCallableMock(spec_set=[ + "compute_event_context", + "get_current_state", + ]), + ) + + self.federation = NonCallableMock(spec_set=[ + "handle_new_event", + "send_invite", + "get_state_for_room", + ]) + + self.datastore = hs.get_datastore() + self.handlers = hs.get_handlers() + self.notifier = hs.get_notifier() + self.state_handler = hs.get_state_handler() + self.distributor = hs.get_distributor() + self.auth = hs.get_auth() + self.hs = hs + + self.handlers.federation_handler = self.federation + + self.distributor.declare("collect_presencelike_data") + + self.handlers.room_member_handler = RoomMemberHandler(self.hs) + self.handlers.profile_handler = ProfileHandler(self.hs) + self.room_member_handler = self.handlers.room_member_handler + + self.ratelimiter = hs.get_ratelimiter() + self.ratelimiter.send_message.return_value = (True, 0) + + self.datastore.persist_event.return_value = (1,1) + self.datastore.add_event_hashes.return_value = [] + + @defer.inlineCallbacks + def test_invite(self): + room_id = "!foo:red" + user_id = "@bob:red" + target_user_id = "@red:blue" + content = {"membership": Membership.INVITE} + + builder = self.hs.get_event_builder_factory().new({ + "type": EventTypes.Member, + "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([]) + ) + + def annotate(_): + ctx = Mock() + ctx.current_state = { + (EventTypes.Member, "@alice:green"): self._create_member( + user_id="@alice:green", + room_id=room_id, + ), + (EventTypes.Member, "@bob:red"): self._create_member( + user_id="@bob:red", + room_id=room_id, + ), + } + ctx.prev_state_events = [] + + return defer.succeed(ctx) + + self.state_handler.compute_event_context.side_effect = annotate + + def add_auth(_, ctx): + ctx.auth_events = ctx.current_state[ + (EventTypes.Member, "@bob:red") + ] + + return defer.succeed(True) + self.auth.add_auth_events.side_effect = add_auth + + def send_invite(domain, event): + return defer.succeed(event) + + self.federation.send_invite.side_effect = send_invite + + room_handler = self.room_member_handler + event, context = yield room_handler._create_new_client_event( + builder + ) + + yield room_handler.change_membership(event, context) + + self.state_handler.compute_event_context.assert_called_once_with( + builder + ) + + 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, context=context, + ) + self.notifier.on_new_room_event.assert_called_once_with( + event, 1, 1, extra_users=[UserID.from_string(target_user_id)] + ) + self.assertFalse(self.datastore.get_room.called) + self.assertFalse(self.datastore.store_room.called) + self.assertFalse(self.federation.get_state_for_room.called) + + @defer.inlineCallbacks + def test_simple_join(self): + room_id = "!foo:red" + user_id = "@bob:red" + user = UserID.from_string(user_id) + + join_signal_observer = Mock() + self.distributor.observe("user_joined_room", join_signal_observer) + + builder = self.hs.get_event_builder_factory().new({ + "type": EventTypes.Member, + "sender": user_id, + "state_key": user_id, + "room_id": room_id, + "content": {"membership": Membership.JOIN}, + }) + + self.datastore.get_latest_events_in_room.return_value = ( + defer.succeed([]) + ) + + def annotate(_): + ctx = Mock() + ctx.current_state = { + (EventTypes.Member, "@bob:red"): self._create_member( + user_id="@bob:red", + room_id=room_id, + membership=Membership.INVITE + ), + } + ctx.prev_state_events = [] + + return defer.succeed(ctx) + + self.state_handler.compute_event_context.side_effect = annotate + + def add_auth(_, ctx): + ctx.auth_events = ctx.current_state[ + (EventTypes.Member, "@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, destinations=set() + ) + + self.datastore.persist_event.assert_called_once_with( + event, context=context + ) + self.notifier.on_new_room_event.assert_called_once_with( + event, 1, 1, extra_users=[user] + ) + + join_signal_observer.assert_called_with( + user=user, room_id=room_id + ) + + def _create_member(self, user_id, room_id, membership=Membership.JOIN): + builder = self.hs.get_event_builder_factory().new({ + "type": EventTypes.Member, + "sender": user_id, + "state_key": user_id, + "room_id": room_id, + "content": {"membership": membership}, + }) + + return builder.build() + + @defer.inlineCallbacks + def test_simple_leave(self): + room_id = "!foo:red" + user_id = "@bob:red" + user = UserID.from_string(user_id) + + builder = self.hs.get_event_builder_factory().new({ + "type": EventTypes.Member, + "sender": user_id, + "state_key": user_id, + "room_id": room_id, + "content": {"membership": Membership.LEAVE}, + }) + + self.datastore.get_latest_events_in_room.return_value = ( + defer.succeed([]) + ) + + def annotate(_): + ctx = Mock() + ctx.current_state = { + (EventTypes.Member, "@bob:red"): self._create_member( + user_id="@bob:red", + room_id=room_id, + membership=Membership.JOIN + ), + } + ctx.prev_state_events = [] + + return defer.succeed(ctx) + + self.state_handler.compute_event_context.side_effect = annotate + + def add_auth(_, ctx): + ctx.auth_events = ctx.current_state[ + (EventTypes.Member, "@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 + ) + + leave_signal_observer = Mock() + self.distributor.observe("user_left_room", leave_signal_observer) + + # Actual invocation + yield room_handler.change_membership(event, context) + + self.federation.handle_new_event.assert_called_once_with( + event, destinations=set(['red']) + ) + + self.datastore.persist_event.assert_called_once_with( + event, context=context + ) + self.notifier.on_new_room_event.assert_called_once_with( + event, 1, 1, extra_users=[user] + ) + + leave_signal_observer.assert_called_with( + user=user, room_id=room_id + ) + + +class RoomCreationTest(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + self.hostname = "red" + + hs = yield setup_test_homeserver( + self.hostname, + datastore=NonCallableMock(spec_set=[ + "store_room", + "snapshot_room", + "persist_event", + "get_joined_hosts_for_room", + ]), + http_client=NonCallableMock(spec_set=[]), + notifier=NonCallableMock(spec_set=["on_new_room_event"]), + handlers=NonCallableMock(spec_set=[ + "room_creation_handler", + "message_handler", + ]), + auth=NonCallableMock(spec_set=["check", "add_auth_events"]), + ratelimiter=NonCallableMock(spec_set=[ + "send_message", + ]), + ) + + self.federation = NonCallableMock(spec_set=[ + "handle_new_event", + ]) + + self.handlers = hs.get_handlers() + + self.handlers.room_creation_handler = RoomCreationHandler(hs) + self.room_creation_handler = self.handlers.room_creation_handler + + self.message_handler = self.handlers.message_handler + + self.ratelimiter = hs.get_ratelimiter() + self.ratelimiter.send_message.return_value = (True, 0) + + @defer.inlineCallbacks + def test_room_creation(self): + user_id = "@foo:red" + room_id = "!bobs_room:red" + config = {"visibility": "private"} + + yield self.room_creation_handler.create_room( + user_id=user_id, + room_id=room_id, + config=config, + ) + + self.assertTrue(self.message_handler.create_and_send_event.called) + + event_dicts = [ + e[0][0] + for e in self.message_handler.create_and_send_event.call_args_list + ] + + self.assertTrue(len(event_dicts) > 3) + + self.assertDictContainsSubset( + { + "type": EventTypes.Create, + "sender": user_id, + "room_id": room_id, + }, + event_dicts[0] + ) + + self.assertEqual(user_id, event_dicts[0]["content"]["creator"]) + + self.assertDictContainsSubset( + { + "type": EventTypes.Member, + "sender": user_id, + "room_id": room_id, + "state_key": user_id, + }, + event_dicts[1] + ) + + self.assertEqual( + Membership.JOIN, + event_dicts[1]["content"]["membership"] + ) |