def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_handler = Mock(spec=[ "get_displayname", "set_displayname", "get_avatar_url", "set_avatar_url", ]) self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, federation=Mock(), replication_layer=Mock(), datastore=None, config=self.mock_config, ) def _get_user_by_req(request=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_req = _get_user_by_req hs.get_handlers().profile_handler = self.mock_handler hs.register_servlets()
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "red", db_pool=None, http_client=None, datastore=MemoryDataStore(), replication_layer=Mock(), state_handler=state_handler, persistence_service=persistence_service, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return hs.parse_userid(self.auth_user_id) hs.get_auth().get_user_by_token = _get_user_by_token synapse.rest.room.register_servlets(hs, self.mock_resource) self.room_id = yield self.create_room_as(self.user_id)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_handler = Mock(spec=[ "get_displayname", "set_displayname", "get_avatar_url", "set_avatar_url", ]) hs = HomeServer("test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, federation=Mock(), replication_layer=Mock(), datastore=None, ) def _get_user_by_token(token=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_token = _get_user_by_token hs.get_handlers().profile_handler = self.mock_handler hs.register_servlets()
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_handler = Mock(spec=[ "get_displayname", "set_displayname", "get_avatar_url", "set_avatar_url", ]) self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer("test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, federation=Mock(), replication_layer=Mock(), datastore=None, config=self.mock_config, ) def _get_user_by_req(request=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_req = _get_user_by_req hs.get_handlers().profile_handler = self.mock_handler hs.register_servlets()
def __init__(self, hs: HomeServer): """ Args: hs: server """ super().__init__() self.auth = hs.get_auth() self.store = hs.get_datastores().main self.http_client = hs.get_simple_http_client() self.main_uri = hs.config.worker.worker_main_http_uri
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=None, datastore=Mock(spec=[ "has_presence_state", "get_presence_state", "allow_presence_visible", "is_presence_visible", "add_presence_list_pending", "set_presence_list_accepted", "del_presence_list", "get_presence_list", "insert_client_ip", ]), http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, config=self.mock_config, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def has_presence_state(user_localpart): return defer.succeed(user_localpart in ( "apple", "banana", )) self.datastore.has_presence_state = has_presence_state def _get_user_by_token(token=None): return { "user": hs.parse_userid(myid), "admin": False, "device_id": None, } room_member_handler = hs.handlers.room_member_handler = Mock(spec=[ "get_rooms_for_user", ]) hs.get_auth().get_user_by_token = _get_user_by_token hs.register_servlets() self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer("test", db_pool=None, datastore=Mock(spec=[ "has_presence_state", "get_presence_state", "allow_presence_visible", "is_presence_visible", "add_presence_list_pending", "set_presence_list_accepted", "del_presence_list", "get_presence_list", "insert_client_ip", ]), http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, config=self.mock_config, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def has_presence_state(user_localpart): return defer.succeed( user_localpart in ("apple", "banana",) ) self.datastore.has_presence_state = has_presence_state def _get_user_by_token(token=None): return { "user": hs.parse_userid(myid), "admin": False, "device_id": None, } room_member_handler = hs.handlers.room_member_handler = Mock( spec=[ "get_rooms_for_user", ] ) hs.get_auth().get_user_by_token = _get_user_by_token hs.register_servlets() self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.auth_handler = hs.get_auth_handler() self.macaroon_generator = hs.get_macaroon_generator() # MAU tests # AuthBlocking reads from the hs' config on initialization. We need to # modify its config instead of the hs' self.auth_blocking = hs.get_auth()._auth_blocking self.auth_blocking._max_mau_value = 50 self.small_number_of_users = 1 self.large_number_of_users = 100 self.user1 = self.register_user("a_user", "pass")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "red", db_pool=db_pool, http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip synapse.rest.room.register_servlets(hs, self.mock_resource) # Since I'm getting my own presence I need to exist as far as presence # is concerned. hs.get_handlers().presence_handler.registered_user( hs.parse_userid(self.user_id)) # create the room self.room_id = yield self.create_room_as(self.user_id)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "red", db_pool=db_pool, http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.hs = hs self.event_source = hs.get_event_sources().sources["typing"] self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip synapse.rest.room.register_servlets(hs, self.mock_resource) self.room_id = yield self.create_room_as(self.user_id) # Need another user to make notifications actually work yield self.join(self.room_id, user="******")
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=None, datastore=Mock(spec=[ "get_presence_state", "set_presence_state", "insert_client_ip", ]), http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, config=self.mock_config, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def get_presence_list(*a, **kw): return defer.succeed([]) self.datastore.get_presence_list = get_presence_list def _get_user_by_token(token=None): return { "user": hs.parse_userid(myid), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token room_member_handler = hs.handlers.room_member_handler = Mock(spec=[ "get_rooms_for_user", ]) def get_rooms_for_user(user): return defer.succeed([]) room_member_handler.get_rooms_for_user = get_rooms_for_user hs.register_servlets() self.u_apple = hs.parse_userid(myid)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.auth_user_id = self.user_id self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "red", db_pool=db_pool, http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip synapse.rest.room.register_servlets(hs, self.mock_resource) # Since I'm getting my own presence I need to exist as far as presence # is concerned. hs.get_handlers().presence_handler.registered_user( hs.parse_userid(self.user_id) ) # create the room self.room_id = yield self.create_room_as(self.user_id)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer("test", db_pool=None, datastore=Mock(spec=[ "get_presence_state", "set_presence_state", "insert_client_ip", ]), http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, config=self.mock_config, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def get_presence_list(*a, **kw): return defer.succeed([]) self.datastore.get_presence_list = get_presence_list def _get_user_by_token(token=None): return { "user": hs.parse_userid(myid), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token room_member_handler = hs.handlers.room_member_handler = Mock( spec=[ "get_rooms_for_user", ] ) def get_rooms_for_user(user): return defer.succeed([]) room_member_handler.get_rooms_for_user = get_rooms_for_user hs.register_servlets() self.u_apple = hs.parse_userid(myid)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) hs = HomeServer( "test", db_pool=None, datastore=Mock(spec=[ "get_presence_state", "set_presence_state", ]), http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def get_presence_list(*a, **kw): return defer.succeed([]) self.datastore.get_presence_list = get_presence_list def _get_user_by_token(token=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_token = _get_user_by_token room_member_handler = hs.handlers.room_member_handler = Mock(spec=[ "get_rooms_for_user", ]) def get_rooms_for_user(user): return defer.succeed([]) room_member_handler.get_rooms_for_user = get_rooms_for_user hs.register_servlets() self.u_apple = hs.parse_userid(myid)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) hs = HomeServer("test", db_pool=None, datastore=Mock(spec=[ "get_presence_state", "set_presence_state", ]), http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() def get_presence_list(*a, **kw): return defer.succeed([]) self.datastore.get_presence_list = get_presence_list def _get_user_by_token(token=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_token = _get_user_by_token room_member_handler = hs.handlers.room_member_handler = Mock( spec=[ "get_rooms_for_user", ] ) def get_rooms_for_user(user): return defer.succeed([]) room_member_handler.get_rooms_for_user = get_rooms_for_user hs.register_servlets() self.u_apple = hs.parse_userid(myid)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "red", db_pool=db_pool, http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "red", db_pool=None, http_client=None, datastore=MemoryDataStore(), replication_layer=Mock(), state_handler=state_handler, persistence_service=persistence_service, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return hs.parse_userid(self.auth_user_id) hs.get_auth().get_user_by_token = _get_user_by_token self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) # HIDEOUS HACKERY # TODO(paul): This should be injected in via the HomeServer DI system from synapse.streams.events import ( PresenceEventSource, NullSource, EventSources ) old_SOURCE_TYPES = EventSources.SOURCE_TYPES def tearDown(): EventSources.SOURCE_TYPES = old_SOURCE_TYPES self.tearDown = tearDown EventSources.SOURCE_TYPES = { k: NullSource for k in old_SOURCE_TYPES.keys() } EventSources.SOURCE_TYPES["presence"] = PresenceEventSource hs = HomeServer("test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, datastore=Mock(spec=[ "set_presence_state", "get_presence_list", ]), clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", ]), ) hs.get_clock().time_msec.return_value = 1000000 def _get_user_by_req(req=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_req = _get_user_by_req hs.register_servlets() hs.handlers.room_member_handler = Mock(spec=[]) self.room_members = [] def get_rooms_for_user(user): if user in self.room_members: return ["a-room"] else: return [] hs.handlers.room_member_handler.get_rooms_for_user = get_rooms_for_user self.mock_datastore = hs.get_datastore() def get_profile_displayname(user_id): return defer.succeed("Frank") self.mock_datastore.get_profile_displayname = get_profile_displayname def get_profile_avatar_url(user_id): return defer.succeed(None) self.mock_datastore.get_profile_avatar_url = get_profile_avatar_url def user_rooms_intersect(user_list): room_member_ids = map(lambda u: u.to_string(), self.room_members) shared = all(map(lambda i: i in room_member_ids, user_list)) return defer.succeed(shared) self.mock_datastore.user_rooms_intersect = user_rooms_intersect def get_joined_hosts_for_room(room_id): return [] self.mock_datastore.get_joined_hosts_for_room = get_joined_hosts_for_room self.presence = hs.get_handlers().presence_handler self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: mock_notifier = hs.get_notifier() self.on_new_event = mock_notifier.on_new_event self.handler = hs.get_typing_handler() self.event_source = hs.get_event_sources().sources.typing self.datastore = hs.get_datastores().main self.datastore.get_destination_retry_timings = Mock( return_value=make_awaitable(None)) self.datastore.get_device_updates_by_remote = Mock( return_value=make_awaitable((0, []))) self.datastore.get_destination_last_successful_stream_ordering = Mock( return_value=make_awaitable(None)) def get_received_txn_response(*args): return defer.succeed(None) self.datastore.get_received_txn_response = get_received_txn_response self.room_members = [] async def check_user_in_room(room_id: str, user_id: str) -> None: if user_id not in [u.to_string() for u in self.room_members]: raise AuthError(401, "User is not in the room") return None hs.get_auth().check_user_in_room = check_user_in_room async def check_host_in_room(room_id: str, server_name: str) -> bool: return room_id == ROOM_ID hs.get_event_auth_handler().check_host_in_room = check_host_in_room async def get_current_hosts_in_room(room_id: str): return {member.domain for member in self.room_members} hs.get_storage_controllers().state.get_current_hosts_in_room = ( get_current_hosts_in_room) async def get_users_in_room(room_id: str): return {str(u) for u in self.room_members} self.datastore.get_users_in_room = get_users_in_room self.datastore.get_user_directory_stream_pos = Mock(side_effect=( # we deliberately return a non-None stream pos to avoid doing an initial_spam lambda: make_awaitable(1))) self.datastore.get_partial_current_state_deltas = Mock( return_value=(0, None)) self.datastore.get_to_device_stream_token = lambda: 0 self.datastore.get_new_device_msgs_for_remote = ( lambda *args, **kargs: make_awaitable(([], 0))) self.datastore.delete_device_msgs_for_remote = ( lambda *args, **kargs: make_awaitable(None)) self.datastore.set_received_txn_response = ( lambda *args, **kwargs: make_awaitable(None))
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) # HIDEOUS HACKERY # TODO(paul): This should be injected in via the HomeServer DI system from synapse.streams.events import (PresenceEventSource, NullSource, EventSources) old_SOURCE_TYPES = EventSources.SOURCE_TYPES def tearDown(): EventSources.SOURCE_TYPES = old_SOURCE_TYPES self.tearDown = tearDown EventSources.SOURCE_TYPES = { k: NullSource for k in old_SOURCE_TYPES.keys() } EventSources.SOURCE_TYPES["presence"] = PresenceEventSource hs = HomeServer( "test", db_pool=None, http_client=None, resource_for_client=self.mock_resource, resource_for_federation=self.mock_resource, datastore=Mock(spec=[ "set_presence_state", "get_presence_list", ]), clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", ]), ) hs.get_clock().time_msec.return_value = 1000000 def _get_user_by_req(req=None): return hs.parse_userid(myid) hs.get_auth().get_user_by_req = _get_user_by_req hs.register_servlets() hs.handlers.room_member_handler = Mock(spec=[]) self.room_members = [] def get_rooms_for_user(user): if user in self.room_members: return ["a-room"] else: return [] hs.handlers.room_member_handler.get_rooms_for_user = get_rooms_for_user self.mock_datastore = hs.get_datastore() def get_profile_displayname(user_id): return defer.succeed("Frank") self.mock_datastore.get_profile_displayname = get_profile_displayname def get_profile_avatar_url(user_id): return defer.succeed(None) self.mock_datastore.get_profile_avatar_url = get_profile_avatar_url def user_rooms_intersect(user_list): room_member_ids = map(lambda u: u.to_string(), self.room_members) shared = all(map(lambda i: i in room_member_ids, user_list)) return defer.succeed(shared) self.mock_datastore.user_rooms_intersect = user_rooms_intersect def get_joined_hosts_for_room(room_id): return [] self.mock_datastore.get_joined_hosts_for_room = get_joined_hosts_for_room self.presence = hs.get_handlers().presence_handler self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
def setUp(self): self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] self.hostname = "red" hs = HomeServer( self.hostname, db_pool=None, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), datastore=NonCallableMock(spec_set=[ "persist_event", "get_room_member", "get_room", "store_room", "get_latest_events_in_room", ]), 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", ]), config=self.mock_config, ) 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)
def setUp(self): self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] self.hostname = "red" hs = HomeServer( self.hostname, db_pool=None, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), datastore=NonCallableMock(spec_set=[ "persist_event", "get_room_member", "get_room", "store_room", "get_latest_events_in_room", ]), 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", ]), config=self.mock_config, ) 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)
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) state_handler = Mock(spec=["handle_new_event"]) state_handler.handle_new_event.return_value = True persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] hs = HomeServer( "red", db_pool=None, http_client=None, datastore=MemoryDataStore(), replication_layer=Mock(), state_handler=state_handler, persistence_service=persistence_service, ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "red", db_pool=db_pool, http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.get_handlers().federation_handler = Mock() def _get_user_by_token(token=None): return { "user": hs.parse_userid(self.auth_user_id), "admin": False, "device_id": None, } hs.get_auth().get_user_by_token = _get_user_by_token def _insert_client_ip(*args, **kwargs): return defer.succeed(None) hs.get_datastore().insert_client_ip = _insert_client_ip self.auth_user_id = self.rmcreator_id synapse.rest.room.register_servlets(hs, self.mock_resource) self.auth = hs.get_auth() # create some rooms under the name rmcreator_id self.uncreated_rmid = "!aa:test" self.created_rmid = yield self.create_room_as(self.rmcreator_id, is_public=False) self.created_public_rmid = yield self.create_room_as(self.rmcreator_id, is_public=True) # send a message in one of the rooms self.created_rmid_msg_path = ("/rooms/%s/send/m.room.message/a1" % (self.created_rmid)) (code, response) = yield self.mock_resource.trigger( "PUT", self.created_rmid_msg_path, '{"msgtype":"m.text","body":"test msg"}') self.assertEquals(200, code, msg=str(response)) # set topic for public room (code, response) = yield self.mock_resource.trigger( "PUT", "/rooms/%s/state/m.room.topic" % self.created_public_rmid, '{"topic":"Public Room Topic"}') self.assertEquals(200, code, msg=str(response)) # auth as user_id now self.auth_user_id = self.user_id