diff --git a/keystoneclient/tests/auth/test_identity_common.py b/keystoneclient/tests/auth/test_identity_common.py index 6557a8061..38a4a3e95 100644 --- a/keystoneclient/tests/auth/test_identity_common.py +++ b/keystoneclient/tests/auth/test_identity_common.py @@ -13,13 +13,11 @@ import abc import uuid -import httpretty import six from keystoneclient.auth import base from keystoneclient.auth.identity import v2 from keystoneclient.auth.identity import v3 -from keystoneclient.openstack.common import jsonutils from keystoneclient import session from keystoneclient.tests import utils @@ -39,10 +37,6 @@ class CommonIdentityTests(object): def setUp(self): super(CommonIdentityTests, self).setUp() - httpretty.reset() - httpretty.enable() - self.addCleanup(httpretty.disable) - self.TEST_URL = '%s%s' % (self.TEST_ROOT_URL, self.version) self.TEST_ADMIN_URL = '%s%s' % (self.TEST_ROOT_ADMIN_URL, self.version) @@ -97,15 +91,14 @@ class CommonIdentityTests(object): """The API version being tested.""" def test_discovering(self): - self.stub_url(httpretty.GET, [], + self.stub_url('GET', [], base_url=self.TEST_COMPUTE_ADMIN, json=self.TEST_DISCOVERY) body = 'SUCCESS' # which gives our sample values - self.stub_url(httpretty.GET, ['path'], - body=body, status=200) + self.stub_url('GET', ['path'], text=body) a = self.create_auth_plugin() s = session.Session(auth=a) @@ -119,9 +112,9 @@ class CommonIdentityTests(object): new_body = 'SC SUCCESS' # if we don't specify a version, we use the URL from the SC - self.stub_url(httpretty.GET, ['path'], + self.stub_url('GET', ['path'], base_url=self.TEST_COMPUTE_ADMIN, - body=new_body, status=200) + text=new_body) resp = s.get('/path', endpoint_filter={'service_type': 'compute', 'interface': 'admin'}) @@ -132,15 +125,11 @@ class CommonIdentityTests(object): def test_discovery_uses_session_cache(self): # 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 - disc_body = jsonutils.dumps(self.TEST_DISCOVERY) - disc_responses = [httpretty.Response(body=disc_body, status=200), - httpretty.Response(body='', status=500)] - httpretty.register_uri(httpretty.GET, - self.TEST_COMPUTE_ADMIN, - responses=disc_responses) + resps = [{'json': self.TEST_DISCOVERY}, {'status_code': 500}] + self.requests.register_uri('GET', self.TEST_COMPUTE_ADMIN, resps) body = 'SUCCESS' - self.stub_url(httpretty.GET, ['path'], body=body, status=200) + self.stub_url('GET', ['path'], text=body) # now either of the two plugins I use, it should not cause a second # request to the discovery url. @@ -161,15 +150,11 @@ class CommonIdentityTests(object): def test_discovery_uses_plugin_cache(self): # 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 - disc_body = jsonutils.dumps(self.TEST_DISCOVERY) - disc_responses = [httpretty.Response(body=disc_body, status=200), - httpretty.Response(body='', status=500)] - httpretty.register_uri(httpretty.GET, - self.TEST_COMPUTE_ADMIN, - responses=disc_responses) + resps = [{'json': self.TEST_DISCOVERY}, {'status_code': 500}] + self.requests.register_uri('GET', self.TEST_COMPUTE_ADMIN, resps) body = 'SUCCESS' - self.stub_url(httpretty.GET, ['path'], body=body, status=200) + self.stub_url('GET', ['path'], text=body) # now either of the two sessions I use, it should not cause a second # request to the discovery url. @@ -190,14 +175,14 @@ class CommonIdentityTests(object): def test_discovering_with_no_data(self): # which returns discovery information pointing to TEST_URL but there is # no data there. - self.stub_url(httpretty.GET, [], + self.stub_url('GET', [], base_url=self.TEST_COMPUTE_ADMIN, - status=400) + status_code=400) # so the url that will be used is the same TEST_COMPUTE_ADMIN body = 'SUCCESS' - self.stub_url(httpretty.GET, ['path'], - base_url=self.TEST_COMPUTE_ADMIN, body=body, status=200) + self.stub_url('GET', ['path'], base_url=self.TEST_COMPUTE_ADMIN, + text=body, status_code=200) a = self.create_auth_plugin() s = session.Session(auth=a) @@ -339,8 +324,8 @@ class V3(CommonIdentityTests, utils.TestCase): if not subject_token: subject_token = self.TEST_TOKEN - self.stub_url(httpretty.POST, ['auth', 'tokens'], - X_Subject_Token=subject_token, **kwargs) + kwargs.setdefault('headers', {})['X-Subject-Token'] = subject_token + self.stub_url('POST', ['auth', 'tokens'], **kwargs) def create_auth_plugin(self): return v3.Password(self.TEST_URL, @@ -426,4 +411,4 @@ class V2(CommonIdentityTests, utils.TestCase): self.stub_auth(json=token) def stub_auth(self, **kwargs): - self.stub_url(httpretty.POST, ['tokens'], **kwargs) + self.stub_url('POST', ['tokens'], **kwargs) diff --git a/keystoneclient/tests/auth/test_identity_v2.py b/keystoneclient/tests/auth/test_identity_v2.py index 0beea8344..46a505b26 100644 --- a/keystoneclient/tests/auth/test_identity_v2.py +++ b/keystoneclient/tests/auth/test_identity_v2.py @@ -13,12 +13,8 @@ import copy import uuid -import httpretty -from six.moves import urllib - from keystoneclient.auth.identity import v2 from keystoneclient import exceptions -from keystoneclient.openstack.common import jsonutils from keystoneclient import session from keystoneclient.tests import utils @@ -98,9 +94,8 @@ class V2IdentityPlugin(utils.TestCase): } def stub_auth(self, **kwargs): - self.stub_url(httpretty.POST, ['tokens'], **kwargs) + self.stub_url('POST', ['tokens'], **kwargs) - @httpretty.activate def test_authenticate_with_username_password(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v2.Password(self.TEST_URL, username=self.TEST_USER, @@ -115,7 +110,6 @@ class V2IdentityPlugin(utils.TestCase): self.assertRequestHeaderEqual('Accept', 'application/json') self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_authenticate_with_username_password_scoped(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v2.Password(self.TEST_URL, username=self.TEST_USER, @@ -129,7 +123,6 @@ class V2IdentityPlugin(utils.TestCase): self.assertRequestBodyIs(json=req) self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_authenticate_with_token(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v2.Token(self.TEST_URL, 'foo') @@ -143,7 +136,6 @@ class V2IdentityPlugin(utils.TestCase): self.assertRequestHeaderEqual('Accept', 'application/json') self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_with_trust_id(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v2.Password(self.TEST_URL, username=self.TEST_USER, @@ -158,12 +150,11 @@ class V2IdentityPlugin(utils.TestCase): self.assertRequestBodyIs(json=req) self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def _do_service_url_test(self, base_url, endpoint_filter): self.stub_auth(json=self.TEST_RESPONSE_DICT) - self.stub_url(httpretty.GET, ['path'], + self.stub_url('GET', ['path'], base_url=base_url, - body='SUCCESS', status=200) + text='SUCCESS', status_code=200) a = v2.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -172,8 +163,7 @@ class V2IdentityPlugin(utils.TestCase): resp = s.get('/path', endpoint_filter=endpoint_filter) self.assertEqual(resp.status_code, 200) - path = "%s/%s" % (urllib.parse.urlparse(base_url).path, 'path') - self.assertEqual(httpretty.last_request().path, path) + self.assertEqual(self.requests.last_request.url, base_url + '/path') def test_service_url(self): endpoint_filter = {'service_type': 'compute', @@ -185,7 +175,6 @@ class V2IdentityPlugin(utils.TestCase): endpoint_filter = {'service_type': 'compute'} self._do_service_url_test('http://nova/novapi/public', endpoint_filter) - @httpretty.activate def test_endpoint_filter_without_service_type_fails(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) @@ -196,12 +185,11 @@ class V2IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.EndpointNotFound, s.get, '/path', endpoint_filter={'interface': 'admin'}) - @httpretty.activate def test_full_url_overrides_endpoint_filter(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) - self.stub_url(httpretty.GET, [], + self.stub_url('GET', [], base_url='http://testurl/', - body='SUCCESS', status=200) + text='SUCCESS', status_code=200) a = v2.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -212,7 +200,6 @@ class V2IdentityPlugin(utils.TestCase): self.assertEqual(resp.status_code, 200) self.assertEqual(resp.text, 'SUCCESS') - @httpretty.activate def test_invalid_auth_response_dict(self): self.stub_auth(json={'hello': 'world'}) @@ -223,9 +210,8 @@ class V2IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.InvalidResponse, s.get, 'http://any', authenticated=True) - @httpretty.activate def test_invalid_auth_response_type(self): - self.stub_url(httpretty.POST, ['tokens'], body='testdata') + self.stub_url('POST', ['tokens'], text='testdata') a = v2.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -234,7 +220,6 @@ class V2IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.InvalidResponse, s.get, 'http://any', authenticated=True) - @httpretty.activate def test_invalidate_response(self): resp_data1 = copy.deepcopy(self.TEST_RESPONSE_DICT) resp_data2 = copy.deepcopy(self.TEST_RESPONSE_DICT) @@ -242,12 +227,8 @@ class V2IdentityPlugin(utils.TestCase): resp_data1['access']['token']['id'] = 'token1' resp_data2['access']['token']['id'] = 'token2' - auth_responses = [httpretty.Response(body=jsonutils.dumps(resp_data1), - status=200), - httpretty.Response(body=jsonutils.dumps(resp_data2), - status=200)] - - self.stub_auth(responses=auth_responses) + auth_responses = [{'json': resp_data1}, {'json': resp_data2}] + self.stub_auth(response_list=auth_responses) a = v2.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -257,7 +238,6 @@ class V2IdentityPlugin(utils.TestCase): a.invalidate() self.assertEqual('token2', s.get_token()) - @httpretty.activate def test_doesnt_log_password(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) password = uuid.uuid4().hex diff --git a/keystoneclient/tests/auth/test_identity_v3.py b/keystoneclient/tests/auth/test_identity_v3.py index a147a317b..ecdc38abc 100644 --- a/keystoneclient/tests/auth/test_identity_v3.py +++ b/keystoneclient/tests/auth/test_identity_v3.py @@ -13,13 +13,9 @@ import copy import uuid -import httpretty -from six.moves import urllib - from keystoneclient import access from keystoneclient.auth.identity import v3 from keystoneclient import exceptions -from keystoneclient.openstack.common import jsonutils from keystoneclient import session from keystoneclient.tests import utils @@ -147,10 +143,9 @@ class V3IdentityPlugin(utils.TestCase): if not subject_token: subject_token = self.TEST_TOKEN - self.stub_url(httpretty.POST, ['auth', 'tokens'], - X_Subject_Token=subject_token, **kwargs) + self.stub_url('POST', ['auth', 'tokens'], + headers={'X-Subject-Token': subject_token}, **kwargs) - @httpretty.activate def test_authenticate_with_username_password(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v3.Password(self.TEST_URL, @@ -170,7 +165,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertRequestHeaderEqual('Accept', 'application/json') self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_authenticate_with_username_password_domain_scoped(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v3.Password(self.TEST_URL, username=self.TEST_USER, @@ -186,7 +180,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertRequestBodyIs(json=req) self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_authenticate_with_username_password_project_scoped(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v3.Password(self.TEST_URL, username=self.TEST_USER, @@ -204,7 +197,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) self.assertEqual(s.auth.auth_ref.project_id, self.TEST_DOMAIN_ID) - @httpretty.activate def test_authenticate_with_token(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v3.Token(self.TEST_URL, self.TEST_TOKEN) @@ -221,7 +213,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertRequestHeaderEqual('Accept', 'application/json') self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_with_expired(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) @@ -245,7 +236,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.AuthorizationFailure, a.get_token, None) - @httpretty.activate def test_with_trust_id(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) a = v3.Password(self.TEST_URL, username=self.TEST_USER, @@ -261,7 +251,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertRequestBodyIs(json=req) self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_with_multiple_mechanisms_factory(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) p = v3.PasswordMethod(username=self.TEST_USER, password=self.TEST_PASS) @@ -279,7 +268,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertRequestBodyIs(json=req) self.assertEqual(s.auth.auth_ref.auth_token, self.TEST_TOKEN) - @httpretty.activate def test_with_multiple_mechanisms(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) p = v3.PasswordMethod(username=self.TEST_USER, @@ -312,12 +300,11 @@ class V3IdentityPlugin(utils.TestCase): domain_id='x', trust_id='x') self.assertRaises(exceptions.AuthorizationFailure, a.get_auth_ref, s) - @httpretty.activate def _do_service_url_test(self, base_url, endpoint_filter): self.stub_auth(json=self.TEST_RESPONSE_DICT) - self.stub_url(httpretty.GET, ['path'], + self.stub_url('GET', ['path'], base_url=base_url, - body='SUCCESS', status=200) + text='SUCCESS', status_code=200) a = v3.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -326,8 +313,7 @@ class V3IdentityPlugin(utils.TestCase): resp = s.get('/path', endpoint_filter=endpoint_filter) self.assertEqual(resp.status_code, 200) - path = "%s/%s" % (urllib.parse.urlparse(base_url).path, 'path') - self.assertEqual(httpretty.last_request().path, path) + self.assertEqual(self.requests.last_request.url, base_url + '/path') def test_service_url(self): endpoint_filter = {'service_type': 'compute', @@ -339,7 +325,6 @@ class V3IdentityPlugin(utils.TestCase): endpoint_filter = {'service_type': 'compute'} self._do_service_url_test('http://nova/novapi/public', endpoint_filter) - @httpretty.activate def test_endpoint_filter_without_service_type_fails(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) @@ -350,12 +335,11 @@ class V3IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.EndpointNotFound, s.get, '/path', endpoint_filter={'interface': 'admin'}) - @httpretty.activate def test_full_url_overrides_endpoint_filter(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) - self.stub_url(httpretty.GET, [], + self.stub_url('GET', [], base_url='http://testurl/', - body='SUCCESS', status=200) + text='SUCCESS', status_code=200) a = v3.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -366,7 +350,6 @@ class V3IdentityPlugin(utils.TestCase): self.assertEqual(resp.status_code, 200) self.assertEqual(resp.text, 'SUCCESS') - @httpretty.activate def test_invalid_auth_response_dict(self): self.stub_auth(json={'hello': 'world'}) @@ -377,9 +360,8 @@ class V3IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.InvalidResponse, s.get, 'http://any', authenticated=True) - @httpretty.activate def test_invalid_auth_response_type(self): - self.stub_url(httpretty.POST, ['auth', 'tokens'], body='testdata') + self.stub_url('POST', ['auth', 'tokens'], text='testdata') a = v3.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -388,19 +370,14 @@ class V3IdentityPlugin(utils.TestCase): self.assertRaises(exceptions.InvalidResponse, s.get, 'http://any', authenticated=True) - @httpretty.activate def test_invalidate_response(self): - body = jsonutils.dumps(self.TEST_RESPONSE_DICT) - auth_responses = [httpretty.Response(body=body, - X_Subject_Token='token1', - status=200), - httpretty.Response(body=body, - X_Subject_Token='token2', - status=200)] + auth_responses = [{'status_code': 200, 'json': self.TEST_RESPONSE_DICT, + 'headers': {'X-Subject-Token': 'token1'}}, + {'status_code': 200, 'json': self.TEST_RESPONSE_DICT, + 'headers': {'X-Subject-Token': 'token2'}}] - httpretty.register_uri(httpretty.POST, - '%s/auth/tokens' % self.TEST_URL, - responses=auth_responses) + self.requests.register_uri('POST', '%s/auth/tokens' % self.TEST_URL, + auth_responses) a = v3.Password(self.TEST_URL, username=self.TEST_USER, password=self.TEST_PASS) @@ -410,7 +387,6 @@ class V3IdentityPlugin(utils.TestCase): a.invalidate() self.assertEqual('token2', s.get_token()) - @httpretty.activate def test_doesnt_log_password(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) diff --git a/keystoneclient/tests/auth/test_token_endpoint.py b/keystoneclient/tests/auth/test_token_endpoint.py index c59e17e1c..1f2c01d6a 100644 --- a/keystoneclient/tests/auth/test_token_endpoint.py +++ b/keystoneclient/tests/auth/test_token_endpoint.py @@ -10,8 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty - from keystoneclient.auth import token_endpoint from keystoneclient import session from keystoneclient.tests import utils @@ -22,9 +20,8 @@ class TokenEndpointTest(utils.TestCase): TEST_TOKEN = 'aToken' TEST_URL = 'http://server/prefix' - @httpretty.activate def test_basic_case(self): - httpretty.register_uri(httpretty.GET, self.TEST_URL, body='body') + self.requests.register_uri('GET', self.TEST_URL, text='body') a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN) s = session.Session(auth=a) @@ -34,9 +31,8 @@ class TokenEndpointTest(utils.TestCase): self.assertEqual(data.text, 'body') self.assertRequestHeaderEqual('X-Auth-Token', self.TEST_TOKEN) - @httpretty.activate def test_basic_endpoint_case(self): - self.stub_url(httpretty.GET, ['p'], body='body') + self.stub_url('GET', ['p'], text='body') a = token_endpoint.Token(self.TEST_URL, self.TEST_TOKEN) s = session.Session(auth=a) diff --git a/keystoneclient/tests/generic/test_client.py b/keystoneclient/tests/generic/test_client.py index 1ea67cbbb..fc5816ba9 100644 --- a/keystoneclient/tests/generic/test_client.py +++ b/keystoneclient/tests/generic/test_client.py @@ -13,8 +13,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty - from keystoneclient.generic import client from keystoneclient.openstack.common import jsonutils from keystoneclient.tests import utils @@ -54,12 +52,11 @@ def _create_extension_list(extensions): EXTENSION_LIST = _create_extension_list([EXTENSION_FOO, EXTENSION_BAR]) -@httpretty.activate class ClientDiscoveryTests(utils.TestCase): def test_discover_extensions_v2(self): - httpretty.register_uri(httpretty.GET, "%s/extensions" % V2_URL, - body=EXTENSION_LIST) + self.requests.register_uri('GET', "%s/extensions" % V2_URL, + text=EXTENSION_LIST) extensions = client.Client().discover_extensions(url=V2_URL) self.assertIn(EXTENSION_ALIAS_FOO, extensions) self.assertEqual(extensions[EXTENSION_ALIAS_FOO], EXTENSION_NAME_FOO) diff --git a/keystoneclient/tests/test_auth_token_middleware.py b/keystoneclient/tests/test_auth_token_middleware.py index 248db145c..5e1a71f7f 100644 --- a/keystoneclient/tests/test_auth_token_middleware.py +++ b/keystoneclient/tests/test_auth_token_middleware.py @@ -23,9 +23,10 @@ import time import uuid import fixtures -import httpretty import iso8601 import mock +from requests_mock.contrib import fixture as mock_fixture +from six.moves.urllib import parse as urlparse import testresources import testtools from testtools import matchers @@ -204,6 +205,8 @@ class BaseAuthTokenMiddlewareTest(testtools.TestCase): self.response_status = None self.response_headers = None + self.requests = self.useFixture(mock_fixture.Fixture()) + def set_middleware(self, expected_env=None, conf=None): """Configure the class ready to call the auth_token middleware. @@ -239,10 +242,10 @@ class BaseAuthTokenMiddlewareTest(testtools.TestCase): def assertLastPath(self, path): if path: - self.assertEqual(path, httpretty.last_request().path) + parts = urlparse.urlparse(self.requests.last_request.url) + self.assertEqual(path, parts.path) else: - self.assertIsInstance(httpretty.last_request(), - httpretty.core.HTTPrettyRequestEmpty) + self.assertIsNone(self.requests.last_request) class MultiStepAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, @@ -250,28 +253,24 @@ class MultiStepAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, resources = [('examples', client_fixtures.EXAMPLES_RESOURCE)] - @httpretty.activate def test_fetch_revocation_list_with_expire(self): self.set_middleware() # 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. - httpretty.register_uri(httpretty.POST, "%s/v2.0/tokens" % BASE_URI, - body=FAKE_ADMIN_TOKEN) + self.requests.register_uri('POST', "%s/v2.0/tokens" % BASE_URI, + text=FAKE_ADMIN_TOKEN) - responses = [httpretty.Response(body='', status=401), - httpretty.Response( - body=self.examples.SIGNED_REVOCATION_LIST)] - - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/revoked" % BASE_URI, - responses=responses) + text = self.examples.SIGNED_REVOCATION_LIST + self.requests.register_uri('GET', "%s/v2.0/tokens/revoked" % BASE_URI, + response_list=[{'status_code': 401}, + {'text': text}]) fetched_list = jsonutils.loads(self.middleware.fetch_revocation_list()) self.assertEqual(fetched_list, self.examples.REVOCATION_LIST) # Check that 4 requests have been made - self.assertEqual(len(httpretty.httpretty.latest_requests), 4) + self.assertEqual(len(self.requests.request_history), 4) class DiabloAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, @@ -292,25 +291,17 @@ class DiabloAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, super(DiabloAuthTokenMiddlewareTest, self).setUp( expected_env=expected_env) - httpretty.reset() - httpretty.enable() - self.addCleanup(httpretty.disable) + self.requests.register_uri('GET', "%s/" % BASE_URI, + text=VERSION_LIST_v2, status_code=300) - httpretty.register_uri(httpretty.GET, - "%s/" % BASE_URI, - body=VERSION_LIST_v2, - status=300) - - httpretty.register_uri(httpretty.POST, - "%s/v2.0/tokens" % BASE_URI, - body=FAKE_ADMIN_TOKEN) + self.requests.register_uri('POST', "%s/v2.0/tokens" % BASE_URI, + text=FAKE_ADMIN_TOKEN) self.token_id = self.examples.VALID_DIABLO_TOKEN token_response = self.examples.JSON_TOKEN_RESPONSES[self.token_id] - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/%s" % (BASE_URI, self.token_id), - body=token_response) + url = '%s/v2.0/tokens/%s' % (BASE_URI, self.token_id) + self.requests.register_uri('GET', url, text=token_response) self.set_middleware() @@ -435,7 +426,6 @@ class GeneralAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, @testtools.skipUnless(memcached_available(), 'memcached not available') def test_encrypt_cache_data(self): - httpretty.disable() conf = { 'memcached_servers': MEMCACHED_SERVERS, 'memcache_security_strategy': 'encrypt', @@ -453,7 +443,6 @@ class GeneralAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, @testtools.skipUnless(memcached_available(), 'memcached not available') def test_sign_cache_data(self): - httpretty.disable() conf = { 'memcached_servers': MEMCACHED_SERVERS, 'memcache_security_strategy': 'mac', @@ -471,7 +460,6 @@ class GeneralAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, @testtools.skipUnless(memcached_available(), 'memcached not available') def test_no_memcache_protection(self): - httpretty.disable() conf = { 'memcached_servers': MEMCACHED_SERVERS, 'memcache_secret_key': 'mysecret' @@ -833,10 +821,8 @@ class CommonAuthTokenMiddlewareTest(object): self.assertEqual(self.middleware.token_revocation_list, in_memory_list) def test_invalid_revocation_list_raises_service_error(self): - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/revoked" % BASE_URI, - body="{}", - status=200) + self.requests.register_uri('GET', '%s/v2.0/tokens/revoked' % BASE_URI, + text='{}') self.assertRaises(auth_token.ServiceError, self.middleware.fetch_revocation_list) @@ -851,7 +837,8 @@ class CommonAuthTokenMiddlewareTest(object): # remember because we are testing the middleware we stub the connection # to the keystone server, but this is not what gets returned invalid_uri = "%s/v2.0/tokens/invalid-token" % BASE_URI - httpretty.register_uri(httpretty.GET, invalid_uri, body="", status=404) + self.requests.register_uri('GET', invalid_uri, text="", + status_code=404) req = webob.Request.blank('/') req.headers['X-Auth-Token'] = 'invalid-token' @@ -924,9 +911,6 @@ class CommonAuthTokenMiddlewareTest(object): return self.middleware._token_cache._cache_get(token_id) def test_memcache(self): - # NOTE(jamielennox): it appears that httpretty can mess with the - # memcache socket. Just disable it as it's not required here anyway. - httpretty.disable() req = webob.Request.blank('/') token = self.token_dict['signed_token_scoped'] req.headers['X-Auth-Token'] = token @@ -934,7 +918,6 @@ class CommonAuthTokenMiddlewareTest(object): self.assertIsNotNone(self._get_cached_token(token)) def test_expired(self): - httpretty.disable() req = webob.Request.blank('/') token = self.token_dict['signed_token_scoped_expired'] req.headers['X-Auth-Token'] = token @@ -943,7 +926,7 @@ class CommonAuthTokenMiddlewareTest(object): def test_memcache_set_invalid_uuid(self): invalid_uri = "%s/v2.0/tokens/invalid-token" % BASE_URI - httpretty.register_uri(httpretty.GET, invalid_uri, body="", status=404) + self.requests.register_uri('GET', invalid_uri, status_code=404) req = webob.Request.blank('/') token = 'invalid-token' @@ -978,7 +961,6 @@ class CommonAuthTokenMiddlewareTest(object): exp_mode='sha256') def test_memcache_set_expired(self, extra_conf={}, extra_environ={}): - httpretty.disable() token_cache_time = 10 conf = { 'token_cache_time': token_cache_time, @@ -1232,22 +1214,16 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest, } self.set_middleware(conf=conf) - httpretty.reset() - httpretty.enable() - self.addCleanup(httpretty.disable) - # Usually we supply a signed_dir with pre-installed certificates, # so invocation of /usr/bin/openssl succeeds. This time we give it # an empty directory, so it fails. def test_request_no_token_dummy(self): cms._ensure_subprocess() - httpretty.register_uri(httpretty.GET, - "%s%s" % (BASE_URI, self.ca_path), - status=404) - httpretty.register_uri(httpretty.GET, - "%s%s" % (BASE_URI, self.signing_path), - status=404) + self.requests.register_uri('GET', "%s%s" % (BASE_URI, self.ca_path), + status_code=404) + url = "%s%s" % (BASE_URI, self.signing_path) + self.requests.register_uri('GET', url, status_code=404) self.assertRaises(exceptions.CertificateConfigError, self.middleware.verify_signed_token, self.examples.SIGNED_TOKEN_SCOPED, @@ -1255,29 +1231,25 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest, def test_fetch_signing_cert(self): data = 'FAKE CERT' - httpretty.register_uri(httpretty.GET, - "%s%s" % (BASE_URI, self.signing_path), - body=data) + url = '%s%s' % (BASE_URI, self.signing_path) + self.requests.register_uri('GET', url, text=data) self.middleware.fetch_signing_cert() with open(self.middleware.signing_cert_file_name, 'r') as f: self.assertEqual(f.read(), data) - self.assertEqual("/testadmin%s" % self.signing_path, - httpretty.last_request().path) + self.assertLastPath("/testadmin%s" % self.signing_path) def test_fetch_signing_ca(self): data = 'FAKE CA' - httpretty.register_uri(httpretty.GET, - "%s%s" % (BASE_URI, self.ca_path), - body=data) + self.requests.register_uri('GET', "%s%s" % (BASE_URI, self.ca_path), + text=data) self.middleware.fetch_ca_cert() with open(self.middleware.signing_ca_file_name, 'r') as f: self.assertEqual(f.read(), data) - self.assertEqual("/testadmin%s" % self.ca_path, - httpretty.last_request().path) + self.assertLastPath("/testadmin%s" % self.ca_path) def test_prefix_trailing_slash(self): del self.conf['identity_uri'] @@ -1286,24 +1258,21 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest, self.conf['auth_port'] = 1234 self.conf['auth_admin_prefix'] = '/newadmin/' - httpretty.register_uri(httpretty.GET, - "%s/newadmin%s" % (BASE_HOST, self.ca_path), - body='FAKECA') - httpretty.register_uri(httpretty.GET, - "%s/newadmin%s" % - (BASE_HOST, self.signing_path), body='FAKECERT') + self.requests.register_uri('GET', + "%s/newadmin%s" % (BASE_HOST, self.ca_path), + text='FAKECA') + url = "%s/newadmin%s" % (BASE_HOST, self.signing_path) + self.requests.register_uri('GET', url, text='FAKECERT') self.set_middleware(conf=self.conf) self.middleware.fetch_ca_cert() - self.assertEqual('/newadmin%s' % self.ca_path, - httpretty.last_request().path) + self.assertLastPath('/newadmin%s' % self.ca_path) self.middleware.fetch_signing_cert() - self.assertEqual('/newadmin%s' % self.signing_path, - httpretty.last_request().path) + self.assertLastPath('/newadmin%s' % self.signing_path) def test_without_prefix(self): del self.conf['identity_uri'] @@ -1312,24 +1281,21 @@ class V2CertDownloadMiddlewareTest(BaseAuthTokenMiddlewareTest, self.conf['auth_port'] = 1234 self.conf['auth_admin_prefix'] = '' - httpretty.register_uri(httpretty.GET, - "%s%s" % (BASE_HOST, self.ca_path), - body='FAKECA') - httpretty.register_uri(httpretty.GET, - "%s%s" % (BASE_HOST, self.signing_path), - body='FAKECERT') + self.requests.register_uri('GET', "%s%s" % (BASE_HOST, self.ca_path), + text='FAKECA') + self.requests.register_uri('GET', "%s%s" % (BASE_HOST, + self.signing_path), + text='FAKECERT') self.set_middleware(conf=self.conf) self.middleware.fetch_ca_cert() - self.assertEqual(self.ca_path, - httpretty.last_request().path) + self.assertLastPath(self.ca_path) self.middleware.fetch_signing_cert() - self.assertEqual(self.signing_path, - httpretty.last_request().path) + self.assertLastPath(self.signing_path) class V3CertDownloadMiddlewareTest(V2CertDownloadMiddlewareTest): @@ -1391,23 +1357,14 @@ class v2AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, self.examples.REVOKED_TOKEN_HASH_SHA256, } - httpretty.reset() - httpretty.enable() - self.addCleanup(httpretty.disable) + self.requests.register_uri('GET', "%s/" % BASE_URI, + text=VERSION_LIST_v2, status_code=300) - httpretty.register_uri(httpretty.GET, - "%s/" % BASE_URI, - body=VERSION_LIST_v2, - status=300) + self.requests.register_uri('POST', "%s/v2.0/tokens" % BASE_URI, + text=FAKE_ADMIN_TOKEN) - httpretty.register_uri(httpretty.POST, - "%s/v2.0/tokens" % BASE_URI, - body=FAKE_ADMIN_TOKEN) - - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/revoked" % BASE_URI, - body=self.examples.SIGNED_REVOCATION_LIST, - status=200) + self.requests.register_uri('GET', "%s/v2.0/tokens/revoked" % BASE_URI, + text=self.examples.SIGNED_REVOCATION_LIST) for token in (self.examples.UUID_TOKEN_DEFAULT, self.examples.UUID_TOKEN_UNSCOPED, @@ -1415,14 +1372,15 @@ class v2AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, self.examples.UUID_TOKEN_UNKNOWN_BIND, self.examples.UUID_TOKEN_NO_SERVICE_CATALOG, self.examples.SIGNED_TOKEN_SCOPED_KEY,): - response_body = self.examples.JSON_TOKEN_RESPONSES[token] - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/%s" % (BASE_URI, token), - body=response_body) + text = self.examples.JSON_TOKEN_RESPONSES[token] + self.requests.register_uri('GET', + '%s/v2.0/tokens/%s' % (BASE_URI, token), + text=text) - httpretty.register_uri(httpretty.GET, - '%s/v2.0/tokens/%s' % (BASE_URI, ERROR_TOKEN), - body=network_error_response) + self.requests.register_uri('GET', + '%s/v2.0/tokens/%s' % (BASE_URI, + ERROR_TOKEN), + text=network_error_response) self.set_middleware() @@ -1483,7 +1441,6 @@ class CrossVersionAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, resources = [('examples', client_fixtures.EXAMPLES_RESOURCE)] - @httpretty.activate def test_valid_uuid_request_forced_to_2_0(self): """Test forcing auth_token to use lower api version. @@ -1499,20 +1456,16 @@ class CrossVersionAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, 'auth_version': 'v2.0' } - httpretty.register_uri(httpretty.GET, - "%s/" % BASE_URI, - body=VERSION_LIST_v3, - status=300) + self.requests.register_uri('GET', '%s/' % BASE_URI, + text=VERSION_LIST_v3, status_code=300) - httpretty.register_uri(httpretty.POST, - "%s/v2.0/tokens" % BASE_URI, - body=FAKE_ADMIN_TOKEN) + self.requests.register_uri('POST', '%s/v2.0/tokens' % BASE_URI, + text=FAKE_ADMIN_TOKEN) token = self.examples.UUID_TOKEN_DEFAULT + url = '%s/v2.0/tokens/%s' % (BASE_URI, token) response_body = self.examples.JSON_TOKEN_RESPONSES[token] - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/%s" % (BASE_URI, token), - body=response_body) + self.requests.register_uri('GET', url, text=response_body) self.set_middleware(conf=conf) @@ -1522,9 +1475,8 @@ class CrossVersionAuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, req.headers['X-Auth-Token'] = self.examples.UUID_TOKEN_DEFAULT self.middleware(req.environ, self.start_fake_response) self.assertEqual(self.response_status, 200) - self.assertEqual("/testadmin/v2.0/tokens/%s" % - self.examples.UUID_TOKEN_DEFAULT, - httpretty.last_request().path) + self.assertLastPath("/testadmin/v2.0/tokens/%s" % + self.examples.UUID_TOKEN_DEFAULT) class v3AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, @@ -1585,40 +1537,28 @@ class v3AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, self.examples.REVOKED_v3_PKIZ_TOKEN_HASH, } - httpretty.reset() - httpretty.enable() - self.addCleanup(httpretty.disable) - - httpretty.register_uri(httpretty.GET, - "%s" % BASE_URI, - body=VERSION_LIST_v3, - status=300) + self.requests.register_uri('GET', BASE_URI, + text=VERSION_LIST_v3, status_code=300) # TODO(jamielennox): auth_token middleware uses a v2 admin token # regardless of the auth_version that is set. - httpretty.register_uri(httpretty.POST, - "%s/v2.0/tokens" % BASE_URI, - body=FAKE_ADMIN_TOKEN) + self.requests.register_uri('POST', '%s/v2.0/tokens' % BASE_URI, + text=FAKE_ADMIN_TOKEN) # TODO(jamielennox): there is no v3 revocation url yet, it uses v2 - httpretty.register_uri(httpretty.GET, - "%s/v2.0/tokens/revoked" % BASE_URI, - body=self.examples.SIGNED_REVOCATION_LIST, - status=200) + self.requests.register_uri('GET', '%s/v2.0/tokens/revoked' % BASE_URI, + text=self.examples.SIGNED_REVOCATION_LIST) - httpretty.register_uri(httpretty.GET, - "%s/v3/auth/tokens" % BASE_URI, - body=self.token_response) + self.requests.register_uri('GET', '%s/v3/auth/tokens' % BASE_URI, + text=self.token_response) self.set_middleware() - def token_response(self, request, uri, headers): + def token_response(self, request, context): auth_id = request.headers.get('X-Auth-Token') token_id = request.headers.get('X-Subject-Token') self.assertEqual(auth_id, FAKE_ADMIN_TOKEN_ID) - headers.pop('status') - status = 200 response = "" if token_id == ERROR_TOKEN: @@ -1627,9 +1567,9 @@ class v3AuthTokenMiddlewareTest(BaseAuthTokenMiddlewareTest, try: response = self.examples.JSON_TOKEN_RESPONSES[token_id] except KeyError: - status = 404 + context.status_code = 404 - return status, headers, response + return response def assert_valid_last_url(self, token_id): self.assertLastPath('/testadmin/v3/auth/tokens') diff --git a/keystoneclient/tests/test_discovery.py b/keystoneclient/tests/test_discovery.py index 725777de1..fc0f5518c 100644 --- a/keystoneclient/tests/test_discovery.py +++ b/keystoneclient/tests/test_discovery.py @@ -10,7 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty import six from testtools import matchers @@ -228,7 +227,6 @@ V3_VERSION_ENTRY = _create_single_version(V3_VERSION) V2_VERSION_ENTRY = _create_single_version(V2_VERSION) -@httpretty.activate class AvailableVersionsTests(utils.TestCase): def test_available_versions_basics(self): @@ -236,10 +234,10 @@ class AvailableVersionsTests(utils.TestCase): 'cinder': jsonutils.dumps(CINDER_EXAMPLES), 'glance': jsonutils.dumps(GLANCE_EXAMPLES)} - for path, ex in six.iteritems(examples): + for path, text in six.iteritems(examples): url = "%s%s" % (BASE_URL, path) - httpretty.register_uri(httpretty.GET, url, status=300, body=ex) + self.requests.register_uri('GET', url, status_code=300, text=text) versions = discover.available_versions(url) for v in versions: @@ -249,8 +247,8 @@ class AvailableVersionsTests(utils.TestCase): matchers.Contains(n))) def test_available_versions_individual(self): - httpretty.register_uri(httpretty.GET, V3_URL, status=200, - body=V3_VERSION_ENTRY) + self.requests.register_uri('GET', V3_URL, status_code=200, + text=V3_VERSION_ENTRY) versions = discover.available_versions(V3_URL) @@ -261,8 +259,8 @@ class AvailableVersionsTests(utils.TestCase): self.assertIn('links', v) def test_available_keystone_data(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) versions = discover.available_versions(BASE_URL) self.assertEqual(2, len(versions)) @@ -276,8 +274,8 @@ class AvailableVersionsTests(utils.TestCase): self.assertEqual(v['media-types'], V3_MEDIA_TYPES) def test_available_cinder_data(self): - body = jsonutils.dumps(CINDER_EXAMPLES) - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, body=body) + text = jsonutils.dumps(CINDER_EXAMPLES) + self.requests.register_uri('GET', BASE_URL, status_code=300, text=text) versions = discover.available_versions(BASE_URL) self.assertEqual(2, len(versions)) @@ -292,8 +290,8 @@ class AvailableVersionsTests(utils.TestCase): self.fail("Invalid version found") def test_available_glance_data(self): - body = jsonutils.dumps(GLANCE_EXAMPLES) - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, body=body) + text = jsonutils.dumps(GLANCE_EXAMPLES) + self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) versions = discover.available_versions(BASE_URL) self.assertEqual(5, len(versions)) @@ -307,12 +305,13 @@ class AvailableVersionsTests(utils.TestCase): self.fail("Invalid version found") -@httpretty.activate class ClientDiscoveryTests(utils.TestCase): def assertCreatesV3(self, **kwargs): - httpretty.register_uri(httpretty.POST, "%s/auth/tokens" % V3_URL, - body=V3_AUTH_RESPONSE, X_Subject_Token=V3_TOKEN) + self.requests.register_uri('POST', + '%s/auth/tokens' % V3_URL, + text=V3_AUTH_RESPONSE, + headers={'X-Subject-Token': V3_TOKEN}) kwargs.setdefault('username', 'foo') kwargs.setdefault('password', 'bar') @@ -321,8 +320,8 @@ class ClientDiscoveryTests(utils.TestCase): return keystone def assertCreatesV2(self, **kwargs): - httpretty.register_uri(httpretty.POST, "%s/tokens" % V2_URL, - body=V2_AUTH_RESPONSE) + self.requests.register_uri('POST', "%s/tokens" % V2_URL, + text=V2_AUTH_RESPONSE) kwargs.setdefault('username', 'foo') kwargs.setdefault('password', 'bar') @@ -345,93 +344,94 @@ class ClientDiscoveryTests(utils.TestCase): client.Client, **kwargs) def test_discover_v3(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) self.assertCreatesV3(auth_url=BASE_URL) def test_discover_v2(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V2_VERSION_LIST) - httpretty.register_uri(httpretty.POST, "%s/tokens" % V2_URL, - body=V2_AUTH_RESPONSE) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V2_VERSION_LIST) + self.requests.register_uri('POST', "%s/tokens" % V2_URL, + text=V2_AUTH_RESPONSE) self.assertCreatesV2(auth_url=BASE_URL) def test_discover_endpoint_v2(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V2_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V2_VERSION_LIST) self.assertCreatesV2(endpoint=BASE_URL, token='fake-token') def test_discover_endpoint_v3(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) self.assertCreatesV3(endpoint=BASE_URL, token='fake-token') def test_discover_invalid_major_version(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) self.assertVersionNotAvailable(auth_url=BASE_URL, version=5) def test_discover_200_response_fails(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, body='ok') + self.requests.register_uri('GET', BASE_URL, + status_code=200, text='ok') self.assertDiscoveryFailure(auth_url=BASE_URL) def test_discover_minor_greater_than_available_fails(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) self.assertVersionNotAvailable(endpoint=BASE_URL, version=3.4) def test_discover_individual_version_v2(self): - httpretty.register_uri(httpretty.GET, V2_URL, status=200, - body=V2_VERSION_ENTRY) + self.requests.register_uri('GET', V2_URL, status_code=200, + text=V2_VERSION_ENTRY) self.assertCreatesV2(auth_url=V2_URL) def test_discover_individual_version_v3(self): - httpretty.register_uri(httpretty.GET, V3_URL, status=200, - body=V3_VERSION_ENTRY) + self.requests.register_uri('GET', V3_URL, status_code=200, + text=V3_VERSION_ENTRY) self.assertCreatesV3(auth_url=V3_URL) def test_discover_individual_endpoint_v2(self): - httpretty.register_uri(httpretty.GET, V2_URL, status=200, - body=V2_VERSION_ENTRY) + self.requests.register_uri('GET', V2_URL, status_code=200, + text=V2_VERSION_ENTRY) self.assertCreatesV2(endpoint=V2_URL, token='fake-token') def test_discover_individual_endpoint_v3(self): - httpretty.register_uri(httpretty.GET, V3_URL, status=200, - body=V3_VERSION_ENTRY) + self.requests.register_uri('GET', V3_URL, status_code=200, + text=V3_VERSION_ENTRY) self.assertCreatesV3(endpoint=V3_URL, token='fake-token') def test_discover_fail_to_create_bad_individual_version(self): - httpretty.register_uri(httpretty.GET, V2_URL, status=200, - body=V2_VERSION_ENTRY) - httpretty.register_uri(httpretty.GET, V3_URL, status=200, - body=V3_VERSION_ENTRY) + self.requests.register_uri('GET', V2_URL, status_code=200, + text=V2_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=V3_URL, version=2) def test_discover_unstable_versions(self): version_list = fixture.DiscoveryList(BASE_URL, v3_status='beta') - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=jsonutils.dumps(version_list)) + self.requests.register_uri('GET', BASE_URL, status_code=300, + json=version_list) self.assertCreatesV2(auth_url=BASE_URL) self.assertVersionNotAvailable(auth_url=BASE_URL, version=3) self.assertCreatesV3(auth_url=BASE_URL, unstable=True) def test_discover_forwards_original_ip(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) ip = '192.168.1.1' self.assertCreatesV3(auth_url=BASE_URL, original_ip=ip) - self.assertThat(httpretty.last_request().headers['forwarded'], + self.assertThat(self.requests.last_request.headers['forwarded'], matchers.Contains(ip)) def test_discover_bad_args(self): @@ -439,8 +439,8 @@ class ClientDiscoveryTests(utils.TestCase): client.Client) def test_discover_bad_response(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=jsonutils.dumps({'FOO': 'BAR'})) + self.requests.register_uri('GET', BASE_URL, status_code=300, + json={'FOO': 'BAR'}) self.assertDiscoveryFailure(auth_url=BASE_URL) def test_discovery_ignore_invalid(self): @@ -449,44 +449,44 @@ class ClientDiscoveryTests(utils.TestCase): 'media-types': V3_MEDIA_TYPES, 'status': 'stable', 'updated': UPDATED}] - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=_create_version_list(resp)) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=_create_version_list(resp)) self.assertDiscoveryFailure(auth_url=BASE_URL) def test_ignore_entry_without_links(self): v3 = V3_VERSION.copy() v3['links'] = [] - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=_create_version_list([v3, V2_VERSION])) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=_create_version_list([v3, V2_VERSION])) self.assertCreatesV2(auth_url=BASE_URL) def test_ignore_entry_without_status(self): v3 = V3_VERSION.copy() del v3['status'] - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=_create_version_list([v3, V2_VERSION])) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=_create_version_list([v3, V2_VERSION])) self.assertCreatesV2(auth_url=BASE_URL) def test_greater_version_than_required(self): versions = fixture.DiscoveryList(BASE_URL, v3_id='v3.6') - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, - body=jsonutils.dumps(versions)) + self.requests.register_uri('GET', BASE_URL, status_code=200, + json=versions) self.assertCreatesV3(auth_url=BASE_URL, version=(3, 4)) def test_lesser_version_than_required(self): versions = fixture.DiscoveryList(BASE_URL, v3_id='v3.4') - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, - body=jsonutils.dumps(versions)) + self.requests.register_uri('GET', BASE_URL, status_code=200, + json=versions) self.assertVersionNotAvailable(auth_url=BASE_URL, version=(3, 6)) def test_bad_response(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body="Ugly Duckling") + self.requests.register_uri('GET', BASE_URL, status_code=300, + text="Ugly Duckling") self.assertDiscoveryFailure(auth_url=BASE_URL) def test_pass_client_arguments(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V2_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V2_VERSION_LIST) kwargs = {'original_ip': '100', 'use_keyring': False, 'stale_duration': 15} @@ -497,11 +497,12 @@ class ClientDiscoveryTests(utils.TestCase): self.assertFalse(cl.use_keyring) def test_overriding_stored_kwargs(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) - httpretty.register_uri(httpretty.POST, "%s/auth/tokens" % V3_URL, - body=V3_AUTH_RESPONSE, X_Subject_Token=V3_TOKEN) + self.requests.register_uri('POST', "%s/auth/tokens" % V3_URL, + text=V3_AUTH_RESPONSE, + headers={'X-Subject-Token': V3_TOKEN}) disc = discover.Discover(auth_url=BASE_URL, debug=False, username='foo') @@ -514,8 +515,8 @@ class ClientDiscoveryTests(utils.TestCase): self.assertEqual(client.password, 'bar') def test_available_versions(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_ENTRY) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_ENTRY) disc = discover.Discover(auth_url=BASE_URL) versions = disc.available_versions() @@ -530,8 +531,8 @@ class ClientDiscoveryTests(utils.TestCase): 'updated': UPDATED} versions = fixture.DiscoveryList() versions.add_version(V4_VERSION) - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=jsonutils.dumps(versions)) + self.requests.register_uri('GET', BASE_URL, status_code=300, + json=versions) disc = discover.Discover(auth_url=BASE_URL) self.assertRaises(exceptions.DiscoveryFailure, @@ -539,20 +540,19 @@ class ClientDiscoveryTests(utils.TestCase): def test_discovery_fail_for_missing_v3(self): versions = fixture.DiscoveryList(v2=True, v3=False) - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=jsonutils.dumps(versions)) + self.requests.register_uri('GET', BASE_URL, status_code=300, + json=versions) disc = discover.Discover(auth_url=BASE_URL) self.assertRaises(exceptions.DiscoveryFailure, disc.create_client, version=(3, 0)) -@httpretty.activate class DiscoverQueryTests(utils.TestCase): def test_available_keystone_data(self): - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, - body=V3_VERSION_LIST) + self.requests.register_uri('GET', BASE_URL, status_code=300, + text=V3_VERSION_LIST) disc = discover.Discover(auth_url=BASE_URL) versions = disc.version_data() @@ -579,8 +579,8 @@ class DiscoverQueryTests(utils.TestCase): self.assertEqual(V2_URL, disc.url_for('v2')) def test_available_cinder_data(self): - body = jsonutils.dumps(CINDER_EXAMPLES) - httpretty.register_uri(httpretty.GET, BASE_URL, status=300, body=body) + text = jsonutils.dumps(CINDER_EXAMPLES) + self.requests.register_uri('GET', BASE_URL, status_code=300, text=text) v1_url = "%sv1/" % BASE_URL v2_url = "%sv2/" % BASE_URL @@ -610,8 +610,8 @@ class DiscoverQueryTests(utils.TestCase): self.assertEqual(v1_url, disc.url_for('v1')) def test_available_glance_data(self): - body = jsonutils.dumps(GLANCE_EXAMPLES) - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, body=body) + text = jsonutils.dumps(GLANCE_EXAMPLES) + self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) v1_url = "%sv1/" % BASE_URL v2_url = "%sv2/" % BASE_URL @@ -659,8 +659,8 @@ class DiscoverQueryTests(utils.TestCase): 'media-types': V3_MEDIA_TYPES, 'status': status, 'updated': UPDATED}] - body = jsonutils.dumps({'versions': version_list}) - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, body=body) + text = jsonutils.dumps({'versions': version_list}) + self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) disc = discover.Discover(auth_url=BASE_URL) @@ -681,8 +681,8 @@ class DiscoverQueryTests(utils.TestCase): 'media-types': V3_MEDIA_TYPES, 'status': status, 'updated': UPDATED}] - body = jsonutils.dumps({'versions': version_list}) - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, body=body) + text = jsonutils.dumps({'versions': version_list}) + self.requests.register_uri('GET', BASE_URL, status_code=200, text=text) disc = discover.Discover(auth_url=BASE_URL) @@ -699,9 +699,8 @@ class DiscoverQueryTests(utils.TestCase): status = 'abcdef' version_list = fixture.DiscoveryList(BASE_URL, v2=False, v3_status=status) - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, - body=jsonutils.dumps(version_list)) - + self.requests.register_uri('GET', BASE_URL, status_code=200, + json=version_list) disc = discover.Discover(auth_url=BASE_URL) versions = disc.version_data() @@ -729,8 +728,9 @@ class DiscoverQueryTests(utils.TestCase): 'links': [{'href': V3_URL, 'rel': 'self'}], }] - body = jsonutils.dumps({'versions': version_list}) - httpretty.register_uri(httpretty.GET, BASE_URL, status=200, body=body) + text = jsonutils.dumps({'versions': version_list}) + self.requests.register_uri('GET', BASE_URL, status_code=200, + text=text) disc = discover.Discover(auth_url=BASE_URL) diff --git a/keystoneclient/tests/test_http.py b/keystoneclient/tests/test_http.py index e089b7c93..118ad771c 100644 --- a/keystoneclient/tests/test_http.py +++ b/keystoneclient/tests/test_http.py @@ -14,7 +14,6 @@ import logging -import httpretty import six from testtools import matchers @@ -63,15 +62,14 @@ class ClientTest(utils.TestCase): self.assertRaises(exceptions.AuthorizationFailure, cl.put, '/hi') self.assertRaises(exceptions.AuthorizationFailure, cl.delete, '/hi') - @httpretty.activate def test_get(self): cl = get_authed_client() - self.stub_url(httpretty.GET, body=RESPONSE_BODY) + self.stub_url('GET', text=RESPONSE_BODY) resp, body = cl.get("/hi") - self.assertEqual(httpretty.last_request().method, 'GET') - self.assertEqual(httpretty.last_request().path, '/hi') + self.assertEqual(self.requests.last_request.method, 'GET') + self.assertEqual(self.requests.last_request.url, self.TEST_URL) self.assertRequestHeaderEqual('X-Auth-Token', 'token') self.assertRequestHeaderEqual('User-Agent', httpclient.USER_AGENT) @@ -79,15 +77,13 @@ class ClientTest(utils.TestCase): # Automatic JSON parsing self.assertEqual(body, {"hi": "there"}) - @httpretty.activate def test_get_error_with_plaintext_resp(self): cl = get_authed_client() - self.stub_url(httpretty.GET, status=400, - body='Some evil plaintext string') + self.stub_url('GET', status_code=400, + text='Some evil plaintext string') self.assertRaises(exceptions.BadRequest, cl.get, '/hi') - @httpretty.activate def test_get_error_with_json_resp(self): cl = get_authed_client() err_response = { @@ -97,7 +93,7 @@ class ClientTest(utils.TestCase): "message": "Error message string" } } - self.stub_url(httpretty.GET, status=400, json=err_response) + self.stub_url('GET', status_code=400, json=err_response) exc_raised = False try: cl.get('/hi') @@ -106,28 +102,26 @@ class ClientTest(utils.TestCase): self.assertEqual(exc.message, "Error message string") self.assertTrue(exc_raised, 'Exception not raised.') - @httpretty.activate def test_post(self): cl = get_authed_client() - self.stub_url(httpretty.POST) + self.stub_url('POST') cl.post("/hi", body=[1, 2, 3]) - self.assertEqual(httpretty.last_request().method, 'POST') - self.assertEqual(httpretty.last_request().body, b'[1, 2, 3]') + self.assertEqual(self.requests.last_request.method, 'POST') + self.assertEqual(self.requests.last_request.body, '[1, 2, 3]') self.assertRequestHeaderEqual('X-Auth-Token', 'token') self.assertRequestHeaderEqual('Content-Type', 'application/json') self.assertRequestHeaderEqual('User-Agent', httpclient.USER_AGENT) - @httpretty.activate def test_forwarded_for(self): ORIGINAL_IP = "10.100.100.1" cl = httpclient.HTTPClient(username="username", password="password", tenant_id="tenant", auth_url="auth_test", original_ip=ORIGINAL_IP) - self.stub_url(httpretty.GET) + self.stub_url('GET') cl.request(self.TEST_URL, 'GET') forwarded = "for=%s;by=%s" % (ORIGINAL_IP, httpclient.USER_AGENT) @@ -165,24 +159,24 @@ class BasicRequestTests(utils.TestCase): self.addCleanup(self.logger.removeHandler, handler) self.addCleanup(self.logger.setLevel, level) - def request(self, method='GET', response='Test Response', status=200, + def request(self, method='GET', response='Test Response', status_code=200, url=None, **kwargs): if not url: url = self.url - httpretty.register_uri(method, url, body=response, status=status) + self.requests.register_uri(method, url, text=response, + status_code=status_code) return httpclient.request(url, method, **kwargs) - @httpretty.activate def test_basic_params(self): method = 'GET' response = 'Test Response' status = 200 - self.request(method=method, status=status, response=response) + self.request(method=method, status_code=status, response=response) - self.assertEqual(httpretty.last_request().method, method) + self.assertEqual(self.requests.last_request.method, method) logger_message = self.logger_message.getvalue() @@ -194,7 +188,6 @@ class BasicRequestTests(utils.TestCase): self.assertThat(logger_message, matchers.Contains(str(status))) self.assertThat(logger_message, matchers.Contains(response)) - @httpretty.activate def test_headers(self): headers = {'key': 'val', 'test': 'other'} @@ -207,7 +200,6 @@ class BasicRequestTests(utils.TestCase): self.assertThat(self.logger_message.getvalue(), matchers.Contains('-H "%s: %s"' % header)) - @httpretty.activate def test_body(self): data = "BODY DATA" self.request(response=data) diff --git a/keystoneclient/tests/test_s3_token_middleware.py b/keystoneclient/tests/test_s3_token_middleware.py index c3272cc3e..0233e8b40 100644 --- a/keystoneclient/tests/test_s3_token_middleware.py +++ b/keystoneclient/tests/test_s3_token_middleware.py @@ -12,7 +12,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty import mock import requests import six @@ -54,10 +53,6 @@ class S3TokenMiddlewareTestBase(utils.TestCase): 'auth_protocol': self.TEST_PROTOCOL, } - httpretty.reset() - httpretty.enable() - self.addCleanup(httpretty.disable) - def start_fake_response(self, status, headers): self.response_status = int(status.split(' ', 1)[0]) self.response_headers = dict(headers) @@ -69,8 +64,8 @@ class S3TokenMiddlewareTestGood(S3TokenMiddlewareTestBase): super(S3TokenMiddlewareTestGood, self).setUp() self.middleware = s3_token.S3Token(FakeApp(), self.conf) - httpretty.register_uri(httpretty.POST, self.TEST_URL, - status=201, body=jsonutils.dumps(GOOD_RESPONSE)) + self.requests.register_uri('POST', self.TEST_URL, + status_code=201, json=GOOD_RESPONSE) # Ignore the request and pass to the next middleware in the # pipeline if no path has been specified. @@ -101,6 +96,12 @@ class S3TokenMiddlewareTestGood(S3TokenMiddlewareTestBase): self.assertEqual(req.headers['X-Auth-Token'], 'TOKEN_ID') def test_authorized_http(self): + TEST_URL = 'http://%s:%d/v2.0/s3tokens' % (self.TEST_HOST, + self.TEST_PORT) + + self.requests.register_uri('POST', TEST_URL, + status_code=201, json=GOOD_RESPONSE) + self.middleware = ( s3_token.filter_factory({'auth_protocol': 'http', 'auth_host': self.TEST_HOST, @@ -152,8 +153,8 @@ class S3TokenMiddlewareTestBad(S3TokenMiddlewareTestBase): {"message": "EC2 access key not found.", "code": 401, "title": "Unauthorized"}} - httpretty.register_uri(httpretty.POST, self.TEST_URL, - status=403, body=jsonutils.dumps(ret)) + self.requests.register_uri('POST', self.TEST_URL, + status_code=403, json=ret) req = webob.Request.blank('/v1/AUTH_cfa/c/o') req.headers['Authorization'] = 'access:signature' req.headers['X-Storage-Token'] = 'token' @@ -185,8 +186,8 @@ class S3TokenMiddlewareTestBad(S3TokenMiddlewareTestBase): self.assertEqual(resp.status_int, s3_invalid_req.status_int) def test_bad_reply(self): - httpretty.register_uri(httpretty.POST, self.TEST_URL, - status=201, body="") + self.requests.register_uri('POST', self.TEST_URL, + status_code=201, text="") req = webob.Request.blank('/v1/AUTH_cfa/c/o') req.headers['Authorization'] = 'access:signature' diff --git a/keystoneclient/tests/test_session.py b/keystoneclient/tests/test_session.py index 432ff6a7d..20596e6d0 100644 --- a/keystoneclient/tests/test_session.py +++ b/keystoneclient/tests/test_session.py @@ -13,7 +13,6 @@ import argparse import uuid -import httpretty import mock from oslo.config import cfg import requests @@ -33,73 +32,66 @@ class SessionTests(utils.TestCase): TEST_URL = 'http://127.0.0.1:5000/' - @httpretty.activate def test_get(self): session = client_session.Session() - self.stub_url(httpretty.GET, body='response') + self.stub_url('GET', text='response') resp = session.get(self.TEST_URL) - self.assertEqual(httpretty.GET, httpretty.last_request().method) + self.assertEqual('GET', self.requests.last_request.method) self.assertEqual(resp.text, 'response') self.assertTrue(resp.ok) - @httpretty.activate def test_post(self): session = client_session.Session() - self.stub_url(httpretty.POST, body='response') + self.stub_url('POST', text='response') resp = session.post(self.TEST_URL, json={'hello': 'world'}) - self.assertEqual(httpretty.POST, httpretty.last_request().method) + self.assertEqual('POST', self.requests.last_request.method) self.assertEqual(resp.text, 'response') self.assertTrue(resp.ok) self.assertRequestBodyIs(json={'hello': 'world'}) - @httpretty.activate def test_head(self): session = client_session.Session() - self.stub_url(httpretty.HEAD) + self.stub_url('HEAD') resp = session.head(self.TEST_URL) - self.assertEqual(httpretty.HEAD, httpretty.last_request().method) + self.assertEqual('HEAD', self.requests.last_request.method) self.assertTrue(resp.ok) self.assertRequestBodyIs('') - @httpretty.activate def test_put(self): session = client_session.Session() - self.stub_url(httpretty.PUT, body='response') + self.stub_url('PUT', text='response') resp = session.put(self.TEST_URL, json={'hello': 'world'}) - self.assertEqual(httpretty.PUT, httpretty.last_request().method) + self.assertEqual('PUT', self.requests.last_request.method) self.assertEqual(resp.text, 'response') self.assertTrue(resp.ok) self.assertRequestBodyIs(json={'hello': 'world'}) - @httpretty.activate def test_delete(self): session = client_session.Session() - self.stub_url(httpretty.DELETE, body='response') + self.stub_url('DELETE', text='response') resp = session.delete(self.TEST_URL) - self.assertEqual(httpretty.DELETE, httpretty.last_request().method) + self.assertEqual('DELETE', self.requests.last_request.method) self.assertTrue(resp.ok) self.assertEqual(resp.text, 'response') - @httpretty.activate def test_patch(self): session = client_session.Session() - self.stub_url(httpretty.PATCH, body='response') + self.stub_url('PATCH', text='response') resp = session.patch(self.TEST_URL, json={'hello': 'world'}) - self.assertEqual(httpretty.PATCH, httpretty.last_request().method) + self.assertEqual('PATCH', self.requests.last_request.method) self.assertTrue(resp.ok) self.assertEqual(resp.text, 'response') self.assertRequestBodyIs(json={'hello': 'world'}) - @httpretty.activate def test_user_agent(self): session = client_session.Session(user_agent='test-agent') - self.stub_url(httpretty.GET, body='response') + self.stub_url('GET', text='response') resp = session.get(self.TEST_URL) self.assertTrue(resp.ok) @@ -114,7 +106,6 @@ class SessionTests(utils.TestCase): self.assertTrue(resp.ok) self.assertRequestHeaderEqual('User-Agent', 'overrides-agent') - @httpretty.activate def test_http_session_opts(self): session = client_session.Session(cert='cert.pem', timeout=5, verify='certs') @@ -134,26 +125,23 @@ class SessionTests(utils.TestCase): self.assertEqual(mock_kwargs['verify'], 'certs') self.assertEqual(mock_kwargs['timeout'], 5) - @httpretty.activate def test_not_found(self): session = client_session.Session() - self.stub_url(httpretty.GET, status=404) + self.stub_url('GET', status_code=404) self.assertRaises(exceptions.NotFound, session.get, self.TEST_URL) - @httpretty.activate def test_server_error(self): session = client_session.Session() - self.stub_url(httpretty.GET, status=500) + self.stub_url('GET', status_code=500) self.assertRaises(exceptions.InternalServerError, session.get, self.TEST_URL) - @httpretty.activate def test_session_debug_output(self): session = client_session.Session(verify=False) headers = {'HEADERA': 'HEADERVALB'} body = 'BODYRESPONSE' data = 'BODYDATA' - self.stub_url(httpretty.POST, body=body) + self.stub_url('POST', text=body) session.post(self.TEST_URL, headers=headers, data=data) self.assertIn('curl', self.logger.output) @@ -177,37 +165,36 @@ class RedirectTests(utils.TestCase): DEFAULT_REDIRECT_BODY = 'Redirect' DEFAULT_RESP_BODY = 'Found' - def setup_redirects(self, method=httpretty.GET, status=305, + def setup_redirects(self, method='GET', status_code=305, redirect_kwargs={}, final_kwargs={}): - redirect_kwargs.setdefault('body', self.DEFAULT_REDIRECT_BODY) + redirect_kwargs.setdefault('text', self.DEFAULT_REDIRECT_BODY) for s, d in zip(self.REDIRECT_CHAIN, self.REDIRECT_CHAIN[1:]): - httpretty.register_uri(method, s, status=status, location=d, - **redirect_kwargs) + self.requests.register_uri(method, s, status_code=status_code, + headers={'Location': d}, + **redirect_kwargs) - final_kwargs.setdefault('status', 200) - final_kwargs.setdefault('body', self.DEFAULT_RESP_BODY) - httpretty.register_uri(method, self.REDIRECT_CHAIN[-1], **final_kwargs) + final_kwargs.setdefault('status_code', 200) + final_kwargs.setdefault('text', self.DEFAULT_RESP_BODY) + self.requests.register_uri(method, self.REDIRECT_CHAIN[-1], + **final_kwargs) def assertResponse(self, resp): self.assertEqual(resp.status_code, 200) self.assertEqual(resp.text, self.DEFAULT_RESP_BODY) - @httpretty.activate def test_basic_get(self): session = client_session.Session() self.setup_redirects() resp = session.get(self.REDIRECT_CHAIN[-2]) self.assertResponse(resp) - @httpretty.activate def test_basic_post_keeps_correct_method(self): session = client_session.Session() - self.setup_redirects(method=httpretty.POST, status=301) + self.setup_redirects(method='POST', status_code=301) resp = session.post(self.REDIRECT_CHAIN[-2]) self.assertResponse(resp) - @httpretty.activate def test_redirect_forever(self): session = client_session.Session(redirect=True) self.setup_redirects() @@ -215,7 +202,6 @@ class RedirectTests(utils.TestCase): self.assertResponse(resp) self.assertTrue(len(resp.history), len(self.REDIRECT_CHAIN)) - @httpretty.activate def test_no_redirect(self): session = client_session.Session(redirect=False) self.setup_redirects() @@ -223,7 +209,6 @@ class RedirectTests(utils.TestCase): self.assertEqual(resp.status_code, 305) self.assertEqual(resp.url, self.REDIRECT_CHAIN[0]) - @httpretty.activate def test_redirect_limit(self): self.setup_redirects() for i in (1, 2): @@ -233,9 +218,8 @@ class RedirectTests(utils.TestCase): self.assertEqual(resp.url, self.REDIRECT_CHAIN[i]) self.assertEqual(resp.text, self.DEFAULT_REDIRECT_BODY) - @httpretty.activate def test_history_matches_requests(self): - self.setup_redirects(status=301) + self.setup_redirects(status_code=301) session = client_session.Session(redirect=True) req_resp = requests.get(self.REDIRECT_CHAIN[0], allow_redirects=True) @@ -345,13 +329,12 @@ class SessionAuthTests(utils.TestCase): TEST_JSON = {'hello': 'world'} def stub_service_url(self, service_type, interface, path, - method=httpretty.GET, **kwargs): + method='GET', **kwargs): base_url = AuthPlugin.SERVICE_URLS[service_type][interface] uri = "%s/%s" % (base_url.rstrip('/'), path.lstrip('/')) - httpretty.register_uri(method, uri, **kwargs) + self.requests.register_uri(method, uri, **kwargs) - @httpretty.activate def test_auth_plugin_default_with_plugin(self): self.stub_url('GET', base_url=self.TEST_URL, json=self.TEST_JSON) @@ -363,7 +346,6 @@ class SessionAuthTests(utils.TestCase): self.assertRequestHeaderEqual('X-Auth-Token', AuthPlugin.TEST_TOKEN) - @httpretty.activate def test_auth_plugin_disable(self): self.stub_url('GET', base_url=self.TEST_URL, json=self.TEST_JSON) @@ -374,7 +356,6 @@ class SessionAuthTests(utils.TestCase): self.assertRequestHeaderEqual('X-Auth-Token', None) - @httpretty.activate def test_service_type_urls(self): service_type = 'compute' interface = 'public' @@ -385,15 +366,16 @@ class SessionAuthTests(utils.TestCase): self.stub_service_url(service_type=service_type, interface=interface, path=path, - status=status, - body=body) + status_code=status, + text=body) sess = client_session.Session(auth=AuthPlugin()) resp = sess.get(path, endpoint_filter={'service_type': service_type, 'interface': interface}) - self.assertEqual(httpretty.last_request().path, '/v1.0/instances') + self.assertEqual(self.requests.last_request.url, + AuthPlugin.SERVICE_URLS['compute']['public'] + path) self.assertEqual(resp.text, body) self.assertEqual(resp.status_code, status) @@ -411,12 +393,10 @@ class SessionAuthTests(utils.TestCase): endpoint_filter={'service_type': 'unknown', 'interface': 'public'}) - @httpretty.activate def test_raises_exc_only_when_asked(self): # 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 - - self.stub_url(httpretty.GET, status=401) + self.requests.register_uri('GET', self.TEST_URL, status_code=401) sess = client_session.Session() self.assertRaises(exceptions.Unauthorized, sess.get, self.TEST_URL) @@ -424,14 +404,13 @@ class SessionAuthTests(utils.TestCase): resp = sess.get(self.TEST_URL, raise_exc=False) self.assertEqual(401, resp.status_code) - @httpretty.activate def test_passed_auth_plugin(self): passed = CalledAuthPlugin() sess = client_session.Session() - httpretty.register_uri(httpretty.GET, - CalledAuthPlugin.ENDPOINT + 'path', - status=200) + self.requests.register_uri('GET', + CalledAuthPlugin.ENDPOINT + 'path', + status_code=200) endpoint_filter = {'service_type': 'identity'} # no plugin with authenticated won't work @@ -448,16 +427,15 @@ class SessionAuthTests(utils.TestCase): self.assertTrue(passed.get_endpoint_called) self.assertTrue(passed.get_token_called) - @httpretty.activate def test_passed_auth_plugin_overrides(self): fixed = CalledAuthPlugin() passed = CalledAuthPlugin() sess = client_session.Session(fixed) - httpretty.register_uri(httpretty.GET, - CalledAuthPlugin.ENDPOINT + 'path', - status=200) + self.requests.register_uri('GET', + CalledAuthPlugin.ENDPOINT + 'path', + status_code=200) resp = sess.get('path', auth=passed, endpoint_filter={'service_type': 'identity'}) @@ -485,15 +463,13 @@ class SessionAuthTests(utils.TestCase): auth=requests_auth, verify=mock.ANY) - @httpretty.activate def test_reauth_called(self): auth = CalledAuthPlugin(invalidate=True) sess = client_session.Session(auth=auth) - responses = [httpretty.Response(body='Failed', status=401), - httpretty.Response(body='Hello', status=200)] - httpretty.register_uri(httpretty.GET, self.TEST_URL, - responses=responses) + self.requests.register_uri('GET', self.TEST_URL, + [{'text': 'Failed', 'status_code': 401}, + {'text': 'Hello', 'status_code': 200}]) # allow_reauth=True is the default resp = sess.get(self.TEST_URL, authenticated=True) @@ -502,15 +478,13 @@ class SessionAuthTests(utils.TestCase): self.assertEqual('Hello', resp.text) self.assertTrue(auth.invalidate_called) - @httpretty.activate def test_reauth_not_called(self): auth = CalledAuthPlugin(invalidate=True) sess = client_session.Session(auth=auth) - responses = [httpretty.Response(body='Failed', status=401), - httpretty.Response(body='Hello', status=200)] - httpretty.register_uri(httpretty.GET, self.TEST_URL, - responses=responses) + self.requests.register_uri('GET', self.TEST_URL, + [{'text': 'Failed', 'status_code': 401}, + {'text': 'Hello', 'status_code': 200}]) self.assertRaises(exceptions.Unauthorized, sess.get, self.TEST_URL, authenticated=True, allow_reauth=False) @@ -527,10 +501,9 @@ class AdapterTest(utils.TestCase): TEST_URL = CalledAuthPlugin.ENDPOINT - @httpretty.activate def test_setting_variables(self): response = uuid.uuid4().hex - self.stub_url(httpretty.GET, body=response) + self.stub_url('GET', text=response) auth = CalledAuthPlugin() sess = client_session.Session() @@ -557,13 +530,12 @@ class AdapterTest(utils.TestCase): self.assertTrue(auth.get_token_called) self.assertRequestHeaderEqual('User-Agent', self.USER_AGENT) - @httpretty.activate def test_legacy_binding(self): key = uuid.uuid4().hex val = uuid.uuid4().hex response = jsonutils.dumps({key: val}) - self.stub_url(httpretty.GET, body=response) + self.stub_url('GET', text=response) auth = CalledAuthPlugin() sess = client_session.Session(auth=auth) @@ -577,10 +549,10 @@ class AdapterTest(utils.TestCase): self.assertEqual(resp.text, response) self.assertEqual(val, body[key]) - @httpretty.activate def test_legacy_binding_non_json_resp(self): response = uuid.uuid4().hex - self.stub_url(httpretty.GET, body=response, content_type='text/html') + self.stub_url('GET', text=response, + headers={'Content-Type': 'text/html'}) auth = CalledAuthPlugin() sess = client_session.Session(auth=auth) diff --git a/keystoneclient/tests/utils.py b/keystoneclient/tests/utils.py index 1ef3927c7..4465835e7 100644 --- a/keystoneclient/tests/utils.py +++ b/keystoneclient/tests/utils.py @@ -16,10 +16,10 @@ import time import uuid import fixtures -import httpretty import mock from mox3 import mox import requests +from requests_mock.contrib import fixture import six from six.moves.urllib import parse as urlparse import testtools @@ -28,6 +28,7 @@ from keystoneclient.openstack.common import jsonutils class TestCase(testtools.TestCase): + TEST_DOMAIN_ID = '1' TEST_DOMAIN_NAME = 'aDomain' TEST_GROUP_ID = uuid.uuid4().hex @@ -48,6 +49,8 @@ class TestCase(testtools.TestCase): self.time_patcher = mock.patch.object(time, 'time', lambda: 1234) self.time_patcher.start() + self.requests = self.useFixture(fixture.Fixture()) + def tearDown(self): self.time_patcher.stop() self.mox.UnsetStubs() @@ -59,23 +62,20 @@ class TestCase(testtools.TestCase): base_url = self.TEST_URL if json: - kwargs['body'] = jsonutils.dumps(json) - kwargs['content_type'] = 'application/json' + kwargs['text'] = jsonutils.dumps(json) + headers = kwargs.setdefault('headers', {}) + headers['Content-Type'] = 'application/json' if parts: url = '/'.join([p.strip('/') for p in [base_url] + parts]) else: url = base_url - # For urls containing queries url = url.replace("/?", "?") - httpretty.register_uri(method, url, **kwargs) + self.requests.register_uri(method, url, **kwargs) def assertRequestBodyIs(self, body=None, json=None): - last_request_body = httpretty.last_request().body - if six.PY3: - last_request_body = last_request_body.decode('utf-8') - + last_request_body = self.requests.last_request.body if json: val = jsonutils.loads(last_request_body) self.assertEqual(json, val) @@ -88,10 +88,13 @@ class TestCase(testtools.TestCase): The qs parameter should be of the format \'foo=bar&abc=xyz\' """ expected = urlparse.parse_qs(qs) - self.assertEqual(expected, httpretty.last_request().querystring) + parts = urlparse.urlparse(self.requests.last_request.url) + querystring = urlparse.parse_qs(parts.query) + self.assertEqual(expected, querystring) def assertQueryStringContains(self, **kwargs): - qs = httpretty.last_request().querystring + parts = urlparse.urlparse(self.requests.last_request.url) + qs = urlparse.parse_qs(parts.query) for k, v in six.iteritems(kwargs): self.assertIn(k, qs) @@ -100,10 +103,9 @@ class TestCase(testtools.TestCase): def assertRequestHeaderEqual(self, name, val): """Verify that the last request made contains a header and its value - The request must have already been made and httpretty must have been - activated for the request. + The request must have already been made. """ - headers = httpretty.last_request().headers + headers = self.requests.last_request.headers self.assertEqual(headers.get(name), val) diff --git a/keystoneclient/tests/v2_0/test_auth.py b/keystoneclient/tests/v2_0/test_auth.py index 0e03140d2..0c426990e 100644 --- a/keystoneclient/tests/v2_0/test_auth.py +++ b/keystoneclient/tests/v2_0/test_auth.py @@ -10,11 +10,8 @@ # License for the specific language governing permissions and limitations # under the License. +import copy import datetime -import json - -import httpretty -import six from keystoneclient import exceptions from keystoneclient.openstack.common import jsonutils @@ -51,26 +48,23 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): }, } - @httpretty.activate def test_authenticate_success_expired(self): - # Build an expired token - self.TEST_RESPONSE_DICT['access']['token']['expires'] = ( - (timeutils.utcnow() - datetime.timedelta(1)).isoformat()) + resp_a = copy.deepcopy(self.TEST_RESPONSE_DICT) + resp_b = copy.deepcopy(self.TEST_RESPONSE_DICT) + headers = {'Content-Type': 'application/json'} - exp_resp = httpretty.Response(body=json.dumps(self.TEST_RESPONSE_DICT), - content_type='application/json') + # Build an expired token + resp_a['access']['token']['expires'] = ( + (timeutils.utcnow() - datetime.timedelta(1)).isoformat()) # Build a new response TEST_TOKEN = "abcdef" - self.TEST_RESPONSE_DICT['access']['token']['expires'] = ( - '2020-01-01T00:00:10.000123Z') - self.TEST_RESPONSE_DICT['access']['token']['id'] = TEST_TOKEN - - new_resp = httpretty.Response(body=json.dumps(self.TEST_RESPONSE_DICT), - content_type='application/json') + resp_b['access']['token']['expires'] = '2020-01-01T00:00:10.000123Z' + resp_b['access']['token']['id'] = TEST_TOKEN # return expired first, and then the new response - self.stub_auth(responses=[exp_resp, new_resp]) + self.stub_auth(response_list=[{'json': resp_a, 'headers': headers}, + {'json': resp_b, 'headers': headers}]) cs = client.Client(tenant_id=self.TEST_TENANT_ID, auth_url=self.TEST_URL, @@ -84,7 +78,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertEqual(cs.auth_token, TEST_TOKEN) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_failure(self): _auth = 'auth' _cred = 'passwordCredentials' @@ -93,7 +86,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): error = {"unauthorized": {"message": "Unauthorized", "code": "401"}} - self.stub_auth(status=401, json=error) + self.stub_auth(status_code=401, json=error) # Workaround for issue with assertRaises on python2.6 # where with assertRaises(exceptions.Unauthorized): doesn't work @@ -107,10 +100,9 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertRaises(exceptions.Unauthorized, client_create_wrapper) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_auth_redirect(self): - self.stub_auth(status=305, body='Use Proxy', - location=self.TEST_ADMIN_URL + "/tokens") + self.stub_auth(status_code=305, body='Use Proxy', + headers={'Location': self.TEST_ADMIN_URL + "/tokens"}) self.stub_auth(base_url=self.TEST_ADMIN_URL, json=self.TEST_RESPONSE_DICT) @@ -127,7 +119,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_DICT["access"]["token"]["id"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_password_scoped(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) @@ -142,7 +133,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_DICT["access"]["token"]["id"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_password_unscoped(self): del self.TEST_RESPONSE_DICT['access']['serviceCatalog'] del self.TEST_REQUEST_BODY['auth']['tenantId'] @@ -157,7 +147,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertFalse('serviceCatalog' in cs.service_catalog.catalog) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_auth_url_token_authentication(self): fake_token = 'fake_token' fake_url = '/fake-url' @@ -169,19 +158,15 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): cl = client.Client(auth_url=self.TEST_URL, token=fake_token) - body = httpretty.last_request().body - if six.PY3: - body = body.decode('utf-8') - body = jsonutils.loads(body) - self.assertEqual(body['auth']['token']['id'], fake_token) + json_body = jsonutils.loads(self.requests.last_request.body) + self.assertEqual(json_body['auth']['token']['id'], fake_token) resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - self.TEST_TOKEN) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(self.TEST_TOKEN, token) - @httpretty.activate def test_authenticate_success_token_scoped(self): del self.TEST_REQUEST_BODY['auth']['passwordCredentials'] self.TEST_REQUEST_BODY['auth']['token'] = {'id': self.TEST_TOKEN} @@ -197,7 +182,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_DICT["access"]["token"]["id"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_token_scoped_trust(self): del self.TEST_REQUEST_BODY['auth']['passwordCredentials'] self.TEST_REQUEST_BODY['auth']['token'] = {'id': self.TEST_TOKEN} @@ -216,7 +200,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertEqual(cs.auth_ref.trustee_user_id, self.TEST_USER) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_token_unscoped(self): del self.TEST_REQUEST_BODY['auth']['passwordCredentials'] del self.TEST_REQUEST_BODY['auth']['tenantId'] @@ -232,7 +215,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertFalse('serviceCatalog' in cs.service_catalog.catalog) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_allow_override_of_auth_token(self): fake_url = '/fake-url' fake_token = 'fake_token' @@ -253,8 +235,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - self.TEST_TOKEN) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(self.TEST_TOKEN, token) # then override that token and the new token shall be used cl.auth_token = fake_token @@ -262,8 +244,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - fake_token) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(fake_token, token) # if we clear that overridden token then we fall back to the original del cl.auth_token @@ -271,5 +253,5 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - self.TEST_TOKEN) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(self.TEST_TOKEN, token) diff --git a/keystoneclient/tests/v2_0/test_client.py b/keystoneclient/tests/v2_0/test_client.py index fac0a5ba9..61d2cd2e2 100644 --- a/keystoneclient/tests/v2_0/test_client.py +++ b/keystoneclient/tests/v2_0/test_client.py @@ -12,8 +12,6 @@ import json -import httpretty - from keystoneclient import exceptions from keystoneclient import fixture from keystoneclient.tests.v2_0 import client_fixtures @@ -23,7 +21,6 @@ from keystoneclient.v2_0 import client class KeystoneClientTest(utils.TestCase): - @httpretty.activate def test_unscoped_init(self): self.stub_auth(json=client_fixtures.unscoped_token()) @@ -37,7 +34,6 @@ class KeystoneClientTest(utils.TestCase): self.assertIsNone(c.auth_ref.trust_id) self.assertFalse(c.auth_ref.trust_scoped) - @httpretty.activate def test_scoped_init(self): self.stub_auth(json=client_fixtures.project_scoped_token()) @@ -52,7 +48,6 @@ class KeystoneClientTest(utils.TestCase): self.assertIsNone(c.auth_ref.trust_id) self.assertFalse(c.auth_ref.trust_scoped) - @httpretty.activate def test_auth_ref_load(self): self.stub_auth(json=client_fixtures.project_scoped_token()) @@ -73,7 +68,6 @@ class KeystoneClientTest(utils.TestCase): self.assertEqual(new_client.management_url, 'http://admin:35357/v2.0') - @httpretty.activate def test_auth_ref_load_with_overridden_arguments(self): self.stub_auth(json=client_fixtures.project_scoped_token()) @@ -104,7 +98,6 @@ class KeystoneClientTest(utils.TestCase): username='exampleuser', password='password') - @httpretty.activate def test_management_url_is_updated(self): first = fixture.V2Token() first.set_scope() @@ -121,19 +114,17 @@ class KeystoneClientTest(utils.TestCase): s.add_endpoint(public='http://secondurl:5000/v2.0', admin=second_url) - self.stub_auth(json=first) + self.stub_auth(response_list=[{'json': first}, {'json': second}]) + cl = client.Client(username='exampleuser', password='password', tenant_name='exampleproject', auth_url=self.TEST_URL) - cl.authenticate() self.assertEqual(cl.management_url, admin_url) - self.stub_auth(json=second) cl.authenticate() self.assertEqual(cl.management_url, second_url) - @httpretty.activate def test_client_with_region_name_passes_to_service_catalog(self): # NOTE(jamielennox): this is deprecated behaviour that should be # removed ASAP, however must remain compatible. diff --git a/keystoneclient/tests/v2_0/test_discovery.py b/keystoneclient/tests/v2_0/test_discovery.py index a3192c9da..7c4f320f9 100644 --- a/keystoneclient/tests/v2_0/test_discovery.py +++ b/keystoneclient/tests/v2_0/test_discovery.py @@ -10,7 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty from keystoneclient.generic import client from keystoneclient.tests.v2_0 import utils @@ -52,9 +51,8 @@ class DiscoverKeystoneTests(utils.UnauthenticatedTestCase): }, } - @httpretty.activate def test_get_versions(self): - self.stub_url(httpretty.GET, base_url=self.TEST_ROOT_URL, + self.stub_url('GET', base_url=self.TEST_ROOT_URL, json=self.TEST_RESPONSE_DICT) cs = client.Client() @@ -67,9 +65,8 @@ class DiscoverKeystoneTests(utils.UnauthenticatedTestCase): self.TEST_RESPONSE_DICT['versions']['values'][0]['links'][0] ['href']) - @httpretty.activate def test_get_version_local(self): - self.stub_url(httpretty.GET, base_url="http://localhost:35357/", + self.stub_url('GET', base_url="http://localhost:35357/", json=self.TEST_RESPONSE_DICT) cs = client.Client() diff --git a/keystoneclient/tests/v2_0/test_ec2.py b/keystoneclient/tests/v2_0/test_ec2.py index dbdaadd39..cfb6fa813 100644 --- a/keystoneclient/tests/v2_0/test_ec2.py +++ b/keystoneclient/tests/v2_0/test_ec2.py @@ -10,15 +10,12 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty - from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import ec2 class EC2Tests(utils.TestCase): - @httpretty.activate def test_create(self): user_id = 'usr' tenant_id = 'tnt' @@ -34,8 +31,8 @@ class EC2Tests(utils.TestCase): "enabled": True, } } - self.stub_url(httpretty.POST, ['users', user_id, 'credentials', - 'OS-EC2'], json=resp_body) + self.stub_url('POST', ['users', user_id, 'credentials', + 'OS-EC2'], json=resp_body) cred = self.client.ec2.create(user_id, tenant_id) self.assertIsInstance(cred, ec2.EC2) @@ -45,7 +42,6 @@ class EC2Tests(utils.TestCase): self.assertEqual(cred.secret, 'secret') self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_get(self): user_id = 'usr' tenant_id = 'tnt' @@ -58,8 +54,8 @@ class EC2Tests(utils.TestCase): "enabled": True, } } - self.stub_url(httpretty.GET, ['users', user_id, 'credentials', - 'OS-EC2', 'access'], json=resp_body) + self.stub_url('GET', ['users', user_id, 'credentials', + 'OS-EC2', 'access'], json=resp_body) cred = self.client.ec2.get(user_id, 'access') self.assertIsInstance(cred, ec2.EC2) @@ -68,7 +64,6 @@ class EC2Tests(utils.TestCase): self.assertEqual(cred.access, 'access') self.assertEqual(cred.secret, 'secret') - @httpretty.activate def test_list(self): user_id = 'usr' tenant_id = 'tnt' @@ -92,8 +87,8 @@ class EC2Tests(utils.TestCase): ] } } - self.stub_url(httpretty.GET, ['users', user_id, 'credentials', - 'OS-EC2'], json=resp_body) + self.stub_url('GET', ['users', user_id, 'credentials', + 'OS-EC2'], json=resp_body) creds = self.client.ec2.list(user_id) self.assertEqual(len(creds), 2) @@ -104,10 +99,9 @@ class EC2Tests(utils.TestCase): self.assertEqual(cred.access, 'access') self.assertEqual(cred.secret, 'secret') - @httpretty.activate def test_delete(self): user_id = 'usr' access = 'access' - self.stub_url(httpretty.DELETE, ['users', user_id, 'credentials', - 'OS-EC2', access], status=204) + self.stub_url('DELETE', ['users', user_id, 'credentials', + 'OS-EC2', access], status_code=204) self.client.ec2.delete(user_id, access) diff --git a/keystoneclient/tests/v2_0/test_endpoints.py b/keystoneclient/tests/v2_0/test_endpoints.py index 1f94534ed..5272ca05f 100644 --- a/keystoneclient/tests/v2_0/test_endpoints.py +++ b/keystoneclient/tests/v2_0/test_endpoints.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import endpoints @@ -40,7 +38,6 @@ class EndpointTests(utils.TestCase): ] } - @httpretty.activate def test_create_with_optional_params(self): req_body = { "endpoint": { @@ -62,7 +59,7 @@ class EndpointTests(utils.TestCase): } } - self.stub_url(httpretty.POST, ['endpoints'], json=resp_body) + self.stub_url('POST', ['endpoints'], json=resp_body) endpoint = self.client.endpoints.create( region=req_body['endpoint']['region'], @@ -74,7 +71,6 @@ class EndpointTests(utils.TestCase): self.assertIsInstance(endpoint, endpoints.Endpoint) self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_create_with_optional_params_as_none(self): req_body_without_defaults = { "endpoint": { @@ -96,7 +92,7 @@ class EndpointTests(utils.TestCase): } } - self.stub_url(httpretty.POST, ['endpoints'], json=resp_body) + self.stub_url('POST', ['endpoints'], json=resp_body) endpoint_without_defaults = self.client.endpoints.create( region=req_body_without_defaults['endpoint']['region'], @@ -108,7 +104,6 @@ class EndpointTests(utils.TestCase): self.assertIsInstance(endpoint_without_defaults, endpoints.Endpoint) self.assertRequestBodyIs(json=req_body_without_defaults) - @httpretty.activate def test_create_without_optional_params(self): req_body_without_defaults = { "endpoint": { @@ -130,7 +125,7 @@ class EndpointTests(utils.TestCase): } } - self.stub_url(httpretty.POST, ['endpoints'], json=resp_body) + self.stub_url('POST', ['endpoints'], json=resp_body) endpoint_without_defaults = self.client.endpoints.create( region=req_body_without_defaults['endpoint']['region'], @@ -140,14 +135,12 @@ class EndpointTests(utils.TestCase): self.assertIsInstance(endpoint_without_defaults, endpoints.Endpoint) self.assertRequestBodyIs(json=req_body_without_defaults) - @httpretty.activate def test_delete(self): - self.stub_url(httpretty.DELETE, ['endpoints', '8f953'], status=204) + self.stub_url('DELETE', ['endpoints', '8f953'], status_code=204) self.client.endpoints.delete('8f953') - @httpretty.activate def test_list(self): - self.stub_url(httpretty.GET, ['endpoints'], json=self.TEST_ENDPOINTS) + self.stub_url('GET', ['endpoints'], json=self.TEST_ENDPOINTS) endpoint_list = self.client.endpoints.list() [self.assertIsInstance(r, endpoints.Endpoint) diff --git a/keystoneclient/tests/v2_0/test_extensions.py b/keystoneclient/tests/v2_0/test_extensions.py index 6f4787d9c..6a77a5ddb 100644 --- a/keystoneclient/tests/v2_0/test_extensions.py +++ b/keystoneclient/tests/v2_0/test_extensions.py @@ -10,8 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty - from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import extensions @@ -51,9 +49,8 @@ class ExtensionTests(utils.TestCase): } } - @httpretty.activate def test_list(self): - self.stub_url(httpretty.GET, ['extensions'], json=self.TEST_EXTENSIONS) + self.stub_url('GET', ['extensions'], json=self.TEST_EXTENSIONS) extensions_list = self.client.extensions.list() self.assertEqual(2, len(extensions_list)) for extension in extensions_list: diff --git a/keystoneclient/tests/v2_0/test_roles.py b/keystoneclient/tests/v2_0/test_roles.py index b896c753c..bd272246b 100644 --- a/keystoneclient/tests/v2_0/test_roles.py +++ b/keystoneclient/tests/v2_0/test_roles.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import roles @@ -40,7 +38,6 @@ class RoleTests(utils.TestCase): }, } - @httpretty.activate def test_create(self): req_body = { "role": { @@ -54,7 +51,7 @@ class RoleTests(utils.TestCase): "id": role_id, } } - self.stub_url(httpretty.POST, ['OS-KSADM', 'roles'], json=resp_body) + self.stub_url('POST', ['OS-KSADM', 'roles'], json=resp_body) role = self.client.roles.create(req_body['role']['name']) self.assertRequestBodyIs(json=req_body) @@ -62,15 +59,14 @@ class RoleTests(utils.TestCase): self.assertEqual(role.id, role_id) self.assertEqual(role.name, req_body['role']['name']) - @httpretty.activate def test_delete(self): - self.stub_url(httpretty.DELETE, - ['OS-KSADM', 'roles', self.ADMIN_ROLE_ID], status=204) + self.stub_url('DELETE', + ['OS-KSADM', 'roles', self.ADMIN_ROLE_ID], + status_code=204) self.client.roles.delete(self.ADMIN_ROLE_ID) - @httpretty.activate def test_get(self): - self.stub_url(httpretty.GET, ['OS-KSADM', 'roles', self.ADMIN_ROLE_ID], + self.stub_url('GET', ['OS-KSADM', 'roles', self.ADMIN_ROLE_ID], json={'role': self.TEST_ROLES['roles']['values'][0]}) role = self.client.roles.get(self.ADMIN_ROLE_ID) @@ -78,55 +74,48 @@ class RoleTests(utils.TestCase): self.assertEqual(role.id, self.ADMIN_ROLE_ID) self.assertEqual(role.name, 'admin') - @httpretty.activate def test_list(self): - self.stub_url(httpretty.GET, ['OS-KSADM', 'roles'], + self.stub_url('GET', ['OS-KSADM', 'roles'], json=self.TEST_ROLES) role_list = self.client.roles.list() [self.assertIsInstance(r, roles.Role) for r in role_list] - @httpretty.activate def test_roles_for_user(self): - self.stub_url(httpretty.GET, ['users', 'foo', 'roles'], + self.stub_url('GET', ['users', 'foo', 'roles'], json=self.TEST_ROLES) role_list = self.client.roles.roles_for_user('foo') [self.assertIsInstance(r, roles.Role) for r in role_list] - @httpretty.activate def test_roles_for_user_tenant(self): - self.stub_url(httpretty.GET, ['tenants', 'barrr', 'users', 'foo', - 'roles'], json=self.TEST_ROLES) + self.stub_url('GET', ['tenants', 'barrr', 'users', 'foo', + 'roles'], json=self.TEST_ROLES) role_list = self.client.roles.roles_for_user('foo', 'barrr') [self.assertIsInstance(r, roles.Role) for r in role_list] - @httpretty.activate def test_add_user_role(self): - self.stub_url(httpretty.PUT, ['users', 'foo', 'roles', 'OS-KSADM', - 'barrr'], status=204) + self.stub_url('PUT', ['users', 'foo', 'roles', 'OS-KSADM', + 'barrr'], status_code=204) self.client.roles.add_user_role('foo', 'barrr') - @httpretty.activate def test_add_user_role_tenant(self): id_ = uuid.uuid4().hex - self.stub_url(httpretty.PUT, ['tenants', id_, 'users', 'foo', 'roles', - 'OS-KSADM', 'barrr'], status=204) + self.stub_url('PUT', ['tenants', id_, 'users', 'foo', 'roles', + 'OS-KSADM', 'barrr'], status_code=204) self.client.roles.add_user_role('foo', 'barrr', id_) - @httpretty.activate def test_remove_user_role(self): - self.stub_url(httpretty.DELETE, ['users', 'foo', 'roles', 'OS-KSADM', - 'barrr'], status=204) + self.stub_url('DELETE', ['users', 'foo', 'roles', 'OS-KSADM', + 'barrr'], status_code=204) self.client.roles.remove_user_role('foo', 'barrr') - @httpretty.activate def test_remove_user_role_tenant(self): id_ = uuid.uuid4().hex - self.stub_url(httpretty.DELETE, ['tenants', id_, 'users', 'foo', - 'roles', 'OS-KSADM', 'barrr'], - status=204) + self.stub_url('DELETE', ['tenants', id_, 'users', 'foo', + 'roles', 'OS-KSADM', 'barrr'], + status_code=204) self.client.roles.remove_user_role('foo', 'barrr', id_) diff --git a/keystoneclient/tests/v2_0/test_services.py b/keystoneclient/tests/v2_0/test_services.py index 79a19ebe0..aec6811b5 100644 --- a/keystoneclient/tests/v2_0/test_services.py +++ b/keystoneclient/tests/v2_0/test_services.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import services @@ -44,7 +42,6 @@ class ServiceTests(utils.TestCase): }, } - @httpretty.activate def test_create(self): req_body = { "OS-KSADM:service": { @@ -62,7 +59,7 @@ class ServiceTests(utils.TestCase): "id": service_id, } } - self.stub_url(httpretty.POST, ['OS-KSADM', 'services'], json=resp_body) + self.stub_url('POST', ['OS-KSADM', 'services'], json=resp_body) service = self.client.services.create( req_body['OS-KSADM:service']['name'], @@ -73,20 +70,17 @@ class ServiceTests(utils.TestCase): self.assertEqual(service.name, req_body['OS-KSADM:service']['name']) self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_delete(self): - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', ['OS-KSADM', 'services', self.NOVA_SERVICE_ID], - status=204) + status_code=204) self.client.services.delete(self.NOVA_SERVICE_ID) - @httpretty.activate def test_get(self): test_services = self.TEST_SERVICES['OS-KSADM:services']['values'][0] - self.stub_url(httpretty.GET, - ['OS-KSADM', 'services', self.NOVA_SERVICE_ID], + self.stub_url('GET', ['OS-KSADM', 'services', self.NOVA_SERVICE_ID], json={'OS-KSADM:service': test_services}) service = self.client.services.get(self.NOVA_SERVICE_ID) @@ -95,9 +89,8 @@ class ServiceTests(utils.TestCase): self.assertEqual(service.name, 'nova') self.assertEqual(service.type, 'compute') - @httpretty.activate def test_list(self): - self.stub_url(httpretty.GET, ['OS-KSADM', 'services'], + self.stub_url('GET', ['OS-KSADM', 'services'], json=self.TEST_SERVICES) service_list = self.client.services.list() diff --git a/keystoneclient/tests/v2_0/test_tenants.py b/keystoneclient/tests/v2_0/test_tenants.py index e52e2381c..444926153 100644 --- a/keystoneclient/tests/v2_0/test_tenants.py +++ b/keystoneclient/tests/v2_0/test_tenants.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient import exceptions from keystoneclient import fixture from keystoneclient.tests.v2_0 import utils @@ -64,7 +62,6 @@ class TenantTests(utils.TestCase): }, } - @httpretty.activate def test_create(self): req_body = { "tenant": { @@ -84,7 +81,7 @@ class TenantTests(utils.TestCase): "extravalue01": "metadata01", } } - self.stub_url(httpretty.POST, ['tenants'], json=resp_body) + self.stub_url('POST', ['tenants'], json=resp_body) tenant = self.client.tenants.create( req_body['tenant']['name'], @@ -99,7 +96,6 @@ class TenantTests(utils.TestCase): self.assertEqual(tenant.extravalue01, "metadata01") self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_duplicate_create(self): req_body = { "tenant": { @@ -115,7 +111,7 @@ class TenantTests(utils.TestCase): "title": "Conflict", } } - self.stub_url(httpretty.POST, ['tenants'], status=409, json=resp_body) + self.stub_url('POST', ['tenants'], status_code=409, json=resp_body) def create_duplicate_tenant(): self.client.tenants.create(req_body['tenant']['name'], @@ -124,53 +120,46 @@ class TenantTests(utils.TestCase): self.assertRaises(exceptions.Conflict, create_duplicate_tenant) - @httpretty.activate def test_delete(self): - self.stub_url(httpretty.DELETE, ['tenants', self.ADMIN_ID], status=204) + self.stub_url('DELETE', ['tenants', self.ADMIN_ID], status_code=204) self.client.tenants.delete(self.ADMIN_ID) - @httpretty.activate def test_get(self): resp = {'tenant': self.TEST_TENANTS['tenants']['values'][2]} - self.stub_url(httpretty.GET, ['tenants', self.ADMIN_ID], json=resp) + self.stub_url('GET', ['tenants', self.ADMIN_ID], json=resp) t = self.client.tenants.get(self.ADMIN_ID) self.assertIsInstance(t, tenants.Tenant) self.assertEqual(t.id, self.ADMIN_ID) self.assertEqual(t.name, 'admin') - @httpretty.activate def test_list(self): - self.stub_url(httpretty.GET, ['tenants'], json=self.TEST_TENANTS) + self.stub_url('GET', ['tenants'], json=self.TEST_TENANTS) tenant_list = self.client.tenants.list() [self.assertIsInstance(t, tenants.Tenant) for t in tenant_list] - @httpretty.activate def test_list_limit(self): - self.stub_url(httpretty.GET, ['tenants'], json=self.TEST_TENANTS) + self.stub_url('GET', ['tenants'], json=self.TEST_TENANTS) tenant_list = self.client.tenants.list(limit=1) self.assertQueryStringIs('limit=1') [self.assertIsInstance(t, tenants.Tenant) for t in tenant_list] - @httpretty.activate def test_list_marker(self): - self.stub_url(httpretty.GET, ['tenants'], json=self.TEST_TENANTS) + self.stub_url('GET', ['tenants'], json=self.TEST_TENANTS) tenant_list = self.client.tenants.list(marker=1) self.assertQueryStringIs('marker=1') [self.assertIsInstance(t, tenants.Tenant) for t in tenant_list] - @httpretty.activate def test_list_limit_marker(self): - self.stub_url(httpretty.GET, ['tenants'], json=self.TEST_TENANTS) + self.stub_url('GET', ['tenants'], json=self.TEST_TENANTS) tenant_list = self.client.tenants.list(limit=1, marker=1) self.assertQueryStringIs('marker=1&limit=1') [self.assertIsInstance(t, tenants.Tenant) for t in tenant_list] - @httpretty.activate def test_update(self): req_body = { "tenant": { @@ -192,8 +181,7 @@ class TenantTests(utils.TestCase): }, } - self.stub_url(httpretty.POST, ['tenants', self.EXTRAS_ID], - json=resp_body) + self.stub_url('POST', ['tenants', self.EXTRAS_ID], json=resp_body) tenant = self.client.tenants.update( req_body['tenant']['id'], @@ -210,7 +198,6 @@ class TenantTests(utils.TestCase): self.assertFalse(tenant.enabled) self.assertEqual(tenant.extravalue01, "metadataChanged") - @httpretty.activate def test_update_empty_description(self): req_body = { "tenant": { @@ -228,8 +215,7 @@ class TenantTests(utils.TestCase): "description": "", }, } - self.stub_url(httpretty.POST, ['tenants', self.EXTRAS_ID], - json=resp_body) + self.stub_url('POST', ['tenants', self.EXTRAS_ID], json=resp_body) tenant = self.client.tenants.update(req_body['tenant']['id'], req_body['tenant']['name'], @@ -242,28 +228,25 @@ class TenantTests(utils.TestCase): self.assertEqual(tenant.description, "") self.assertFalse(tenant.enabled) - @httpretty.activate def test_add_user(self): - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['tenants', self.EXTRAS_ID, 'users', 'foo', 'roles', 'OS-KSADM', 'barrr'], - status=204) + status_code=204) self.client.tenants.add_user(self.EXTRAS_ID, 'foo', 'barrr') - @httpretty.activate def test_remove_user(self): - self.stub_url(httpretty.DELETE, ['tenants', self.EXTRAS_ID, 'users', - 'foo', 'roles', 'OS-KSADM', 'barrr'], - status=204) + self.stub_url('DELETE', ['tenants', self.EXTRAS_ID, 'users', + 'foo', 'roles', 'OS-KSADM', 'barrr'], + status_code=204) self.client.tenants.remove_user(self.EXTRAS_ID, 'foo', 'barrr') - @httpretty.activate def test_tenant_add_user(self): - self.stub_url(httpretty.PUT, ['tenants', self.EXTRAS_ID, 'users', - 'foo', 'roles', 'OS-KSADM', 'barrr'], - status=204) + self.stub_url('PUT', ['tenants', self.EXTRAS_ID, 'users', + 'foo', 'roles', 'OS-KSADM', 'barrr'], + status_code=204) req_body = { "tenant": { @@ -279,11 +262,10 @@ class TenantTests(utils.TestCase): tenant.add_user('foo', 'barrr') self.assertIsInstance(tenant, tenants.Tenant) - @httpretty.activate def test_tenant_remove_user(self): - self.stub_url(httpretty.DELETE, ['tenants', self.EXTRAS_ID, 'users', - 'foo', 'roles', 'OS-KSADM', 'barrr'], - status=204) + self.stub_url('DELETE', ['tenants', self.EXTRAS_ID, 'users', + 'foo', 'roles', 'OS-KSADM', 'barrr'], + status_code=204) req_body = { "tenant": { @@ -300,7 +282,6 @@ class TenantTests(utils.TestCase): tenant.remove_user('foo', 'barrr') self.assertIsInstance(tenant, tenants.Tenant) - @httpretty.activate def test_tenant_list_users(self): tenant_id = uuid.uuid4().hex user_id1 = uuid.uuid4().hex @@ -334,8 +315,8 @@ class TenantTests(utils.TestCase): } } - self.stub_url(httpretty.GET, ['tenants', tenant_id], json=tenant_resp) - self.stub_url(httpretty.GET, + self.stub_url('GET', ['tenants', tenant_id], json=tenant_resp) + self.stub_url('GET', ['tenants', tenant_id, 'users'], json=users_resp) @@ -348,9 +329,8 @@ class TenantTests(utils.TestCase): self.assertEqual(set([user_id1, user_id2]), set([u.id for u in user_objs])) - @httpretty.activate def test_list_tenants_use_admin_url(self): - self.stub_url(httpretty.GET, ['tenants'], json=self.TEST_TENANTS) + self.stub_url('GET', ['tenants'], json=self.TEST_TENANTS) self.assertEqual(self.TEST_URL, self.client.management_url) @@ -360,7 +340,6 @@ class TenantTests(utils.TestCase): self.assertEqual(len(self.TEST_TENANTS['tenants']['values']), len(tenant_list)) - @httpretty.activate def test_list_tenants_fallback_to_auth_url(self): new_auth_url = 'http://keystone.test:5000/v2.0' @@ -369,7 +348,7 @@ class TenantTests(utils.TestCase): user_id=self.TEST_USER_ID) self.stub_auth(base_url=new_auth_url, json=token) - self.stub_url(httpretty.GET, ['tenants'], base_url=new_auth_url, + self.stub_url('GET', ['tenants'], base_url=new_auth_url, json=self.TEST_TENANTS) c = client.Client(username=self.TEST_USER, diff --git a/keystoneclient/tests/v2_0/test_tokens.py b/keystoneclient/tests/v2_0/test_tokens.py index efc3f1231..688972bd7 100644 --- a/keystoneclient/tests/v2_0/test_tokens.py +++ b/keystoneclient/tests/v2_0/test_tokens.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient import fixture from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import client @@ -21,13 +19,12 @@ from keystoneclient.v2_0 import tokens class TokenTests(utils.TestCase): - @httpretty.activate + def test_delete(self): id_ = uuid.uuid4().hex - self.stub_url(httpretty.DELETE, ['tokens', id_], status=204) + self.stub_url('DELETE', ['tokens', id_], status_code=204) self.client.tokens.delete(id_) - @httpretty.activate def test_user_password(self): token_fixture = fixture.V2Token(user_name=self.TEST_USER) self.stub_auth(json=token_fixture) @@ -51,7 +48,6 @@ class TokenTests(utils.TestCase): self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_with_token_id(self): token_fixture = fixture.V2Token() self.stub_auth(json=token_fixture) @@ -78,7 +74,6 @@ class TokenTests(utils.TestCase): self.assertRaises(ValueError, self.client.tokens.authenticate, tenant_id=uuid.uuid4().hex) - @httpretty.activate def test_with_tenant_id(self): token_fixture = fixture.V2Token() token_fixture.set_scope() @@ -108,7 +103,6 @@ class TokenTests(utils.TestCase): self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_with_tenant_name(self): token_fixture = fixture.V2Token() token_fixture.set_scope() @@ -138,7 +132,6 @@ class TokenTests(utils.TestCase): self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_authenticate_use_admin_url(self): token_fixture = fixture.V2Token() token_fixture.set_scope() @@ -151,7 +144,6 @@ class TokenTests(utils.TestCase): self.assertEqual(token_fixture.token_id, token_ref.id) self.assertEqual(token_fixture.expires_str, token_ref.expires) - @httpretty.activate def test_authenticate_fallback_to_auth_url(self): new_auth_url = 'http://keystone.test:5000/v2.0' diff --git a/keystoneclient/tests/v2_0/test_users.py b/keystoneclient/tests/v2_0/test_users.py index 89901e4d8..81598df7d 100644 --- a/keystoneclient/tests/v2_0/test_users.py +++ b/keystoneclient/tests/v2_0/test_users.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient.tests.v2_0 import utils from keystoneclient.v2_0 import roles from keystoneclient.v2_0 import users @@ -43,7 +41,6 @@ class UserTests(utils.TestCase): } } - @httpretty.activate def test_create(self): tenant_id = uuid.uuid4().hex user_id = uuid.uuid4().hex @@ -69,7 +66,7 @@ class UserTests(utils.TestCase): } } - self.stub_url(httpretty.POST, ['users'], json=resp_body) + self.stub_url('POST', ['users'], json=resp_body) user = self.client.users.create(req_body['user']['name'], req_body['user']['password'], @@ -83,7 +80,6 @@ class UserTests(utils.TestCase): self.assertRequestBodyIs(json=req_body) self.assertNotIn(password, self.logger.output) - @httpretty.activate def test_create_user_without_email(self): tenant_id = uuid.uuid4().hex req_body = { @@ -107,7 +103,7 @@ class UserTests(utils.TestCase): } } - self.stub_url(httpretty.POST, ['users'], json=resp_body) + self.stub_url('POST', ['users'], json=resp_body) user = self.client.users.create( req_body['user']['name'], @@ -119,7 +115,6 @@ class UserTests(utils.TestCase): self.assertEqual(user.name, "gabriel") self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_create_user_without_password(self): user_name = 'test' user_id = uuid.uuid4().hex @@ -143,7 +138,7 @@ class UserTests(utils.TestCase): } } - self.stub_url(httpretty.POST, ['users'], json=resp_body) + self.stub_url('POST', ['users'], json=resp_body) user = self.client.users.create(user_name, tenant_id=tenant_id, enabled=user_enabled) @@ -152,15 +147,12 @@ class UserTests(utils.TestCase): self.assertEqual(user_name, user.name) self.assertRequestBodyIs(json=req_body) - @httpretty.activate def test_delete(self): - self.stub_url(httpretty.DELETE, ['users', self.ADMIN_USER_ID], - status=204) + self.stub_url('DELETE', ['users', self.ADMIN_USER_ID], status_code=204) self.client.users.delete(self.ADMIN_USER_ID) - @httpretty.activate def test_get(self): - self.stub_url(httpretty.GET, ['users', self.ADMIN_USER_ID], + self.stub_url('GET', ['users', self.ADMIN_USER_ID], json={'user': self.TEST_USERS['users']['values'][0]}) u = self.client.users.get(self.ADMIN_USER_ID) @@ -168,42 +160,34 @@ class UserTests(utils.TestCase): self.assertEqual(u.id, self.ADMIN_USER_ID) self.assertEqual(u.name, 'admin') - @httpretty.activate def test_list(self): - self.stub_url(httpretty.GET, ['users'], json=self.TEST_USERS) + self.stub_url('GET', ['users'], json=self.TEST_USERS) user_list = self.client.users.list() [self.assertIsInstance(u, users.User) for u in user_list] - @httpretty.activate def test_list_limit(self): - self.stub_url(httpretty.GET, ['users'], json=self.TEST_USERS) + self.stub_url('GET', ['users'], json=self.TEST_USERS) user_list = self.client.users.list(limit=1) - self.assertEqual(httpretty.last_request().querystring, - {'limit': ['1']}) + self.assertQueryStringIs('limit=1') [self.assertIsInstance(u, users.User) for u in user_list] - @httpretty.activate def test_list_marker(self): - self.stub_url(httpretty.GET, ['users'], json=self.TEST_USERS) + self.stub_url('GET', ['users'], json=self.TEST_USERS) user_list = self.client.users.list(marker='foo') - self.assertDictEqual(httpretty.last_request().querystring, - {'marker': ['foo']}) + self.assertQueryStringIs('marker=foo') [self.assertIsInstance(u, users.User) for u in user_list] - @httpretty.activate def test_list_limit_marker(self): - self.stub_url(httpretty.GET, ['users'], json=self.TEST_USERS) + self.stub_url('GET', ['users'], json=self.TEST_USERS) user_list = self.client.users.list(limit=1, marker='foo') - self.assertDictEqual(httpretty.last_request().querystring, - {'marker': ['foo'], 'limit': ['1']}) + self.assertQueryStringIs('marker=foo&limit=1') [self.assertIsInstance(u, users.User) for u in user_list] - @httpretty.activate def test_update(self): req_1 = { "user": { @@ -233,14 +217,14 @@ class UserTests(utils.TestCase): } } - self.stub_url(httpretty.PUT, ['users', self.DEMO_USER_ID], json=req_1) - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['users', self.DEMO_USER_ID], json=req_1) + self.stub_url('PUT', ['users', self.DEMO_USER_ID, 'OS-KSADM', 'password'], json=req_2) - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['users', self.DEMO_USER_ID, 'OS-KSADM', 'tenant'], json=req_3) - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['users', self.DEMO_USER_ID, 'OS-KSADM', 'enabled'], json=req_4) @@ -256,7 +240,6 @@ class UserTests(utils.TestCase): self.assertRequestBodyIs(json=req_4) self.assertNotIn(password, self.logger.output) - @httpretty.activate def test_update_own_password(self): old_password = uuid.uuid4().hex new_password = uuid.uuid4().hex @@ -270,8 +253,7 @@ class UserTests(utils.TestCase): 'access': {} } user_id = uuid.uuid4().hex - self.stub_url(httpretty.PATCH, ['OS-KSCRUD', 'users', user_id], - json=resp_body) + self.stub_url('PATCH', ['OS-KSCRUD', 'users', user_id], json=resp_body) self.client.user_id = user_id self.client.users.update_own_password(old_password, new_password) @@ -279,7 +261,6 @@ class UserTests(utils.TestCase): self.assertNotIn(old_password, self.logger.output) self.assertNotIn(new_password, self.logger.output) - @httpretty.activate def test_user_role_listing(self): user_id = uuid.uuid4().hex role_id1 = uuid.uuid4().hex @@ -309,10 +290,8 @@ class UserTests(utils.TestCase): } } - self.stub_url(httpretty.GET, - ['users', user_id], - json=user_resp) - self.stub_url(httpretty.GET, + self.stub_url('GET', ['users', user_id], json=user_resp) + self.stub_url('GET', ['tenants', tenant_id, 'users', user_id, 'roles'], json=roles_resp) diff --git a/keystoneclient/tests/v2_0/utils.py b/keystoneclient/tests/v2_0/utils.py index f4c89114e..7132236c3 100644 --- a/keystoneclient/tests/v2_0/utils.py +++ b/keystoneclient/tests/v2_0/utils.py @@ -10,12 +10,9 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty - from keystoneclient.tests import utils from keystoneclient.v2_0 import client - TestResponse = utils.TestResponse @@ -88,4 +85,4 @@ class TestCase(UnauthenticatedTestCase): endpoint=self.TEST_URL) def stub_auth(self, **kwargs): - self.stub_url(httpretty.POST, ['tokens'], **kwargs) + self.stub_url('POST', ['tokens'], **kwargs) diff --git a/keystoneclient/tests/v3/client_fixtures.py b/keystoneclient/tests/v3/client_fixtures.py index 6764257d6..517f9ae07 100644 --- a/keystoneclient/tests/v3/client_fixtures.py +++ b/keystoneclient/tests/v3/client_fixtures.py @@ -122,7 +122,7 @@ def project_scoped_token(): AUTH_SUBJECT_TOKEN = '3e2813b7ba0b4006840c3825860b86ed' AUTH_RESPONSE_HEADERS = { - 'X-Subject-Token': AUTH_SUBJECT_TOKEN + 'X-Subject-Token': AUTH_SUBJECT_TOKEN, } diff --git a/keystoneclient/tests/v3/saml2_fixtures.py b/keystoneclient/tests/v3/saml2_fixtures.py index afe3536ee..2ecae6ad8 100644 --- a/keystoneclient/tests/v3/saml2_fixtures.py +++ b/keystoneclient/tests/v3/saml2_fixtures.py @@ -10,7 +10,9 @@ # License for the specific language governing permissions and limitations # under the License. -SP_SOAP_RESPONSE = b""" - """ + +""") -SAML2_ASSERTION = b""" +SAML2_ASSERTION = six.b(""" VALUE= -""" +""") UNSCOPED_TOKEN_HEADER = 'UNSCOPED_TOKEN' diff --git a/keystoneclient/tests/v3/test_auth.py b/keystoneclient/tests/v3/test_auth.py index 71edd33e8..fb079b6b1 100644 --- a/keystoneclient/tests/v3/test_auth.py +++ b/keystoneclient/tests/v3/test_auth.py @@ -10,9 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty -import six - from keystoneclient import exceptions from keystoneclient.openstack.common import jsonutils from keystoneclient.tests.v3 import utils @@ -79,7 +76,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): 'X-Subject-Token': self.TEST_TOKEN } - @httpretty.activate def test_authenticate_success(self): TEST_TOKEN = "abcdef" ident = self.TEST_REQUEST_BODY['auth']['identity'] @@ -96,14 +92,13 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertEqual(cs.auth_token, TEST_TOKEN) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_failure(self): ident = self.TEST_REQUEST_BODY['auth']['identity'] ident['password']['user']['password'] = 'bad_key' error = {"unauthorized": {"message": "Unauthorized", "code": "401"}} - self.stub_auth(status=401, json=error) + self.stub_auth(status_code=401, json=error) # Workaround for issue with assertRaises on python2.6 # where with assertRaises(exceptions.Unauthorized): doesn't work @@ -118,10 +113,9 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertRaises(exceptions.Unauthorized, client_create_wrapper) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_auth_redirect(self): - self.stub_auth(status=305, body='Use proxy', - location=self.TEST_ADMIN_URL + '/auth/tokens') + headers = {'Location': self.TEST_ADMIN_URL + '/auth/tokens'} + self.stub_auth(status_code=305, text='Use proxy', headers=headers) self.stub_auth(json=self.TEST_RESPONSE_DICT, base_url=self.TEST_ADMIN_URL) @@ -138,7 +132,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertEqual(cs.auth_token, self.TEST_RESPONSE_HEADERS["X-Subject-Token"]) - @httpretty.activate def test_authenticate_success_domain_username_password_scoped(self): self.stub_auth(json=self.TEST_RESPONSE_DICT) @@ -153,7 +146,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertEqual(cs.auth_token, self.TEST_RESPONSE_HEADERS["X-Subject-Token"]) - @httpretty.activate def test_authenticate_success_userid_password_domain_scoped(self): ident = self.TEST_REQUEST_BODY['auth']['identity'] del ident['password']['user']['domain'] @@ -186,7 +178,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_HEADERS["X-Subject-Token"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_userid_password_project_scoped(self): ident = self.TEST_REQUEST_BODY['auth']['identity'] del ident['password']['user']['domain'] @@ -208,7 +199,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_HEADERS["X-Subject-Token"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_password_unscoped(self): del self.TEST_RESPONSE_DICT['token']['catalog'] del self.TEST_REQUEST_BODY['auth']['scope'] @@ -224,7 +214,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertFalse('catalog' in cs.service_catalog.catalog) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_auth_url_token_authentication(self): fake_token = 'fake_token' fake_url = '/fake-url' @@ -236,19 +225,15 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): cl = client.Client(auth_url=self.TEST_URL, token=fake_token) - body = httpretty.last_request().body - if six.PY3: - body = body.decode('utf-8') - body = jsonutils.loads(body) + body = jsonutils.loads(self.requests.last_request.body) self.assertEqual(body['auth']['identity']['token']['id'], fake_token) resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - self.TEST_TOKEN) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(self.TEST_TOKEN, token) - @httpretty.activate def test_authenticate_success_token_domain_scoped(self): ident = self.TEST_REQUEST_BODY['auth']['identity'] del ident['password'] @@ -283,7 +268,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_HEADERS["X-Subject-Token"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_token_project_scoped(self): ident = self.TEST_REQUEST_BODY['auth']['identity'] del ident['password'] @@ -306,7 +290,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.TEST_RESPONSE_HEADERS["X-Subject-Token"]) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_authenticate_success_token_unscoped(self): ident = self.TEST_REQUEST_BODY['auth']['identity'] del ident['password'] @@ -326,7 +309,6 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): self.assertFalse('catalog' in cs.service_catalog.catalog) self.assertRequestBodyIs(json=self.TEST_REQUEST_BODY) - @httpretty.activate def test_allow_override_of_auth_token(self): fake_url = '/fake-url' fake_token = 'fake_token' @@ -347,8 +329,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - self.TEST_TOKEN) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(self.TEST_TOKEN, token) # then override that token and the new token shall be used cl.auth_token = fake_token @@ -356,8 +338,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - fake_token) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(fake_token, token) # if we clear that overridden token then we fall back to the original del cl.auth_token @@ -365,5 +347,5 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase): resp, body = cl.get(fake_url) self.assertEqual(fake_resp, body) - self.assertEqual(httpretty.last_request().headers.get('X-Auth-Token'), - self.TEST_TOKEN) + token = self.requests.last_request.headers.get('X-Auth-Token') + self.assertEqual(self.TEST_TOKEN, token) diff --git a/keystoneclient/tests/v3/test_auth_saml2.py b/keystoneclient/tests/v3/test_auth_saml2.py index 995b18f07..2003795c7 100644 --- a/keystoneclient/tests/v3/test_auth_saml2.py +++ b/keystoneclient/tests/v3/test_auth_saml2.py @@ -12,23 +12,21 @@ import uuid -import httpretty from lxml import etree -import requests from keystoneclient.auth import conf from keystoneclient.contrib.auth.v3 import saml2 from keystoneclient import exceptions from keystoneclient.openstack.common.fixture import config -from keystoneclient.openstack.common import jsonutils from keystoneclient import session -from keystoneclient.tests.auth import utils as auth_utils from keystoneclient.tests.v3 import client_fixtures from keystoneclient.tests.v3 import saml2_fixtures from keystoneclient.tests.v3 import utils -class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): +class AuthenticateviaSAML2Tests(utils.TestCase): + + GROUP = 'auth' class _AuthenticatedResponse(object): headers = { @@ -47,15 +45,13 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): headers = {} def setUp(self): - utils.TestCase.setUp(self) - auth_utils.TestCase.setUp(self) + super(AuthenticateviaSAML2Tests, self).setUp() - self.conf_fixture = auth_utils.TestCase.useFixture(self, - config.Config()) + self.conf_fixture = self.useFixture(config.Config()) conf.register_conf_options(self.conf_fixture.conf, group=self.GROUP) - self.session = session.Session(auth=None, verify=False, - session=requests.Session()) + self.session = session.Session() + self.ECP_SP_EMPTY_REQUEST_HEADERS = { 'Accept': 'text/html; application/vnd.paos+xml', 'PAOS': ('ver="urn:liberty:paos:2003-08";' @@ -91,11 +87,6 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.IDENTITY_PROVIDER, self.IDENTITY_PROVIDER_URL, self.TEST_USER, self.TEST_TOKEN) - def simple_http(self, method, url, body=b'', content_type=None, - headers=None, status=200, **kwargs): - self.stub_url(method, base_url=url, body=body, adding_headers=headers, - content_type=content_type, status=status, **kwargs) - def make_oneline(self, s): return etree.tostring(etree.XML(s)).replace(b'\n', b'') @@ -123,12 +114,12 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.assertEqual(username, a.username) self.assertEqual(password, a.password) - @httpretty.activate def test_initial_sp_call(self): """Test initial call, expect SOAP message.""" - self.simple_http('GET', self.FEDERATION_AUTH_URL, - body=self.make_oneline( - saml2_fixtures.SP_SOAP_RESPONSE)) + self.requests.register_uri( + 'GET', + self.FEDERATION_AUTH_URL, + content=self.make_oneline(saml2_fixtures.SP_SOAP_RESPONSE)) a = self.saml2plugin._send_service_provider_request(self.session) self.assertFalse(a) @@ -150,13 +141,13 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.SHIB_CONSUMER_URL, str(self.saml2plugin.sp_response_consumer_url))) - @httpretty.activate def test_initial_sp_call_when_saml_authenticated(self): + self.requests.register_uri( + 'GET', + self.FEDERATION_AUTH_URL, + json=saml2_fixtures.UNSCOPED_TOKEN, + headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) - headers = {'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER} - self.simple_http('GET', self.FEDERATION_AUTH_URL, - body=jsonutils.dumps(saml2_fixtures.UNSCOPED_TOKEN), - headers=headers) a = self.saml2plugin._send_service_provider_request(self.session) self.assertTrue(a) self.assertEqual( @@ -166,32 +157,34 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): saml2_fixtures.UNSCOPED_TOKEN_HEADER, self.saml2plugin.authenticated_response.headers['X-Subject-Token']) - @httpretty.activate def test_get_unscoped_token_when_authenticated(self): - headers = {'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER} - self.simple_http('GET', self.FEDERATION_AUTH_URL, - body=jsonutils.dumps(saml2_fixtures.UNSCOPED_TOKEN), - headers=headers) + self.requests.register_uri( + 'GET', + self.FEDERATION_AUTH_URL, + json=saml2_fixtures.UNSCOPED_TOKEN, + headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER, + 'Content-Type': 'application/json'}) + token, token_body = self.saml2plugin._get_unscoped_token(self.session) self.assertEqual(saml2_fixtures.UNSCOPED_TOKEN['token'], token_body) self.assertEqual(saml2_fixtures.UNSCOPED_TOKEN_HEADER, token) - @httpretty.activate def test_initial_sp_call_invalid_response(self): """Send initial SP HTTP request and receive wrong server response.""" - self.simple_http('GET', self.FEDERATION_AUTH_URL, - body="NON XML RESPONSE") + self.requests.register_uri('GET', + self.FEDERATION_AUTH_URL, + text='NON XML RESPONSE') self.assertRaises( exceptions.AuthorizationFailure, self.saml2plugin._send_service_provider_request, self.session) - @httpretty.activate def test_send_authn_req_to_idp(self): - self.simple_http('POST', self.IDENTITY_PROVIDER_URL, - body=saml2_fixtures.SAML2_ASSERTION) + self.requests.register_uri('POST', + self.IDENTITY_PROVIDER_URL, + content=saml2_fixtures.SAML2_ASSERTION) self.saml2plugin.sp_response_consumer_url = self.SHIB_CONSUMER_URL self.saml2plugin.saml2_authn_request = etree.XML( @@ -207,10 +200,10 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): idp_response) self.assertEqual(idp_response, saml2_assertion_oneline, error) - @httpretty.activate def test_fail_basicauth_idp_authentication(self): - self.simple_http('POST', self.IDENTITY_PROVIDER_URL, - status=401) + self.requests.register_uri('POST', + self.IDENTITY_PROVIDER_URL, + status_code=401) self.saml2plugin.sp_response_consumer_url = self.SHIB_CONSUMER_URL self.saml2plugin.saml2_authn_request = etree.XML( @@ -226,13 +219,11 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.TEST_URL, self.IDENTITY_PROVIDER, self.IDENTITY_PROVIDER_URL) - @httpretty.activate def test_send_authn_response_to_sp(self): - self.simple_http( - 'POST', self.SHIB_CONSUMER_URL, - body=jsonutils.dumps(saml2_fixtures.UNSCOPED_TOKEN), - content_type='application/json', - status=200, + self.requests.register_uri( + 'POST', + self.SHIB_CONSUMER_URL, + json=saml2_fixtures.UNSCOPED_TOKEN, headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) self.saml2plugin.relay_state = etree.XML( @@ -259,9 +250,8 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.session, self.SHIB_CONSUMER_URL, self.SHIB_CONSUMER_URL) - @httpretty.activate def test_consumer_url_mismatch(self): - self.simple_http('POST', self.SHIB_CONSUMER_URL) + self.requests.register_uri('POST', self.SHIB_CONSUMER_URL) invalid_consumer_url = uuid.uuid4().hex self.assertRaises( exceptions.ValidationError, @@ -269,16 +259,20 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.session, self.SHIB_CONSUMER_URL, invalid_consumer_url) - @httpretty.activate def test_custom_302_redirection(self): - self.simple_http('POST', self.SHIB_CONSUMER_URL, - body='BODY', - headers={'location': self.FEDERATION_AUTH_URL}, - status=302) - self.simple_http( - 'GET', self.FEDERATION_AUTH_URL, - body=jsonutils.dumps(saml2_fixtures.UNSCOPED_TOKEN), + self.requests.register_uri( + 'POST', + self.SHIB_CONSUMER_URL, + text='BODY', + headers={'location': self.FEDERATION_AUTH_URL}, + status_code=302) + + self.requests.register_uri( + 'GET', + self.FEDERATION_AUTH_URL, + json=saml2_fixtures.UNSCOPED_TOKEN, headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) + self.session.redirect = False response = self.session.post( self.SHIB_CONSUMER_URL, data='CLIENT BODY') @@ -292,19 +286,22 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): self.assertEqual(self.FEDERATION_AUTH_URL, response.request.url) self.assertEqual('GET', response.request.method) - @httpretty.activate def test_end_to_end_workflow(self): - self.simple_http('GET', self.FEDERATION_AUTH_URL, - body=self.make_oneline( - saml2_fixtures.SP_SOAP_RESPONSE)) - self.simple_http('POST', self.IDENTITY_PROVIDER_URL, - body=saml2_fixtures.SAML2_ASSERTION) - self.simple_http( - 'POST', self.SHIB_CONSUMER_URL, - body=jsonutils.dumps(saml2_fixtures.UNSCOPED_TOKEN), - content_type='application/json', - status=200, - headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER}) + self.requests.register_uri( + 'GET', + self.FEDERATION_AUTH_URL, + content=self.make_oneline(saml2_fixtures.SP_SOAP_RESPONSE)) + + self.requests.register_uri('POST', + self.IDENTITY_PROVIDER_URL, + content=saml2_fixtures.SAML2_ASSERTION) + + self.requests.register_uri( + 'POST', + self.SHIB_CONSUMER_URL, + json=saml2_fixtures.UNSCOPED_TOKEN, + headers={'X-Subject-Token': saml2_fixtures.UNSCOPED_TOKEN_HEADER, + 'Content-Type': 'application/json'}) self.session.redirect = False response = self.saml2plugin.get_auth_ref(self.session) @@ -313,6 +310,9 @@ class AuthenticateviaSAML2Tests(auth_utils.TestCase, utils.TestCase): class ScopeFederationTokenTests(AuthenticateviaSAML2Tests): + + TEST_TOKEN = client_fixtures.AUTH_SUBJECT_TOKEN + def setUp(self): super(ScopeFederationTokenTests, self).setUp() @@ -334,12 +334,8 @@ class ScopeFederationTokenTests(AuthenticateviaSAML2Tests): self.TEST_URL, saml2_fixtures.UNSCOPED_TOKEN_HEADER, project_id=self.TEST_TENANT_ID) - @httpretty.activate def test_scope_saml2_token_to_project(self): - self.simple_http('POST', self.TEST_URL + '/auth/tokens', - body=jsonutils.dumps(self.PROJECT_SCOPED_TOKEN_JSON), - content_type='application/json', - headers=client_fixtures.AUTH_RESPONSE_HEADERS) + self.stub_auth(json=self.PROJECT_SCOPED_TOKEN_JSON) token = self.saml2_scope_plugin.get_auth_ref(self.session) self.assertTrue(token.project_scoped, "Received token is not scoped") @@ -347,18 +343,16 @@ class ScopeFederationTokenTests(AuthenticateviaSAML2Tests): self.assertEqual(self.TEST_TENANT_ID, token.project_id) self.assertEqual(self.TEST_TENANT_NAME, token.project_name) - @httpretty.activate def test_scope_saml2_token_to_invalid_project(self): - self.simple_http('POST', self.TEST_URL + '/auth/tokens', status=401) + self.stub_auth(status_code=401) self.saml2_scope_plugin.project_id = uuid.uuid4().hex self.saml2_scope_plugin.project_name = None self.assertRaises(exceptions.Unauthorized, self.saml2_scope_plugin.get_auth_ref, self.session) - @httpretty.activate def test_scope_saml2_token_to_invalid_domain(self): - self.simple_http('POST', self.TEST_URL + '/auth/tokens', status=401) + self.stub_auth(status_code=401) self.saml2_scope_plugin.project_id = None self.saml2_scope_plugin.project_name = None self.saml2_scope_plugin.domain_id = uuid.uuid4().hex @@ -367,13 +361,8 @@ class ScopeFederationTokenTests(AuthenticateviaSAML2Tests): self.saml2_scope_plugin.get_auth_ref, self.session) - @httpretty.activate def test_scope_saml2_token_to_domain(self): - self.simple_http('POST', self.TEST_URL + '/auth/tokens', - body=jsonutils.dumps(self.DOMAIN_SCOPED_TOKEN_JSON), - content_type='application/json', - headers=client_fixtures.AUTH_RESPONSE_HEADERS) - + self.stub_auth(json=self.DOMAIN_SCOPED_TOKEN_JSON) token = self.saml2_scope_plugin.get_auth_ref(self.session) self.assertTrue(token.domain_scoped, "Received token is not scoped") self.assertEqual(client_fixtures.AUTH_SUBJECT_TOKEN, token.auth_token) diff --git a/keystoneclient/tests/v3/test_client.py b/keystoneclient/tests/v3/test_client.py index a1465e39f..640ee76e7 100644 --- a/keystoneclient/tests/v3/test_client.py +++ b/keystoneclient/tests/v3/test_client.py @@ -13,8 +13,6 @@ import copy import json -import httpretty - from keystoneclient import exceptions from keystoneclient.tests.v3 import client_fixtures from keystoneclient.tests.v3 import utils @@ -23,7 +21,6 @@ from keystoneclient.v3 import client class KeystoneClientTest(utils.TestCase): - @httpretty.activate def test_unscoped_init(self): self.stub_auth(json=client_fixtures.unscoped_token()) @@ -37,7 +34,6 @@ class KeystoneClientTest(utils.TestCase): self.assertEqual(c.auth_user_id, 'c4da488862bd435c9e6c0275a0d0e49a') - @httpretty.activate def test_domain_scoped_init(self): self.stub_auth(json=client_fixtures.domain_scoped_token()) @@ -53,7 +49,6 @@ class KeystoneClientTest(utils.TestCase): self.assertEqual(c.auth_domain_id, '8e9283b7ba0b1038840c3842058b86ab') - @httpretty.activate def test_project_scoped_init(self): self.stub_auth(json=client_fixtures.project_scoped_token()), @@ -70,7 +65,6 @@ class KeystoneClientTest(utils.TestCase): self.assertEqual(c.auth_tenant_id, '225da22d3ce34b15877ea70b2a575f58') - @httpretty.activate def test_auth_ref_load(self): self.stub_auth(json=client_fixtures.project_scoped_token()) @@ -88,7 +82,6 @@ class KeystoneClientTest(utils.TestCase): self.assertEqual(new_client.management_url, 'http://admin:35357/v3') - @httpretty.activate def test_auth_ref_load_with_overridden_arguments(self): new_auth_url = 'https://newkeystone.com/v3' @@ -112,7 +105,6 @@ class KeystoneClientTest(utils.TestCase): self.assertEqual(new_client.management_url, 'http://admin:35357/v3') - @httpretty.activate def test_trust_init(self): self.stub_auth(json=client_fixtures.trust_token()) @@ -157,29 +149,25 @@ class KeystoneClientTest(utils.TestCase): 'interface': 'admin' }] - self.stub_auth(json=fixture) + self.stub_auth(response_list=[{'json': fixture}, {'json': second}]) + cl = client.Client(username='exampleuser', password='password', auth_url=self.TEST_URL, **kwargs) - self.assertEqual(cl.management_url, first_url) - self.stub_auth(json=second) cl.authenticate() self.assertEqual(cl.management_url, second_url % 35357) - @httpretty.activate def test_management_url_is_updated_with_project(self): self._management_url_is_updated(client_fixtures.project_scoped_token(), project_name='exampleproject') - @httpretty.activate def test_management_url_is_updated_with_domain(self): self._management_url_is_updated(client_fixtures.domain_scoped_token(), domain_name='exampledomain') - @httpretty.activate def test_client_with_region_name_passes_to_service_catalog(self): # NOTE(jamielennox): this is deprecated behaviour that should be # removed ASAP, however must remain compatible. diff --git a/keystoneclient/tests/v3/test_discover.py b/keystoneclient/tests/v3/test_discover.py index 19be82d0e..08e5358dd 100644 --- a/keystoneclient/tests/v3/test_discover.py +++ b/keystoneclient/tests/v3/test_discover.py @@ -10,10 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import json - -import httpretty - from keystoneclient.generic import client from keystoneclient.tests.v3 import utils @@ -64,11 +60,10 @@ class DiscoverKeystoneTests(utils.UnauthenticatedTestCase): 'Accept': 'application/json', } - @httpretty.activate def test_get_version_local(self): - httpretty.register_uri(httpretty.GET, "http://localhost:35357/", - status=300, - body=json.dumps(self.TEST_RESPONSE_DICT)) + self.requests.register_uri('GET', "http://localhost:35357/", + status_code=300, + json=self.TEST_RESPONSE_DICT) cs = client.Client() versions = cs.discover() diff --git a/keystoneclient/tests/v3/test_endpoint_filter.py b/keystoneclient/tests/v3/test_endpoint_filter.py index f3e283c35..f4be431a9 100644 --- a/keystoneclient/tests/v3/test_endpoint_filter.py +++ b/keystoneclient/tests/v3/test_endpoint_filter.py @@ -14,8 +14,6 @@ import uuid -import httpretty - from keystoneclient.tests.v3 import utils @@ -55,20 +53,18 @@ class EndpointFilterTests(utils.TestCase): kwargs.setdefault('name', uuid.uuid4().hex) return kwargs - @httpretty.activate def test_add_endpoint_to_project_via_id(self): endpoint_id = uuid.uuid4().hex project_id = uuid.uuid4().hex - self.stub_url(httpretty.PUT, + self.stub_url('PUT', [self.manager.OS_EP_FILTER_EXT, 'projects', project_id, 'endpoints', endpoint_id], - status=201) + status_code=201) self.manager.add_endpoint_to_project(project=project_id, endpoint=endpoint_id) - @httpretty.activate def test_add_endpoint_to_project_via_obj(self): project_ref = self.new_project_ref() endpoint_ref = self.new_endpoint_ref() @@ -79,51 +75,48 @@ class EndpointFilterTests(utils.TestCase): endpoint_ref, loaded=True) - self.stub_url(httpretty.PUT, + self.stub_url('PUT', [self.manager.OS_EP_FILTER_EXT, 'projects', project_ref['id'], 'endpoints', endpoint_ref['id']], - status=201) + status_code=201) self.manager.add_endpoint_to_project(project=project, endpoint=endpoint) - @httpretty.activate def test_delete_endpoint_from_project(self): endpoint_id = uuid.uuid4().hex project_id = uuid.uuid4().hex - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', [self.manager.OS_EP_FILTER_EXT, 'projects', project_id, 'endpoints', endpoint_id], - status=201) + status_code=201) self.manager.delete_endpoint_from_project(project=project_id, endpoint=endpoint_id) - @httpretty.activate def test_check_endpoint_in_project(self): endpoint_id = uuid.uuid4().hex project_id = uuid.uuid4().hex - self.stub_url(httpretty.HEAD, + self.stub_url('HEAD', [self.manager.OS_EP_FILTER_EXT, 'projects', project_id, 'endpoints', endpoint_id], - status=201) + status_code=201) self.manager.check_endpoint_in_project(project=project_id, endpoint=endpoint_id) - @httpretty.activate def test_list_endpoints_for_project(self): project_id = uuid.uuid4().hex endpoints = {'endpoints': [self.new_endpoint_ref(), self.new_endpoint_ref()]} - self.stub_url(httpretty.GET, + self.stub_url('GET', [self.manager.OS_EP_FILTER_EXT, 'projects', project_id, 'endpoints'], json=endpoints, - status=200) + status_code=200) endpoints_resp = self.manager.list_endpoints_for_project( project=project_id) @@ -133,16 +126,15 @@ class EndpointFilterTests(utils.TestCase): actual_endpoint_ids = [endpoint.id for endpoint in endpoints_resp] self.assertEqual(expected_endpoint_ids, actual_endpoint_ids) - @httpretty.activate def test_list_projects_for_endpoint(self): endpoint_id = uuid.uuid4().hex projects = {'projects': [self.new_project_ref(), self.new_project_ref()]} - self.stub_url(httpretty.GET, + self.stub_url('GET', [self.manager.OS_EP_FILTER_EXT, 'endpoints', endpoint_id, 'projects'], json=projects, - status=200) + status_code=200) projects_resp = self.manager.list_projects_for_endpoint( endpoint=endpoint_id) diff --git a/keystoneclient/tests/v3/test_federation.py b/keystoneclient/tests/v3/test_federation.py index 36e3c4996..9d35d41a8 100644 --- a/keystoneclient/tests/v3/test_federation.py +++ b/keystoneclient/tests/v3/test_federation.py @@ -13,8 +13,6 @@ import copy import uuid -import httpretty - from keystoneclient import exceptions from keystoneclient.tests.v3 import utils from keystoneclient.v3.contrib.federation import identity_providers @@ -67,7 +65,6 @@ class IdentityProviderTests(utils.TestCase, utils.CrudTests): self.assertRaises(TypeError, getattr(self.manager, f_name), *args) - @httpretty.activate def test_create(self, ref=None, req_ref=None): ref = ref or self.new_ref() @@ -78,7 +75,7 @@ class IdentityProviderTests(utils.TestCase, utils.CrudTests): req_ref = (req_ref or ref).copy() req_ref.pop('id') - self.stub_entity(httpretty.PUT, entity=ref, id=ref['id'], status=201) + self.stub_entity('PUT', entity=ref, id=ref['id'], status_code=201) returned = self.manager.create(**ref) self.assertIsInstance(returned, self.model) @@ -105,7 +102,6 @@ class MappingTests(utils.TestCase, utils.CrudTests): uuid.uuid4().hex]) return kwargs - @httpretty.activate def test_create(self, ref=None, req_ref=None): ref = ref or self.new_ref() manager_ref = ref.copy() @@ -117,8 +113,8 @@ class MappingTests(utils.TestCase, utils.CrudTests): # from datetime object to timestamp string) req_ref = (req_ref or ref).copy() - self.stub_entity(httpretty.PUT, entity=req_ref, id=mapping_id, - status=201) + self.stub_entity('PUT', entity=req_ref, id=mapping_id, + status_code=201) returned = self.manager.create(mapping_id=mapping_id, **manager_ref) self.assertIsInstance(returned, self.model) @@ -156,7 +152,7 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): return kwargs def build_parts(self, identity_provider, protocol_id=None): - """Build array used to construct httpretty URL/ + """Build array used to construct mocking URL. Construct and return array with URL parts later used by methods like utils.TestCase.stub_entity(). @@ -204,7 +200,6 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): '/'.join([self.manager.base_url, identity_provider_id, self.manager.collection_key]), url) - @httpretty.activate def test_create(self): """Test creating federation protocol tied to an Identity Provider. @@ -216,14 +211,13 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): expected = self._transform_to_response(request_args) parts = self.build_parts(request_args['identity_provider'], request_args['protocol_id']) - self.stub_entity(httpretty.PUT, entity=expected, - parts=parts, status=201) + self.stub_entity('PUT', entity=expected, + parts=parts, status_code=201) returned = self.manager.create(**request_args) self.assertEqual(expected, returned.to_dict()) request_body = {'mapping_id': request_args['mapping']} self.assertEntityRequestBodyIs(request_body) - @httpretty.activate def test_get(self): """Fetch federation protocol object. @@ -236,15 +230,14 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): parts = self.build_parts(request_args['identity_provider'], request_args['protocol_id']) - self.stub_entity(httpretty.GET, entity=expected, - parts=parts, status=201) + self.stub_entity('GET', entity=expected, + parts=parts, status_code=201) returned = self.manager.get(request_args['identity_provider'], request_args['protocol_id']) self.assertIsInstance(returned, self.model) self.assertEqual(expected, returned.to_dict()) - @httpretty.activate def test_delete(self): """Delete federation protocol object. @@ -256,12 +249,11 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): parts = self.build_parts(request_args['identity_provider'], request_args['protocol_id']) - self.stub_entity(httpretty.DELETE, parts=parts, status=204) + self.stub_entity('DELETE', parts=parts, status_code=204) self.manager.delete(request_args['identity_provider'], request_args['protocol_id']) - @httpretty.activate def test_list(self): """Test listing all federation protocols tied to the Identity Provider. @@ -278,28 +270,26 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): request_args = self.new_ref() expected = [_ref_protocols() for _ in range(3)] parts = self.build_parts(request_args['identity_provider']) - self.stub_entity(httpretty.GET, parts=parts, - entity=expected, status=200) + self.stub_entity('GET', parts=parts, + entity=expected, status_code=200) returned = self.manager.list(request_args['identity_provider']) for obj, ref_obj in zip(returned, expected): self.assertEqual(obj.to_dict(), ref_obj) - @httpretty.activate def test_list_params(self): request_args = self.new_ref() filter_kwargs = {uuid.uuid4().hex: uuid.uuid4().hex} parts = self.build_parts(request_args['identity_provider']) # Return HTTP 401 as we don't accept such requests. - self.stub_entity(httpretty.GET, parts=parts, status=401) + self.stub_entity('GET', parts=parts, status_code=401) self.assertRaises(exceptions.Unauthorized, self.manager.list, request_args['identity_provider'], **filter_kwargs) self.assertQueryStringContains(**filter_kwargs) - @httpretty.activate def test_update(self): """Test updating federation protocol @@ -313,8 +303,8 @@ class ProtocolTests(utils.TestCase, utils.CrudTests): parts = self.build_parts(request_args['identity_provider'], request_args['protocol_id']) - self.stub_entity(httpretty.PATCH, parts=parts, - entity=expected, status=200) + self.stub_entity('PATCH', parts=parts, + entity=expected, status_code=200) returned = self.manager.update(request_args['identity_provider'], request_args['protocol_id'], diff --git a/keystoneclient/tests/v3/test_groups.py b/keystoneclient/tests/v3/test_groups.py index 74a4a4ca5..7fa087051 100644 --- a/keystoneclient/tests/v3/test_groups.py +++ b/keystoneclient/tests/v3/test_groups.py @@ -14,8 +14,6 @@ import uuid -import httpretty - from keystoneclient.tests.v3 import utils from keystoneclient.v3 import groups @@ -33,31 +31,28 @@ class GroupTests(utils.TestCase, utils.CrudTests): kwargs.setdefault('name', uuid.uuid4().hex) return kwargs - @httpretty.activate def test_list_groups_for_user(self): user_id = uuid.uuid4().hex ref_list = [self.new_ref(), self.new_ref()] - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['users', user_id, self.collection_key], - status=200, entity=ref_list) + status_code=200, entity=ref_list) returned_list = self.manager.list(user=user_id) self.assertEqual(len(ref_list), len(returned_list)) [self.assertIsInstance(r, self.model) for r in returned_list] - @httpretty.activate def test_list_groups_for_domain(self): ref_list = [self.new_ref(), self.new_ref()] domain_id = uuid.uuid4().hex - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key], - status=200, entity=ref_list) + status_code=200, entity=ref_list) returned_list = self.manager.list(domain=domain_id) self.assertTrue(len(ref_list), len(returned_list)) [self.assertIsInstance(r, self.model) for r in returned_list] - self.assertEqual(httpretty.last_request().querystring, - {'domain_id': [domain_id]}) + self.assertQueryStringIs('domain_id=%s' % domain_id) diff --git a/keystoneclient/tests/v3/test_oauth1.py b/keystoneclient/tests/v3/test_oauth1.py index 8adcdaf99..0dc9c2a80 100644 --- a/keystoneclient/tests/v3/test_oauth1.py +++ b/keystoneclient/tests/v3/test_oauth1.py @@ -13,7 +13,6 @@ import uuid -import httpretty import mock import six from six.moves.urllib import parse as urlparse @@ -56,28 +55,26 @@ class ConsumerTests(BaseTest, utils.CrudTests): kwargs.setdefault('description', uuid.uuid4().hex) return kwargs - @httpretty.activate def test_description_is_optional(self): consumer_id = uuid.uuid4().hex resp_ref = {'consumer': {'description': None, 'id': consumer_id}} - self.stub_url(httpretty.POST, + self.stub_url('POST', [self.path_prefix, self.collection_key], - status=201, json=resp_ref) + status_code=201, json=resp_ref) consumer = self.manager.create() self.assertEqual(consumer_id, consumer.id) self.assertIsNone(consumer.description) - @httpretty.activate def test_description_not_included(self): consumer_id = uuid.uuid4().hex resp_ref = {'consumer': {'id': consumer_id}} - self.stub_url(httpretty.POST, + self.stub_url('POST', [self.path_prefix, self.collection_key], - status=201, json=resp_ref) + status_code=201, json=resp_ref) consumer = self.manager.create() self.assertEqual(consumer_id, consumer.id) @@ -144,7 +141,6 @@ class RequestTokenTests(TokenTests): self.manager = self.client.oauth1.request_tokens self.path_prefix = 'OS-OAUTH1' - @httpretty.activate def test_authorize_request_token(self): request_key = uuid.uuid4().hex info = {'id': request_key, @@ -154,9 +150,9 @@ class RequestTokenTests(TokenTests): verifier = uuid.uuid4().hex resp_ref = {'token': {'oauth_verifier': verifier}} - self.stub_url(httpretty.PUT, + self.stub_url('PUT', [self.path_prefix, 'authorize', request_key], - status=200, json=resp_ref) + status_code=200, json=resp_ref) # Assert the manager is returning the expected data role_id = uuid.uuid4().hex @@ -167,7 +163,6 @@ class RequestTokenTests(TokenTests): exp_body = {'roles': [{'id': role_id}]} self.assertRequestBodyIs(json=exp_body) - @httpretty.activate def test_create_request_token(self): project_id = uuid.uuid4().hex consumer_key = uuid.uuid4().hex @@ -175,9 +170,9 @@ class RequestTokenTests(TokenTests): request_key, request_secret, resp_ref = self._new_oauth_token() - self.stub_url(httpretty.POST, [self.path_prefix, 'request_token'], - status=201, body=resp_ref, - content_type='application/x-www-form-urlencoded') + headers = {'Content-Type': 'application/x-www-form-urlencoded'} + self.stub_url('POST', [self.path_prefix, 'request_token'], + status_code=201, text=resp_ref, headers=headers) # Assert the manager is returning request token object request_token = self.manager.create(consumer_key, consumer_secret, @@ -188,7 +183,7 @@ class RequestTokenTests(TokenTests): # Assert that the project id is in the header self.assertRequestHeaderEqual('requested_project_id', project_id) - req_headers = httpretty.last_request().headers + req_headers = self.requests.last_request.headers oauth_client = oauth1.Client(consumer_key, client_secret=consumer_secret, @@ -205,7 +200,6 @@ class AccessTokenTests(TokenTests): self.model = access_tokens.AccessToken self.path_prefix = 'OS-OAUTH1' - @httpretty.activate def test_create_access_token_expires_at(self): verifier = uuid.uuid4().hex consumer_key = uuid.uuid4().hex @@ -216,9 +210,9 @@ class AccessTokenTests(TokenTests): t = self._new_oauth_token_with_expires_at() access_key, access_secret, expires_at, resp_ref = t - self.stub_url(httpretty.POST, [self.path_prefix, 'access_token'], - status=201, body=resp_ref, - content_type='application/x-www-form-urlencoded') + headers = {'Content-Type': 'application/x-www-form-urlencoded'} + self.stub_url('POST', [self.path_prefix, 'access_token'], + status_code=201, text=resp_ref, headers=headers) # Assert that the manager creates an access token object access_token = self.manager.create(consumer_key, consumer_secret, @@ -229,7 +223,7 @@ class AccessTokenTests(TokenTests): self.assertEqual(access_secret, access_token.secret) self.assertEqual(expires_at, access_token.expires) - req_headers = httpretty.last_request().headers + req_headers = self.requests.last_request.headers oauth_client = oauth1.Client(consumer_key, client_secret=consumer_secret, resource_owner_key=request_key, @@ -247,7 +241,6 @@ class AuthenticateWithOAuthTests(TokenTests): if oauth1 is None: self.skipTest('optional package oauthlib is not installed') - @httpretty.activate def test_oauth_authenticate_success(self): consumer_key = uuid.uuid4().hex consumer_secret = uuid.uuid4().hex @@ -282,7 +275,7 @@ class AuthenticateWithOAuthTests(TokenTests): self.assertRequestBodyIs(json=OAUTH_REQUEST_BODY) # Assert that the headers have the same oauthlib data - req_headers = httpretty.last_request().headers + req_headers = self.requests.last_request.headers oauth_client = oauth1.Client(consumer_key, client_secret=consumer_secret, resource_owner_key=access_key, diff --git a/keystoneclient/tests/v3/test_projects.py b/keystoneclient/tests/v3/test_projects.py index 1d4b2d7c1..8087e424e 100644 --- a/keystoneclient/tests/v3/test_projects.py +++ b/keystoneclient/tests/v3/test_projects.py @@ -12,8 +12,6 @@ import uuid -import httpretty - from keystoneclient.tests.v3 import utils from keystoneclient.v3 import projects @@ -33,12 +31,11 @@ class ProjectTests(utils.TestCase, utils.CrudTests): kwargs.setdefault('name', uuid.uuid4().hex) return kwargs - @httpretty.activate def test_list_projects_for_user(self): ref_list = [self.new_ref(), self.new_ref()] user_id = uuid.uuid4().hex - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['users', user_id, self.collection_key], entity=ref_list) @@ -46,17 +43,15 @@ class ProjectTests(utils.TestCase, utils.CrudTests): self.assertEqual(len(ref_list), len(returned_list)) [self.assertIsInstance(r, self.model) for r in returned_list] - @httpretty.activate def test_list_projects_for_domain(self): ref_list = [self.new_ref(), self.new_ref()] domain_id = uuid.uuid4().hex - self.stub_entity(httpretty.GET, [self.collection_key], + self.stub_entity('GET', [self.collection_key], entity=ref_list) returned_list = self.manager.list(domain=domain_id) self.assertEqual(len(ref_list), len(returned_list)) [self.assertIsInstance(r, self.model) for r in returned_list] - self.assertEqual(httpretty.last_request().querystring, - {'domain_id': [domain_id]}) + self.assertQueryStringIs('domain_id=%s' % domain_id) diff --git a/keystoneclient/tests/v3/test_role_assignments.py b/keystoneclient/tests/v3/test_role_assignments.py index a28024e4a..f47d9ec60 100644 --- a/keystoneclient/tests/v3/test_role_assignments.py +++ b/keystoneclient/tests/v3/test_role_assignments.py @@ -10,8 +10,6 @@ # License for the specific language governing permissions and limitations # under the License. -import httpretty - from keystoneclient import exceptions from keystoneclient.tests.v3 import utils from keystoneclient.v3 import role_assignments @@ -73,10 +71,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): self.assertEqual(len(ref_list), len(returned_list)) [self.assertIsInstance(r, self.model) for r in returned_list] - @httpretty.activate def test_list_params(self): ref_list = self.TEST_USER_PROJECT_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?scope.project.id=%s&user.id=%s' % (self.TEST_TENANT_ID, self.TEST_USER_ID)], @@ -90,10 +87,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): 'user.id': self.TEST_USER_ID} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_all_assignments_list(self): ref_list = self.TEST_ALL_RESPONSE_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key], entity=ref_list) @@ -103,10 +99,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): kwargs = {} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_project_assignments_list(self): ref_list = self.TEST_GROUP_PROJECT_LIST + self.TEST_USER_PROJECT_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?scope.project.id=%s' % self.TEST_TENANT_ID], entity=ref_list) @@ -117,10 +112,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): kwargs = {'scope.project.id': self.TEST_TENANT_ID} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_domain_assignments_list(self): ref_list = self.TEST_USER_DOMAIN_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?scope.domain.id=%s' % self.TEST_DOMAIN_ID], entity=ref_list) @@ -131,10 +125,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): kwargs = {'scope.domain.id': self.TEST_DOMAIN_ID} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_group_assignments_list(self): ref_list = self.TEST_GROUP_PROJECT_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?group.id=%s' % self.TEST_GROUP_ID], entity=ref_list) @@ -145,10 +138,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): kwargs = {'group.id': self.TEST_GROUP_ID} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_user_assignments_list(self): ref_list = self.TEST_USER_DOMAIN_LIST + self.TEST_USER_PROJECT_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?user.id=%s' % self.TEST_USER_ID], entity=ref_list) @@ -159,10 +151,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): kwargs = {'user.id': self.TEST_USER_ID} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_effective_assignments_list(self): ref_list = self.TEST_USER_PROJECT_LIST + self.TEST_USER_DOMAIN_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?effective=True'], entity=ref_list) @@ -173,10 +164,9 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests): kwargs = {'effective': 'True'} self.assertQueryStringContains(**kwargs) - @httpretty.activate def test_role_assignments_list(self): ref_list = self.TEST_ALL_RESPONSE_LIST - self.stub_entity(httpretty.GET, + self.stub_entity('GET', [self.collection_key, '?role.id=' + self.TEST_ROLE_ID], entity=ref_list) diff --git a/keystoneclient/tests/v3/test_roles.py b/keystoneclient/tests/v3/test_roles.py index 9e3b8177e..151a337d0 100644 --- a/keystoneclient/tests/v3/test_roles.py +++ b/keystoneclient/tests/v3/test_roles.py @@ -14,8 +14,6 @@ import uuid -import httpretty - from keystoneclient import exceptions from keystoneclient.tests.v3 import utils from keystoneclient.v3 import roles @@ -34,213 +32,196 @@ class RoleTests(utils.TestCase, utils.CrudTests): kwargs.setdefault('name', uuid.uuid4().hex) return kwargs - @httpretty.activate def test_domain_role_grant(self): user_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['domains', domain_id, 'users', user_id, self.collection_key, ref['id']], - status=201) + status_code=201) self.manager.grant(role=ref['id'], domain=domain_id, user=user_id) - @httpretty.activate def test_domain_group_role_grant(self): group_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['domains', domain_id, 'groups', group_id, self.collection_key, ref['id']], - status=201) + status_code=201) self.manager.grant(role=ref['id'], domain=domain_id, group=group_id) - @httpretty.activate def test_domain_role_list(self): user_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref_list = [self.new_ref(), self.new_ref()] - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['domains', domain_id, 'users', user_id, self.collection_key], entity=ref_list) self.manager.list(domain=domain_id, user=user_id) - @httpretty.activate def test_domain_group_role_list(self): group_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref_list = [self.new_ref(), self.new_ref()] - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['domains', domain_id, 'groups', group_id, self.collection_key], entity=ref_list) self.manager.list(domain=domain_id, group=group_id) - @httpretty.activate def test_domain_role_check(self): user_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.HEAD, + self.stub_url('HEAD', ['domains', domain_id, 'users', user_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.check(role=ref['id'], domain=domain_id, user=user_id) - @httpretty.activate def test_domain_group_role_check(self): return group_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.HEAD, + self.stub_url('HEAD', ['domains', domain_id, 'groups', group_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.check(role=ref['id'], domain=domain_id, group=group_id) - @httpretty.activate def test_domain_role_revoke(self): user_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', ['domains', domain_id, 'users', user_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.revoke(role=ref['id'], domain=domain_id, user=user_id) - @httpretty.activate def test_domain_group_role_revoke(self): group_id = uuid.uuid4().hex domain_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', ['domains', domain_id, 'groups', group_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.revoke(role=ref['id'], domain=domain_id, group=group_id) - @httpretty.activate def test_project_role_grant(self): user_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['projects', project_id, 'users', user_id, self.collection_key, ref['id']], - status=201) + status_code=201) self.manager.grant(role=ref['id'], project=project_id, user=user_id) - @httpretty.activate def test_project_group_role_grant(self): group_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['projects', project_id, 'groups', group_id, self.collection_key, ref['id']], - status=201) + status_code=201) self.manager.grant(role=ref['id'], project=project_id, group=group_id) - @httpretty.activate def test_project_role_list(self): user_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref_list = [self.new_ref(), self.new_ref()] - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['projects', project_id, 'users', user_id, self.collection_key], entity=ref_list) self.manager.list(project=project_id, user=user_id) - @httpretty.activate def test_project_group_role_list(self): group_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref_list = [self.new_ref(), self.new_ref()] - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['projects', project_id, 'groups', group_id, self.collection_key], entity=ref_list) self.manager.list(project=project_id, group=group_id) - @httpretty.activate def test_project_role_check(self): user_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.HEAD, + self.stub_url('HEAD', ['projects', project_id, 'users', user_id, self.collection_key, ref['id']], - status=200) + status_code=200) self.manager.check(role=ref['id'], project=project_id, user=user_id) - @httpretty.activate def test_project_group_role_check(self): group_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.HEAD, + self.stub_url('HEAD', ['projects', project_id, 'groups', group_id, self.collection_key, ref['id']], - status=200) + status_code=200) self.manager.check(role=ref['id'], project=project_id, group=group_id) - @httpretty.activate def test_project_role_revoke(self): user_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', ['projects', project_id, 'users', user_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.revoke(role=ref['id'], project=project_id, user=user_id) - @httpretty.activate def test_project_group_role_revoke(self): group_id = uuid.uuid4().hex project_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', ['projects', project_id, 'groups', group_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.revoke(role=ref['id'], project=project_id, group=group_id) - @httpretty.activate def test_domain_project_role_grant_fails(self): user_id = uuid.uuid4().hex project_id = uuid.uuid4().hex diff --git a/keystoneclient/tests/v3/test_users.py b/keystoneclient/tests/v3/test_users.py index 0841e9df1..f11bef2be 100644 --- a/keystoneclient/tests/v3/test_users.py +++ b/keystoneclient/tests/v3/test_users.py @@ -14,8 +14,6 @@ import uuid -import httpretty - from keystoneclient import exceptions from keystoneclient.tests.v3 import utils from keystoneclient.v3 import users @@ -38,13 +36,12 @@ class UserTests(utils.TestCase, utils.CrudTests): kwargs.setdefault('default_project_id', uuid.uuid4().hex) return kwargs - @httpretty.activate def test_add_user_to_group(self): group_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.PUT, + self.stub_url('PUT', ['groups', group_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.add_to_group(user=ref['id'], group=group_id) self.assertRaises(exceptions.ValidationError, @@ -52,12 +49,11 @@ class UserTests(utils.TestCase, utils.CrudTests): user=ref['id'], group=None) - @httpretty.activate def test_list_users_in_group(self): group_id = uuid.uuid4().hex ref_list = [self.new_ref(), self.new_ref()] - self.stub_entity(httpretty.GET, + self.stub_entity('GET', ['groups', group_id, self.collection_key], entity=ref_list) @@ -65,14 +61,13 @@ class UserTests(utils.TestCase, utils.CrudTests): self.assertEqual(len(ref_list), len(returned_list)) [self.assertIsInstance(r, self.model) for r in returned_list] - @httpretty.activate def test_check_user_in_group(self): group_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.HEAD, + self.stub_url('HEAD', ['groups', group_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.check_in_group(user=ref['id'], group=group_id) @@ -81,14 +76,13 @@ class UserTests(utils.TestCase, utils.CrudTests): user=ref['id'], group=None) - @httpretty.activate def test_remove_user_from_group(self): group_id = uuid.uuid4().hex ref = self.new_ref() - self.stub_url(httpretty.DELETE, + self.stub_url('DELETE', ['groups', group_id, self.collection_key, ref['id']], - status=204) + status_code=204) self.manager.remove_from_group(user=ref['id'], group=group_id) self.assertRaises(exceptions.ValidationError, @@ -96,13 +90,12 @@ class UserTests(utils.TestCase, utils.CrudTests): user=ref['id'], group=None) - @httpretty.activate def test_create_doesnt_log_password(self): password = uuid.uuid4().hex ref = self.new_ref() - self.stub_entity(httpretty.POST, [self.collection_key], - status=201, entity=ref) + self.stub_entity('POST', [self.collection_key], + status_code=201, entity=ref) req_ref = ref.copy() req_ref.pop('id') @@ -115,14 +108,13 @@ class UserTests(utils.TestCase, utils.CrudTests): self.assertNotIn(password, self.logger.output) - @httpretty.activate def test_create_with_project(self): # Can create a user with the deprecated project option rather than # default_project_id. ref = self.new_ref() - self.stub_entity(httpretty.POST, [self.collection_key], - status=201, entity=ref) + self.stub_entity('POST', [self.collection_key], + status_code=201, entity=ref) req_ref = ref.copy() req_ref.pop('id') @@ -140,15 +132,14 @@ class UserTests(utils.TestCase, utils.CrudTests): 'Expected different %s' % attr) self.assertEntityRequestBodyIs(req_ref) - @httpretty.activate def test_create_with_project_and_default_project(self): # Can create a user with the deprecated project and default_project_id. # The backend call should only pass the default_project_id. ref = self.new_ref() - self.stub_entity(httpretty.POST, + self.stub_entity('POST', [self.collection_key], - status=201, entity=ref) + status_code=201, entity=ref) req_ref = ref.copy() req_ref.pop('id') @@ -167,7 +158,6 @@ class UserTests(utils.TestCase, utils.CrudTests): 'Expected different %s' % attr) self.assertEntityRequestBodyIs(req_ref) - @httpretty.activate def test_update_doesnt_log_password(self): password = uuid.uuid4().hex ref = self.new_ref() @@ -176,9 +166,9 @@ class UserTests(utils.TestCase, utils.CrudTests): req_ref.pop('id') param_ref = req_ref.copy() - self.stub_entity(httpretty.PATCH, + self.stub_entity('PATCH', [self.collection_key, ref['id']], - status=200, entity=ref) + status_code=200, entity=ref) param_ref['password'] = password params = utils.parameterize(param_ref) @@ -187,7 +177,6 @@ class UserTests(utils.TestCase, utils.CrudTests): self.assertNotIn(password, self.logger.output) - @httpretty.activate def test_update_with_project(self): # Can update a user with the deprecated project option rather than # default_project_id. @@ -196,9 +185,9 @@ class UserTests(utils.TestCase, utils.CrudTests): req_ref.pop('id') param_ref = req_ref.copy() - self.stub_entity(httpretty.PATCH, + self.stub_entity('PATCH', [self.collection_key, ref['id']], - status=200, entity=ref) + status_code=200, entity=ref) # Use deprecated project_id rather than new default_project_id. param_ref['project_id'] = param_ref.pop('default_project_id') @@ -213,16 +202,15 @@ class UserTests(utils.TestCase, utils.CrudTests): 'Expected different %s' % attr) self.assertEntityRequestBodyIs(req_ref) - @httpretty.activate def test_update_with_project_and_default_project(self, ref=None): ref = self.new_ref() req_ref = ref.copy() req_ref.pop('id') param_ref = req_ref.copy() - self.stub_entity(httpretty.PATCH, + self.stub_entity('PATCH', [self.collection_key, ref['id']], - status=200, entity=ref) + status_code=200, entity=ref) # Add the deprecated project_id in the call, the value will be ignored. param_ref['project_id'] = 'project' @@ -237,12 +225,11 @@ class UserTests(utils.TestCase, utils.CrudTests): 'Expected different %s' % attr) self.assertEntityRequestBodyIs(req_ref) - @httpretty.activate def test_update_password(self): old_password = uuid.uuid4().hex new_password = uuid.uuid4().hex - self.stub_url(httpretty.POST, + self.stub_url('POST', [self.collection_key, self.TEST_USER, 'password']) self.client.user_id = self.TEST_USER self.manager.update_password(old_password, new_password) @@ -253,8 +240,8 @@ class UserTests(utils.TestCase, utils.CrudTests): } } - self.assertEqual('/v3/users/test/password', - httpretty.last_request().path) + self.assertEqual(self.TEST_URL + '/users/test/password', + self.requests.last_request.url) self.assertRequestBodyIs(json=exp_req_body) self.assertNotIn(old_password, self.logger.output) self.assertNotIn(new_password, self.logger.output) diff --git a/keystoneclient/tests/v3/utils.py b/keystoneclient/tests/v3/utils.py index dbc0f06e9..092940396 100644 --- a/keystoneclient/tests/v3/utils.py +++ b/keystoneclient/tests/v3/utils.py @@ -12,11 +12,9 @@ import uuid -import httpretty import six from six.moves.urllib import parse as urlparse -from keystoneclient.openstack.common import jsonutils from keystoneclient.tests import utils from keystoneclient.v3 import client @@ -141,8 +139,17 @@ class TestCase(UnauthenticatedTestCase): if not subject_token: subject_token = self.TEST_TOKEN - self.stub_url(httpretty.POST, ['auth', 'tokens'], - X_Subject_Token=subject_token, **kwargs) + try: + response_list = kwargs['response_list'] + except KeyError: + headers = kwargs.setdefault('headers', {}) + headers['X-Subject-Token'] = subject_token + else: + for resp in response_list: + headers = resp.setdefault('headers', {}) + headers['X-Subject-Token'] = subject_token + + self.stub_url('POST', ['auth', 'tokens'], **kwargs) class CrudTests(object): @@ -186,7 +193,6 @@ class CrudTests(object): def assertEntityRequestBodyIs(self, entity): self.assertRequestBodyIs(json=self.encode(entity)) - @httpretty.activate def test_create(self, ref=None, req_ref=None): ref = ref or self.new_ref() manager_ref = ref.copy() @@ -199,7 +205,7 @@ class CrudTests(object): req_ref = (req_ref or ref).copy() req_ref.pop('id') - self.stub_entity(httpretty.POST, entity=req_ref, status=201) + self.stub_entity('POST', entity=req_ref, status_code=201) returned = self.manager.create(**parameterize(manager_ref)) self.assertIsInstance(returned, self.model) @@ -210,11 +216,10 @@ class CrudTests(object): 'Expected different %s' % attr) self.assertEntityRequestBodyIs(req_ref) - @httpretty.activate def test_get(self, ref=None): ref = ref or self.new_ref() - self.stub_entity(httpretty.GET, id=ref['id'], entity=ref) + self.stub_entity('GET', id=ref['id'], entity=ref) returned = self.manager.get(ref['id']) self.assertIsInstance(returned, self.model) @@ -234,15 +239,15 @@ class CrudTests(object): return expected_path - @httpretty.activate def test_list(self, ref_list=None, expected_path=None, expected_query=None, **filter_kwargs): ref_list = ref_list or [self.new_ref(), self.new_ref()] expected_path = self._get_expected_path(expected_path) - httpretty.register_uri(httpretty.GET, - urlparse.urljoin(self.TEST_URL, expected_path), - body=jsonutils.dumps(self.encode(ref_list))) + self.requests.register_uri('GET', + urlparse.urljoin(self.TEST_URL, + expected_path), + json=self.encode(ref_list)) returned_list = self.manager.list(**filter_kwargs) self.assertEqual(len(ref_list), len(returned_list)) @@ -250,7 +255,8 @@ class CrudTests(object): # register_uri doesn't match the querystring component, so we have to # explicitly test the querystring component passed by the manager - qs_args = httpretty.last_request().querystring + parts = urlparse.urlparse(self.requests.last_request.url) + qs_args = urlparse.parse_qs(parts.query) qs_args_expected = expected_query or filter_kwargs for key, value in six.iteritems(qs_args_expected): self.assertIn(key, qs_args) @@ -264,25 +270,24 @@ class CrudTests(object): for key in qs_args: self.assertIn(key, qs_args_expected) - @httpretty.activate def test_list_params(self): ref_list = [self.new_ref()] filter_kwargs = {uuid.uuid4().hex: uuid.uuid4().hex} expected_path = self._get_expected_path() - httpretty.register_uri(httpretty.GET, - urlparse.urljoin(self.TEST_URL, expected_path), - body=jsonutils.dumps(self.encode(ref_list))) + self.requests.register_uri('GET', + urlparse.urljoin(self.TEST_URL, + expected_path), + json=self.encode(ref_list)) self.manager.list(**filter_kwargs) self.assertQueryStringContains(**filter_kwargs) - @httpretty.activate def test_find(self, ref=None): ref = ref or self.new_ref() ref_list = [ref] - self.stub_entity(httpretty.GET, entity=ref_list) + self.stub_entity('GET', entity=ref_list) returned = self.manager.find(name=getattr(ref, 'name', None)) self.assertIsInstance(returned, self.model) @@ -297,11 +302,10 @@ class CrudTests(object): else: self.assertQueryStringIs('') - @httpretty.activate def test_update(self, ref=None, req_ref=None): ref = ref or self.new_ref() - self.stub_entity(httpretty.PATCH, id=ref['id'], entity=ref) + self.stub_entity('PATCH', id=ref['id'], entity=ref) # req_ref argument allows you to specify a different # signature for the request when the manager does some @@ -319,9 +323,8 @@ class CrudTests(object): 'Expected different %s' % attr) self.assertEntityRequestBodyIs(req_ref) - @httpretty.activate def test_delete(self, ref=None): ref = ref or self.new_ref() - self.stub_entity(httpretty.DELETE, id=ref['id'], status=204) + self.stub_entity('DELETE', id=ref['id'], status_code=204) self.manager.delete(ref['id']) diff --git a/test-requirements.txt b/test-requirements.txt index 61fb67b93..5d70425c3 100644 --- a/test-requirements.txt +++ b/test-requirements.txt @@ -2,13 +2,13 @@ coverage>=3.6 discover fixtures>=0.3.14 hacking>=0.8.0,<0.9 -httpretty>=0.8.0,!=0.8.1,!=0.8.2 keyring>=2.1,!=3.3 mock>=1.0 mox3>=0.7.0 oauthlib>=0.6 oslosphinx pycrypto>=2.6 +requests-mock>=0.4.0 # Apache-2.0 sphinx>=1.1.2,!=1.2.0,<1.3 testrepository>=0.0.18 testresources>=0.2.4