diff --git a/tests/handlers/test_federation.py b/tests/handlers/test_federation.py
index fae33716a3..91f7351087 100644
--- a/tests/handlers/test_federation.py
+++ b/tests/handlers/test_federation.py
@@ -20,7 +20,7 @@ from synapse.api.events.room import (
MessageEvent,
)
-from synapse.api.events import SynapseEvent
+from synapse.events import FrozenEvent
from synapse.handlers.federation import FederationHandler
from synapse.server import HomeServer
@@ -37,7 +37,7 @@ class FederationTestCase(unittest.TestCase):
self.mock_config.signing_key = [MockKey()]
self.state_handler = NonCallableMock(spec_set=[
- "annotate_event_with_state",
+ "annotate_context_with_state",
])
self.auth = NonCallableMock(spec_set=[
@@ -78,36 +78,42 @@ class FederationTestCase(unittest.TestCase):
@defer.inlineCallbacks
def test_msg(self):
- pdu = SynapseEvent(
- type=MessageEvent.TYPE,
- room_id="foo",
- content={"msgtype": u"fooo"},
- origin_server_ts=0,
- event_id="$a:b",
- user_id="@a:b",
- origin="b",
- auth_events=[],
- hashes={"sha256":"AcLrgtUIqqwaGoHhrEvYG1YLDIsVPYJdSRGhkp3jJp8"},
- )
+ pdu = FrozenEvent({
+ "type": MessageEvent.TYPE,
+ "room_id": "foo",
+ "content": {"msgtype": u"fooo"},
+ "origin_server_ts": 0,
+ "event_id": "$a:b",
+ "user_id":"@a:b",
+ "origin": "b",
+ "auth_events": [],
+ "hashes": {"sha256":"AcLrgtUIqqwaGoHhrEvYG1YLDIsVPYJdSRGhkp3jJp8"},
+ })
self.datastore.persist_event.return_value = defer.succeed(None)
self.datastore.get_room.return_value = defer.succeed(True)
self.auth.check_host_in_room.return_value = defer.succeed(True)
- def annotate(ev, old_state=None):
- ev.old_state_events = []
+ def annotate(ev, context, old_state=None):
+ context.current_state = {}
+ context.auth_events = {}
return defer.succeed(False)
- self.state_handler.annotate_event_with_state.side_effect = annotate
+ self.state_handler.annotate_context_with_state.side_effect = annotate
yield self.handlers.federation_handler.on_receive_pdu(
"fo", pdu, False
)
self.datastore.persist_event.assert_called_once_with(
- ANY, is_new_state=False, backfilled=False, current_state=None
+ ANY,
+ is_new_state=True,
+ backfilled=False,
+ current_state=None,
+ context=ANY,
)
- self.state_handler.annotate_event_with_state.assert_called_once_with(
+ self.state_handler.annotate_context_with_state.assert_called_once_with(
+ ANY,
ANY,
old_state=None,
)
diff --git a/tests/handlers/test_room.py b/tests/handlers/test_room.py
index 3a71ed0aed..21853fdc50 100644
--- a/tests/handlers/test_room.py
+++ b/tests/handlers/test_room.py
@@ -20,7 +20,7 @@ from tests import unittest
from synapse.api.events.room import (
RoomMemberEvent,
)
-from synapse.api.constants import Membership
+from synapse.api.constants import EventTypes, Membership
from synapse.handlers.room import RoomMemberHandler, RoomCreationHandler
from synapse.handlers.profile import ProfileHandler
from synapse.server import HomeServer
@@ -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,
- )
+ join_signal_observer = Mock()
+ self.distributor.observe("user_joined_room", join_signal_observer)
+
+ 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},
+ })
- self.auth.check_host_in_room.return_value = defer.succeed(True)
+ self.datastore.get_latest_events_in_room.return_value = (
+ defer.succeed([])
+ )
- 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.
+ def annotate(_, ctx):
+ ctx.current_state = {
+ (RoomMemberEvent.TYPE, "@bob:red"): self._create_member(
+ user_id="@bob:red",
+ room_id=room_id,
+ membership=Membership.INVITE
+ ),
+ }
- prev_state = NonCallableMock()
- prev_state.membership = Membership.INVITE
- prev_state.sender = "@foo:red"
- self.datastore.get_room_member.return_value = defer.succeed(prev_state)
+ return defer.succeed(True)
- join_signal_observer = Mock()
- self.distributor.observe("user_joined_room", join_signal_observer)
+ self.state_handler.annotate_context_with_state.side_effect = annotate
- event.state_events = {
- (RoomMemberEvent.TYPE, "@alice:green"): self._create_member(
- user_id="@alice:green",
- room_id=room_id,
- ),
- (RoomMemberEvent.TYPE, user_id): event,
- }
+ def add_auth(_, ctx):
+ ctx.auth_events = ctx.current_state[
+ (RoomMemberEvent.TYPE, "@bob:red")
+ ]
- event.old_state_events = {
- (RoomMemberEvent.TYPE, "@alice:green"): self._create_member(
- user_id="@alice:green",
- room_id=room_id,
- ),
- }
+ return defer.succeed(True)
+ self.auth.add_auth_events.side_effect = add_auth
- event.state_events = event.old_state_events
- event.state_events[(RoomMemberEvent.TYPE, user_id)] = event
+ room_handler = self.room_member_handler
+ event, context = yield room_handler._create_new_client_event(
+ builder
+ )
# Actual invocation
- yield self.room_member_handler.change_membership(event)
+ yield room_handler.change_membership(event, context)
self.federation.handle_new_event.assert_called_once_with(
- event, self.snapshot
- )
-
- self.assertEquals(
- set(["red", "green"]),
- set(event.destinations)
+ 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,54 +236,71 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
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": RoomMemberEvent.TYPE,
+ "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 = self.hs.parse_userid(user_id)
- event = self._create_member(
- user_id=user_id,
- room_id=room_id,
- membership=Membership.LEAVE,
+ 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.LEAVE},
+ })
+
+ self.datastore.get_latest_events_in_room.return_value = (
+ defer.succeed([])
)
- prev_state = NonCallableMock()
- prev_state.membership = Membership.JOIN
- prev_state.sender = user_id
- self.datastore.get_room_member.return_value = defer.succeed(prev_state)
+ 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")
+ ]
- event.state_events = {
- (RoomMemberEvent.TYPE, user_id): event,
- }
+ return defer.succeed(True)
+ self.auth.add_auth_events.side_effect = add_auth
- event.old_state_events = {
- (RoomMemberEvent.TYPE, user_id): self._create_member(
- user_id=user_id,
- room_id=room_id,
- ),
- }
+ 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 self.room_member_handler.change_membership(event)
+ yield room_handler.change_membership(event, context)
leave_signal_observer.assert_called_with(
user=user, room_id=room_id
)
- def _create_member(self, user_id, room_id, membership=Membership.JOIN):
- 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,
- content={"membership": membership},
- )
-
class RoomCreationTest(unittest.TestCase):
@@ -292,13 +323,9 @@ class RoomCreationTest(unittest.TestCase):
notifier=NonCallableMock(spec_set=["on_new_room_event"]),
handlers=NonCallableMock(spec_set=[
"room_creation_handler",
- "room_member_handler",
- "federation_handler",
+ "message_handler",
]),
auth=NonCallableMock(spec_set=["check", "add_auth_events"]),
- state_handler=NonCallableMock(spec_set=[
- "annotate_event_with_state",
- ]),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
@@ -309,30 +336,12 @@ class RoomCreationTest(unittest.TestCase):
"handle_new_event",
])
- self.datastore = hs.get_datastore()
self.handlers = hs.get_handlers()
- self.notifier = hs.get_notifier()
- self.state_handler = hs.get_state_handler()
- self.hs = hs
-
- self.handlers.federation_handler = self.federation
- self.handlers.room_creation_handler = RoomCreationHandler(self.hs)
+ self.handlers.room_creation_handler = RoomCreationHandler(hs)
self.room_creation_handler = self.handlers.room_creation_handler
- self.handlers.room_member_handler = NonCallableMock(spec_set=[
- "change_membership"
- ])
- self.room_member_handler = self.handlers.room_member_handler
-
- def annotate(event):
- event.state_events = {}
- return defer.succeed(None)
- self.state_handler.annotate_event_with_state.side_effect = annotate
-
- def hosts(room):
- return defer.succeed([])
- self.datastore.get_joined_hosts_for_room.side_effect = hosts
+ self.message_handler = self.handlers.message_handler
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
@@ -349,14 +358,36 @@ class RoomCreationTest(unittest.TestCase):
config=config,
)
- self.assertTrue(self.room_member_handler.change_membership.called)
- join_event = self.room_member_handler.change_membership.call_args[0][0]
+ self.assertTrue(self.message_handler.handle_event.called)
+
+ event_dicts = [
+ e[0][0] for e in self.message_handler.handle_event.call_args_list
+ ]
- self.assertEquals(RoomMemberEvent.TYPE, join_event.type)
- self.assertEquals(room_id, join_event.room_id)
- self.assertEquals(user_id, join_event.user_id)
- self.assertEquals(user_id, join_event.state_key)
+ self.assertTrue(len(event_dicts) > 3)
+
+ self.assertDictContainsSubset(
+ {
+ "type": EventTypes.Create,
+ "sender": user_id,
+ "room_id": room_id,
+ },
+ event_dicts[0]
+ )
- self.assertTrue(self.state_handler.annotate_event_with_state.called)
+ self.assertEqual(user_id, event_dicts[0]["content"]["creator"])
- self.assertTrue(self.federation.handle_new_event.called)
+ 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"]
+ )
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index 391e287adc..0d4b368a43 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -137,7 +137,7 @@ class TypingNotificationsTestCase(unittest.TestCase):
if ignore_user is not None and member == ignore_user:
continue
- if member.is_mine:
+ if hs.is_mine(member):
if localusers is not None:
localusers.add(member)
else:
|
