def setUp(self): self.hs = yield setup_test_homeserver(self.addCleanup) self.server_notices_sender = self.hs.get_server_notices_sender() # relying on [1] is far from ideal, but the only case where # ResourceLimitsServerNotices class needs to be isolated is this test, # general code should never have a reason to do so ... self._rlsn = self.server_notices_sender._server_notices[1] if not isinstance(self._rlsn, ResourceLimitsServerNotices): raise Exception("Failed to find reference to ResourceLimitsServerNotices") self._rlsn._store.user_last_seen_monthly_active = Mock( return_value=defer.succeed(1000) ) self._send_notice = self._rlsn._server_notices_manager.send_notice self._rlsn._server_notices_manager.send_notice = Mock() self._rlsn._state.get_current_state = Mock(return_value=defer.succeed(None)) self._rlsn._store.get_events = Mock(return_value=defer.succeed({})) self._send_notice = self._rlsn._server_notices_manager.send_notice self.hs.config.limit_usage_by_mau = True self.user_id = "@user_id:test" # self.server_notices_mxid = "@server:test" # self.server_notices_mxid_display_name = None # self.server_notices_mxid_avatar_url = None # self.server_notices_room_name = "Server Notices" self._rlsn._server_notices_manager.get_notice_room_for_user = Mock( returnValue="" ) self._rlsn._store.add_tag_to_room = Mock() self._rlsn._store.get_tags_for_room = Mock(return_value={}) self.hs.config.admin_contact = "mailto:[email protected]"
def setUp(self): self.as_yaml_files = [] hs = yield setup_test_homeserver( self.addCleanup, federation_sender=Mock(), federation_client=Mock() ) hs.config.app_service_config_files = self.as_yaml_files hs.config.event_cache_size = 1 hs.config.password_providers = [] self.db_pool = hs.get_db_pool() self.engine = hs.database_engine self.as_list = [ {"token": "token1", "url": "https://matrix-as.org", "id": "id_1"}, {"token": "alpha_tok", "url": "https://alpha.com", "id": "id_alpha"}, {"token": "beta_tok", "url": "https://beta.com", "id": "id_beta"}, {"token": "gamma_tok", "url": "https://gamma.com", "id": "id_gamma"}, ] for s in self.as_list: yield self._add_service(s["url"], s["token"], s["id"]) self.as_yaml_files = [] database = Database(hs) self.store = TestTransactionStore(database, hs.get_db_conn(), hs)
def setUp(self): self.mock_federation = Mock() self.mock_registry = Mock() self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_registry.register_query_handler = register_query_handler hs = yield setup_test_homeserver( self.addCleanup, http_client=None, handlers=None, resource_for_federation=Mock(), federation_client=self.mock_federation, federation_server=Mock(), federation_registry=self.mock_registry, ratelimiter=NonCallableMock(spec_set=["can_do_action"]), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.can_do_action.return_value = (True, 0) self.store = hs.get_datastore() self.frank = UserID.from_string("@1234ABCD:test") self.bob = UserID.from_string("@4567:test") self.alice = UserID.from_string("@alice:remote") yield self.store.create_profile(self.frank.localpart) self.handler = hs.get_profile_handler()
def setUp(self): self.clock = MockClock() self.mock_federation_resource = MockHttpResource() self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() hs_kwargs = {} if hasattr(self, "make_datastore_mock"): hs_kwargs["datastore"] = self.make_datastore_mock() hs = yield setup_test_homeserver( clock=self.clock, handlers=None, resource_for_federation=self.mock_federation_resource, http_client=self.mock_http_client, keyring=Mock(), **hs_kwargs ) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() self.setUp_roommemberhandler_mocks(hs.handlers) self.handler = hs.get_handlers().presence_handler self.event_source = hs.get_event_sources().sources["presence"] self.distributor = hs.get_distributor() self.distributor.declare("user_joined_room") yield self.setUp_users(hs)
def setUp(self): self.as_yaml_files = [] hs = yield setup_test_homeserver( self.addCleanup, federation_sender=Mock(), federation_client=Mock() ) hs.config.app_service_config_files = self.as_yaml_files hs.config.event_cache_size = 1 hs.config.password_providers = [] self.as_list = [ {"token": "token1", "url": "https://matrix-as.org", "id": "id_1"}, {"token": "alpha_tok", "url": "https://alpha.com", "id": "id_alpha"}, {"token": "beta_tok", "url": "https://beta.com", "id": "id_beta"}, {"token": "gamma_tok", "url": "https://gamma.com", "id": "id_gamma"}, ] for s in self.as_list: yield self._add_service(s["url"], s["token"], s["id"]) self.as_yaml_files = [] # We assume there is only one database in these tests database = hs.get_datastores().databases[0] self.db_pool = database._db_pool self.engine = database.engine db_config = hs.config.get_single_database() self.store = TestTransactionStore( database, make_conn(db_config, self.engine), hs )
def setUp(self): self.hs = yield setup_test_homeserver( "blue", http_client=None, federation_client=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), ) self.hs.get_ratelimiter().send_message.return_value = (True, 0) self.master_store = self.hs.get_datastore() self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs) self.event_id = 0 server_factory = ReplicationStreamProtocolFactory(self.hs) # XXX: mktemp is unsafe and should never be used. but we're just a test. path = tempfile.mktemp(prefix="base_slaved_store_test_case_socket") listener = reactor.listenUNIX(path, server_factory) self.addCleanup(listener.stopListening) self.streamer = server_factory.streamer self.replication_handler = ReplicationClientHandler(self.slaved_store) client_factory = ReplicationClientFactory( self.hs, "client_name", self.replication_handler ) client_connector = reactor.connectUNIX(path, client_factory) self.addCleanup(client_factory.stopTrying) self.addCleanup(client_connector.disconnect)
def setUp(self): hs = yield setup_test_homeserver(self.addCleanup) self.store = hs.get_datastore() self.room = RoomID.from_string("!abcde:test") self.alias = RoomAlias.from_string("#my-room:test")
def setUp(self): self.hs = yield setup_test_homeserver() self.store = UserDirectoryStore(None, self.hs) # alice and bob are both in !room_id. bobby is not but shares # a homeserver with alice. yield self.store.add_profiles_to_user_dir( "!room:id", { ALICE: ProfileInfo(None, "alice"), BOB: ProfileInfo(None, "bob"), BOBBY: ProfileInfo(None, "bobby") }, ) yield self.store.add_users_to_public_room( "!room:id", [ALICE, BOB], ) yield self.store.add_users_who_share_room( "!room:id", False, ( (ALICE, BOB), (BOB, ALICE), ), )
def setUp(self): self.hs = yield setup_test_homeserver( "blue", http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), ) self.hs.get_ratelimiter().send_message.return_value = (True, 0) self.master_store = self.hs.get_datastore() self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs) self.event_id = 0 server_factory = ReplicationStreamProtocolFactory(self.hs) listener = reactor.listenUNIX("\0xxx", server_factory) self.addCleanup(listener.stopListening) self.streamer = server_factory.streamer self.replication_handler = ReplicationClientHandler(self.slaved_store) client_factory = ReplicationClientFactory( self.hs, "client_name", self.replication_handler ) client_connector = reactor.connectUNIX("\0xxx", client_factory) self.addCleanup(client_factory.stopTrying) self.addCleanup(client_connector.disconnect)
def setUp(self): self.hs = yield setup_test_homeserver( "blue", http_client=None, federation_client=Mock(), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), ) self.hs.get_ratelimiter().send_message.return_value = (True, 0) self.master_store = self.hs.get_datastore() self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs) self.event_id = 0 server_factory = ReplicationStreamProtocolFactory(self.hs) # XXX: mktemp is unsafe and should never be used. but we're just a test. path = tempfile.mktemp(prefix="base_slaved_store_test_case_socket") listener = reactor.listenUNIX(path, server_factory) self.addCleanup(listener.stopListening) self.streamer = server_factory.streamer self.replication_handler = TestReplicationClientHandler(self.slaved_store) client_factory = ReplicationClientFactory( self.hs, "client_name", self.replication_handler ) client_connector = reactor.connectUNIX(path, client_factory) self.addCleanup(client_factory.stopTrying) self.addCleanup(client_connector.disconnect)
def setUp(self): self.hs = yield setup_test_homeserver(self.addCleanup) self.event_creation_handler = self.hs.get_event_creation_handler() self.event_builder_factory = self.hs.get_event_builder_factory() self.storage = self.hs.get_storage() yield defer.ensureDeferred(create_room(self.hs, TEST_ROOM_ID, "@someone:ROOM"))
def setUp(self): self.mock_federation = Mock() self.mock_registry = Mock() self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_registry.register_query_handler = register_query_handler hs = yield setup_test_homeserver( self.addCleanup, http_client=None, resource_for_federation=Mock(), federation_client=self.mock_federation, federation_registry=self.mock_registry, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler self.store = hs.get_datastore() self.my_room = RoomAlias.from_string("#my-room:test") self.your_room = RoomAlias.from_string("#your-room:test") self.remote_room = RoomAlias.from_string("#another:remote")
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", ]) self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler hs = yield setup_test_homeserver( http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler self.store = hs.get_datastore() self.my_room = RoomAlias.from_string("#my-room:test") self.your_room = RoomAlias.from_string("#your-room:test") self.remote_room = RoomAlias.from_string("#another:remote")
def setUp(self): self.hs = yield setup_test_homeserver(self.addCleanup) self.event_creation_handler = self.hs.get_event_creation_handler() self.event_builder_factory = self.hs.get_event_builder_factory() self.store = self.hs.get_datastore() yield create_room(self.hs, TEST_ROOM_ID, "@someone:ROOM")
def setUp(self): self.as_yaml_files = [] config = Mock( app_service_config_files=self.as_yaml_files, event_cache_size=1, password_providers=[], ) hs = yield setup_test_homeserver( config=config, federation_sender=Mock(), replication_layer=Mock(), ) self.as_token = "token1" self.as_url = "some_url" self.as_id = "as1" self._add_appservice( self.as_token, self.as_id, self.as_url, "some_hs_token", "bob" ) self._add_appservice("token2", "as2", "some_url", "some_hs_token", "bob") self._add_appservice("token3", "as3", "some_url", "some_hs_token", "bob") # must be done after inserts self.store = ApplicationServiceStore(hs)
def setUp(self): self.clock = MockClock() self.mock_federation_resource = MockHttpResource() self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() hs_kwargs = {} if hasattr(self, "make_datastore_mock"): hs_kwargs["datastore"] = self.make_datastore_mock() hs = yield setup_test_homeserver( clock=self.clock, handlers=None, resource_for_federation=self.mock_federation_resource, http_client=self.mock_http_client, keyring=Mock(), **hs_kwargs) hs.handlers = JustPresenceHandlers(hs) self.datastore = hs.get_datastore() self.setUp_roommemberhandler_mocks(hs.handlers) self.handler = hs.get_handlers().presence_handler self.event_source = hs.get_event_sources().sources["presence"] self.distributor = hs.get_distributor() self.distributor.declare("user_joined_room") yield self.setUp_users(hs)
def setUp(self): hs = yield setup_test_homeserver(self.addCleanup) self.store = DirectoryStore(None, hs) self.room = RoomID.from_string("!abcde:test") self.alias = RoomAlias.from_string("#my-room:test")
def setUp(self): hs = yield setup_test_homeserver(self.addCleanup) self.store = hs.get_datastore() self.user = UserID.from_string("@abcde:test") self.displayname = "Frank"
def setUp(self): hs = yield setup_test_homeserver() self.store = DirectoryStore(hs) self.room = RoomID.from_string("!abcde:test") self.alias = RoomAlias.from_string("#my-room:test")
def setUp(self): hs = yield setup_test_homeserver(clock=MockClock()) self.store = PresenceStore(hs) self.u_apple = UserID.from_string("@apple:test") self.u_banana = UserID.from_string("@banana:test")
def setUp(self): self.hs = yield setup_test_homeserver(self.addCleanup) self.store = self.hs.get_datastore() self.server_notices_sender = self.hs.get_server_notices_sender() self.server_notices_manager = self.hs.get_server_notices_manager() self.event_source = self.hs.get_event_sources() # relying on [1] is far from ideal, but the only case where # ResourceLimitsServerNotices class needs to be isolated is this test, # general code should never have a reason to do so ... self._rlsn = self.server_notices_sender._server_notices[1] if not isinstance(self._rlsn, ResourceLimitsServerNotices): raise Exception( "Failed to find reference to ResourceLimitsServerNotices") self.hs.config.limit_usage_by_mau = True self.hs.config.hs_disabled = False self.hs.config.max_mau_value = 5 self.hs.config.server_notices_mxid = "@server:test" self.hs.config.server_notices_mxid_display_name = None self.hs.config.server_notices_mxid_avatar_url = None self.hs.config.server_notices_room_name = "Test Server Notice Room" self.user_id = "@user_id:test" self.hs.config.admin_contact = "mailto:[email protected]"
async def make_homeserver(reactor, config=None): """ Make a Homeserver suitable for running benchmarks against. Args: reactor: A Twisted reactor to run under. config: A HomeServerConfig to use, or None. """ cleanup_tasks = [] clock = Clock(reactor) if not config: config = default_config("test") config_obj = HomeServerConfig() config_obj.parse_config_dict(config, "", "") hs = setup_test_homeserver(cleanup_tasks.append, config=config_obj, reactor=reactor, clock=clock) stor = hs.get_datastore() # Run the database background updates. if hasattr(stor.db_pool.updates, "do_next_background_update"): while not await stor.db_pool.updates.has_completed_background_updates( ): await stor.db_pool.updates.do_next_background_update(1) def cleanup(): for i in cleanup_tasks: i() return hs, clock.sleep, cleanup
def setUp(self): self.as_yaml_files = [] config = Mock(app_service_config_files=self.as_yaml_files) hs = yield setup_test_homeserver(config=config) self.db_pool = hs.get_db_pool() self.as_list = [ { "token": "token1", "url": "https://matrix-as.org", "id": "token1" }, { "token": "alpha_tok", "url": "https://alpha.com", "id": "alpha_tok" }, { "token": "beta_tok", "url": "https://beta.com", "id": "beta_tok" }, { "token": "delta_tok", "url": "https://delta.com", "id": "delta_tok" }, ] for s in self.as_list: yield self._add_service(s["url"], s["token"]) self.as_yaml_files = [] self.store = TestTransactionStore(hs)
def setUp(self): self.as_yaml_files = [] hs = yield setup_test_homeserver( self.addCleanup, federation_sender=Mock(), federation_client=Mock() ) hs.config.app_service_config_files = self.as_yaml_files hs.config.event_cache_size = 1 hs.config.password_providers = [] self.db_pool = hs.get_db_pool() self.engine = hs.database_engine self.as_list = [ {"token": "token1", "url": "https://matrix-as.org", "id": "id_1"}, {"token": "alpha_tok", "url": "https://alpha.com", "id": "id_alpha"}, {"token": "beta_tok", "url": "https://beta.com", "id": "id_beta"}, {"token": "gamma_tok", "url": "https://gamma.com", "id": "id_gamma"}, ] for s in self.as_list: yield self._add_service(s["url"], s["token"], s["id"]) self.as_yaml_files = [] self.store = TestTransactionStore(hs.get_db_conn(), hs)
def setUp(self): self.mock_federation = Mock() self.mock_registry = Mock() self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_registry.register_query_handler = register_query_handler hs = yield setup_test_homeserver( self.addCleanup, http_client=None, handlers=None, resource_for_federation=Mock(), federation_client=self.mock_federation, federation_server=Mock(), federation_registry=self.mock_registry, ) self.store = hs.get_datastore() self.frank = UserID.from_string("@1234ABCD:test") self.bob = UserID.from_string("@4567:test") self.alice = UserID.from_string("@alice:remote") yield self.store.create_profile(self.frank.localpart) self.handler = hs.get_profile_handler() self.hs = hs
def setUp(self): self.mock_federation = Mock() self.mock_registry = Mock() self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_registry.register_query_handler = register_query_handler hs = yield setup_test_homeserver( http_client=None, handlers=None, resource_for_federation=Mock(), federation_client=self.mock_federation, federation_server=Mock(), federation_registry=self.mock_registry, ratelimiter=NonCallableMock(spec_set=[ "send_message", ])) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) self.store = hs.get_datastore() self.frank = UserID.from_string("@1234ABCD:test") self.bob = UserID.from_string("@4567:test") self.alice = UserID.from_string("@alice:remote") yield self.store.create_profile(self.frank.localpart) self.handler = hs.get_profile_handler()
def setUp(self): self.as_yaml_files = [] config = Mock( app_service_config_files=self.as_yaml_files, event_cache_size=1, password_providers=[], ) hs = yield setup_test_homeserver( config=config, federation_sender=Mock(), federation_client=Mock(), ) self.as_token = "token1" self.as_url = "some_url" self.as_id = "as1" self._add_appservice( self.as_token, self.as_id, self.as_url, "some_hs_token", "bob" ) self._add_appservice("token2", "as2", "some_url", "some_hs_token", "bob") self._add_appservice("token3", "as3", "some_url", "some_hs_token", "bob") # must be done after inserts self.store = ApplicationServiceStore(None, hs)
def setUp(self): self.mock_federation = Mock(spec=[ "make_query", "register_edu_handler", ]) self.query_handlers = {} def register_query_handler(query_type, handler): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler hs = yield setup_test_homeserver( http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler self.store = hs.get_datastore() self.my_room = RoomAlias.from_string("#my-room:test") self.your_room = RoomAlias.from_string("#your-room:test") self.remote_room = RoomAlias.from_string("#another:remote")
def setUp(self): hs = yield setup_test_homeserver(self.addCleanup) self.store = hs.get_datastore() self.u_apple = UserID.from_string("@apple:test") self.u_banana = UserID.from_string("@banana:test")
def setUp(self): self.hs = yield utils.setup_test_homeserver( self.addCleanup, handlers=None, replication_layer=mock.Mock(), ) self.handler = synapse.handlers.e2e_room_keys.E2eRoomKeysHandler(self.hs) self.local_user = "******" + self.hs.hostname
def test_unique_works(self): f1 = self._write_config(suffix="1") f2 = self._write_config(suffix="2") config = Mock(app_service_config_files=[f1, f2], event_cache_size=1) hs = yield setup_test_homeserver(config=config, datastore=Mock()) ApplicationServiceStore(hs)
def setUp(self): self.mock_perspective_server = MockPerspectiveServer() self.http_client = Mock() self.hs = yield utils.setup_test_homeserver( self.addCleanup, handlers=None, http_client=self.http_client ) keys = self.mock_perspective_server.get_verify_keys() self.hs.config.perspectives = {self.mock_perspective_server.server_name: keys}
def setUp(self): self.hs = yield utils.setup_test_homeserver( self.addCleanup, handlers=None, replication_layer=mock.Mock(), ) self.handler = synapse.handlers.e2e_room_keys.E2eRoomKeysHandler( self.hs) self.local_user = "******" + self.hs.hostname
def setUp(self): hs = yield setup_test_homeserver() self.store = RegistrationStore(hs) self.user_id = "@my-user:test" self.tokens = ["AbCdEfGhIjKlMnOpQrStUvWxYz", "BcDeFgHiJkLmNoPqRsTuVwXyZa"] self.pwhash = "{xx1}123456789"
def setUp(self): self.hs = yield setup_test_homeserver(self.addCleanup, handlers=None) self.hs.handlers = AuthHandlers(self.hs) self.auth_handler = self.hs.handlers.auth_handler self.macaroon_generator = self.hs.get_macaroon_generator() # MAU tests self.hs.config.max_mau_value = 50 self.small_number_of_users = 1 self.large_number_of_users = 100
def setUp(self): hs = yield setup_test_homeserver() self.store = hs.get_datastore() self.clock = hs.get_clock() self.update_handler = Mock() yield self.store.register_background_update_handler( "test_update", self.update_handler)
def setUp(self): self.hs = yield setup_test_homeserver( resource_for_federation=Mock(), http_client=None, ) self.store = self.hs.get_datastore() self.db_pool = self.hs.get_db_pool() self.message_handler = self.hs.get_handlers().message_handler self.event_injector = EventInjector(self.hs)
def setUp(self): hs = yield setup_test_homeserver(self.addCleanup) self.store = hs.get_datastore() self.user_id = "@my-user:test" self.tokens = ["AbCdEfGhIjKlMnOpQrStUvWxYz", "BcDeFgHiJkLmNoPqRsTuVwXyZa"] self.pwhash = "{xx1}123456789" self.device_id = "akgjhdjklgshg"
def setUp(self): self.hs = yield setup_test_homeserver(self.addCleanup) self.store = UserDirectoryStore(self.hs.get_db_conn(), self.hs) # alice and bob are both in !room_id. bobby is not but shares # a homeserver with alice. yield self.store.update_profile_in_user_dir(ALICE, "alice", None) yield self.store.update_profile_in_user_dir(BOB, "bob", None) yield self.store.update_profile_in_user_dir(BOBBY, "bobby", None) yield self.store.add_users_in_public_rooms("!room:id", (ALICE, BOB))
def setUp(self): hs = yield setup_test_homeserver() self.store = hs.get_datastore() self.clock = hs.get_clock() self.update_handler = Mock() yield self.store.register_background_update_handler( "test_update", self.update_handler )
def setUp(self): self.hs = yield setup_test_homeserver( "red", http_client=None, replication_layer=Mock(), ratelimiter=NonCallableMock(spec_set=["send_message"]) ) self.user_id = "@seeing:red" self.user = UserID.from_string(self.user_id) self.hs.get_ratelimiter().send_message.return_value = (True, 0) self.resource = ReplicationResource(self.hs)
def setUp(self): self.state_handler = Mock() self.store = Mock() self.hs = yield setup_test_homeserver(handlers=None) self.hs.get_datastore = Mock(return_value=self.store) self.auth = Auth(self.hs) self.test_user = "******" self.test_token = "_test_token_"
def setUp(self): hs = yield setup_test_homeserver(self.addCleanup) self.db_pool = hs.get_db_pool() self.store = hs.get_datastore() self.user_id = "@my-user:test" self.tokens = ["AbCdEfGhIjKlMnOpQrStUvWxYz", "BcDeFgHiJkLmNoPqRsTuVwXyZa"] self.pwhash = "{xx1}123456789" self.device_id = "akgjhdjklgshg"
def setUp(self): hs = setup_test_homeserver(self.addCleanup) # Room events need the full datastore, for persist_event() and # get_room_state() self.store = hs.get_datastore() self.event_factory = hs.get_event_factory() self.room = RoomID.from_string("!abcde:test") yield self.store.store_room( self.room.to_string(), room_creator_user_id="@creator:text", is_public=True )
def test_unique_works(self): f1 = self._write_config(suffix="1") f2 = self._write_config(suffix="2") hs = yield setup_test_homeserver( self.addCleanup, federation_sender=Mock(), federation_client=Mock() ) hs.config.app_service_config_files = [f1, f2] hs.config.event_cache_size = 1 hs.config.password_providers = [] ApplicationServiceStore(hs.get_db_conn(), hs)
def setUp(self): self.as_yaml_files = [] config = Mock( app_service_config_files=self.as_yaml_files ) hs = yield setup_test_homeserver(config=config) self.as_token = "token1" self.as_url = "some_url" self._add_appservice(self.as_token, self.as_url, "some_hs_token", "bob") self._add_appservice("token2", "some_url", "some_hs_token", "bob") self._add_appservice("token3", "some_url", "some_hs_token", "bob") # must be done after inserts self.store = ApplicationServiceStore(hs)
def setUp(self): self.state_handler = Mock() self.store = Mock() self.hs = yield setup_test_homeserver(handlers=None) self.hs.get_datastore = Mock(return_value=self.store) self.hs.handlers = TestHandlers(self.hs) self.auth = Auth(self.hs) self.test_user = "******" self.test_token = "_test_token_" # this is overridden for the appservice tests self.store.get_app_service_by_token = Mock(return_value=None)
def test_duplicate_as_tokens(self): f1 = self._write_config(as_token="as_token", suffix="1") f2 = self._write_config(as_token="as_token", suffix="2") config = Mock(app_service_config_files=[f1, f2], event_cache_size=1) hs = yield setup_test_homeserver(config=config, datastore=Mock()) with self.assertRaises(ConfigError) as cm: ApplicationServiceStore(hs) e = cm.exception self.assertIn(f1, e.message) self.assertIn(f2, e.message) self.assertIn("as_token", e.message)
def setUp(self): hs = yield setup_test_homeserver(resource_for_federation=Mock(), http_client=None) self.store = hs.get_datastore() self.event_builder_factory = hs.get_event_builder_factory() self.handlers = hs.get_handlers() self.message_handler = self.handlers.message_handler self.u_alice = UserID.from_string("@alice:test") self.u_bob = UserID.from_string("@bob:test") self.room1 = RoomID.from_string("!abc123:test") self.room2 = RoomID.from_string("!xyx987:test") self.depth = 1
def setUp(self): self.mock_distributor = Mock() self.mock_distributor.declare("registered_user") self.mock_captcha_client = Mock() self.hs = yield setup_test_homeserver( handlers=None, http_client=None, expire_access_token=True, profile_handler=Mock(), ) self.macaroon_generator = Mock( generate_access_token=Mock(return_value='secret')) self.hs.get_macaroon_generator = Mock(return_value=self.macaroon_generator) self.hs.handlers = RegistrationHandlers(self.hs) self.handler = self.hs.get_handlers().registration_handler
def setUp(self): hs = yield setup_test_homeserver() # We can't test RoomStore on its own without the DirectoryStore, for # management of the 'room_aliases' table self.store = hs.get_datastore() self.room = RoomID.from_string("!abcde:test") self.alias = RoomAlias.from_string("#a-room-name:test") self.u_creator = UserID.from_string("@creator:test") yield self.store.store_room(self.room.to_string(), room_creator_user_id=self.u_creator.to_string(), is_public=True )
def setUp(self): self.mock_federation_resource = MockHttpResource() self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() hs = yield setup_test_homeserver( handlers=None, http_client=self.mock_http_client, keyring=Mock(), ) self.filtering = hs.get_filtering() self.datastore = hs.get_datastore()