def _test_handle_template(self,
client_id,
redirect_uri,
scope,
state,
encrypted_login,
expected_redirect=None,
encrypted_access=None,
redirect_qparam=None):
'''This method provides a template for testing handle_grant method from implicit grant provider.'''
if not encrypted_access:
encrypted_access = "encrypted access token"
if not expected_redirect:
scope = scope or ""
state = state or ""
expected_redirect = "%s#access_token=%s&state=%s&token_type=access&expires_in=%s&scope=%s" % \
(redirect_uri, encrypted_access,
urllib.parse.quote(state), self._EXPIRES_IN,
urllib.parse.quote(scope))
login_token = Token({"user_id": 1})
access_token = Token({"type": "access"})
request = Mock()
request.params = {
"client_id": client_id,
"redirect_uri": redirect_uri,
"scope": scope,
"state": state,
"login_token": encrypted_login,
"redirect": redirect_qparam
}
self._tokens_service.decrypt = Mock(return_value=login_token)
self._tokens_service.generate = Mock(return_value=access_token)
self._tokens_service.encrypt = Mock(return_value=encrypted_access)
response = self._handler.handle_grant(request)
if not redirect_qparam:
self.assertIsInstance(response, RedirectResponse)
else:
self.assertIsInstance(response, Response)
self.assertEqual(expected_redirect, response.headers.get("Location"))
self._tokens_service.decrypt.assert_called_once_with(encrypted_login)
self._tokens_service.validate.assert_called_once_with(login_token)
self._tokens_service.generate.assert_called_once_with(
{
"client_id": client_id,
"user_id": login_token.user_id,
"scopes": scope,
"expires_in": self._EXPIRES_IN
}, TokenGeneratorFactory.ACCESS_TOKEN)
self._tokens_service.encrypt.assert_called_once_with(
access_token, client_id)
def _test_exception_form(self, ex, error, description, uri, return_url, expected_url=None):
'''This method provides a test case template for application/x-www-form-urlencoded exception handling.'''
if not expected_url:
expected_url = "%s&error=%s&error_description=%s&error_uri=%s" % \
(return_url, error, description, urllib.parse.quote(uri))
request = Mock()
request.params = {"error_format": ExceptionFormattersFactory.HASH,
"redirect_uri": return_url}
environ = {"fantastico.request": request}
start_response = Mock()
app = Mock(side_effect=ex)
middleware = OAuth2ExceptionsMiddleware(app, settings_facade_cls=self._mock_settings_facade())
body = middleware(environ, start_response)
self.assertIsNotNone(body)
self.assertEqual(b'', body[0])
app.assert_called_once_with(environ, start_response)
start_response.assert_called_once_with("302 Found", [("Location", expected_url),
('Content-Type', 'text/html'),
('Content-Length', '0'),
("Access-Control-Allow-Origin", "*"),
("Access-Control-Allow-Methods", "OPTIONS,GET,POST,PUT,DELETE")])
def test_error_redirect(self):
'''This test case ensures a redirect response is sent if the implicit handler request contains error query parameter.
This case occurs only when authentication fails.'''
request = Mock()
request.params = {
"client_id": "sample-app",
"redirect_uri": "/sample/cb",
"state": "xyz",
"error": "access_denied",
"error_description": "Simple error.",
"error_uri": "/sample/uri/122.html"
}
response = self._handler.handle_grant(request)
self.assertIsInstance(response, RedirectResponse)
expected_redirect = "%s#error=%s&error_description=%s&error_uri=%s&state=%s" % \
(request.params["redirect_uri"],
request.params["error"],
urllib.parse.quote(request.params["error_description"]),
urllib.parse.quote(request.params["error_uri"]), request.params["state"])
self.assertEqual(expected_redirect, response.headers["Location"])
def test_3login_flow(self):
ver_code_of_last_user, last_uid = DBSession.query(User.ver_code, User.id).all()[-1]
self.assert_(ver_code_of_last_user, 'Wrong order of tests')
req = DummyRequest(path='linkedin_confirm/%s' % ver_code_of_last_user,
matchdict={'code': ver_code_of_last_user}, user=self.founder)
auth_uids = []
confirm_acc.remember = lambda x, y: auth_uids.append(y)
ret = confirm_acc.linkedin_confirm_view(req)
self.assert_(last_uid in auth_uids, 'User should be logged in')
self.assert_(isinstance(ret, HTTPFound), 'Should redirect to linkedin')
# now test the linkedin return but mock out all the linkedin credential checks
req2 = Mock()
req2.params = {'code': 'test'}
req2.authenticated_userid = last_uid
login.get_oauth_flow_linkedin = Mock()
login.requests = Mock()
linkedin_user_resp = Mock()
linkedin_email = '*****@*****.**'
linkedin_user_resp.json = {'id': 'dummyLinkedinID', 'emailAddress': linkedin_email}
login.requests.get = lambda *x, **k: linkedin_user_resp
login.check_csrf_token = Mock()
# end of mocks
self.assert_(self.get_linkedin_email_db(last_uid) != linkedin_email, 'Linkedin email should not be set yet')
ret = login.oauthcallback_view(req2)
# oauth callback view calls complete_confirm_acc
self.assert_(isinstance(ret, HTTPFound), 'Should redirect to profile')
self.assert_(self.get_linkedin_email_db(last_uid) == linkedin_email,
'Linkedin email should be set by complete_confirm_acc')
def test_show_login_ok(self):
'''This test case ensures login screen is displayed correctly when all required parameters are passed.'''
redirect_param_name = self._idp_controller.REDIRECT_PARAM
request = Mock()
request.params = {redirect_param_name: "/simple/test"}
self._idp_controller.load_template = Mock(return_value="cool result")
response = self._idp_controller.show_login(request)
self.assertIsNotNone(response)
self.assertEqual(200, response.status_code)
self.assertIsNotNone(response.body)
body = response.body.decode()
self.assertEqual("cool result", body)
self._idp_controller.load_template.assert_called_once_with(
self._TPL_LOGIN, {
redirect_param_name:
urllib.parse.quote(request.params[redirect_param_name])
},
enable_global_folder=True)
def _test_authorize_template(self, response_type="supported_grant", factory_ex=None, handler_ex=None):
'''This method provides a template method for testing handle_authorize method from oauth2 controller.'''
expected_response = Mock()
client_facade = Mock()
client_facade.session = Mock()
request = Mock()
request.params = {"response_type": response_type}
request.models = Mock()
request.models.Client = client_facade
grant_handler = Mock()
if not handler_ex:
grant_handler.handle_grant = Mock(return_value=expected_response)
else:
grant_handler.handle_grant = Mock(side_effect=handler_ex)
if not factory_ex:
self._handlers_factory.get_handler = Mock(return_value=grant_handler)
else:
self._handlers_factory.get_handler = Mock(side_effect=factory_ex)
response = self._oauth2_controller.handle_authorize(request)
self.assertEqual(expected_response, response)
self._handlers_factory.get_handler.assert_called_once_with("supported_grant", client_facade.session)
grant_handler.handle_grant.assert_called_once_with(request)
def test_get_collection_default_values_emptyresult(self):
'''This test case ensures get collection works as expected without any query parameters passed. It ensures
empty items returns correct '''
self._controller.validate_security_context = Mock(return_value=None)
expected_records = []
expected_records_count = 0
version = "1.0"
resource_url = "/sample-resources"
request = Mock()
request.params = {}
resource = Mock()
resource.user_dependent = False
resource.model = Mock()
self._mock_model_facade(records=expected_records, records_count=expected_records_count)
self._resources_registry.find_by_url = Mock(return_value=resource)
response = self._controller.get_collection(request, version, resource_url)
self._assert_get_collection_response(request, response,
records=expected_records,
records_count=expected_records_count,
offset=self._controller.OFFSET_DEFAULT,
limit=self._controller.LIMIT_DEFAULT)
self._resources_registry.find_by_url.assert_called_once_with(resource_url, float(version))
self._json_serializer_cls.assert_called_once_with(resource)
def _test_exception_json(self, ex):
'''This method provides a template test case for ensuring invalid request error response is correctly built.'''
request = Mock()
request.params = {}
environ = {"fantastico.request": request}
start_response = Mock()
app = Mock(side_effect=ex)
middleware = OAuth2ExceptionsMiddleware(app, settings_facade_cls=self._mock_settings_facade())
body = middleware(environ, start_response)
self.assertIsNotNone(body)
content_length = len(body[0])
body = json.loads(body[0].decode())
app.assert_called_once_with(environ, start_response)
http_code = ex.http_code
if http_code >= 500:
http_code = 400
http_code = "%s %s" % (http_code, status_reasons[http_code])
start_response.assert_called_once_with(http_code, [("Content-Type", "application/json; charset=UTF-8"),
("Content-Length", str(content_length)),
("Access-Control-Allow-Origin", "*"),
("Access-Control-Allow-Methods", "OPTIONS,GET,POST,PUT,DELETE")])
return body
def _mock_module(self):
mock_module = Mock()
mock_module.params = {'gather_subset': self.gather_subset,
'gather_timeout': 10,
'filter': '*'}
mock_module.get_bin_path = Mock(return_value='/usr/bin/lsb_release')
mock_module.run_command = Mock(return_value=(0, lsb_release_a_fedora_output, ''))
return mock_module
def _mock_module(self):
mock_module = Mock()
mock_module.params = {'gather_subset': self.gather_subset,
'gather_timeout': 10,
'filter': '*'}
mock_module.get_bin_path = Mock(return_value='/not/actually/facter')
mock_module.run_command = Mock(return_value=(0, facter_json_output, ''))
return mock_module
def mock_module():
mock_module = Mock()
mock_module.params = {
'gather_subset': ['all'],
'gather_timeout': 5,
'filter': '*'
}
mock_module.get_bin_path = Mock(return_value=None)
return mock_module
def _mock_module(self):
mock_module = Mock()
mock_module.params = {
'gather_subset': self.gather_subset,
'gather_timeout': 5,
'filter': '*'
}
mock_module.get_bin_path = Mock(return_value=None)
return mock_module
def test_get_collection_first_page(self):
'''This test case ensures get collection can return first page populated with items. In addition it ensures
filtering and sorting is supported.'''
self._controller.validate_security_context = Mock(return_value=None)
expected_fields = "name,description"
expected_records = [{"name": "Resource 1", "description": ""},
{"name": "Resource 2", "description": ""}]
expected_records_count = 3
expected_filter = Mock()
expected_sort = Mock()
version = "latest"
resource_url = "/sample-resources"
request = Mock()
request.params = {"offset": "0", "limit": "2",
"filter": "like(name, \"resource 1\")",
"order": "asc(name)",
"fields": expected_fields}
resource = Mock()
resource.user_dependent = False
resource.model = Mock()
self._query_parser.parse_filter = Mock(return_value=expected_filter)
self._query_parser.parse_sort = Mock(return_value=expected_sort)
self._mock_model_facade(records=expected_records, records_count=expected_records_count)
self._model_facade.get_records_paged = Mock(return_value=expected_records)
self._model_facade.count_records = Mock(return_value=expected_records_count)
self._resources_registry.find_by_url = Mock(return_value=resource)
def mock_serialize(model, fields):
self.assertEqual(expected_fields, fields)
return model
self._json_serializer.serialize = mock_serialize
response = self._controller.get_collection(request, version, resource_url)
self._assert_get_collection_response(request, response,
records=expected_records,
records_count=expected_records_count,
offset=0,
limit=2,
expected_filter=expected_filter,
expected_sort=expected_sort)
self._resources_registry.find_by_url.assert_called_once_with(resource_url, version)
self._json_serializer_cls.assert_called_once_with(resource)
self._query_parser.parse_filter.assert_called_once_with(request.params["filter"], resource.model)
self._query_parser.parse_sort.assert_called_once_with([request.params["order"]], resource.model)
def _mock_module(self):
mock_module = Mock()
mock_module.params = {
'gather_subset': self.gather_subset,
'gather_timeout': 10,
'filter': '*'
}
mock_module.get_bin_path = Mock(return_value='/usr/sbin/capsh')
mock_module.run_command = Mock(return_value=(0, 'Current: =ep', ''))
return mock_module
def test_get_item_ok(self):
'''This test case ensures an item can be correctly retrieved from collection.'''
self._controller.validate_security_context = Mock(return_value=None)
url = "/simple-resources"
version = "1.0"
fields = "id,name,description"
model = Mock()
resource = Resource(name="Mock Simple Resource",
url=url,
version=float(version))
resource(MockSimpleResourceRoa, self._resources_registry)
request = Mock()
request.params = {"fields": fields}
resource_id = 1986
expected_body = {
"id": resource_id,
"name": "Test resource",
"description": "Simple description."
}
self._resources_registry.find_by_url = Mock(return_value=resource)
self._model_facade.model_pk_cols = [MockSimpleResourceRoa.id]
self._model_facade.find_by_pk = Mock(return_value=model)
self._json_serializer.serialize = Mock(return_value=expected_body)
response = self._controller.get_item(request, version, url,
resource_id)
self.assertIsNotNone(response)
self.assertEqual(200, response.status_code)
self.assertEqual("application/json", response.content_type)
self._assert_cors_headers(response)
self.assertIsNotNone(response.body)
body = json.loads(response.body.decode())
self.assertEqual(expected_body, body)
self._resources_registry.find_by_url.assert_called_once_with(
url, float(version))
self._model_facade.find_by_pk.assert_called_once_with(
{MockSimpleResourceRoa.id: resource_id})
self._json_serializer_cls.assert_called_once_with(resource)
self._json_serializer.serialize(model, fields)
self._controller.validate_security_context.assert_called_once_with(
request, "read")
def test_validates_with_correct_request_param(self):
"""Requests validate OK when they have the correct ``_csrf``."""
from ..csrf import CSRFError
mock_request = Mock()
mock_request.method = 'a'
mock_request.params = {'_csrf': 'token'}
validator = self.makeOne('token', target_methods=['a'])
retval = validator.validate(mock_request)
self.assertTrue(retval is None)
def test_show_login_missingreturn(self):
'''This test case ensures login screen is not displayed if return_url query parameter is not provided.'''
request = Mock()
request.params = {}
for return_url in [None, "", " "]:
request.params[self._idp_controller.REDIRECT_PARAM] = return_url
with self.assertRaises(OAuth2MissingQueryParamError) as ctx:
self._idp_controller.show_login(request)
self.assertEqual(self._idp_controller.REDIRECT_PARAM, ctx.exception.param_name)
def mock_module(gather_subset=None, filter=None):
if gather_subset is None:
gather_subset = ['all', '!facter', '!ohai']
if filter is None:
filter = '*'
mock_module = Mock()
mock_module.params = {
'gather_subset': gather_subset,
'gather_timeout': 5,
'filter': filter
}
mock_module.get_bin_path = Mock(return_value=None)
return mock_module
def test_show_login_missingreturn(self):
'''This test case ensures login screen is not displayed if return_url query parameter is not provided.'''
request = Mock()
request.params = {}
for return_url in [None, "", " "]:
request.params[self._idp_controller.REDIRECT_PARAM] = return_url
with self.assertRaises(OAuth2MissingQueryParamError) as ctx:
self._idp_controller.show_login(request)
self.assertEqual(self._idp_controller.REDIRECT_PARAM,
ctx.exception.param_name)
def test_raises_csrf_error_with_wrong_request_param(self):
"""Requests must have the right ``_csrf``."""
from ..csrf import CSRFError
mock_request = Mock()
mock_request.method = 'a'
mock_request.params = {'_csrf': 'wrong'}
validator = self.makeOne('token', target_methods=['a'])
self.assertRaises(
CSRFError,
validator.validate,
mock_request
)
def test_get_item_ok(self):
'''This test case ensures an item can be correctly retrieved from collection.'''
self._controller.validate_security_context = Mock(return_value=None)
url = "/simple-resources"
version = "1.0"
fields = "id,name,description"
model = Mock()
resource = Resource(name="Mock Simple Resource", url=url,
version=float(version))
resource(MockSimpleResourceRoa, self._resources_registry)
request = Mock()
request.params = {"fields": fields}
resource_id = 1986
expected_body = {"id": resource_id,
"name": "Test resource",
"description": "Simple description."}
self._resources_registry.find_by_url = Mock(return_value=resource)
self._model_facade.model_pk_cols = [MockSimpleResourceRoa.id]
self._model_facade.find_by_pk = Mock(return_value=model)
self._json_serializer.serialize = Mock(return_value=expected_body)
response = self._controller.get_item(request, version, url, resource_id)
self.assertIsNotNone(response)
self.assertEqual(200, response.status_code)
self.assertEqual("application/json", response.content_type)
self._assert_cors_headers(response)
self.assertIsNotNone(response.body)
body = json.loads(response.body.decode())
self.assertEqual(expected_body, body)
self._resources_registry.find_by_url.assert_called_once_with(url, float(version))
self._model_facade.find_by_pk.assert_called_once_with({MockSimpleResourceRoa.id: resource_id})
self._json_serializer_cls.assert_called_once_with(resource)
self._json_serializer.serialize(model, fields)
self._controller.validate_security_context.assert_called_once_with(request, "read")
def _test_handle_template(self, client_id, redirect_uri, scope, state, encrypted_login, expected_redirect=None,
encrypted_access=None, redirect_qparam=None):
'''This method provides a template for testing handle_grant method from implicit grant provider.'''
if not encrypted_access:
encrypted_access = "encrypted access token"
if not expected_redirect:
scope = scope or ""
state = state or ""
expected_redirect = "%s#access_token=%s&state=%s&token_type=access&expires_in=%s&scope=%s" % \
(redirect_uri, encrypted_access,
urllib.parse.quote(state), self._EXPIRES_IN,
urllib.parse.quote(scope))
login_token = Token({"user_id": 1})
access_token = Token({"type": "access"})
request = Mock()
request.params = {"client_id": client_id,
"redirect_uri": redirect_uri,
"scope": scope,
"state": state,
"login_token": encrypted_login,
"redirect": redirect_qparam}
self._tokens_service.decrypt = Mock(return_value=login_token)
self._tokens_service.generate = Mock(return_value=access_token)
self._tokens_service.encrypt = Mock(return_value=encrypted_access)
response = self._handler.handle_grant(request)
if not redirect_qparam:
self.assertIsInstance(response, RedirectResponse)
else:
self.assertIsInstance(response, Response)
self.assertEqual(expected_redirect, response.headers.get("Location"))
self._tokens_service.decrypt.assert_called_once_with(encrypted_login)
self._tokens_service.validate.assert_called_once_with(login_token)
self._tokens_service.generate.assert_called_once_with({"client_id": client_id,
"user_id": login_token.user_id,
"scopes": scope,
"expires_in": self._EXPIRES_IN},
TokenGeneratorFactory.ACCESS_TOKEN)
self._tokens_service.encrypt.assert_called_once_with(access_token, client_id)
def test_get_collection_resource_notfound(self):
'''This test case ensures 404 is returned if we try to access a resource which does not exist.'''
url = "/resource-not-found"
version = "1.0"
request = Mock()
request.params = {}
self._settings_facade.get = Mock(return_value=self._doc_base)
self._resources_registry.find_by_url = Mock(return_value=None)
response = self._controller.get_collection(request, version, url)
self._assert_resource_error(response, 404, 10000, version, url)
self._resources_registry.find_by_url.assert_called_once_with(url, float(version))
def test_get_collection_resource_notfound(self):
'''This test case ensures 404 is returned if we try to access a resource which does not exist.'''
url = "/resource-not-found"
version = "1.0"
request = Mock()
request.params = {}
self._settings_facade.get = Mock(return_value=self._doc_base)
self._resources_registry.find_by_url = Mock(return_value=None)
response = self._controller.get_collection(request, version, url)
self._assert_resource_error(response, 404, 10000, version, url)
self._resources_registry.find_by_url.assert_called_once_with(
url, float(version))
def test_handle_grant_invalidredirect(self):
'''This test case ensures an exception is raised if the given redirect uri is not supported by the current client.'''
client_id = "abcd"
redirect_uri = "/abcduri"
request = Mock()
request.params = {"client_id": client_id,
"redirect_uri": redirect_uri,
"state": "xyz",
"scope": "a b c"}
self._client_repo.load_client_by_returnurl = Mock(return_value=None)
response = self._handler.handle_grant(request)
self.assertIsNotNone(response)
self.assertEqual(401, response.status_code)
self.assertTrue(response.body.decode().find(redirect_uri) > -1)
self._client_repo.load_client_by_returnurl.assert_called_once_with(redirect_uri)
def _mock_authenticate_dependencies(self, token, user, return_url):
'''This method mocks authenticate dependencies and returns them as a tuple object.'''
if return_url:
return_url_base = return_url
if return_url_base.find("?") > -1:
return_url_base = return_url_base[:return_url_base.find("?")]
clienturl_facade = Mock()
if return_url:
clienturl_facade.get_records_paged = Mock(
return_value=[return_url_base])
clienturl_facade.session = Mock()
request = Mock()
request.params = {
"username": user.username,
"password": user.password,
self._idp_controller.REDIRECT_PARAM: return_url
}
request.models = Mock()
request.models.ClientReturnUrl = clienturl_facade
request.redirect = lambda destination: RedirectResponse(destination)
user_repo = Mock()
user_repo.load_by_username = Mock(return_value=user)
user_repo_cls = Mock(return_value=user_repo)
self._hasher.hash_password = Mock(return_value="12345")
tokens_service = Mock()
tokens_service_cls = Mock(return_value=tokens_service)
tokens_service.generate = Mock(return_value=token)
tokens_service.encrypt = Mock(return_value="123")
return (request, user_repo_cls, user_repo, tokens_service_cls,
tokens_service, clienturl_facade)
def test_xmlhttprequests_headers(self):
"""``X-CSRFToken`` will be overriden by ``_csrf``."""
from ..csrf import CSRFError
mock_request = Mock()
mock_request.method = 'A'
mock_request.headers = {
'X-Requested-With': 'XMLHttpRequest',
'X-CSRFToken': 'wrong'
}
validator = self.makeOne('token', target_methods=['a'])
self.assertRaises(
CSRFError,
validator.validate,
mock_request
)
mock_request.params = {'_csrf': 'token'}
validator = self.makeOne('token', target_methods=['a'])
retval = validator.validate(mock_request)
self.assertTrue(retval is None)
def test_get_collection_default_values_emptyresult(self):
'''This test case ensures get collection works as expected without any query parameters passed. It ensures
empty items returns correct '''
self._controller.validate_security_context = Mock(return_value=None)
expected_records = []
expected_records_count = 0
version = "1.0"
resource_url = "/sample-resources"
request = Mock()
request.params = {}
resource = Mock()
resource.user_dependent = False
resource.model = Mock()
self._mock_model_facade(records=expected_records,
records_count=expected_records_count)
self._resources_registry.find_by_url = Mock(return_value=resource)
response = self._controller.get_collection(request, version,
resource_url)
self._assert_get_collection_response(
request,
response,
records=expected_records,
records_count=expected_records_count,
offset=self._controller.OFFSET_DEFAULT,
limit=self._controller.LIMIT_DEFAULT)
self._resources_registry.find_by_url.assert_called_once_with(
resource_url, float(version))
self._json_serializer_cls.assert_called_once_with(resource)
def test_error_redirect(self):
'''This test case ensures a redirect response is sent if the implicit handler request contains error query parameter.
This case occurs only when authentication fails.'''
request = Mock()
request.params = {"client_id": "sample-app",
"redirect_uri": "/sample/cb",
"state": "xyz",
"error": "access_denied",
"error_description": "Simple error.",
"error_uri": "/sample/uri/122.html"}
response = self._handler.handle_grant(request)
self.assertIsInstance(response, RedirectResponse)
expected_redirect = "%s#error=%s&error_description=%s&error_uri=%s&state=%s" % \
(request.params["redirect_uri"],
request.params["error"],
urllib.parse.quote(request.params["error_description"]),
urllib.parse.quote(request.params["error_uri"]), request.params["state"])
self.assertEqual(expected_redirect, response.headers["Location"])
def test_show_login_ok(self):
'''This test case ensures login screen is displayed correctly when all required parameters are passed.'''
redirect_param_name = self._idp_controller.REDIRECT_PARAM
request = Mock()
request.params = {redirect_param_name: "/simple/test"}
self._idp_controller.load_template = Mock(return_value="cool result")
response = self._idp_controller.show_login(request)
self.assertIsNotNone(response)
self.assertEqual(200, response.status_code)
self.assertIsNotNone(response.body)
body = response.body.decode()
self.assertEqual("cool result", body)
self._idp_controller.load_template.assert_called_once_with(
self._TPL_LOGIN,
{redirect_param_name: urllib.parse.quote(request.params[redirect_param_name])},
enable_global_folder=True)
def _mock_authenticate_dependencies(self, token, user, return_url):
'''This method mocks authenticate dependencies and returns them as a tuple object.'''
if return_url:
return_url_base = return_url
if return_url_base.find("?") > -1:
return_url_base = return_url_base[:return_url_base.find("?")]
clienturl_facade = Mock()
if return_url:
clienturl_facade.get_records_paged = Mock(return_value=[return_url_base])
clienturl_facade.session = Mock()
request = Mock()
request.params = {"username": user.username,
"password": user.password,
self._idp_controller.REDIRECT_PARAM: return_url}
request.models = Mock()
request.models.ClientReturnUrl = clienturl_facade
request.redirect = lambda destination: RedirectResponse(destination)
user_repo = Mock()
user_repo.load_by_username = Mock(return_value=user)
user_repo_cls = Mock(return_value=user_repo)
self._hasher.hash_password = Mock(return_value="12345")
tokens_service = Mock()
tokens_service_cls = Mock(return_value=tokens_service)
tokens_service.generate = Mock(return_value=token)
tokens_service.encrypt = Mock(return_value="123")
return (request, user_repo_cls, user_repo, tokens_service_cls, tokens_service, clienturl_facade)
def test_handle_grant_invalidredirect(self):
'''This test case ensures an exception is raised if the given redirect uri is not supported by the current client.'''
client_id = "abcd"
redirect_uri = "/abcduri"
request = Mock()
request.params = {
"client_id": client_id,
"redirect_uri": redirect_uri,
"state": "xyz",
"scope": "a b c"
}
self._client_repo.load_client_by_returnurl = Mock(return_value=None)
response = self._handler.handle_grant(request)
self.assertIsNotNone(response)
self.assertEqual(401, response.status_code)
self.assertTrue(response.body.decode().find(redirect_uri) > -1)
self._client_repo.load_client_by_returnurl.assert_called_once_with(
redirect_uri)
def test_get_collection_first_page(self):
'''This test case ensures get collection can return first page populated with items. In addition it ensures
filtering and sorting is supported.'''
self._controller.validate_security_context = Mock(return_value=None)
expected_fields = "name,description"
expected_records = [{
"name": "Resource 1",
"description": ""
}, {
"name": "Resource 2",
"description": ""
}]
expected_records_count = 3
expected_filter = Mock()
expected_sort = Mock()
version = "latest"
resource_url = "/sample-resources"
request = Mock()
request.params = {
"offset": "0",
"limit": "2",
"filter": "like(name, \"resource 1\")",
"order": "asc(name)",
"fields": expected_fields
}
resource = Mock()
resource.user_dependent = False
resource.model = Mock()
self._query_parser.parse_filter = Mock(return_value=expected_filter)
self._query_parser.parse_sort = Mock(return_value=expected_sort)
self._mock_model_facade(records=expected_records,
records_count=expected_records_count)
self._model_facade.get_records_paged = Mock(
return_value=expected_records)
self._model_facade.count_records = Mock(
return_value=expected_records_count)
self._resources_registry.find_by_url = Mock(return_value=resource)
def mock_serialize(model, fields):
self.assertEqual(expected_fields, fields)
return model
self._json_serializer.serialize = mock_serialize
response = self._controller.get_collection(request, version,
resource_url)
self._assert_get_collection_response(
request,
response,
records=expected_records,
records_count=expected_records_count,
offset=0,
limit=2,
expected_filter=expected_filter,
expected_sort=expected_sort)
self._resources_registry.find_by_url.assert_called_once_with(
resource_url, version)
self._json_serializer_cls.assert_called_once_with(resource)
self._query_parser.parse_filter.assert_called_once_with(
request.params["filter"], resource.model)
self._query_parser.parse_sort.assert_called_once_with(
[request.params["order"]], resource.model)
def create_ansible_mock_yaml(yaml_config):
mock_ansible = Mock()
mock_ansible.params = yaml.load(yaml_config)
return mock_ansible
def create_ansible_mock(params):
mock_ansible = Mock()
mock_ansible.params = params
return mock_ansible
