def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register') self.request.args = {} self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: defer.succeed(self.appservice))) self.auth_result = (False, None, None, None) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x, y, z: self.auth_result), get_session_data=Mock(return_value=None)) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock(auth_handler=self.auth_handler, registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.config.enable_registration = True # init the thing we're testing self.servlet = RegisterRestServlet(self.hs)
def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path="/_matrix/api/v2_alpha/register" ) self.request.args = {} self.appservice = None self.auth = Mock(get_appservice_by_req=Mock(side_effect=lambda x: defer.succeed(self.appservice))) self.auth_result = (False, None, None) self.auth_handler = Mock(check_auth=Mock(side_effect=lambda x, y, z: self.auth_result)) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( auth_handler=self.auth_handler, registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler, ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.config.disable_registration = False # init the thing we're testing self.servlet = RegisterRestServlet(self.hs)
def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register' ) self.request.args = {} self.request.requestHeaders.getRawHeaders = mock_getRawHeaders() self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: self.appservice) ) self.auth_result = failure.Failure(InteractiveAuthIncompleteError(None)) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x, y, z: self.auth_result), get_session_data=Mock(return_value=None) ) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() self.device_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.get_auth_handler = Mock(return_value=self.auth_handler) self.hs.get_device_handler = Mock(return_value=self.device_handler) self.hs.config.enable_registration = True self.hs.config.auto_join_rooms = [] # init the thing we're testing self.servlet = RegisterRestServlet(self.hs)
def _listen_http(self, listener_config): port = listener_config["port"] bind_addresses = listener_config["bind_addresses"] site_tag = listener_config.get("tag", port) resources = {} for res in listener_config["resources"]: for name in res["names"]: if name == "metrics": resources[METRICS_PREFIX] = MetricsResource(RegistryProxy) elif name == "client": resource = JsonResource(self, canonical_json=False) PublicRoomListRestServlet(self).register(resource) RoomMemberListRestServlet(self).register(resource) JoinedRoomMemberListRestServlet(self).register(resource) RoomStateRestServlet(self).register(resource) RoomEventContextServlet(self).register(resource) RoomMessageListRestServlet(self).register(resource) RegisterRestServlet(self).register(resource) LoginRestServlet(self).register(resource) ThreepidRestServlet(self).register(resource) KeyQueryServlet(self).register(resource) KeyChangesServlet(self).register(resource) VoipRestServlet(self).register(resource) PushRuleRestServlet(self).register(resource) VersionsRestServlet(self).register(resource) groups.register_servlets(self, resource) resources.update({"/_matrix/client": resource}) root_resource = create_resource_tree(resources, NoResource()) _base.listen_tcp( bind_addresses, port, SynapseSite( "synapse.access.http.%s" % (site_tag, ), site_tag, listener_config, root_resource, self.version_string, ), ) logger.info("Synapse client reader now listening on port %d", port)
def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register' ) self.request.args = {} self.request.requestHeaders.getRawHeaders = mock_getRawHeaders() self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: self.appservice) ) self.auth_result = failure.Failure(InteractiveAuthIncompleteError(None)) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x, y, z: self.auth_result), get_session_data=Mock(return_value=None) ) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() self.device_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.get_auth_handler = Mock(return_value=self.auth_handler) self.hs.get_device_handler = Mock(return_value=self.device_handler) self.hs.config.enable_registration = True self.hs.config.registrations_require_3pid = [] self.hs.config.auto_join_rooms = [] # init the thing we're testing self.servlet = RegisterRestServlet(self.hs)
class RegisterRestServletTestCase(unittest.TestCase): def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register' ) self.request.args = {} self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: defer.succeed(self.appservice)) ) self.auth_result = (False, None, None) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x,y,z: self.auth_result) ) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( auth_handler=self.auth_handler, registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.config.enable_registration = True # init the thing we're testing self.servlet = RegisterRestServlet(self.hs) @defer.inlineCallbacks def test_POST_appservice_registration_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = { "id": "1234" } self.registration_handler.appservice_register = Mock( return_value=(user_id, token) ) result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (200, { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname })) @defer.inlineCallbacks def test_POST_appservice_registration_invalid(self): self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = None # no application service exists result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (401, None)) def test_POST_bad_password(self): self.request_data = json.dumps({ "username": "******", "password": 666 }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) def test_POST_bad_username(self): self.request_data = json.dumps({ "username": 777, "password": "******" }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) @defer.inlineCallbacks def test_POST_user_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" self.request_data = json.dumps({ "username": "******", "password": "******" }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (True, None, { "username": "******", "password": "******" }) self.registration_handler.register = Mock(return_value=(user_id, token)) result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (200, { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname })) def test_POST_disabled_registration(self): self.hs.config.enable_registration = False self.request_data = json.dumps({ "username": "******", "password": "******" }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (True, None, { "username": "******", "password": "******" }) self.registration_handler.register = Mock(return_value=("@user:id", "t")) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError)
def _listen_http(self, listener_config: ListenerConfig): port = listener_config.port bind_addresses = listener_config.bind_addresses assert listener_config.http_options is not None site_tag = listener_config.http_options.tag if site_tag is None: site_tag = port # We always include a health resource. resources = {"/health": HealthResource()} for res in listener_config.http_options.resources: for name in res.names: if name == "metrics": resources[METRICS_PREFIX] = MetricsResource(RegistryProxy) elif name == "client": resource = JsonResource(self, canonical_json=False) RegisterRestServlet(self).register(resource) LoginRestServlet(self).register(resource) ThreepidRestServlet(self).register(resource) DevicesRestServlet(self).register(resource) KeyQueryServlet(self).register(resource) OneTimeKeyServlet(self).register(resource) KeyChangesServlet(self).register(resource) VoipRestServlet(self).register(resource) PushRuleRestServlet(self).register(resource) VersionsRestServlet(self).register(resource) ProfileAvatarURLRestServlet(self).register(resource) ProfileDisplaynameRestServlet(self).register(resource) ProfileRestServlet(self).register(resource) KeyUploadServlet(self).register(resource) AccountDataServlet(self).register(resource) RoomAccountDataServlet(self).register(resource) sync.register_servlets(self, resource) events.register_servlets(self, resource) room.register_servlets(self, resource, True) room.register_deprecated_servlets(self, resource) InitialSyncRestServlet(self).register(resource) room_keys.register_servlets(self, resource) tags.register_servlets(self, resource) account_data.register_servlets(self, resource) receipts.register_servlets(self, resource) read_marker.register_servlets(self, resource) SendToDeviceRestServlet(self).register(resource) user_directory.register_servlets(self, resource) # If presence is disabled, use the stub servlet that does # not allow sending presence if not self.config.use_presence: PresenceStatusStubServlet(self).register(resource) groups.register_servlets(self, resource) resources.update({CLIENT_API_PREFIX: resource}) elif name == "federation": resources.update( {FEDERATION_PREFIX: TransportLayerServer(self)}) elif name == "media": if self.config.can_load_media_repo: media_repo = self.get_media_repository_resource() # We need to serve the admin servlets for media on the # worker. admin_resource = JsonResource(self, canonical_json=False) register_servlets_for_media_repo(self, admin_resource) resources.update({ MEDIA_PREFIX: media_repo, LEGACY_MEDIA_PREFIX: media_repo, "/_synapse/admin": admin_resource, }) else: logger.warning( "A 'media' listener is configured but the media" " repository is disabled. Ignoring.") if name == "openid" and "federation" not in res.names: # Only load the openid resource separately if federation resource # is not specified since federation resource includes openid # resource. resources.update({ FEDERATION_PREFIX: TransportLayerServer(self, servlet_groups=["openid"]) }) if name in ["keys", "federation"]: resources[SERVER_KEY_V2_PREFIX] = KeyApiV2Resource(self) if name == "replication": resources[REPLICATION_PREFIX] = ReplicationRestResource( self) root_resource = create_resource_tree(resources, OptionsResource()) _base.listen_tcp( bind_addresses, port, SynapseSite( "synapse.access.http.%s" % (site_tag, ), site_tag, listener_config, root_resource, self.version_string, ), reactor=self.get_reactor(), ) logger.info("Synapse worker now listening on port %d", port)
def on_POST(self, request): self._clear_old_nonces() if not self.hs.config.registration_shared_secret: raise SynapseError(400, "Shared secret registration is not enabled") body = parse_json_object_from_request(request) if "nonce" not in body: raise SynapseError( 400, "nonce must be specified", errcode=Codes.BAD_JSON, ) nonce = body["nonce"] if nonce not in self.nonces: raise SynapseError( 400, "unrecognised nonce", ) # Delete the nonce, so it can't be reused, even if it's invalid del self.nonces[nonce] if "username" not in body: raise SynapseError( 400, "username must be specified", errcode=Codes.BAD_JSON, ) else: if (not isinstance(body['username'], text_type) or len(body['username']) > 512): raise SynapseError(400, "Invalid username") username = body["username"].encode("utf-8") if b"\x00" in username: raise SynapseError(400, "Invalid username") if "password" not in body: raise SynapseError( 400, "password must be specified", errcode=Codes.BAD_JSON, ) else: if (not isinstance(body['password'], text_type) or len(body['password']) > 512): raise SynapseError(400, "Invalid password") password = body["password"].encode("utf-8") if b"\x00" in password: raise SynapseError(400, "Invalid password") admin = body.get("admin", None) got_mac = body["mac"] want_mac = hmac.new( key=self.hs.config.registration_shared_secret.encode(), digestmod=hashlib.sha1, ) want_mac.update(nonce) want_mac.update(b"\x00") want_mac.update(username) want_mac.update(b"\x00") want_mac.update(password) want_mac.update(b"\x00") want_mac.update(b"admin" if admin else b"notadmin") want_mac = want_mac.hexdigest() if not hmac.compare_digest(want_mac, got_mac.encode('ascii')): raise SynapseError(403, "HMAC incorrect") # Reuse the parts of RegisterRestServlet to reduce code duplication from synapse.rest.client.v2_alpha.register import RegisterRestServlet register = RegisterRestServlet(self.hs) (user_id, _) = yield register.registration_handler.register( localpart=body['username'].lower(), password=body["password"], admin=bool(admin), generate_token=False, ) result = yield register._create_registration_details(user_id, body) defer.returnValue((200, result))
def _listen_http(self, listener_config): port = listener_config["port"] bind_addresses = listener_config["bind_addresses"] site_tag = listener_config.get("tag", port) resources = {} for res in listener_config["resources"]: for name in res["names"]: if name == "metrics": resources[METRICS_PREFIX] = MetricsResource(RegistryProxy) elif name == "client": resource = JsonResource(self, canonical_json=False) PublicRoomListRestServlet(self).register(resource) RoomMemberListRestServlet(self).register(resource) JoinedRoomMemberListRestServlet(self).register(resource) RoomStateRestServlet(self).register(resource) RoomEventContextServlet(self).register(resource) RoomMessageListRestServlet(self).register(resource) RegisterRestServlet(self).register(resource) LoginRestServlet(self).register(resource) ThreepidRestServlet(self).register(resource) KeyQueryServlet(self).register(resource) KeyChangesServlet(self).register(resource) VoipRestServlet(self).register(resource) PushRuleRestServlet(self).register(resource) VersionsRestServlet(self).register(resource) RoomSendEventRestServlet(self).register(resource) RoomMembershipRestServlet(self).register(resource) RoomStateEventRestServlet(self).register(resource) JoinRoomAliasServlet(self).register(resource) ProfileAvatarURLRestServlet(self).register(resource) ProfileDisplaynameRestServlet(self).register(resource) ProfileRestServlet(self).register(resource) KeyUploadServlet(self).register(resource) sync.register_servlets(self, resource) events.register_servlets(self, resource) InitialSyncRestServlet(self).register(resource) RoomInitialSyncRestServlet(self).register(resource) user_directory.register_servlets(self, resource) # If presence is disabled, use the stub servlet that does # not allow sending presence if not self.config.use_presence: PresenceStatusStubServlet(self).register(resource) groups.register_servlets(self, resource) resources.update({CLIENT_API_PREFIX: resource}) elif name == "federation": resources.update( {FEDERATION_PREFIX: TransportLayerServer(self)}) elif name == "media": if self.config.can_load_media_repo: media_repo = self.get_media_repository_resource() # We need to serve the admin servlets for media on the # worker. admin_resource = JsonResource(self, canonical_json=False) register_servlets_for_media_repo(self, admin_resource) resources.update({ MEDIA_PREFIX: media_repo, LEGACY_MEDIA_PREFIX: media_repo, "/_synapse/admin": admin_resource, }) else: logger.warning( "A 'media' listener is configured but the media" " repository is disabled. Ignoring.") if name == "openid" and "federation" not in res["names"]: # Only load the openid resource separately if federation resource # is not specified since federation resource includes openid # resource. resources.update({ FEDERATION_PREFIX: TransportLayerServer(self, servlet_groups=["openid"]) }) if name in ["keys", "federation"]: resources[SERVER_KEY_V2_PREFIX] = KeyApiV2Resource(self) root_resource = create_resource_tree(resources, NoResource()) _base.listen_tcp( bind_addresses, port, SynapseSite( "synapse.access.http.%s" % (site_tag, ), site_tag, listener_config, root_resource, self.version_string, ), reactor=self.get_reactor(), ) logger.info("Synapse worker now listening on port %d", port)
async def on_POST(self, request): self._clear_old_nonces() if not self.hs.config.registration_shared_secret: raise SynapseError(400, "Shared secret registration is not enabled") body = parse_json_object_from_request(request) if "nonce" not in body: raise SynapseError(400, "nonce must be specified", errcode=Codes.BAD_JSON) nonce = body["nonce"] if nonce not in self.nonces: raise SynapseError(400, "unrecognised nonce") # Delete the nonce, so it can't be reused, even if it's invalid del self.nonces[nonce] if "username" not in body: raise SynapseError(400, "username must be specified", errcode=Codes.BAD_JSON) else: if (not isinstance(body["username"], text_type) or len(body["username"]) > 512): raise SynapseError(400, "Invalid username") username = body["username"].encode("utf-8") if b"\x00" in username: raise SynapseError(400, "Invalid username") if "password" not in body: raise SynapseError(400, "password must be specified", errcode=Codes.BAD_JSON) else: password = body["password"] if not isinstance(password, text_type) or len(password) > 512: raise SynapseError(400, "Invalid password") password_bytes = password.encode("utf-8") if b"\x00" in password_bytes: raise SynapseError(400, "Invalid password") password_hash = await self.auth_handler.hash(password) admin = body.get("admin", None) user_type = body.get("user_type", None) if user_type is not None and user_type not in UserTypes.ALL_USER_TYPES: raise SynapseError(400, "Invalid user type") got_mac = body["mac"] want_mac_builder = hmac.new( key=self.hs.config.registration_shared_secret.encode(), digestmod=hashlib.sha1, ) want_mac_builder.update(nonce.encode("utf8")) want_mac_builder.update(b"\x00") want_mac_builder.update(username) want_mac_builder.update(b"\x00") want_mac_builder.update(password_bytes) want_mac_builder.update(b"\x00") want_mac_builder.update(b"admin" if admin else b"notadmin") if user_type: want_mac_builder.update(b"\x00") want_mac_builder.update(user_type.encode("utf8")) want_mac = want_mac_builder.hexdigest() if not hmac.compare_digest(want_mac.encode("ascii"), got_mac.encode("ascii")): raise SynapseError(403, "HMAC incorrect") # Reuse the parts of RegisterRestServlet to reduce code duplication from synapse.rest.client.v2_alpha.register import RegisterRestServlet register = RegisterRestServlet(self.hs) user_id = await register.registration_handler.register_user( localpart=body["username"].lower(), password_hash=password_hash, admin=bool(admin), user_type=user_type, ) result = await register._create_registration_details(user_id, body) return 200, result
def on_POST(self, request): self._clear_old_nonces() if not self.hs.config.registration_shared_secret: raise SynapseError(400, "Shared secret registration is not enabled") body = parse_json_object_from_request(request) if "nonce" not in body: raise SynapseError( 400, "nonce must be specified", errcode=Codes.BAD_JSON, ) nonce = body["nonce"] if nonce not in self.nonces: raise SynapseError( 400, "unrecognised nonce", ) # Delete the nonce, so it can't be reused, even if it's invalid del self.nonces[nonce] if "username" not in body: raise SynapseError( 400, "username must be specified", errcode=Codes.BAD_JSON, ) else: if ( not isinstance(body['username'], text_type) or len(body['username']) > 512 ): raise SynapseError(400, "Invalid username") username = body["username"].encode("utf-8") if b"\x00" in username: raise SynapseError(400, "Invalid username") if "password" not in body: raise SynapseError( 400, "password must be specified", errcode=Codes.BAD_JSON, ) else: if ( not isinstance(body['password'], text_type) or len(body['password']) > 512 ): raise SynapseError(400, "Invalid password") password = body["password"].encode("utf-8") if b"\x00" in password: raise SynapseError(400, "Invalid password") admin = body.get("admin", None) user_type = body.get("user_type", None) if user_type is not None and user_type not in UserTypes.ALL_USER_TYPES: raise SynapseError(400, "Invalid user type") got_mac = body["mac"] want_mac = hmac.new( key=self.hs.config.registration_shared_secret.encode(), digestmod=hashlib.sha1, ) want_mac.update(nonce.encode('utf8')) want_mac.update(b"\x00") want_mac.update(username) want_mac.update(b"\x00") want_mac.update(password) want_mac.update(b"\x00") want_mac.update(b"admin" if admin else b"notadmin") if user_type: want_mac.update(b"\x00") want_mac.update(user_type.encode('utf8')) want_mac = want_mac.hexdigest() if not hmac.compare_digest( want_mac.encode('ascii'), got_mac.encode('ascii') ): raise SynapseError(403, "HMAC incorrect") # Reuse the parts of RegisterRestServlet to reduce code duplication from synapse.rest.client.v2_alpha.register import RegisterRestServlet register = RegisterRestServlet(self.hs) (user_id, _) = yield register.registration_handler.register( localpart=body['username'].lower(), password=body["password"], admin=bool(admin), generate_token=False, user_type=user_type, ) result = yield register._create_registration_details(user_id, body) defer.returnValue((200, result))
class RegisterRestServletTestCase(unittest.TestCase): def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register' ) self.request.args = {} self.request.requestHeaders.getRawHeaders = mock_getRawHeaders() self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: self.appservice) ) self.auth_result = failure.Failure(InteractiveAuthIncompleteError(None)) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x, y, z: self.auth_result), get_session_data=Mock(return_value=None) ) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() self.device_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.get_auth_handler = Mock(return_value=self.auth_handler) self.hs.get_device_handler = Mock(return_value=self.device_handler) self.hs.config.enable_registration = True self.hs.config.auto_join_rooms = [] # init the thing we're testing self.servlet = RegisterRestServlet(self.hs) @defer.inlineCallbacks def test_POST_appservice_registration_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = { "id": "1234" } self.registration_handler.appservice_register = Mock( return_value=user_id ) self.auth_handler.get_access_token_for_user_id = Mock( return_value=token ) (code, result) = yield self.servlet.on_POST(self.request) self.assertEquals(code, 200) det_data = { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname } self.assertDictContainsSubset(det_data, result) @defer.inlineCallbacks def test_POST_appservice_registration_invalid(self): self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = None # no application service exists result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (401, None)) def test_POST_bad_password(self): self.request_data = json.dumps({ "username": "******", "password": 666 }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) def test_POST_bad_username(self): self.request_data = json.dumps({ "username": 777, "password": "******" }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) @defer.inlineCallbacks def test_POST_user_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" device_id = "frogfone" self.request_data = json.dumps({ "username": "******", "password": "******", "device_id": device_id, }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (None, { "username": "******", "password": "******" }, None) self.registration_handler.register = Mock(return_value=(user_id, None)) self.auth_handler.get_access_token_for_user_id = Mock( return_value=token ) self.device_handler.check_device_registered = \ Mock(return_value=device_id) (code, result) = yield self.servlet.on_POST(self.request) self.assertEquals(code, 200) det_data = { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname, "device_id": device_id, } self.assertDictContainsSubset(det_data, result) self.auth_handler.get_login_tuple_for_user_id( user_id, device_id=device_id, initial_device_display_name=None) def test_POST_disabled_registration(self): self.hs.config.enable_registration = False self.request_data = json.dumps({ "username": "******", "password": "******" }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (None, { "username": "******", "password": "******" }, None) self.registration_handler.register = Mock(return_value=("@user:id", "t")) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError)
class RegisterRestServletTestCase(unittest.TestCase): def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register' ) self.request.args = {} self.request.requestHeaders.getRawHeaders = mock_getRawHeaders() self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: self.appservice) ) self.auth_result = failure.Failure(InteractiveAuthIncompleteError(None)) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x, y, z: self.auth_result), get_session_data=Mock(return_value=None) ) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() self.device_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.get_auth_handler = Mock(return_value=self.auth_handler) self.hs.get_device_handler = Mock(return_value=self.device_handler) self.hs.config.enable_registration = True self.hs.config.registrations_require_3pid = [] self.hs.config.auto_join_rooms = [] # init the thing we're testing self.servlet = RegisterRestServlet(self.hs) @defer.inlineCallbacks def test_POST_appservice_registration_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = { "id": "1234" } self.registration_handler.appservice_register = Mock( return_value=user_id ) self.auth_handler.get_access_token_for_user_id = Mock( return_value=token ) (code, result) = yield self.servlet.on_POST(self.request) self.assertEquals(code, 200) det_data = { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname } self.assertDictContainsSubset(det_data, result) @defer.inlineCallbacks def test_POST_appservice_registration_invalid(self): self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = None # no application service exists result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (401, None)) def test_POST_bad_password(self): self.request_data = json.dumps({ "username": "******", "password": 666 }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) def test_POST_bad_username(self): self.request_data = json.dumps({ "username": 777, "password": "******" }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) @defer.inlineCallbacks def test_POST_user_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" device_id = "frogfone" self.request_data = json.dumps({ "username": "******", "password": "******", "device_id": device_id, }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (None, { "username": "******", "password": "******" }, None) self.registration_handler.register = Mock(return_value=(user_id, None)) self.auth_handler.get_access_token_for_user_id = Mock( return_value=token ) self.device_handler.check_device_registered = \ Mock(return_value=device_id) (code, result) = yield self.servlet.on_POST(self.request) self.assertEquals(code, 200) det_data = { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname, "device_id": device_id, } self.assertDictContainsSubset(det_data, result) self.auth_handler.get_login_tuple_for_user_id( user_id, device_id=device_id, initial_device_display_name=None) def test_POST_disabled_registration(self): self.hs.config.enable_registration = False self.request_data = json.dumps({ "username": "******", "password": "******" }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (None, { "username": "******", "password": "******" }, None) self.registration_handler.register = Mock(return_value=("@user:id", "t")) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError)
class RegisterRestServletTestCase(unittest.TestCase): def setUp(self): # do the dance to hook up request data to self.request_data self.request_data = "" self.request = Mock( content=Mock(read=Mock(side_effect=lambda: self.request_data)), path='/_matrix/api/v2_alpha/register' ) self.request.args = {} self.appservice = None self.auth = Mock(get_appservice_by_req=Mock( side_effect=lambda x: defer.succeed(self.appservice)) ) self.auth_result = (False, None, None) self.auth_handler = Mock( check_auth=Mock(side_effect=lambda x,y,z: self.auth_result) ) self.registration_handler = Mock() self.identity_handler = Mock() self.login_handler = Mock() # do the dance to hook it up to the hs global self.handlers = Mock( auth_handler=self.auth_handler, registration_handler=self.registration_handler, identity_handler=self.identity_handler, login_handler=self.login_handler ) self.hs = Mock() self.hs.hostname = "superbig~testing~thing.com" self.hs.get_auth = Mock(return_value=self.auth) self.hs.get_handlers = Mock(return_value=self.handlers) self.hs.config.disable_registration = False # init the thing we're testing self.servlet = RegisterRestServlet(self.hs) @defer.inlineCallbacks def test_POST_appservice_registration_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = { "id": "1234" } self.registration_handler.appservice_register = Mock( return_value=(user_id, token) ) result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (200, { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname })) @defer.inlineCallbacks def test_POST_appservice_registration_invalid(self): self.request.args = { "access_token": "i_am_an_app_service" } self.request_data = json.dumps({ "username": "******" }) self.appservice = None # no application service exists result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (401, None)) def test_POST_bad_password(self): self.request_data = json.dumps({ "username": "******", "password": 666 }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) def test_POST_bad_username(self): self.request_data = json.dumps({ "username": 777, "password": "******" }) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError) @defer.inlineCallbacks def test_POST_user_valid(self): user_id = "@kermit:muppet" token = "kermits_access_token" self.request_data = json.dumps({ "username": "******", "password": "******" }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (True, None, { "username": "******", "password": "******" }) self.registration_handler.register = Mock(return_value=(user_id, token)) result = yield self.servlet.on_POST(self.request) self.assertEquals(result, (200, { "user_id": user_id, "access_token": token, "home_server": self.hs.hostname })) def test_POST_disabled_registration(self): self.hs.config.disable_registration = True self.request_data = json.dumps({ "username": "******", "password": "******" }) self.registration_handler.check_username = Mock(return_value=True) self.auth_result = (True, None, { "username": "******", "password": "******" }) self.registration_handler.register = Mock(return_value=("@user:id", "t")) d = self.servlet.on_POST(self.request) return self.assertFailure(d, SynapseError)