tileradotorg/synapse
1
0
Fork 0
forked from MirrorHub/synapse
Code Pull requests Activity

Fix membership handler test

Browse source
This commit is contained in:
Erik Johnston 2014-12-12 14:32:39 +00:00
parent 41ff21c907
commit ebf2ec3ce6
1 changed files with 102 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

189
tests/handlers/test_room.py
View file

@ -47,7 +47,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
"get_room_member", "get_room_member",
"get_room", "get_room",
"store_room", "store_room",
"snapshot_room", "get_latest_events_in_room",
]), ]),
resource_for_federation=NonCallableMock(), resource_for_federation=NonCallableMock(),
http_client=NonCallableMock(spec_set=[]), http_client=NonCallableMock(spec_set=[]),
@ -63,7 +63,7 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
"check_host_in_room", "check_host_in_room",
]), ]),
state_handler=NonCallableMock(spec_set=[ state_handler=NonCallableMock(spec_set=[
"annotate_event_with_state", "annotate_context_with_state",
"get_current_state", "get_current_state",
]), ]),
config=self.mock_config, config=self.mock_config,
@ -91,9 +91,6 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
self.handlers.profile_handler = ProfileHandler(self.hs) self.handlers.profile_handler = ProfileHandler(self.hs)
self.room_member_handler = self.handlers.room_member_handler 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 = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0) self.ratelimiter.send_message.return_value = (True, 0)
@ -104,50 +101,68 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
target_user_id = "@red:blue" target_user_id = "@red:blue"
content = {"membership": Membership.INVITE} content = {"membership": Membership.INVITE}
event = self.hs.get_event_factory().create_event( builder = self.hs.get_event_builder_factory().new({
etype=RoomMemberEvent.TYPE, "type": RoomMemberEvent.TYPE,
user_id=user_id, "sender": user_id,
state_key=target_user_id, "state_key": target_user_id,
room_id=room_id, "room_id": room_id,
membership=Membership.INVITE, "content": content,
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" return defer.succeed(True)
self.datastore.persist_event.return_value = defer.succeed(store_id)
self.datastore.get_room_member.return_value = defer.succeed(None) self.state_handler.annotate_context_with_state.side_effect = annotate
event.old_state_events = { def add_auth(_, ctx):
(RoomMemberEvent.TYPE, "@alice:green"): self._create_member( ctx.auth_events = ctx.current_state[
user_id="@alice:green", (RoomMemberEvent.TYPE, "@bob:red")
room_id=room_id, ]
),
(RoomMemberEvent.TYPE, "@bob:red"): self._create_member(
user_id="@bob:red",
room_id=room_id,
),
}
event.state_events = event.old_state_events return defer.succeed(True)
event.state_events[(RoomMemberEvent.TYPE, target_user_id)] = event self.auth.add_auth_events.side_effect = add_auth
# Actual invocation def send_invite(domain, event):
yield self.room_member_handler.change_membership(event) return defer.succeed(event)
self.federation.handle_new_event.assert_called_once_with( self.federation.send_invite.side_effect = send_invite
event, self.snapshot,
room_handler = self.room_member_handler
event, context = yield room_handler._create_new_client_event(
builder
) )
self.assertEquals( yield room_handler.change_membership(event, context)
set(["red", "green"]),
set(event.destinations) 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( self.datastore.persist_event.assert_called_once_with(
event event, context=context,
) )
self.notifier.on_new_room_event.assert_called_once_with( self.notifier.on_new_room_event.assert_called_once_with(
event, extra_users=[self.hs.parse_userid(target_user_id)] event, extra_users=[self.hs.parse_userid(target_user_id)]
@ -162,57 +177,56 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
user_id = "@bob:red" user_id = "@bob:red"
user = self.hs.parse_userid(user_id) 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() join_signal_observer = Mock()
self.distributor.observe("user_joined_room", join_signal_observer) self.distributor.observe("user_joined_room", join_signal_observer)
event.state_events = { builder = self.hs.get_event_builder_factory().new({
(RoomMemberEvent.TYPE, "@alice:green"): self._create_member( "type": RoomMemberEvent.TYPE,
user_id="@alice:green", "sender": user_id,
room_id=room_id, "state_key": user_id,
), "room_id": room_id,
(RoomMemberEvent.TYPE, user_id): event, "content": {"membership": Membership.JOIN},
} })
event.old_state_events = { self.datastore.get_latest_events_in_room.return_value = (
(RoomMemberEvent.TYPE, "@alice:green"): self._create_member( defer.succeed([])
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.assertEquals( def annotate(_, ctx):
set(["red", "green"]), ctx.current_state = {
set(event.destinations) (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( self.datastore.persist_event.assert_called_once_with(
event event, context=context
) )
self.notifier.on_new_room_event.assert_called_once_with( self.notifier.on_new_room_event.assert_called_once_with(
event, extra_users=[user] event, extra_users=[user]
@ -222,15 +236,16 @@ class RoomMemberHandlerTestCase(unittest.TestCase):
user=user, room_id=room_id user=user, room_id=room_id
) )
def _create_member(self, user_id, room_id): def _create_member(self, user_id, room_id, membership=Membership.JOIN):
return self.hs.get_event_factory().create_event( builder = self.hs.get_event_builder_factory().new({
etype=RoomMemberEvent.TYPE, "type": RoomMemberEvent.TYPE,
user_id=user_id, "sender": user_id,
state_key=user_id, "state_key": user_id,
room_id=room_id, "room_id": room_id,
membership=Membership.JOIN, "content": {"membership": membership},
content={"membership": Membership.JOIN}, })
)
return builder.build()
class RoomCreationTest(unittest.TestCase): class RoomCreationTest(unittest.TestCase):