def setUp(self): self.hostname = "test" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "persist_event", "store_room", "get_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", "federation_handler", ]), ) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.hs = hs self.handlers.federation_handler = FederationHandler(self.hs)
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.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", ]) 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): self._callback_url = hs.config.oidc_callback_url # type: str self._scopes = hs.config.oidc_scopes # type: List[str] self._client_auth = ClientAuth( hs.config.oidc_client_id, hs.config.oidc_client_secret, hs.config.oidc_client_auth_method, ) # type: ClientAuth self._client_auth_method = hs.config.oidc_client_auth_method # type: str self._provider_metadata = OpenIDProviderMetadata( issuer=hs.config.oidc_issuer, authorization_endpoint=hs.config.oidc_authorization_endpoint, token_endpoint=hs.config.oidc_token_endpoint, userinfo_endpoint=hs.config.oidc_userinfo_endpoint, jwks_uri=hs.config.oidc_jwks_uri, ) # type: OpenIDProviderMetadata self._provider_needs_discovery = hs.config.oidc_discover # type: bool self._user_mapping_provider = hs.config.oidc_user_mapping_provider_class( hs.config.oidc_user_mapping_provider_config ) # type: OidcMappingProvider self._skip_verification = hs.config.oidc_skip_verification # type: bool self._http_client = hs.get_proxied_http_client() self._auth_handler = hs.get_auth_handler() self._registration_handler = hs.get_registration_handler() self._datastore = hs.get_datastore() self._clock = hs.get_clock() self._hostname = hs.hostname # type: str self._server_name = hs.config.server_name # type: str self._macaroon_secret_key = hs.config.macaroon_secret_key self._error_template = load_jinja2_templates( hs.config.sso_template_dir, ["sso_error.html"])[0] # identifier for the external_ids table self._auth_provider_id = "oidc"
def setUp(self): self.mock_resource = MockHttpResource() self.mock_http_client = Mock(spec=[ "get_json", "put_json", ]) self.mock_persistence = Mock(spec=[ "get_current_state_for_context", "get_pdu", "persist_event", "update_min_depth_for_context", "prep_send_transaction", "delivered_txn", "get_received_txn_response", "set_received_txn_response", ]) self.mock_persistence.get_received_txn_response.return_value = ( defer.succeed(None) ) self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] self.clock = MockClock() hs = HomeServer("test", resource_for_federation=self.mock_resource, http_client=self.mock_http_client, db_pool=None, datastore=self.mock_persistence, clock=self.clock, config=self.mock_config, keyring=Mock(), ) self.federation = initialize_http_replication(hs) self.distributor = hs.get_distributor()
def setup_test_homeserver(name="test", datastore=None, config=None, **kargs): """Setup a homeserver suitable for running tests against. Keyword arguments are passed to the Homeserver constructor. If no datastore is supplied a datastore backed by an in-memory sqlite db will be given to the HS. """ if config is None: config = Mock() config.signing_key = [MockKey()] config.event_cache_size = 1 config.disable_registration = False if "clock" not in kargs: kargs["clock"] = MockClock() if datastore is None: db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer(name, db_pool=db_pool, config=config, version_string="Synapse/tests", database_engine=create_engine("sqlite3"), **kargs) else: hs = HomeServer(name, db_pool=None, datastore=datastore, config=config, version_string="Synapse/tests", database_engine=create_engine("sqlite3"), **kargs) defer.returnValue(hs)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastore() 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 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() self.auth_user_id = self.user_id 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)
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, 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, clock, hs: HomeServer): 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") self.get_success(self.register_user(self.frank.localpart, "frankpassword")) self.handler = hs.get_profile_handler()
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 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 = HomeServer("test", db_pool=None, http_client=None, datastore=Mock(spec=[ "get_profile_displayname", "set_profile_displayname", "get_profile_avatar_url", "set_profile_avatar_url", ]), handlers=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = ProfileHandlers(hs) self.datastore = hs.get_datastore() self.frank = hs.parse_userid("@1234ABCD:test") self.bob = hs.parse_userid("@4567:test") self.alice = hs.parse_userid("@alice:remote") self.handler = hs.get_handlers().profile_handler # TODO(paul): Icky signal declarings.. booo hs.get_distributor().declare("changed_presencelike_data")
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 db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, http_client=None, handlers=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = ProfileHandlers(hs) self.store = hs.get_datastore() self.frank = hs.parse_userid("@1234ABCD:test") self.bob = hs.parse_userid("@4567:test") self.alice = hs.parse_userid("@alice:remote") yield self.store.create_profile(self.frank.localpart) self.handler = hs.get_handlers().profile_handler # TODO(paul): Icky signal declarings.. booo hs.get_distributor().declare("changed_presencelike_data")
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=db_pool, config=self.mock_config, resource_for_federation=Mock(), http_client=None, ) # We can't test the RoomMemberStore on its own without the other event # storage logic 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 = hs.parse_userid("@alice:test") self.u_bob = hs.parse_userid("@bob:test") # User elsewhere on another host self.u_charlie = hs.parse_userid("@charlie:elsewhere") self.room = hs.parse_roomid("!abc123:test")
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, ) self.store = ProfileStore(hs) self.u_frank = hs.parse_userid("@frank:test")
def __init__(self, hs: HomeServer): self._clock = hs.get_clock() self.keyring = hs.get_keyring() self.server_name = hs.hostname self.store = hs.get_datastore() self.federation_domain_whitelist = hs.config.federation_domain_whitelist self.notifier = hs.get_notifier() self.replication_client = None if hs.config.worker.worker_app: self.replication_client = hs.get_tcp_replication()
def setUp(self): self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) persistence_service = Mock(spec=["get_latest_pdus_in_context"]) persistence_service.get_latest_pdus_in_context.return_value = [] self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", db_pool=db_pool, http_client=None, replication_layer=Mock(), persistence_service=persistence_service, clock=Mock(spec=[ "call_later", "cancel_call_later", "time_msec", "time" ]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.config.enable_registration_captcha = False hs.get_handlers().federation_handler = Mock() hs.get_clock().time_msec.return_value = 1000000 hs.get_clock().time.return_value = 1000 synapse.rest.register.register_servlets(hs, self.mock_resource) synapse.rest.events.register_servlets(hs, self.mock_resource) synapse.rest.room.register_servlets(hs, self.mock_resource) # register an account self.user_id = "sid1" response = yield self.register(self.user_id) self.token = response["access_token"] self.user_id = response["user_id"] # register a 2nd account self.other_user = "******" response = yield self.register(self.other_user) self.other_token = response["access_token"] self.other_user = response["user_id"]
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", db_pool=db_pool, ) self.store = ProfileStore(hs) self.u_frank = hs.parse_userid("@frank:test")
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, ) self.store = DirectoryStore(hs) self.room = hs.parse_roomid("!abcde:test") self.alias = hs.parse_roomalias("#my-room:test")
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", db_pool=db_pool, ) self.store = DirectoryStore(hs) self.room = hs.parse_roomid("!abcde:test") self.alias = hs.parse_roomalias("#my-room: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_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): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", clock=MockClock(), db_pool=db_pool, ) self.store = PresenceStore(hs) self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test")
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 db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, 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 = hs.parse_roomalias("#my-room:test") self.your_room = hs.parse_roomalias("#your-room:test") self.remote_room = hs.parse_roomalias("#another:remote")
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.store = hs.get_datastore() 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 setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=db_pool, config=self.mock_config, 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 = hs.parse_userid("@alice:test") self.u_bob = hs.parse_userid("@bob:test") self.room1 = hs.parse_roomid("!abc123:test") self.room2 = hs.parse_roomid("!xyx987:test") self.depth = 1
def setup_test_homeserver(name="test", datastore=None, config=None, **kargs): """Setup a homeserver suitable for running tests against. Keyword arguments are passed to the Homeserver constructor. If no datastore is supplied a datastore backed by an in-memory sqlite db will be given to the HS. """ if config is None: config = Mock() config.signing_key = [MockKey()] config.event_cache_size = 1 config.disable_registration = False config.macaroon_secret_key = "not even a little secret" config.server_name = "server.under.test" if "clock" not in kargs: kargs["clock"] = MockClock() if datastore is None: db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer(name, db_pool=db_pool, config=config, version_string="Synapse/tests", database_engine=create_engine("sqlite3"), **kargs) else: hs = HomeServer(name, db_pool=None, datastore=datastore, config=config, version_string="Synapse/tests", database_engine=create_engine("sqlite3"), **kargs) # bcrypt is far too slow to be doing in unit tests def swap_out_hash_for_testing(old_build_handlers): def build_handlers(): handlers = old_build_handlers() auth_handler = handlers.auth_handler auth_handler.hash = lambda p: hashlib.md5(p).hexdigest() auth_handler.validate_hash = lambda p, h: hashlib.md5(p).hexdigest( ) == h return handlers return build_handlers hs.build_handlers = swap_out_hash_for_testing(hs.build_handlers) defer.returnValue(hs)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: # Allow us to modify cached feature flags mid-test self.as_handler = hs.get_application_service_handler() # Mock ApplicationServiceApi's put_json, so we can verify the raw JSON that # will be sent over the wire self.put_json = simple_async_mock() hs.get_application_service_api( ).put_json = self.put_json # type: ignore[assignment] # Mock out application services, and allow defining our own in tests self._services: List[ApplicationService] = [] self.hs.get_datastores().main.get_app_services = Mock( return_value=self._services)
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.db_pool = Mock(spec=["runInteraction"]) self.mock_txn = Mock() self.mock_conn = Mock(spec_set=["cursor", "rollback", "commit"]) self.mock_conn.cursor.return_value = self.mock_txn self.mock_conn.rollback.return_value = None # Our fake runInteraction just runs synchronously inline def runInteraction(func, *args, **kwargs): return defer.succeed(func(self.mock_txn, *args, **kwargs)) self.db_pool.runInteraction = runInteraction def runWithConnection(func, *args, **kwargs): return defer.succeed(func(self.mock_conn, *args, **kwargs)) self.db_pool.runWithConnection = runWithConnection config = Mock() config.event_cache_size = 1 config.database_config = {"name": "sqlite3"} hs = HomeServer( "test", db_pool=self.db_pool, config=config, database_engine=create_engine(config), ) self.datastore = SQLBaseStore(hs)
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer): self.store: EventsWorkerStore = hs.get_datastore() self.room_id = f"!room:{hs.hostname}" self.event_ids = [f"event{i}" for i in range(20)] self._populate_events()
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.media_repo = hs.get_media_repository_resource() self.preview_url = self.media_repo.children[b"preview_url"] self.lookups: Dict[str, Any] = {} class Resolver: def resolveHostName( _self, resolutionReceiver: IResolutionReceiver, hostName: str, portNumber: int = 0, addressTypes: Optional[Sequence[Type[IAddress]]] = None, transportSemantics: str = "TCP", ) -> IResolutionReceiver: resolution = HostResolution(hostName) resolutionReceiver.resolutionBegan(resolution) if hostName not in self.lookups: raise DNSLookupError("OH NO") for i in self.lookups[hostName]: resolutionReceiver.addressResolved(i[0]("TCP", i[1], portNumber)) resolutionReceiver.resolutionComplete() return resolutionReceiver self.reactor.nameResolver = Resolver() # type: ignore[assignment]
def prepare(self, reactor: MemoryReactor, clock: Clock, hs: HomeServer) -> None: self.clock = clock self._storage_controllers = hs.get_storage_controllers() self.virtual_user_id, _ = self.register_appservice_user( "as_user_potato", self.appservice.token)
async def _make_callback_with_userinfo( hs: HomeServer, userinfo: dict, client_redirect_url: str = "http://client/redirect") -> None: """Mock up an OIDC callback with the given userinfo dict We'll pull out the OIDC handler from the homeserver, stub out a couple of methods, and poke in the userinfo dict as if it were the response to an OIDC userinfo call. Args: hs: the HomeServer impl to send the callback to. userinfo: the OIDC userinfo dict client_redirect_url: the URL to redirect to on success. """ from synapse.handlers.oidc import OidcSessionData handler = hs.get_oidc_handler() provider = handler._providers["oidc"] provider._exchange_code = simple_async_mock(return_value={}) provider._parse_id_token = simple_async_mock(return_value=userinfo) provider._fetch_userinfo = simple_async_mock(return_value=userinfo) state = "state" session = handler._token_generator.generate_oidc_session_token( state=state, session_data=OidcSessionData( idp_id="oidc", nonce="nonce", client_redirect_url=client_redirect_url, ui_auth_session_id="", ), ) request = _build_callback_request("code", state, session) await handler.handle_oidc_callback(request)
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 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( "test", db_pool=None, http_client=None, replication_layer=Mock(), state_handler=state_handler, datastore=MemoryDataStore(), persistence_service=persistence_service, clock=Mock( spec=["call_later", "cancel_call_later", "time_msec", "time"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0) hs.config.enable_registration_captcha = False hs.get_handlers().federation_handler = Mock() hs.get_clock().time_msec.return_value = 1000000 synapse.rest.register.register_servlets(hs, self.mock_resource) synapse.rest.events.register_servlets(hs, self.mock_resource) synapse.rest.room.register_servlets(hs, self.mock_resource) # register an account self.user_id = "sid1" response = yield self.register(self.user_id) self.token = response["access_token"] self.user_id = response["user_id"] # register a 2nd account self.other_user = "******" response = yield self.register(self.other_user) self.other_token = response["access_token"] self.other_user = response["user_id"]
def setup_test_homeserver(name="test", datastore=None, config=None, **kargs): """Setup a homeserver suitable for running tests against. Keyword arguments are passed to the Homeserver constructor. If no datastore is supplied a datastore backed by an in-memory sqlite db will be given to the HS. """ if config is None: config = Mock() config.signing_key = [MockKey()] config.event_cache_size = 1 config.disable_registration = False config.macaroon_secret_key = "not even a little secret" config.server_name = "server.under.test" if "clock" not in kargs: kargs["clock"] = MockClock() if datastore is None: db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( name, db_pool=db_pool, config=config, version_string="Synapse/tests", database_engine=create_engine("sqlite3"), **kargs ) else: hs = HomeServer( name, db_pool=None, datastore=datastore, config=config, version_string="Synapse/tests", database_engine=create_engine("sqlite3"), **kargs ) # bcrypt is far too slow to be doing in unit tests def swap_out_hash_for_testing(old_build_handlers): def build_handlers(): handlers = old_build_handlers() auth_handler = handlers.auth_handler auth_handler.hash = lambda p: hashlib.md5(p).hexdigest() auth_handler.validate_hash = lambda p, h: hashlib.md5(p).hexdigest() == h return handlers return build_handlers hs.build_handlers = swap_out_hash_for_testing(hs.build_handlers) defer.returnValue(hs)
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 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 db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( "test", db_pool=db_pool, http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, config=self.mock_config, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler self.store = hs.get_datastore() self.my_room = hs.parse_roomalias("#my-room:test") self.your_room = hs.parse_roomalias("#your-room:test") self.remote_room = hs.parse_roomalias("#another:remote")
def setUp(self): self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] self.state_handler = NonCallableMock(spec_set=[ "compute_event_context", ]) self.auth = NonCallableMock(spec_set=[ "check", "check_host_in_room", ]) self.hostname = "test" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "persist_event", "store_room", "get_room", "get_destination_retry_timings", "set_destination_retry_timings", ]), resource_for_federation=NonCallableMock(), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_member_handler", "federation_handler", ]), config=self.mock_config, auth=self.auth, state_handler=self.state_handler, keyring=Mock(), ) self.datastore = hs.get_datastore() self.handlers = hs.get_handlers() self.notifier = hs.get_notifier() self.hs = hs self.handlers.federation_handler = FederationHandler(self.hs)
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", clock=MockClock(), db_pool=db_pool, handlers=None, resource_for_federation=Mock(), http_client=None, ) hs.handlers = JustPresenceHandlers(hs) self.store = hs.get_datastore() # Mock the RoomMemberHandler room_member_handler = Mock(spec=[]) hs.handlers.room_member_handler = room_member_handler # Some local users to test with self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test") self.u_clementine = hs.parse_userid("@clementine:test") yield self.store.create_presence(self.u_apple.localpart) yield self.store.set_presence_state( self.u_apple.localpart, {"state": ONLINE, "status_msg": "Online"} ) self.handler = hs.get_handlers().presence_handler self.room_members = [] def get_rooms_for_user(user): if user in self.room_members: return defer.succeed(["a-room"]) else: return defer.succeed([]) room_member_handler.get_rooms_for_user = get_rooms_for_user def get_room_members(room_id): if room_id == "a-room": return defer.succeed(self.room_members) else: return defer.succeed([]) room_member_handler.get_room_members = get_room_members def user_rooms_intersect(userlist): room_member_ids = map(lambda u: u.to_string(), self.room_members) shared = all(map(lambda i: i in room_member_ids, userlist)) return defer.succeed(shared) self.store.user_rooms_intersect = user_rooms_intersect self.mock_start = Mock() self.mock_stop = Mock() self.handler.start_polling_presence = self.mock_start self.handler.stop_polling_presence = self.mock_stop
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, ) # 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 = hs.parse_roomid("!abcde:test") yield self.store.store_room(self.room.to_string(), room_creator_user_id="@creator:text", is_public=True )
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) # create the room self.room_id = yield self.create_room_as(self.user_id) self.path = "/rooms/%s/state/m.room.topic" % (self.room_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=[ "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): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, ) # 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 = hs.parse_roomid("!abcde:test") self.alias = hs.parse_roomalias("#a-room-name:test") self.u_creator = hs.parse_userid("@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_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_joined_hosts_for_room", "get_room_member", "get_room", "store_room", "snapshot_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"]), state_handler=NonCallableMock(spec_set=["handle_new_event"]), config=self.mock_config, ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", "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.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.snapshot = Mock() self.datastore.snapshot_room.return_value = self.snapshot self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
def setUp(self): self.hostname = "red" self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "store_room", "snapshot_room", "persist_event", "get_joined_hosts_for_room", ]), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_creation_handler", "message_handler", ]), auth=NonCallableMock(spec_set=["check", "add_auth_events"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=self.mock_config, ) self.federation = NonCallableMock(spec_set=[ "handle_new_event", ]) self.handlers = hs.get_handlers() self.handlers.room_creation_handler = RoomCreationHandler(hs) self.room_creation_handler = self.handlers.room_creation_handler self.message_handler = self.handlers.message_handler self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
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 = HomeServer("test", datastore=Mock(spec=[ "get_association_from_room_alias", "get_joined_hosts_for_room", ]), http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = DirectoryHandlers(hs) self.handler = hs.get_handlers().directory_handler self.datastore = hs.get_datastore() def hosts(room_id): return defer.succeed([]) self.datastore.get_joined_hosts_for_room.side_effect = hosts self.my_room = hs.parse_roomalias("#my-room:test") self.remote_room = hs.parse_roomalias("#another:remote")
def setUp(self): self.mock_resource = MockHttpResource() self.mock_http_client = Mock(spec=[ "get_json", "put_json", ]) self.mock_persistence = Mock(spec=[ "prep_send_transaction", "delivered_txn", "get_received_txn_response", "set_received_txn_response", "get_destination_retry_timings", "get_auth_chain", ]) self.mock_persistence.get_received_txn_response.return_value = ( defer.succeed(None) ) self.mock_persistence.get_destination_retry_timings.return_value = ( defer.succeed(DestinationsTable.EntryType("", 0, 0)) ) self.mock_persistence.get_auth_chain.return_value = [] self.mock_config = Mock() self.mock_config.signing_key = [MockKey()] self.clock = MockClock() hs = HomeServer( "test", resource_for_federation=self.mock_resource, http_client=self.mock_http_client, db_pool=None, datastore=self.mock_persistence, clock=self.clock, config=self.mock_config, keyring=Mock(), ) self.federation = initialize_http_replication(hs) self.distributor = hs.get_distributor()
def setUp(self): self.mock_http_client = Mock(spec=[]) self.mock_http_client.put_json = DeferredMockCallable() self.mock_federation_resource = MockHttpResource() db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() self.mock_config = NonCallableMock() self.mock_config.signing_key = [MockKey()] hs = HomeServer("test", clock=MockClock(), db_pool=db_pool, handlers=None, resource_for_client=Mock(), resource_for_federation=self.mock_federation_resource, http_client=self.mock_http_client, config=self.mock_config, keyring=Mock(), ) hs.handlers = JustPresenceHandlers(hs) self.store = hs.get_datastore() # Some local users to test with self.u_apple = hs.parse_userid("@apple:test") self.u_banana = hs.parse_userid("@banana:test") yield self.store.create_presence(self.u_apple.localpart) yield self.store.create_presence(self.u_banana.localpart) # ID of a local user that does not exist self.u_durian = hs.parse_userid("@durian:test") # A remote user self.u_cabbage = hs.parse_userid("@cabbage:elsewhere") self.handler = hs.get_handlers().presence_handler self.mock_start = Mock() self.mock_stop = Mock() self.handler.start_polling_presence = self.mock_start self.handler.stop_polling_presence = self.mock_stop
def setUp(self): self.hostname = "red" hs = HomeServer( self.hostname, db_pool=None, datastore=NonCallableMock(spec_set=[ "store_room", "snapshot_room", "persist_event", "get_joined_hosts_for_room", ]), http_client=NonCallableMock(spec_set=[]), notifier=NonCallableMock(spec_set=["on_new_room_event"]), handlers=NonCallableMock(spec_set=[ "room_creation_handler", "room_member_handler", "federation_handler", ]), auth=NonCallableMock(spec_set=["check"]), state_handler=NonCallableMock(spec_set=["handle_new_event"]), ratelimiter=NonCallableMock(spec_set=[ "send_message", ]), config=NonCallableMock(), ) self.federation = NonCallableMock(spec_set=[ "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.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 hosts(room): return defer.succeed([]) self.datastore.get_joined_hosts_for_room.side_effect = hosts self.ratelimiter = hs.get_ratelimiter() self.ratelimiter.send_message.return_value = (True, 0)
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): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer("test", db_pool=db_pool, ) # We can't test the RoomMemberStore on its own without the other event # storage logic self.store = hs.get_datastore() self.event_factory = hs.get_event_factory() self.u_alice = hs.parse_userid("@alice:test") self.u_bob = hs.parse_userid("@bob:test") # User elsewhere on another host self.u_charlie = hs.parse_userid("@charlie:elsewhere") self.room = hs.parse_roomid("!abc123:test")
def setUp(self): db_pool = SQLiteMemoryDbPool() yield db_pool.prepare() hs = HomeServer( "test", db_pool=db_pool, ) self.store = hs.get_datastore() self.event_factory = hs.get_event_factory() self.u_alice = hs.parse_userid("@alice:test") self.u_bob = hs.parse_userid("@bob:test") self.room1 = hs.parse_roomid("!abc123:test") self.depth = 1
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)