def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.db_pool: DatabasePool = self.store.db_pool self.get_success( self.db_pool.runInteraction("_setup_db", self._setup_db))
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.handler = hs.get_user_directory_handler() self.event_builder_factory = self.hs.get_event_builder_factory() self.event_creation_handler = self.hs.get_event_creation_handler() self.user_dir_helper = GetUserDirectoryTables(self.store)
def prepare( self, reactor: MemoryReactor, clock: Clock, homeserver: HomeServer ) -> None: self.store = homeserver.get_datastores().main self.module_api = homeserver.get_module_api() self.event_creation_handler = homeserver.get_event_creation_handler() self.sync_handler = homeserver.get_sync_handler() self.auth_handler = homeserver.get_auth_handler()
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.user_id = self.register_user("kermit", "test") self.user_id_tok = self.login("kermit", "test") self.email = "*****@*****.**" self.url_3pid = b"account/3pid"
def prepare( self, reactor: MemoryReactor, clock: Clock, homeserver: HomeServer ) -> None: self._store = homeserver.get_datastores().main self._module_api = homeserver.get_module_api() self._account_data_mgr = self._module_api.account_data_manager self.user_id = self.register_user("kristina", "secret")
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.admin_user = self.register_user("admin", "pass", admin=True) self.admin_user_tok = self.login("admin", "pass") self.other_user = self.register_user("user", "pass") self.other_user_tok = self.login("user", "pass") self.url = "/_synapse/admin/v1/registration_tokens"
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main # alice and bob are both in !room_id. bobby is not but shares # a homeserver with alice. self.get_success(self.store.update_profile_in_user_dir(ALICE, "alice", None)) self.get_success(self.store.update_profile_in_user_dir(BOB, "bob", None)) self.get_success(self.store.update_profile_in_user_dir(BOBBY, "bobby", None)) self.get_success(self.store.update_profile_in_user_dir(BELA, "Bela", None)) self.get_success(self.store.add_users_in_public_rooms("!room:id", (ALICE, BOB)))
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 prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: media_resource = hs.get_media_repository_resource() self.download_resource = media_resource.children[b"download"] self.thumbnail_resource = media_resource.children[b"thumbnail"] self.store = hs.get_datastores().main self.media_repo = hs.get_media_repository() self.media_id = "example.com/12345"
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.creator = self.register_user("creator", "pass") self.creator_token = self.login(self.creator, "pass") self.other = self.register_user("user", "pass") self.other_token = self.login(self.other, "pass") self.room_id = self.helper.create_room_as(self.creator, tok=self.creator_token) self.helper.join(self.room_id, self.other, tok=self.other_token)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.frank = UserID.from_string("@1234abcd:test") self.bob = UserID.from_string("@4567:test") self.alice = UserID.from_string("@alice:remote") self.register_user(self.frank.localpart, "frankpassword") self.handler = hs.get_profile_handler()
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.admin_user = self.register_user("admin", "pass", admin=True) self.admin_user_tok = self.login("admin", "pass") self.dest = "sub0.example.com" self.url = f"/_synapse/admin/v1/federation/destinations/{self.dest}/rooms" # Record that we successfully contacted a destination in the DB. self.get_success( self.store.set_destination_retry_timings(self.dest, None, 0, 0) )
def _make_test_homeserver_synchronous(server: HomeServer) -> None: """ Make the given test homeserver's database interactions synchronous. """ clock = server.get_clock() for database in server.get_datastores().databases: pool = database._db_pool def runWithConnection(func, *args, **kwargs): return threads.deferToThreadPool( pool._reactor, pool.threadpool, pool._runWithConnection, func, *args, **kwargs, ) def runInteraction(interaction, *args, **kwargs): return threads.deferToThreadPool( pool._reactor, pool.threadpool, pool._runInteraction, interaction, *args, **kwargs, ) pool.runWithConnection = runWithConnection pool.runInteraction = runInteraction # Replace the thread pool with a threadless 'thread' pool pool.threadpool = ThreadPool(clock._reactor) pool.running = True # We've just changed the Databases to run DB transactions on the same # thread, so we need to disable the dedicated thread behaviour. server.get_datastores( ).main.USE_DEDICATED_DB_THREADS_FOR_EVENT_FETCHING = False
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer): self.store: EventsWorkerStore = hs.get_datastores().main self.user = self.register_user("user", "pass") self.token = self.login(self.user, "pass") self.room = self.helper.create_room_as(self.user, tok=self.token) res = self.helper.send(self.room, tok=self.token) self.event_id = res["event_id"] # Reset the event cache so the tests start with it empty self.store._get_event_cache.clear()
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.room_shutdown_handler = hs.get_room_shutdown_handler() self.pagination_handler = hs.get_pagination_handler() self.server_notices_manager = self.hs.get_server_notices_manager() # Create user self.admin_user = self.register_user("admin", "pass", admin=True) self.admin_user_tok = self.login("admin", "pass") self.other_user = self.register_user("user", "pass") self.other_user_token = self.login("user", "pass") self.url = "/_synapse/admin/v1/send_server_notice"
def run_background_updates(hs: HomeServer) -> None: store = hs.get_datastores().main async def run_background_updates() -> None: await store.db_pool.updates.run_background_updates(sleep=False) # Stop the reactor to exit the script once every background update is run. reactor.stop() def run() -> None: # Apply all background updates on the database. defer.ensureDeferred( run_as_background_process("background_updates", run_background_updates)) reactor.callWhenRunning(run) reactor.run()
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.storage = hs.get_datastores().main self.table_name = "table_" + secrets.token_hex(6) self.get_success( self.storage.db_pool.runInteraction( "create", lambda x, *a: x.execute(*a), "CREATE TABLE %s (id INTEGER, username TEXT, value TEXT)" % (self.table_name, ), )) self.get_success( self.storage.db_pool.runInteraction( "index", lambda x, *a: x.execute(*a), "CREATE UNIQUE INDEX %sindex ON %s(id, username)" % (self.table_name, self.table_name), ))
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer): super().prepare(reactor, clock, hs) # poke the other server's signing key into the key store, so that we don't # make requests for it verify_key = signedjson.key.get_verify_key( self.OTHER_SERVER_SIGNATURE_KEY) verify_key_id = "%s:%s" % (verify_key.alg, verify_key.version) self.get_success(hs.get_datastores().main.store_server_verify_keys( from_server=self.OTHER_SERVER_NAME, ts_added_ms=clock.time_msec(), verify_keys=[( self.OTHER_SERVER_NAME, verify_key_id, FetchKeyResult( verify_key=verify_key, valid_until_ts=clock.time_msec() + 1000, ), )], ))
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: media_repo = hs.get_media_repository_resource() self.store = hs.get_datastores().main self.admin_user = self.register_user("admin", "pass", admin=True) self.admin_user_tok = self.login("admin", "pass") # Create media upload_resource = media_repo.children[b"upload"] # Upload some media into the room response = self.helper.upload_media( upload_resource, SMALL_PNG, tok=self.admin_user_tok, expect_code=HTTPStatus.OK, ) # Extract media ID from the response server_and_media_id = response["content_uri"][6:] # Cut off 'mxc://' self.media_id = server_and_media_id.split("/")[1] self.url = "/_synapse/admin/v1/media/%s/%s"
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.url = "/sync?since=%s" self.next_batch = "s0" # Register the first user (used to create the room to knock on). self.user_id = self.register_user("kermit", "monkey") self.tok = self.login("kermit", "monkey") # Create the room we'll knock on. self.room_id = self.helper.create_room_as( self.user_id, is_public=False, room_version="7", tok=self.tok, ) # Register the second user (used to knock on the room). self.knocker = self.register_user("knocker", "monkey") self.knocker_tok = self.login("knocker", "monkey") # Perform an initial sync for the knocking user. channel = self.make_request( "GET", self.url % self.next_batch, access_token=self.tok, ) self.assertEqual(channel.code, 200, channel.json_body) # Store the next batch for the next request. self.next_batch = channel.json_body["next_batch"] # Set up some room state to test with. self.expected_room_state = self.send_example_state_events_to_room( hs, self.room_id, self.user_id )
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.remote_server_name = "remote.homeserver" self.store = hs.get_datastores().main # Create a user to upload media with test_user_id = self.register_user("alice", "password") # Inject media (recently accessed, old access, never accessed, old access # quarantined media) into both the local store and the remote cache, plus # one additional local media that is marked as protected from quarantine. media_repository = hs.get_media_repository() test_media_content = b"example string" def _create_media_and_set_attributes( last_accessed_ms: Optional[int], is_quarantined: Optional[bool] = False, is_protected: Optional[bool] = False, ) -> str: # "Upload" some media to the local media store mxc_uri = self.get_success( media_repository.create_content( media_type="text/plain", upload_name=None, content=io.BytesIO(test_media_content), content_length=len(test_media_content), auth_user=UserID.from_string(test_user_id), ) ) media_id = mxc_uri.split("/")[-1] # Set the last recently accessed time for this media if last_accessed_ms is not None: self.get_success( self.store.update_cached_last_access_time( local_media=(media_id,), remote_media=(), time_ms=last_accessed_ms, ) ) if is_quarantined: # Mark this media as quarantined self.get_success( self.store.quarantine_media_by_id( server_name=self.hs.config.server.server_name, media_id=media_id, quarantined_by="@theadmin:test", ) ) if is_protected: # Mark this media as protected from quarantine self.get_success( self.store.mark_local_media_as_safe( media_id=media_id, safe=True, ) ) return media_id def _cache_remote_media_and_set_attributes( media_id: str, last_accessed_ms: Optional[int], is_quarantined: Optional[bool] = False, ) -> str: # Pretend to cache some remote media self.get_success( self.store.store_cached_remote_media( origin=self.remote_server_name, media_id=media_id, media_type="text/plain", media_length=1, time_now_ms=clock.time_msec(), upload_name="testfile.txt", filesystem_id="abcdefg12345", ) ) # Set the last recently accessed time for this media if last_accessed_ms is not None: self.get_success( hs.get_datastores().main.update_cached_last_access_time( local_media=(), remote_media=((self.remote_server_name, media_id),), time_ms=last_accessed_ms, ) ) if is_quarantined: # Mark this media as quarantined self.get_success( self.store.quarantine_media_by_id( server_name=self.remote_server_name, media_id=media_id, quarantined_by="@theadmin:test", ) ) return media_id # Start with the local media store self.local_recently_accessed_media = _create_media_and_set_attributes( last_accessed_ms=self.THIRTY_DAYS_IN_MS, ) self.local_not_recently_accessed_media = _create_media_and_set_attributes( last_accessed_ms=self.ONE_DAY_IN_MS, ) self.local_not_recently_accessed_quarantined_media = ( _create_media_and_set_attributes( last_accessed_ms=self.ONE_DAY_IN_MS, is_quarantined=True, ) ) self.local_not_recently_accessed_protected_media = ( _create_media_and_set_attributes( last_accessed_ms=self.ONE_DAY_IN_MS, is_protected=True, ) ) self.local_never_accessed_media = _create_media_and_set_attributes( last_accessed_ms=None, ) # And now the remote media store self.remote_recently_accessed_media = _cache_remote_media_and_set_attributes( media_id="a", last_accessed_ms=self.THIRTY_DAYS_IN_MS, ) self.remote_not_recently_accessed_media = ( _cache_remote_media_and_set_attributes( media_id="b", last_accessed_ms=self.ONE_DAY_IN_MS, ) ) self.remote_not_recently_accessed_quarantined_media = ( _cache_remote_media_and_set_attributes( media_id="c", last_accessed_ms=self.ONE_DAY_IN_MS, is_quarantined=True, ) )
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.room_creator = hs.get_room_creation_handler()
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.submit_token_resource = PasswordResetSubmitTokenResource(hs)
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 prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.user_dir_helper = GetUserDirectoryTables(self.store)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.admin_user = self.register_user("admin", "pass", admin=True) self.admin_user_tok = self.login("admin", "pass") self.updater = BackgroundUpdater(hs, self.store.db_pool)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main # Advance the clock a bit self.reactor.advance(FORTY_DAYS)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self._store = hs.get_datastores().main self.user = self.register_user("user", "pass") self.token = self.login("user", "pass")
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastores().main self.u_frank = UserID.from_string("@frank:test")