openstack/python-keystoneclient
Code Issues Proposed changes

Merge "Update requests-mock syntax"

Browse Source
This commit is contained in:
Jenkins
2015-01-28 02:54:37 +00:00
committed by Gerrit Code Review
parent 7fdd89d527 97e777840e
commit 0eab8ff920
12 changed files with 173 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
keystoneclient/tests/auth/test_identity_common.py
View File

@@ -114,7 +114,7 @@ class CommonIdentityTests(object):
# register responses such that if the discovery URL is hit more than # register responses such that if the discovery URL is hit more than
# once then the response will be invalid and not point to COMPUTE_ADMIN # once then the response will be invalid and not point to COMPUTE_ADMIN
resps = [{'json': self.TEST_DISCOVERY}, {'status_code': 500}] resps = [{'json': self.TEST_DISCOVERY}, {'status_code': 500}]
self.requests.register_uri('GET', self.TEST_COMPUTE_ADMIN, resps) self.requests.get(self.TEST_COMPUTE_ADMIN, resps)
body = 'SUCCESS' body = 'SUCCESS'
self.stub_url('GET', ['path'], text=body) self.stub_url('GET', ['path'], text=body)
@@ -139,7 +139,7 @@ class CommonIdentityTests(object):
# register responses such that if the discovery URL is hit more than # register responses such that if the discovery URL is hit more than
# once then the response will be invalid and not point to COMPUTE_ADMIN # once then the response will be invalid and not point to COMPUTE_ADMIN
resps = [{'json': self.TEST_DISCOVERY}, {'status_code': 500}] resps = [{'json': self.TEST_DISCOVERY}, {'status_code': 500}]
self.requests.register_uri('GET', self.TEST_COMPUTE_ADMIN, resps) self.requests.get(self.TEST_COMPUTE_ADMIN, resps)
body = 'SUCCESS' body = 'SUCCESS'
self.stub_url('GET', ['path'], text=body) self.stub_url('GET', ['path'], text=body)

3
keystoneclient/tests/auth/test_identity_v3.py
View File

@@ -431,8 +431,7 @@ class V3IdentityPlugin(utils.TestCase):
{'status_code': 200, 'json': self.TEST_RESPONSE_DICT, {'status_code': 200, 'json': self.TEST_RESPONSE_DICT,
'headers': {'X-Subject-Token': 'token2'}}] 'headers': {'X-Subject-Token': 'token2'}}]
self.requests.register_uri('POST', '%s/auth/tokens' % self.TEST_URL, self.requests.post('%s/auth/tokens' % self.TEST_URL, auth_responses)
auth_responses)
a = v3.Password(self.TEST_URL, username=self.TEST_USER, a = v3.Password(self.TEST_URL, username=self.TEST_USER,
password=self.TEST_PASS) password=self.TEST_PASS)

2
keystoneclient/tests/auth/test_token_endpoint.py
View File

@@ -23,7 +23,7 @@ class TokenEndpointTest(utils.TestCase):
TEST_URL = 'http://server/prefix' TEST_URL = 'http://server/prefix'
def test_basic_case(self): def test_basic_case(self):
self.requests.register_uri('GET', self.TEST_URL, text='body') self.requests.get(self.TEST_URL, text='body')
a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN) a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN)
s = session.Session(auth=a) s = session.Session(auth=a)

3
keystoneclient/tests/generic/test_client.py
View File

@@ -56,8 +56,7 @@ EXTENSION_LIST = _create_extension_list([EXTENSION_FOO, EXTENSION_BAR])
class ClientDiscoveryTests(utils.TestCase): class ClientDiscoveryTests(utils.TestCase):
def test_discover_extensions_v2(self): def test_discover_extensions_v2(self):
self.requests.register_uri('GET', "%s/extensions" % V2_URL, self.requests.get("%s/extensions" % V2_URL, text=EXTENSION_LIST)
text=EXTENSION_LIST)
extensions = client.Client().discover_extensions(url=V2_URL) extensions = client.Client().discover_extensions(url=V2_URL)
self.assertIn(EXTENSION_ALIAS_FOO, extensions) self.assertIn(EXTENSION_ALIAS_FOO, extensions)
self.assertEqual(extensions[EXTENSION_ALIAS_FOO], EXTENSION_NAME_FOO) self.assertEqual(extensions[EXTENSION_ALIAS_FOO], EXTENSION_NAME_FOO)

100
keystoneclient/tests/test_auth_token_middleware.py
View File

@@ -275,13 +275,11 @@ class MultiStepAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest,
# Get a token, then try to retrieve revocation list and get a 401. # Get a token, then try to retrieve revocation list and get a 401.
# Get a new token, try to retrieve revocation list and return 200. # Get a new token, try to retrieve revocation list and return 200.
self.requests.register_uri('POST', "%s/v2.0/tokens" % BASE_URI, self.requests.post("%s/v2.0/tokens" % BASE_URI, text=FAKE_ADMIN_TOKEN)
text=FAKE_ADMIN_TOKEN)
text = self.examples.SIGNED_REVOCATION_LIST text = self.examples.SIGNED_REVOCATION_LIST
self.requests.register_uri('GET', "%s/v2.0/tokens/revoked" % BASE_URI, self.requests.get("%s/v2.0/tokens/revoked" % BASE_URI,
response_list=[{'status_code': 401}, response_list=[{'status_code': 401}, {'text': text}])
{'text': text}])
fetched_list = jsonutils.loads(self.middleware.fetch_revocation_list()) fetched_list = jsonutils.loads(self.middleware.fetch_revocation_list())
self.assertEqual(fetched_list, self.examples.REVOCATION_LIST) self.assertEqual(fetched_list, self.examples.REVOCATION_LIST)
@@ -308,17 +306,17 @@ class DiabloAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest,
super(DiabloAuthTokenMiddlewareTest, self).setUp( super(DiabloAuthTokenMiddlewareTest, self).setUp(
expected_env=expected_env) expected_env=expected_env)
self.requests.register_uri('GET', "%s/" % BASE_URI, self.requests.get("%s/" % BASE_URI,
text=VERSION_LIST_v2, status_code=300) text=VERSION_LIST_v2,
status_code=300)
self.requests.register_uri('POST', "%s/v2.0/tokens" % BASE_URI, self.requests.post("%s/v2.0/tokens" % BASE_URI, text=FAKE_ADMIN_TOKEN)
text=FAKE_ADMIN_TOKEN)
self.token_id = self.examples.VALID_DIABLO_TOKEN self.token_id = self.examples.VALID_DIABLO_TOKEN
token_response = self.examples.JSON_TOKEN_RESPONSES[self.token_id] token_response = self.examples.JSON_TOKEN_RESPONSES[self.token_id]
url = '%s/v2.0/tokens/%s' % (BASE_URI, self.token_id) url = '%s/v2.0/tokens/%s' % (BASE_URI, self.token_id)
self.requests.register_uri('GET', url, text=token_response) self.requests.get(url, text=token_response)
self.set_middleware() self.set_middleware()
@@ -873,8 +871,7 @@ class CommonAuthTokenMiddlewareTest(object):
self.assertEqual(self.middleware.token_revocation_list, in_memory_list) self.assertEqual(self.middleware.token_revocation_list, in_memory_list)
def test_invalid_revocation_list_raises_service_error(self): def test_invalid_revocation_list_raises_service_error(self):
self.requests.register_uri('GET', '%s/v2.0/tokens/revoked' % BASE_URI, self.requests.get('%s/v2.0/tokens/revoked' % BASE_URI, text='{}')
text='{}')
self.assertRaises(auth_token.ServiceError, self.assertRaises(auth_token.ServiceError,
self.middleware.fetch_revocation_list) self.middleware.fetch_revocation_list)
@@ -889,8 +886,7 @@ class CommonAuthTokenMiddlewareTest(object):
# remember because we are testing the middleware we stub the connection # remember because we are testing the middleware we stub the connection
# to the keystone server, but this is not what gets returned # to the keystone server, but this is not what gets returned
invalid_uri = "%s/v2.0/tokens/invalid-token" % BASE_URI invalid_uri = "%s/v2.0/tokens/invalid-token" % BASE_URI
self.requests.register_uri('GET', invalid_uri, text="", self.requests.get(invalid_uri, text="", status_code=404)
status_code=404)
req = webob.Request.blank('/') req = webob.Request.blank('/')
req.headers['X-Auth-Token'] = 'invalid-token' req.headers['X-Auth-Token'] = 'invalid-token'
@@ -978,7 +974,7 @@ class CommonAuthTokenMiddlewareTest(object):
def test_memcache_set_invalid_uuid(self): def test_memcache_set_invalid_uuid(self):
invalid_uri = "%s/v2.0/tokens/invalid-token" % BASE_URI invalid_uri = "%s/v2.0/tokens/invalid-token" % BASE_URI
self.requests.register_uri('GET', invalid_uri, status_code=404) self.requests.get(invalid_uri, status_code=404)
req = webob.Request.blank('/') req = webob.Request.blank('/')
token = 'invalid-token' token = 'invalid-token'
@@ -1271,10 +1267,10 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest,
def test_request_no_token_dummy(self): def test_request_no_token_dummy(self):
cms._ensure_subprocess() cms._ensure_subprocess()
self.requests.register_uri('GET', "%s%s" % (BASE_URI, self.ca_path), self.requests.get("%s%s" % (BASE_URI, self.ca_path),
status_code=404) status_code=404)
url = "%s%s" % (BASE_URI, self.signing_path) url = "%s%s" % (BASE_URI, self.signing_path)
self.requests.register_uri('GET', url, status_code=404) self.requests.get(url, status_code=404)
self.assertRaises(exceptions.CertificateConfigError, self.assertRaises(exceptions.CertificateConfigError,
self.middleware.verify_signed_token, self.middleware.verify_signed_token,
self.examples.SIGNED_TOKEN_SCOPED, self.examples.SIGNED_TOKEN_SCOPED,
@@ -1283,7 +1279,7 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest,
def test_fetch_signing_cert(self): def test_fetch_signing_cert(self):
data = 'FAKE CERT' data = 'FAKE CERT'
url = '%s%s' % (BASE_URI, self.signing_path) url = '%s%s' % (BASE_URI, self.signing_path)
self.requests.register_uri('GET', url, text=data) self.requests.get(url, text=data)
self.middleware.fetch_signing_cert() self.middleware.fetch_signing_cert()
with open(self.middleware.signing_cert_file_name, 'r') as f: with open(self.middleware.signing_cert_file_name, 'r') as f:
@@ -1293,8 +1289,7 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest,
def test_fetch_signing_ca(self): def test_fetch_signing_ca(self):
data = 'FAKE CA' data = 'FAKE CA'
self.requests.register_uri('GET', "%s%s" % (BASE_URI, self.ca_path), self.requests.get("%s%s" % (BASE_URI, self.ca_path), text=data)
text=data)
self.middleware.fetch_ca_cert() self.middleware.fetch_ca_cert()
with open(self.middleware.signing_ca_file_name, 'r') as f: with open(self.middleware.signing_ca_file_name, 'r') as f:
@@ -1309,11 +1304,10 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest,
self.conf['auth_port'] = 1234 self.conf['auth_port'] = 1234
self.conf['auth_admin_prefix'] = '/newadmin/' self.conf['auth_admin_prefix'] = '/newadmin/'
self.requests.register_uri('GET', self.requests.get("%s/newadmin%s" % (BASE_HOST, self.ca_path),
"%s/newadmin%s" % (BASE_HOST, self.ca_path), text='FAKECA')
text='FAKECA')
url = "%s/newadmin%s" % (BASE_HOST, self.signing_path) url = "%s/newadmin%s" % (BASE_HOST, self.signing_path)
self.requests.register_uri('GET', url, text='FAKECERT') self.requests.get(url, text='FAKECERT')
self.set_middleware(conf=self.conf) self.set_middleware(conf=self.conf)
@@ -1332,11 +1326,9 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest,
self.conf['auth_port'] = 1234 self.conf['auth_port'] = 1234
self.conf['auth_admin_prefix'] = '' self.conf['auth_admin_prefix'] = ''
self.requests.register_uri('GET', "%s%s" % (BASE_HOST, self.ca_path), self.requests.get("%s%s" % (BASE_HOST, self.ca_path), text='FAKECA')
text='FAKECA') self.requests.get("%s%s" % (BASE_HOST, self.signing_path),
self.requests.register_uri('GET', "%s%s" % (BASE_HOST, text='FAKECERT')
self.signing_path),
text='FAKECERT')
self.set_middleware(conf=self.conf) self.set_middleware(conf=self.conf)
@@ -1408,14 +1400,15 @@ class v2AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest,
self.examples.REVOKED_TOKEN_HASH_SHA256, self.examples.REVOKED_TOKEN_HASH_SHA256,
} }
self.requests.register_uri('GET', "%s/" % BASE_URI, self.requests.get("%s/" % BASE_URI,
text=VERSION_LIST_v2, status_code=300) text=VERSION_LIST_v2,
status_code=300)
self.requests.register_uri('POST', "%s/v2.0/tokens" % BASE_URI, self.requests.post("%s/v2.0/tokens" % BASE_URI,
text=FAKE_ADMIN_TOKEN) text=FAKE_ADMIN_TOKEN)
self.requests.register_uri('GET', "%s/v2.0/tokens/revoked" % BASE_URI, self.requests.get("%s/v2.0/tokens/revoked" % BASE_URI,
text=self.examples.SIGNED_REVOCATION_LIST) text=self.examples.SIGNED_REVOCATION_LIST)
for token in (self.examples.UUID_TOKEN_DEFAULT, for token in (self.examples.UUID_TOKEN_DEFAULT,
self.examples.UUID_TOKEN_UNSCOPED, self.examples.UUID_TOKEN_UNSCOPED,
@@ -1425,14 +1418,11 @@ class v2AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest,
self.examples.SIGNED_TOKEN_SCOPED_KEY, self.examples.SIGNED_TOKEN_SCOPED_KEY,
self.examples.SIGNED_TOKEN_SCOPED_PKIZ_KEY,): self.examples.SIGNED_TOKEN_SCOPED_PKIZ_KEY,):
text = self.examples.JSON_TOKEN_RESPONSES[token] text = self.examples.JSON_TOKEN_RESPONSES[token]
self.requests.register_uri('GET', self.requests.get('%s/v2.0/tokens/%s' % (BASE_URI, token),
'%s/v2.0/tokens/%s' % (BASE_URI, token), text=text)
text=text)
self.requests.register_uri('GET', self.requests.get('%s/v2.0/tokens/%s' % (BASE_URI, ERROR_TOKEN),
'%s/v2.0/tokens/%s' % (BASE_URI, text=network_error_response)
ERROR_TOKEN),
text=network_error_response)
self.set_middleware() self.set_middleware()
@@ -1508,16 +1498,16 @@ class CrossVersionAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest,
'auth_version': 'v2.0' 'auth_version': 'v2.0'
} }
self.requests.register_uri('GET', '%s/' % BASE_URI, self.requests.get('%s/' % BASE_URI,
text=VERSION_LIST_v3, status_code=300) text=VERSION_LIST_v3,
status_code=300)
self.requests.register_uri('POST', '%s/v2.0/tokens' % BASE_URI, self.requests.post('%s/v2.0/tokens' % BASE_URI, text=FAKE_ADMIN_TOKEN)
text=FAKE_ADMIN_TOKEN)
token = self.examples.UUID_TOKEN_DEFAULT token = self.examples.UUID_TOKEN_DEFAULT
url = '%s/v2.0/tokens/%s' % (BASE_URI, token) url = '%s/v2.0/tokens/%s' % (BASE_URI, token)
response_body = self.examples.JSON_TOKEN_RESPONSES[token] response_body = self.examples.JSON_TOKEN_RESPONSES[token]
self.requests.register_uri('GET', url, text=response_body) self.requests.get(url, text=response_body)
self.set_middleware(conf=conf) self.set_middleware(conf=conf)
@@ -1589,20 +1579,18 @@ class v3AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest,
self.examples.REVOKED_v3_PKIZ_TOKEN_HASH, self.examples.REVOKED_v3_PKIZ_TOKEN_HASH,
} }
self.requests.register_uri('GET', BASE_URI, self.requests.get(BASE_URI, text=VERSION_LIST_v3, status_code=300)
text=VERSION_LIST_v3, status_code=300)
# TODO(jamielennox): auth_token middleware uses a v2 admin token # TODO(jamielennox): auth_token middleware uses a v2 admin token
# regardless of the auth_version that is set. # regardless of the auth_version that is set.
self.requests.register_uri('POST', '%s/v2.0/tokens' % BASE_URI, self.requests.post('%s/v2.0/tokens' % BASE_URI, text=FAKE_ADMIN_TOKEN)
text=FAKE_ADMIN_TOKEN)
# TODO(jamielennox): there is no v3 revocation url yet, it uses v2 # TODO(jamielennox): there is no v3 revocation url yet, it uses v2
self.requests.register_uri('GET', '%s/v2.0/tokens/revoked' % BASE_URI, self.requests.get('%s/v2.0/tokens/revoked' % BASE_URI,
text=self.examples.SIGNED_REVOCATION_LIST) text=self.examples.SIGNED_REVOCATION_LIST)
self.requests.register_uri('GET', '%s/v3/auth/tokens' % BASE_URI, self.requests.get('%s/v3/auth/tokens' % BASE_URI,
text=self.token_response) text=self.token_response)
self.set_middleware() self.set_middleware()

135
keystoneclient/tests/test_discovery.py
View File

@@ -242,7 +242,7 @@ class AvailableVersionsTests(utils.TestCase):
for path, text in six.iteritems(examples): for path, text in six.iteritems(examples):
url = "%s%s" % (BASE_URL, path) url = "%s%s" % (BASE_URL, path)
self.requests.register_uri('GET', url, status_code=300, text=text) self.requests.get(url, status_code=300, text=text)
versions = discover.available_versions(url) versions = discover.available_versions(url)
for v in versions: for v in versions:
@@ -252,8 +252,7 @@ class AvailableVersionsTests(utils.TestCase):
matchers.Contains(n))) matchers.Contains(n)))
def test_available_versions_individual(self): def test_available_versions_individual(self):
self.requests.register_uri('GET', V3_URL, status_code=200, self.requests.get(V3_URL, status_code=200, text=V3_VERSION_ENTRY)
text=V3_VERSION_ENTRY)
versions = discover.available_versions(V3_URL) versions = discover.available_versions(V3_URL)
@@ -264,8 +263,7 @@ class AvailableVersionsTests(utils.TestCase):
self.assertIn('links', v) self.assertIn('links', v)
def test_available_keystone_data(self): def test_available_keystone_data(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
versions = discover.available_versions(BASE_URL) versions = discover.available_versions(BASE_URL)
self.assertEqual(2, len(versions)) self.assertEqual(2, len(versions))
@@ -280,7 +278,7 @@ class AvailableVersionsTests(utils.TestCase):
def test_available_cinder_data(self): def test_available_cinder_data(self):
text = jsonutils.dumps(CINDER_EXAMPLES) text = jsonutils.dumps(CINDER_EXAMPLES)
self.requests.register_uri('GET', BASE_URL, status_code=300, text=text) self.requests.get(BASE_URL, status_code=300, text=text)
versions = discover.available_versions(BASE_URL) versions = discover.available_versions(BASE_URL)
self.assertEqual(2, len(versions)) self.assertEqual(2, len(versions))
@@ -296,7 +294,7 @@ class AvailableVersionsTests(utils.TestCase):
def test_available_glance_data(self): def test_available_glance_data(self):
text = jsonutils.dumps(GLANCE_EXAMPLES) text = jsonutils.dumps(GLANCE_EXAMPLES)
self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) self.requests.get(BASE_URL, status_code=200, text=text)
versions = discover.available_versions(BASE_URL) versions = discover.available_versions(BASE_URL)
self.assertEqual(5, len(versions)) self.assertEqual(5, len(versions))
@@ -313,10 +311,9 @@ class AvailableVersionsTests(utils.TestCase):
class ClientDiscoveryTests(utils.TestCase): class ClientDiscoveryTests(utils.TestCase):
def assertCreatesV3(self, **kwargs): def assertCreatesV3(self, **kwargs):
self.requests.register_uri('POST', self.requests.post('%s/auth/tokens' % V3_URL,
'%s/auth/tokens' % V3_URL, text=V3_AUTH_RESPONSE,
text=V3_AUTH_RESPONSE, headers={'X-Subject-Token': V3_TOKEN})
headers={'X-Subject-Token': V3_TOKEN})
kwargs.setdefault('username', 'foo') kwargs.setdefault('username', 'foo')
kwargs.setdefault('password', 'bar') kwargs.setdefault('password', 'bar')
@@ -325,8 +322,7 @@ class ClientDiscoveryTests(utils.TestCase):
return keystone return keystone
def assertCreatesV2(self, **kwargs): def assertCreatesV2(self, **kwargs):
self.requests.register_uri('POST', "%s/tokens" % V2_URL, self.requests.post("%s/tokens" % V2_URL, text=V2_AUTH_RESPONSE)
text=V2_AUTH_RESPONSE)
kwargs.setdefault('username', 'foo') kwargs.setdefault('username', 'foo')
kwargs.setdefault('password', 'bar') kwargs.setdefault('password', 'bar')
@@ -349,89 +345,73 @@ class ClientDiscoveryTests(utils.TestCase):
client.Client, **kwargs) client.Client, **kwargs)
def test_discover_v3(self): def test_discover_v3(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
self.assertCreatesV3(auth_url=BASE_URL) self.assertCreatesV3(auth_url=BASE_URL)
def test_discover_v2(self): def test_discover_v2(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V2_VERSION_LIST)
text=V2_VERSION_LIST) self.requests.post("%s/tokens" % V2_URL, text=V2_AUTH_RESPONSE)
self.requests.register_uri('POST', "%s/tokens" % V2_URL,
text=V2_AUTH_RESPONSE)
self.assertCreatesV2(auth_url=BASE_URL) self.assertCreatesV2(auth_url=BASE_URL)
def test_discover_endpoint_v2(self): def test_discover_endpoint_v2(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V2_VERSION_LIST)
text=V2_VERSION_LIST)
self.assertCreatesV2(endpoint=BASE_URL, token='fake-token') self.assertCreatesV2(endpoint=BASE_URL, token='fake-token')
def test_discover_endpoint_v3(self): def test_discover_endpoint_v3(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
self.assertCreatesV3(endpoint=BASE_URL, token='fake-token') self.assertCreatesV3(endpoint=BASE_URL, token='fake-token')
def test_discover_invalid_major_version(self): def test_discover_invalid_major_version(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
self.assertVersionNotAvailable(auth_url=BASE_URL, version=5) self.assertVersionNotAvailable(auth_url=BASE_URL, version=5)
def test_discover_200_response_fails(self): def test_discover_200_response_fails(self):
self.requests.register_uri('GET', BASE_URL, self.requests.get(BASE_URL, text='ok')
status_code=200, text='ok')
self.assertDiscoveryFailure(auth_url=BASE_URL) self.assertDiscoveryFailure(auth_url=BASE_URL)
def test_discover_minor_greater_than_available_fails(self): def test_discover_minor_greater_than_available_fails(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
self.assertVersionNotAvailable(endpoint=BASE_URL, version=3.4) self.assertVersionNotAvailable(endpoint=BASE_URL, version=3.4)
def test_discover_individual_version_v2(self): def test_discover_individual_version_v2(self):
self.requests.register_uri('GET', V2_URL, status_code=200, self.requests.get(V2_URL, text=V2_VERSION_ENTRY)
text=V2_VERSION_ENTRY)
self.assertCreatesV2(auth_url=V2_URL) self.assertCreatesV2(auth_url=V2_URL)
def test_discover_individual_version_v3(self): def test_discover_individual_version_v3(self):
self.requests.register_uri('GET', V3_URL, status_code=200, self.requests.get(V3_URL, text=V3_VERSION_ENTRY)
text=V3_VERSION_ENTRY)
self.assertCreatesV3(auth_url=V3_URL) self.assertCreatesV3(auth_url=V3_URL)
def test_discover_individual_endpoint_v2(self): def test_discover_individual_endpoint_v2(self):
self.requests.register_uri('GET', V2_URL, status_code=200, self.requests.get(V2_URL, text=V2_VERSION_ENTRY)
text=V2_VERSION_ENTRY)
self.assertCreatesV2(endpoint=V2_URL, token='fake-token') self.assertCreatesV2(endpoint=V2_URL, token='fake-token')
def test_discover_individual_endpoint_v3(self): def test_discover_individual_endpoint_v3(self):
self.requests.register_uri('GET', V3_URL, status_code=200, self.requests.get(V3_URL, text=V3_VERSION_ENTRY)
text=V3_VERSION_ENTRY)
self.assertCreatesV3(endpoint=V3_URL, token='fake-token') self.assertCreatesV3(endpoint=V3_URL, token='fake-token')
def test_discover_fail_to_create_bad_individual_version(self): def test_discover_fail_to_create_bad_individual_version(self):
self.requests.register_uri('GET', V2_URL, status_code=200, self.requests.get(V2_URL, text=V2_VERSION_ENTRY)
text=V2_VERSION_ENTRY) self.requests.get(V3_URL, text=V3_VERSION_ENTRY)
self.requests.register_uri('GET', V3_URL, status_code=200,
text=V3_VERSION_ENTRY)
self.assertVersionNotAvailable(auth_url=V2_URL, version=3) self.assertVersionNotAvailable(auth_url=V2_URL, version=3)
self.assertVersionNotAvailable(auth_url=V3_URL, version=2) self.assertVersionNotAvailable(auth_url=V3_URL, version=2)
def test_discover_unstable_versions(self): def test_discover_unstable_versions(self):
version_list = fixture.DiscoveryList(BASE_URL, v3_status='beta') version_list = fixture.DiscoveryList(BASE_URL, v3_status='beta')
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, json=version_list)
json=version_list)
self.assertCreatesV2(auth_url=BASE_URL) self.assertCreatesV2(auth_url=BASE_URL)
self.assertVersionNotAvailable(auth_url=BASE_URL, version=3) self.assertVersionNotAvailable(auth_url=BASE_URL, version=3)
self.assertCreatesV3(auth_url=BASE_URL, unstable=True) self.assertCreatesV3(auth_url=BASE_URL, unstable=True)
def test_discover_forwards_original_ip(self): def test_discover_forwards_original_ip(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
ip = '192.168.1.1' ip = '192.168.1.1'
self.assertCreatesV3(auth_url=BASE_URL, original_ip=ip) self.assertCreatesV3(auth_url=BASE_URL, original_ip=ip)
@@ -444,8 +424,7 @@ class ClientDiscoveryTests(utils.TestCase):
client.Client) client.Client)
def test_discover_bad_response(self): def test_discover_bad_response(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, json={'FOO': 'BAR'})
json={'FOO': 'BAR'})
self.assertDiscoveryFailure(auth_url=BASE_URL) self.assertDiscoveryFailure(auth_url=BASE_URL)
def test_discovery_ignore_invalid(self): def test_discovery_ignore_invalid(self):
@@ -454,44 +433,40 @@ class ClientDiscoveryTests(utils.TestCase):
'media-types': V3_MEDIA_TYPES, 'media-types': V3_MEDIA_TYPES,
'status': 'stable', 'status': 'stable',
'updated': UPDATED}] 'updated': UPDATED}]
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300,
text=_create_version_list(resp)) text=_create_version_list(resp))
self.assertDiscoveryFailure(auth_url=BASE_URL) self.assertDiscoveryFailure(auth_url=BASE_URL)
def test_ignore_entry_without_links(self): def test_ignore_entry_without_links(self):
v3 = V3_VERSION.copy() v3 = V3_VERSION.copy()
v3['links'] = [] v3['links'] = []
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300,
text=_create_version_list([v3, V2_VERSION])) text=_create_version_list([v3, V2_VERSION]))
self.assertCreatesV2(auth_url=BASE_URL) self.assertCreatesV2(auth_url=BASE_URL)
def test_ignore_entry_without_status(self): def test_ignore_entry_without_status(self):
v3 = V3_VERSION.copy() v3 = V3_VERSION.copy()
del v3['status'] del v3['status']
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300,
text=_create_version_list([v3, V2_VERSION])) text=_create_version_list([v3, V2_VERSION]))
self.assertCreatesV2(auth_url=BASE_URL) self.assertCreatesV2(auth_url=BASE_URL)
def test_greater_version_than_required(self): def test_greater_version_than_required(self):
versions = fixture.DiscoveryList(BASE_URL, v3_id='v3.6') versions = fixture.DiscoveryList(BASE_URL, v3_id='v3.6')
self.requests.register_uri('GET', BASE_URL, status_code=200, self.requests.get(BASE_URL, json=versions)
json=versions)
self.assertCreatesV3(auth_url=BASE_URL, version=(3, 4)) self.assertCreatesV3(auth_url=BASE_URL, version=(3, 4))
def test_lesser_version_than_required(self): def test_lesser_version_than_required(self):
versions = fixture.DiscoveryList(BASE_URL, v3_id='v3.4') versions = fixture.DiscoveryList(BASE_URL, v3_id='v3.4')
self.requests.register_uri('GET', BASE_URL, status_code=200, self.requests.get(BASE_URL, json=versions)
json=versions)
self.assertVersionNotAvailable(auth_url=BASE_URL, version=(3, 6)) self.assertVersionNotAvailable(auth_url=BASE_URL, version=(3, 6))
def test_bad_response(self): def test_bad_response(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text="Ugly Duckling")
text="Ugly Duckling")
self.assertDiscoveryFailure(auth_url=BASE_URL) self.assertDiscoveryFailure(auth_url=BASE_URL)
def test_pass_client_arguments(self): def test_pass_client_arguments(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V2_VERSION_LIST)
text=V2_VERSION_LIST)
kwargs = {'original_ip': '100', 'use_keyring': False, kwargs = {'original_ip': '100', 'use_keyring': False,
'stale_duration': 15} 'stale_duration': 15}
@@ -502,12 +477,11 @@ class ClientDiscoveryTests(utils.TestCase):
self.assertFalse(cl.use_keyring) self.assertFalse(cl.use_keyring)
def test_overriding_stored_kwargs(self): def test_overriding_stored_kwargs(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
self.requests.register_uri('POST', "%s/auth/tokens" % V3_URL, self.requests.post("%s/auth/tokens" % V3_URL,
text=V3_AUTH_RESPONSE, text=V3_AUTH_RESPONSE,
headers={'X-Subject-Token': V3_TOKEN}) headers={'X-Subject-Token': V3_TOKEN})
disc = discover.Discover(auth_url=BASE_URL, debug=False, disc = discover.Discover(auth_url=BASE_URL, debug=False,
username='foo') username='foo')
@@ -520,8 +494,7 @@ class ClientDiscoveryTests(utils.TestCase):
self.assertEqual(client.password, 'bar') self.assertEqual(client.password, 'bar')
def test_available_versions(self): def test_available_versions(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_ENTRY)
text=V3_VERSION_ENTRY)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
versions = disc.available_versions() versions = disc.available_versions()
@@ -536,8 +509,7 @@ class ClientDiscoveryTests(utils.TestCase):
'updated': UPDATED} 'updated': UPDATED}
versions = fixture.DiscoveryList() versions = fixture.DiscoveryList()
versions.add_version(V4_VERSION) versions.add_version(V4_VERSION)
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, json=versions)
json=versions)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
self.assertRaises(exceptions.DiscoveryFailure, self.assertRaises(exceptions.DiscoveryFailure,
@@ -545,16 +517,14 @@ class ClientDiscoveryTests(utils.TestCase):
def test_discovery_fail_for_missing_v3(self): def test_discovery_fail_for_missing_v3(self):
versions = fixture.DiscoveryList(v2=True, v3=False) versions = fixture.DiscoveryList(v2=True, v3=False)
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, json=versions)
json=versions)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
self.assertRaises(exceptions.DiscoveryFailure, self.assertRaises(exceptions.DiscoveryFailure,
disc.create_client, version=(3, 0)) disc.create_client, version=(3, 0))
def _do_discovery_call(self, token=None, **kwargs): def _do_discovery_call(self, token=None, **kwargs):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
if not token: if not token:
token = uuid.uuid4().hex token = uuid.uuid4().hex
@@ -581,8 +551,7 @@ class ClientDiscoveryTests(utils.TestCase):
class DiscoverQueryTests(utils.TestCase): class DiscoverQueryTests(utils.TestCase):
def test_available_keystone_data(self): def test_available_keystone_data(self):
self.requests.register_uri('GET', BASE_URL, status_code=300, self.requests.get(BASE_URL, status_code=300, text=V3_VERSION_LIST)
text=V3_VERSION_LIST)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
versions = disc.version_data() versions = disc.version_data()
@@ -610,7 +579,7 @@ class DiscoverQueryTests(utils.TestCase):
def test_available_cinder_data(self): def test_available_cinder_data(self):
text = jsonutils.dumps(CINDER_EXAMPLES) text = jsonutils.dumps(CINDER_EXAMPLES)
self.requests.register_uri('GET', BASE_URL, status_code=300, text=text) self.requests.get(BASE_URL, status_code=300, text=text)
v1_url = "%sv1/" % BASE_URL v1_url = "%sv1/" % BASE_URL
v2_url = "%sv2/" % BASE_URL v2_url = "%sv2/" % BASE_URL
@@ -641,7 +610,7 @@ class DiscoverQueryTests(utils.TestCase):
def test_available_glance_data(self): def test_available_glance_data(self):
text = jsonutils.dumps(GLANCE_EXAMPLES) text = jsonutils.dumps(GLANCE_EXAMPLES)
self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) self.requests.get(BASE_URL, text=text)
v1_url = "%sv1/" % BASE_URL v1_url = "%sv1/" % BASE_URL
v2_url = "%sv2/" % BASE_URL v2_url = "%sv2/" % BASE_URL
@@ -690,7 +659,7 @@ class DiscoverQueryTests(utils.TestCase):
'status': status, 'status': status,
'updated': UPDATED}] 'updated': UPDATED}]
text = jsonutils.dumps({'versions': version_list}) text = jsonutils.dumps({'versions': version_list})
self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) self.requests.get(BASE_URL, text=text)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
@@ -712,7 +681,7 @@ class DiscoverQueryTests(utils.TestCase):
'status': status, 'status': status,
'updated': UPDATED}] 'updated': UPDATED}]
text = jsonutils.dumps({'versions': version_list}) text = jsonutils.dumps({'versions': version_list})
self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) self.requests.get(BASE_URL, text=text)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
@@ -729,8 +698,7 @@ class DiscoverQueryTests(utils.TestCase):
status = 'abcdef' status = 'abcdef'
version_list = fixture.DiscoveryList(BASE_URL, v2=False, version_list = fixture.DiscoveryList(BASE_URL, v2=False,
v3_status=status) v3_status=status)
self.requests.register_uri('GET', BASE_URL, status_code=200, self.requests.get(BASE_URL, json=version_list)
json=version_list)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)
versions = disc.version_data() versions = disc.version_data()
@@ -759,8 +727,7 @@ class DiscoverQueryTests(utils.TestCase):
}] }]
text = jsonutils.dumps({'versions': version_list}) text = jsonutils.dumps({'versions': version_list})
self.requests.register_uri('GET', BASE_URL, status_code=200, self.requests.get(BASE_URL, text=text)
text=text)
disc = discover.Discover(auth_url=BASE_URL) disc = discover.Discover(auth_url=BASE_URL)

12
keystoneclient/tests/test_s3_token_middleware.py
View File

@@ -64,8 +64,7 @@ class S3TokenMiddlewareTestGood(S3TokenMiddlewareTestBase):
super(S3TokenMiddlewareTestGood, self).setUp() super(S3TokenMiddlewareTestGood, self).setUp()
self.middleware = s3_token.S3Token(FakeApp(), self.conf) self.middleware = s3_token.S3Token(FakeApp(), self.conf)
self.requests.register_uri('POST', self.TEST_URL, self.requests.post(self.TEST_URL, status_code=201, json=GOOD_RESPONSE)
status_code=201, json=GOOD_RESPONSE)
# Ignore the request and pass to the next middleware in the # Ignore the request and pass to the next middleware in the
# pipeline if no path has been specified. # pipeline if no path has been specified.
@@ -99,8 +98,7 @@ class S3TokenMiddlewareTestGood(S3TokenMiddlewareTestBase):
TEST_URL = 'http://%s:%d/v2.0/s3tokens' % (self.TEST_HOST, TEST_URL = 'http://%s:%d/v2.0/s3tokens' % (self.TEST_HOST,
self.TEST_PORT) self.TEST_PORT)
self.requests.register_uri('POST', TEST_URL, self.requests.post(TEST_URL, status_code=201, json=GOOD_RESPONSE)
status_code=201, json=GOOD_RESPONSE)
self.middleware = ( self.middleware = (
s3_token.filter_factory({'auth_protocol': 'http', s3_token.filter_factory({'auth_protocol': 'http',
@@ -153,8 +151,7 @@ class S3TokenMiddlewareTestBad(S3TokenMiddlewareTestBase):
{"message": "EC2 access key not found.", {"message": "EC2 access key not found.",
"code": 401, "code": 401,
"title": "Unauthorized"}} "title": "Unauthorized"}}
self.requests.register_uri('POST', self.TEST_URL, self.requests.post(self.TEST_URL, status_code=403, json=ret)
status_code=403, json=ret)
req = webob.Request.blank('/v1/AUTH_cfa/c/o') req = webob.Request.blank('/v1/AUTH_cfa/c/o')
req.headers['Authorization'] = 'access:signature' req.headers['Authorization'] = 'access:signature'
req.headers['X-Storage-Token'] = 'token' req.headers['X-Storage-Token'] = 'token'
@@ -186,8 +183,7 @@ class S3TokenMiddlewareTestBad(S3TokenMiddlewareTestBase):
self.assertEqual(resp.status_int, s3_invalid_req.status_int) self.assertEqual(resp.status_int, s3_invalid_req.status_int)
def test_bad_reply(self): def test_bad_reply(self):
self.requests.register_uri('POST', self.TEST_URL, self.requests.post(self.TEST_URL, status_code=201, text="<badreply>")
status_code=201, text="<badreply>")
req = webob.Request.blank('/v1/AUTH_cfa/c/o') req = webob.Request.blank('/v1/AUTH_cfa/c/o')
req.headers['Authorization'] = 'access:signature' req.headers['Authorization'] = 'access:signature'

30
keystoneclient/tests/test_session.py
View File

@@ -447,7 +447,7 @@ class SessionAuthTests(utils.TestCase):
def test_raises_exc_only_when_asked(self): def test_raises_exc_only_when_asked(self):
# A request that returns a HTTP error should by default raise an # A request that returns a HTTP error should by default raise an
# exception by default, if you specify raise_exc=False then it will not # exception by default, if you specify raise_exc=False then it will not
self.requests.register_uri('GET', self.TEST_URL, status_code=401) self.requests.get(self.TEST_URL, status_code=401)
sess = client_session.Session() sess = client_session.Session()
self.assertRaises(exceptions.Unauthorized, sess.get, self.TEST_URL) self.assertRaises(exceptions.Unauthorized, sess.get, self.TEST_URL)
@@ -459,9 +459,8 @@ class SessionAuthTests(utils.TestCase):
passed = CalledAuthPlugin() passed = CalledAuthPlugin()
sess = client_session.Session() sess = client_session.Session()
self.requests.register_uri('GET', self.requests.get(CalledAuthPlugin.ENDPOINT + 'path',
CalledAuthPlugin.ENDPOINT + 'path', status_code=200)
status_code=200)
endpoint_filter = {'service_type': 'identity'} endpoint_filter = {'service_type': 'identity'}
# no plugin with authenticated won't work # no plugin with authenticated won't work
@@ -484,9 +483,8 @@ class SessionAuthTests(utils.TestCase):
sess = client_session.Session(fixed) sess = client_session.Session(fixed)
self.requests.register_uri('GET', self.requests.get(CalledAuthPlugin.ENDPOINT + 'path',
CalledAuthPlugin.ENDPOINT + 'path', status_code=200)
status_code=200)
resp = sess.get('path', auth=passed, resp = sess.get('path', auth=passed,
endpoint_filter={'service_type': 'identity'}) endpoint_filter={'service_type': 'identity'})
@@ -518,9 +516,9 @@ class SessionAuthTests(utils.TestCase):
auth = CalledAuthPlugin(invalidate=True) auth = CalledAuthPlugin(invalidate=True)
sess = client_session.Session(auth=auth) sess = client_session.Session(auth=auth)
self.requests.register_uri('GET', self.TEST_URL, self.requests.get(self.TEST_URL,
[{'text': 'Failed', 'status_code': 401}, [{'text': 'Failed', 'status_code': 401},
{'text': 'Hello', 'status_code': 200}]) {'text': 'Hello', 'status_code': 200}])
# allow_reauth=True is the default # allow_reauth=True is the default
resp = sess.get(self.TEST_URL, authenticated=True) resp = sess.get(self.TEST_URL, authenticated=True)
@@ -533,9 +531,9 @@ class SessionAuthTests(utils.TestCase):
auth = CalledAuthPlugin(invalidate=True) auth = CalledAuthPlugin(invalidate=True)
sess = client_session.Session(auth=auth) sess = client_session.Session(auth=auth)
self.requests.register_uri('GET', self.TEST_URL, self.requests.get(self.TEST_URL,
[{'text': 'Failed', 'status_code': 401}, [{'text': 'Failed', 'status_code': 401},
{'text': 'Hello', 'status_code': 200}]) {'text': 'Hello', 'status_code': 200}])
self.assertRaises(exceptions.Unauthorized, sess.get, self.TEST_URL, self.assertRaises(exceptions.Unauthorized, sess.get, self.TEST_URL,
authenticated=True, allow_reauth=False) authenticated=True, allow_reauth=False)
@@ -550,7 +548,7 @@ class SessionAuthTests(utils.TestCase):
override_url = override_base + path override_url = override_base + path
resp_text = uuid.uuid4().hex resp_text = uuid.uuid4().hex
self.requests.register_uri('GET', override_url, text=resp_text) self.requests.get(override_url, text=resp_text)
resp = sess.get(path, resp = sess.get(path,
endpoint_override=override_base, endpoint_override=override_base,
@@ -570,7 +568,7 @@ class SessionAuthTests(utils.TestCase):
url = self.TEST_URL + path url = self.TEST_URL + path
resp_text = uuid.uuid4().hex resp_text = uuid.uuid4().hex
self.requests.register_uri('GET', url, text=resp_text) self.requests.get(url, text=resp_text)
resp = sess.get(url, resp = sess.get(url,
endpoint_override='http://someother.url', endpoint_override='http://someother.url',
@@ -692,7 +690,7 @@ class AdapterTest(utils.TestCase):
adpt = adapter.Adapter(sess, endpoint_override=endpoint_override) adpt = adapter.Adapter(sess, endpoint_override=endpoint_override)
response = uuid.uuid4().hex response = uuid.uuid4().hex
self.requests.register_uri('GET', endpoint_url, text=response) self.requests.get(endpoint_url, text=response)
resp = adpt.get(path) resp = adpt.get(path)

99
keystoneclient/tests/v3/test_auth_saml2.py
View File

@@ -128,8 +128,7 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
def test_initial_sp_call(self): def test_initial_sp_call(self):
"""Test initial call, expect SOAP message.""" """Test initial call, expect SOAP message."""
self.requests.register_uri( self.requests.get(
'GET',
self.FEDERATION_AUTH_URL, self.FEDERATION_AUTH_URL,
content=make_oneline(saml2_fixtures.SP_SOAP_RESPONSE)) content=make_oneline(saml2_fixtures.SP_SOAP_RESPONSE))
a = self.saml2plugin._send_service_provider_request(self.session) a = self.saml2plugin._send_service_provider_request(self.session)
@@ -154,8 +153,7 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
str(self.saml2plugin.sp_response_consumer_url))) str(self.saml2plugin.sp_response_consumer_url)))
def test_initial_sp_call_when_saml_authenticated(self): def test_initial_sp_call_when_saml_authenticated(self):
self.requests.register_uri( self.requests.get(
'GET',
self.FEDERATION_AUTH_URL, self.FEDERATION_AUTH_URL,
json=saml2_fixtures.UNSCOPED_TOKEN, json=saml2_fixtures.UNSCOPED_TOKEN,
headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER})
@@ -170,8 +168,7 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
self.saml2plugin.authenticated_response.headers['X-Subject-Token']) self.saml2plugin.authenticated_response.headers['X-Subject-Token'])
def test_get_unscoped_token_when_authenticated(self): def test_get_unscoped_token_when_authenticated(self):
self.requests.register_uri( self.requests.get(
'GET',
self.FEDERATION_AUTH_URL, self.FEDERATION_AUTH_URL,
json=saml2_fixtures.UNSCOPED_TOKEN, json=saml2_fixtures.UNSCOPED_TOKEN,
headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER, headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER,
@@ -184,9 +181,8 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
def test_initial_sp_call_invalid_response(self): def test_initial_sp_call_invalid_response(self):
"""Send initial SP HTTP request and receive wrong server response.""" """Send initial SP HTTP request and receive wrong server response."""
self.requests.register_uri('GET', self.requests.get(self.FEDERATION_AUTH_URL,
self.FEDERATION_AUTH_URL, text='NON XML RESPONSE')
text='NON XML RESPONSE')
self.assertRaises( self.assertRaises(
exceptions.AuthorizationFailure, exceptions.AuthorizationFailure,
@@ -194,9 +190,8 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
self.session) self.session)
def test_send_authn_req_to_idp(self): def test_send_authn_req_to_idp(self):
self.requests.register_uri('POST', self.requests.post(self.IDENTITY_PROVIDER_URL,
self.IDENTITY_PROVIDER_URL, content=saml2_fixtures.SAML2_ASSERTION)
content=saml2_fixtures.SAML2_ASSERTION)
self.saml2plugin.sp_response_consumer_url = self.SHIB_CONSUMER_URL self.saml2plugin.sp_response_consumer_url = self.SHIB_CONSUMER_URL
self.saml2plugin.saml2_authn_request = etree.XML( self.saml2plugin.saml2_authn_request = etree.XML(
@@ -213,9 +208,7 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
self.assertEqual(idp_response, saml2_assertion_oneline, error) self.assertEqual(idp_response, saml2_assertion_oneline, error)
def test_fail_basicauth_idp_authentication(self): def test_fail_basicauth_idp_authentication(self):
self.requests.register_uri('POST', self.requests.post(self.IDENTITY_PROVIDER_URL, status_code=401)
self.IDENTITY_PROVIDER_URL,
status_code=401)
self.saml2plugin.sp_response_consumer_url = self.SHIB_CONSUMER_URL self.saml2plugin.sp_response_consumer_url = self.SHIB_CONSUMER_URL
self.saml2plugin.saml2_authn_request = etree.XML( self.saml2plugin.saml2_authn_request = etree.XML(
@@ -232,8 +225,7 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
self.IDENTITY_PROVIDER_URL) self.IDENTITY_PROVIDER_URL)
def test_send_authn_response_to_sp(self): def test_send_authn_response_to_sp(self):
self.requests.register_uri( self.requests.post(
'POST',
self.SHIB_CONSUMER_URL, self.SHIB_CONSUMER_URL,
json=saml2_fixtures.UNSCOPED_TOKEN, json=saml2_fixtures.UNSCOPED_TOKEN,
headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER})
@@ -263,7 +255,7 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
self.SHIB_CONSUMER_URL) self.SHIB_CONSUMER_URL)
def test_consumer_url_mismatch(self): def test_consumer_url_mismatch(self):
self.requests.register_uri('POST', self.SHIB_CONSUMER_URL) self.requests.post(self.SHIB_CONSUMER_URL)
invalid_consumer_url = uuid.uuid4().hex invalid_consumer_url = uuid.uuid4().hex
self.assertRaises( self.assertRaises(
exceptions.ValidationError, exceptions.ValidationError,
@@ -272,15 +264,13 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
invalid_consumer_url) invalid_consumer_url)
def test_custom_302_redirection(self): def test_custom_302_redirection(self):
self.requests.register_uri( self.requests.post(
'POST',
self.SHIB_CONSUMER_URL, self.SHIB_CONSUMER_URL,
text='BODY', text='BODY',
headers={'location': self.FEDERATION_AUTH_URL}, headers={'location': self.FEDERATION_AUTH_URL},
status_code=302) status_code=302)
self.requests.register_uri( self.requests.get(
'GET',
self.FEDERATION_AUTH_URL, self.FEDERATION_AUTH_URL,
json=saml2_fixtures.UNSCOPED_TOKEN, json=saml2_fixtures.UNSCOPED_TOKEN,
headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER})
@@ -299,17 +289,14 @@ class AuthenticateviaSAML2Tests(utils.TestCase):
self.assertEqual('GET', response.request.method) self.assertEqual('GET', response.request.method)
def test_end_to_end_workflow(self): def test_end_to_end_workflow(self):
self.requests.register_uri( self.requests.get(
'GET',
self.FEDERATION_AUTH_URL, self.FEDERATION_AUTH_URL,
content=make_oneline(saml2_fixtures.SP_SOAP_RESPONSE)) content=make_oneline(saml2_fixtures.SP_SOAP_RESPONSE))
self.requests.register_uri('POST', self.requests.post(self.IDENTITY_PROVIDER_URL,
self.IDENTITY_PROVIDER_URL, content=saml2_fixtures.SAML2_ASSERTION)
content=saml2_fixtures.SAML2_ASSERTION)
self.requests.register_uri( self.requests.post(
'POST',
self.SHIB_CONSUMER_URL, self.SHIB_CONSUMER_URL,
json=saml2_fixtures.UNSCOPED_TOKEN, json=saml2_fixtures.UNSCOPED_TOKEN,
headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER, headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER,
@@ -476,8 +463,8 @@ class AuthenticateviaADFSTests(utils.TestCase):
def test_get_adfs_security_token(self): def test_get_adfs_security_token(self):
"""Test ADFSUnscopedToken._get_adfs_security_token().""" """Test ADFSUnscopedToken._get_adfs_security_token()."""
self.requests.register_uri( self.requests.post(
'POST', self.IDENTITY_PROVIDER_URL, self.IDENTITY_PROVIDER_URL,
content=make_oneline(self.ADFS_SECURITY_TOKEN_RESPONSE), content=make_oneline(self.ADFS_SECURITY_TOKEN_RESPONSE),
status_code=200) status_code=200)
@@ -539,9 +526,9 @@ class AuthenticateviaADFSTests(utils.TestCase):
An exceptions.AuthorizationFailure should be raised including An exceptions.AuthorizationFailure should be raised including
error message from the XML message indicating where was the problem. error message from the XML message indicating where was the problem.
""" """
self.requests.register_uri( self.requests.post(self.IDENTITY_PROVIDER_URL,
'POST', self.IDENTITY_PROVIDER_URL, content=make_oneline(self.ADFS_FAULT),
content=make_oneline(self.ADFS_FAULT), status_code=500) status_code=500)
self.adfsplugin._prepare_adfs_request() self.adfsplugin._prepare_adfs_request()
self.assertRaises(exceptions.AuthorizationFailure, self.assertRaises(exceptions.AuthorizationFailure,
@@ -558,10 +545,9 @@ class AuthenticateviaADFSTests(utils.TestCase):
and correctly raise exceptions.InternalServerError once it cannot and correctly raise exceptions.InternalServerError once it cannot
parse XML fault message parse XML fault message
""" """
self.requests.register_uri( self.requests.post(self.IDENTITY_PROVIDER_URL,
'POST', self.IDENTITY_PROVIDER_URL, content=b'NOT XML',
content=b'NOT XML', status_code=500)
status_code=500)
self.adfsplugin._prepare_adfs_request() self.adfsplugin._prepare_adfs_request()
self.assertRaises(exceptions.InternalServerError, self.assertRaises(exceptions.InternalServerError,
self.adfsplugin._get_adfs_security_token, self.adfsplugin._get_adfs_security_token,
@@ -573,9 +559,9 @@ class AuthenticateviaADFSTests(utils.TestCase):
"""Test whether SP issues a cookie.""" """Test whether SP issues a cookie."""
cookie = uuid.uuid4().hex cookie = uuid.uuid4().hex
self.requests.register_uri('POST', self.SP_ENDPOINT, self.requests.post(self.SP_ENDPOINT,
headers={"set-cookie": cookie}, headers={"set-cookie": cookie},
status_code=302) status_code=302)
self.adfsplugin.adfs_token = self._build_adfs_request() self.adfsplugin.adfs_token = self._build_adfs_request()
self.adfsplugin._prepare_sp_request() self.adfsplugin._prepare_sp_request()
@@ -584,8 +570,7 @@ class AuthenticateviaADFSTests(utils.TestCase):
self.assertEqual(1, len(self.session.session.cookies)) self.assertEqual(1, len(self.session.session.cookies))
def test_send_assertion_to_service_provider_bad_status(self): def test_send_assertion_to_service_provider_bad_status(self):
self.requests.register_uri('POST', self.SP_ENDPOINT, self.requests.post(self.SP_ENDPOINT, status_code=500)
status_code=500)
self.adfsplugin.adfs_token = etree.XML( self.adfsplugin.adfs_token = etree.XML(
self.ADFS_SECURITY_TOKEN_RESPONSE) self.ADFS_SECURITY_TOKEN_RESPONSE)
@@ -605,10 +590,9 @@ class AuthenticateviaADFSTests(utils.TestCase):
self.session) self.session)
def test_check_valid_token_when_authenticated(self): def test_check_valid_token_when_authenticated(self):
self.requests.register_uri( self.requests.get(self.FEDERATION_AUTH_URL,
'GET', self.FEDERATION_AUTH_URL, json=saml2_fixtures.UNSCOPED_TOKEN,
json=saml2_fixtures.UNSCOPED_TOKEN, headers=client_fixtures.AUTH_RESPONSE_HEADERS)
headers=client_fixtures.AUTH_RESPONSE_HEADERS)
self.session.session.cookies = [object()] self.session.session.cookies = [object()]
self.adfsplugin._access_service_provider(self.session) self.adfsplugin._access_service_provider(self.session)
@@ -621,18 +605,15 @@ class AuthenticateviaADFSTests(utils.TestCase):
response.json()['token']) response.json()['token'])
def test_end_to_end_workflow(self): def test_end_to_end_workflow(self):
self.requests.register_uri( self.requests.post(self.IDENTITY_PROVIDER_URL,
'POST', self.IDENTITY_PROVIDER_URL, content=self.ADFS_SECURITY_TOKEN_RESPONSE,
content=self.ADFS_SECURITY_TOKEN_RESPONSE, status_code=200)
status_code=200) self.requests.post(self.SP_ENDPOINT,
self.requests.register_uri( headers={"set-cookie": 'x'},
'POST', self.SP_ENDPOINT, status_code=302)
headers={"set-cookie": 'x'}, self.requests.get(self.FEDERATION_AUTH_URL,
status_code=302) json=saml2_fixtures.UNSCOPED_TOKEN,
self.requests.register_uri( headers=client_fixtures.AUTH_RESPONSE_HEADERS)
'GET', self.FEDERATION_AUTH_URL,
json=saml2_fixtures.UNSCOPED_TOKEN,
headers=client_fixtures.AUTH_RESPONSE_HEADERS)
# NOTE(marek-denis): We need to mimic this until self.requests can # NOTE(marek-denis): We need to mimic this until self.requests can
# issue cookies properly. # issue cookies properly.

6
keystoneclient/tests/v3/test_discover.py
View File

@@ -61,9 +61,9 @@ class DiscoverKeystoneTests(utils.UnauthenticatedTestCase):
} }
def test_get_version_local(self): def test_get_version_local(self):
self.requests.register_uri('GET', "http://localhost:35357/", self.requests.get("http://localhost:35357/",
status_code=300, status_code=300,
json=self.TEST_RESPONSE_DICT) json=self.TEST_RESPONSE_DICT)
cs = client.Client() cs = client.Client()
versions = cs.discover() versions = cs.discover()

6
keystoneclient/tests/v3/test_federation.py
View File

@@ -349,8 +349,7 @@ class FederationProjectTests(utils.TestCase):
projects_json = { projects_json = {
self.collection_key: [self.new_ref(), self.new_ref()] self.collection_key: [self.new_ref(), self.new_ref()]
} }
self.requests.register_uri('GET', self.URL, self.requests.get(self.URL, json=projects_json)
json=projects_json, status_code=200)
returned_list = self.manager.list() returned_list = self.manager.list()
self.assertEqual(len(projects_ref), len(returned_list)) self.assertEqual(len(projects_ref), len(returned_list))
@@ -381,8 +380,7 @@ class FederationDomainTests(utils.TestCase):
domains_json = { domains_json = {
self.collection_key: domains_ref self.collection_key: domains_ref
} }
self.requests.register_uri('GET', self.URL, self.requests.get(self.URL, json=domains_json)
json=domains_json, status_code=200)
returned_list = self.manager.list() returned_list = self.manager.list()
self.assertEqual(len(domains_ref), len(returned_list)) self.assertEqual(len(domains_ref), len(returned_list))
for domain in returned_list: for domain in returned_list:

27
keystoneclient/tests/v3/utils.py
View File

@@ -244,27 +244,22 @@ class CrudTests(object):
ref_list = ref_list or [self.new_ref(), self.new_ref()] ref_list = ref_list or [self.new_ref(), self.new_ref()]
expected_path = self._get_expected_path(expected_path) expected_path = self._get_expected_path(expected_path)
self.requests.register_uri('GET', self.requests.get(urlparse.urljoin(self.TEST_URL, expected_path),
urlparse.urljoin(self.TEST_URL, json=self.encode(ref_list))
expected_path),
json=self.encode(ref_list))
returned_list = self.manager.list(**filter_kwargs) returned_list = self.manager.list(**filter_kwargs)
self.assertEqual(len(ref_list), len(returned_list)) self.assertEqual(len(ref_list), len(returned_list))
[self.assertIsInstance(r, self.model) for r in returned_list] [self.assertIsInstance(r, self.model) for r in returned_list]
# register_uri doesn't match the querystring component, so we have to qs_args = self.requests.last_request.qs
# explicitly test the querystring component passed by the manager
parts = urlparse.urlparse(self.requests.last_request.url)
qs_args = urlparse.parse_qs(parts.query)
qs_args_expected = expected_query or filter_kwargs qs_args_expected = expected_query or filter_kwargs
for key, value in six.iteritems(qs_args_expected): for key, value in six.iteritems(qs_args_expected):
self.assertIn(key, qs_args) self.assertIn(key, qs_args)
# The httppretty.querystring value is a list # The querystring value is a list. Note we convert the value to a
# Note we convert the value to a string, as the query string # string and lower, as the query string is always a string and the
# is always a string and the filter_kwargs may contain non-string # filter_kwargs may contain non-string values, for example a
# values, for example a boolean, causing the comaprison to fail. # boolean, causing the comaprison to fail.
self.assertIn(str(value), qs_args[key]) self.assertIn(str(value).lower(), qs_args[key])
# Also check that no query string args exist which are not expected # Also check that no query string args exist which are not expected
for key in qs_args: for key in qs_args:
@@ -275,10 +270,8 @@ class CrudTests(object):
filter_kwargs = {uuid.uuid4().hex: uuid.uuid4().hex} filter_kwargs = {uuid.uuid4().hex: uuid.uuid4().hex}
expected_path = self._get_expected_path() expected_path = self._get_expected_path()
self.requests.register_uri('GET', self.requests.get(urlparse.urljoin(self.TEST_URL, expected_path),
urlparse.urljoin(self.TEST_URL, json=self.encode(ref_list))
expected_path),
json=self.encode(ref_list))
self.manager.list(**filter_kwargs) self.manager.list(**filter_kwargs)
self.assertQueryStringContains(**filter_kwargs) self.assertQueryStringContains(**filter_kwargs)