Merge remote-tracking branch 'origin/master' into merge-branchfeature/keystoneauth_integration

Conflicts:
	keystoneclient/exceptions.py
	keystoneclient/fixture/discovery.py
	keystoneclient/fixture/v2.py
	keystoneclient/fixture/v3.py
	keystoneclient/middleware/auth_token.py
	keystoneclient/middleware/s3_token.py
	keystoneclient/tests/unit/test_auth_token_middleware.py
	keystoneclient/tests/unit/test_memcache_crypt.py
	keystoneclient/tests/unit/test_s3_token_middleware.py
	requirements.txt
	test-requirements.txt

Change-Id: Ib51acebaac7966bf37c1562fa15b9061df6a7aa5

26 files changed, 399 insertions, 239 deletions

diff --git a/keystoneclient/tests/unit/auth/test_identity_v3.py b/keystoneclient/tests/unit/auth/test_identity_v3.py
index 99062b3..8c23807 100644
--- a/keystoneclient/tests/unit/auth/test_identity_v3.py
+++ b/keystoneclient/tests/unit/auth/test_identity_v3.py
@@ -512,7 +512,8 @@ class V3IdentityPlugin(utils.TestCase):
 
         auth_ref = a.get_access(s)
 
-        self.assertFalse(auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertFalse(auth_ref.scoped)
         body = self.requests_mock.last_request.json()
 
         ident = body['auth']['identity']
diff --git a/keystoneclient/tests/unit/client_fixtures.py b/keystoneclient/tests/unit/client_fixtures.py
index b226e32..46266ce 100644
--- a/keystoneclient/tests/unit/client_fixtures.py
+++ b/keystoneclient/tests/unit/client_fixtures.py
@@ -12,7 +12,9 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+import contextlib
 import os
+import warnings
 
 import fixtures
 from oslo_serialization import jsonutils
@@ -595,3 +597,25 @@ class HackingCode(fixtures.Fixture):
             (30, 0, 'K333'),
         ],
     }
+
+
+class Deprecations(fixtures.Fixture):
+    def setUp(self):
+        super(Deprecations, self).setUp()
+
+        # If keystoneclient calls any deprecated function this will raise an
+        # exception.
+        warnings.filterwarnings('error', category=DeprecationWarning,
+                                module='^keystoneclient\\.')
+        self.addCleanup(warnings.resetwarnings)
+
+    def expect_deprecations(self):
+        """Call this if the test expects to call deprecated function."""
+        warnings.resetwarnings()
+
+    @contextlib.contextmanager
+    def expect_deprecations_here(self):
+        warnings.resetwarnings()
+        yield
+        warnings.filterwarnings('error', category=DeprecationWarning,
+                                module='^keystoneclient\\.')
diff --git a/keystoneclient/tests/unit/test_base.py b/keystoneclient/tests/unit/test_base.py
index dcfbb13..115a35c 100644
--- a/keystoneclient/tests/unit/test_base.py
+++ b/keystoneclient/tests/unit/test_base.py
@@ -36,9 +36,7 @@ class BaseTest(utils.TestCase):
         self.assertEqual(base.getid(TmpObject), 4)
 
     def test_resource_lazy_getattr(self):
-        self.client = client.Client(username=self.TEST_USER,
-                                    token=self.TEST_TOKEN,
-                                    tenant_name=self.TEST_TENANT_NAME,
+        self.client = client.Client(token=self.TEST_TOKEN,
                                     auth_url='http://127.0.0.1:5000',
                                     endpoint='http://127.0.0.1:5000')
 
@@ -85,16 +83,15 @@ class ManagerTest(utils.TestCase):
 
     def setUp(self):
         super(ManagerTest, self).setUp()
-        self.client = client.Client(username=self.TEST_USER,
-                                    token=self.TEST_TOKEN,
-                                    tenant_name=self.TEST_TENANT_NAME,
+        self.client = client.Client(token=self.TEST_TOKEN,
                                     auth_url='http://127.0.0.1:5000',
                                     endpoint='http://127.0.0.1:5000')
         self.mgr = base.Manager(self.client)
         self.mgr.resource_class = base.Resource
 
     def test_api(self):
-        self.assertEqual(self.mgr.api, self.client)
+        with self.deprecations.expect_deprecations_here():
+            self.assertEqual(self.mgr.api, self.client)
 
     def test_get(self):
         get_mock = self.useFixture(mockpatch.PatchObject(
diff --git a/keystoneclient/tests/unit/test_discovery.py b/keystoneclient/tests/unit/test_discovery.py
index 76aaf03..34901ba 100644
--- a/keystoneclient/tests/unit/test_discovery.py
+++ b/keystoneclient/tests/unit/test_discovery.py
@@ -472,7 +472,8 @@ class ClientDiscoveryTests(utils.TestCase):
 
         cl = self.assertCreatesV2(auth_url=BASE_URL, **kwargs)
 
-        self.assertEqual(cl.original_ip, '100')
+        with self.deprecations.expect_deprecations_here():
+            self.assertEqual(cl.original_ip, '100')
         self.assertEqual(cl.stale_duration, 15)
         self.assertFalse(cl.use_keyring)
 
@@ -499,7 +500,8 @@ class ClientDiscoveryTests(utils.TestCase):
                                text=V3_VERSION_ENTRY)
         disc = discover.Discover(auth_url=BASE_URL)
 
-        versions = disc.available_versions()
+        with self.deprecations.expect_deprecations_here():
+            versions = disc.available_versions()
         self.assertEqual(1, len(versions))
         self.assertEqual(V3_VERSION, versions[0])
 
diff --git a/keystoneclient/tests/unit/test_ec2utils.py b/keystoneclient/tests/unit/test_ec2utils.py
index 71fc176..f74eb2f 100644
--- a/keystoneclient/tests/unit/test_ec2utils.py
+++ b/keystoneclient/tests/unit/test_ec2utils.py
@@ -17,12 +17,14 @@ from __future__ import unicode_literals
 import testtools
 
 from keystoneclient.contrib.ec2 import utils
+from keystoneclient.tests.unit import client_fixtures
 
 
 class Ec2SignerTest(testtools.TestCase):
 
     def setUp(self):
         super(Ec2SignerTest, self).setUp()
+        self.useFixture(client_fixtures.Deprecations())
         self.access = '966afbde20b84200ae4e62e09acf46b2'
         self.secret = '89cdf9e94e2643cab35b8b8ac5a51f83'
         self.signer = utils.Ec2Signer(self.secret)
diff --git a/keystoneclient/tests/unit/test_hacking_checks.py b/keystoneclient/tests/unit/test_hacking_checks.py
index 220d258..2e4cc1d 100644
--- a/keystoneclient/tests/unit/test_hacking_checks.py
+++ b/keystoneclient/tests/unit/test_hacking_checks.py
@@ -21,6 +21,9 @@ from keystoneclient.tests.unit import client_fixtures
 
 
 class TestCheckOsloNamespaceImports(testtools.TestCase):
+    def setUp(self):
+        super(TestCheckOsloNamespaceImports, self).setUp()
+        self.useFixture(client_fixtures.Deprecations())
 
     # We are patching pep8 so that only the check under test is actually
     # installed.
diff --git a/keystoneclient/tests/unit/test_http.py b/keystoneclient/tests/unit/test_http.py
index 436c374..2b29ee7 100644
--- a/keystoneclient/tests/unit/test_http.py
+++ b/keystoneclient/tests/unit/test_http.py
@@ -28,7 +28,7 @@ RESPONSE_BODY = '{"hi": "there"}'
 
 def get_client():
     cl = httpclient.HTTPClient(username="username", password="password",
-                               tenant_id="tenant", auth_url="auth_test")
+                               project_id="tenant", auth_url="auth_test")
     return cl
 
 
@@ -67,7 +67,8 @@ class ClientTest(utils.TestCase):
 
         self.stub_url('GET', text=RESPONSE_BODY)
 
-        resp, body = cl.get("/hi")
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get("/hi")
         self.assertEqual(self.requests_mock.last_request.method, 'GET')
         self.assertEqual(self.requests_mock.last_request.url, self.TEST_URL)
 
@@ -96,7 +97,8 @@ class ClientTest(utils.TestCase):
         self.stub_url('GET', status_code=400, json=err_response)
         exc_raised = False
         try:
-            cl.get('/hi')
+            with self.deprecations.expect_deprecations_here():
+                cl.get('/hi')
         except exceptions.BadRequest as exc:
             exc_raised = True
             self.assertEqual(exc.message, "Error message string")
@@ -106,7 +108,8 @@ class ClientTest(utils.TestCase):
         cl = get_authed_client()
 
         self.stub_url('POST')
-        cl.post("/hi", body=[1, 2, 3])
+        with self.deprecations.expect_deprecations_here():
+            cl.post("/hi", body=[1, 2, 3])
 
         self.assertEqual(self.requests_mock.last_request.method, 'POST')
         self.assertEqual(self.requests_mock.last_request.body, '[1, 2, 3]')
@@ -118,12 +121,13 @@ class ClientTest(utils.TestCase):
     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",
+                                   project_id="tenant", auth_url="auth_test",
                                    original_ip=ORIGINAL_IP)
 
         self.stub_url('GET')
 
-        cl.request(self.TEST_URL, 'GET')
+        with self.deprecations.expect_deprecations_here():
+            cl.request(self.TEST_URL, 'GET')
         forwarded = "for=%s;by=%s" % (ORIGINAL_IP, httpclient.USER_AGENT)
         self.assertRequestHeaderEqual('Forwarded', forwarded)
 
@@ -167,7 +171,8 @@ class BasicRequestTests(utils.TestCase):
         self.requests_mock.register_uri(method, url, text=response,
                                         status_code=status_code)
 
-        return httpclient.request(url, method, **kwargs)
+        with self.deprecations.expect_deprecations_here():
+            return httpclient.request(url, method, **kwargs)
 
     def test_basic_params(self):
         method = 'GET'
diff --git a/keystoneclient/tests/unit/test_https.py b/keystoneclient/tests/unit/test_https.py
index ad52de9..607ab9e 100644
--- a/keystoneclient/tests/unit/test_https.py
+++ b/keystoneclient/tests/unit/test_https.py
@@ -28,7 +28,7 @@ RESPONSE_BODY = b'{"hi": "there"}'
 
 def get_client():
     cl = httpclient.HTTPClient(username="username", password="password",
-                               tenant_id="tenant", auth_url="auth_test",
+                               project_id="tenant", auth_url="auth_test",
                                cacert="ca.pem", key="key.pem", cert="cert.pem")
     return cl
 
@@ -47,7 +47,8 @@ class ClientTest(utils.TestCase):
         MOCK_REQUEST.return_value = FAKE_RESPONSE
         cl = get_authed_client()
 
-        resp, body = cl.get("/hi")
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get("/hi")
 
         # this may become too tightly couple later
         mock_args, mock_kwargs = MOCK_REQUEST.call_args
@@ -66,7 +67,8 @@ class ClientTest(utils.TestCase):
         MOCK_REQUEST.return_value = FAKE_RESPONSE
         cl = get_authed_client()
 
-        cl.post("/hi", body=[1, 2, 3])
+        with self.deprecations.expect_deprecations_here():
+            cl.post("/hi", body=[1, 2, 3])
 
         # this may become too tightly couple later
         mock_args, mock_kwargs = MOCK_REQUEST.call_args
@@ -82,12 +84,13 @@ class ClientTest(utils.TestCase):
     def test_post_auth(self, MOCK_REQUEST):
         MOCK_REQUEST.return_value = FAKE_RESPONSE
         cl = httpclient.HTTPClient(
-            username="username", password="password", tenant_id="tenant",
+            username="username", password="password", project_id="tenant",
             auth_url="auth_test", cacert="ca.pem", key="key.pem",
             cert="cert.pem")
         cl.management_url = "https://127.0.0.1:5000"
         cl.auth_token = "token"
-        cl.post("/hi", body=[1, 2, 3])
+        with self.deprecations.expect_deprecations_here():
+            cl.post("/hi", body=[1, 2, 3])
 
         # this may become too tightly couple later
         mock_args, mock_kwargs = MOCK_REQUEST.call_args
diff --git a/keystoneclient/tests/unit/test_keyring.py b/keystoneclient/tests/unit/test_keyring.py
index a54009e..defd233 100644
--- a/keystoneclient/tests/unit/test_keyring.py
+++ b/keystoneclient/tests/unit/test_keyring.py
@@ -19,6 +19,7 @@ from keystoneclient import access
 from keystoneclient import httpclient
 from keystoneclient.tests.unit import utils
 from keystoneclient.tests.unit.v2_0 import client_fixtures
+from keystoneclient import utils as client_utils
 
 try:
     import keyring  # noqa
@@ -87,7 +88,7 @@ class KeyringTest(utils.TestCase):
         the keyring is never accessed.
         """
         cl = httpclient.HTTPClient(username=USERNAME, password=PASSWORD,
-                                   tenant_id=TENANT_ID, auth_url=AUTH_URL)
+                                   project_id=TENANT_ID, auth_url=AUTH_URL)
 
         # stub and check that a new token is received
         method = 'get_raw_token_from_identity_service'
@@ -104,7 +105,7 @@ class KeyringTest(utils.TestCase):
 
     def test_build_keyring_key(self):
         cl = httpclient.HTTPClient(username=USERNAME, password=PASSWORD,
-                                   tenant_id=TENANT_ID, auth_url=AUTH_URL)
+                                   project_id=TENANT_ID, auth_url=AUTH_URL)
 
         keyring_key = cl._build_keyring_key(auth_url=AUTH_URL,
                                             username=USERNAME,
@@ -118,13 +119,13 @@ class KeyringTest(utils.TestCase):
 
     def test_set_and_get_keyring_expired(self):
         cl = httpclient.HTTPClient(username=USERNAME, password=PASSWORD,
-                                   tenant_id=TENANT_ID, auth_url=AUTH_URL,
+                                   project_id=TENANT_ID, auth_url=AUTH_URL,
                                    use_keyring=True)
 
         # set an expired token into the keyring
         auth_ref = access.AccessInfo.factory(body=PROJECT_SCOPED_TOKEN)
         expired = timeutils.utcnow() - datetime.timedelta(minutes=30)
-        auth_ref['token']['expires'] = timeutils.isotime(expired)
+        auth_ref['token']['expires'] = client_utils.isotime(expired)
         self.memory_keyring.password = pickle.dumps(auth_ref)
 
         # stub and check that a new token is received, so not using expired
@@ -146,13 +147,13 @@ class KeyringTest(utils.TestCase):
 
     def test_get_keyring(self):
         cl = httpclient.HTTPClient(username=USERNAME, password=PASSWORD,
-                                   tenant_id=TENANT_ID, auth_url=AUTH_URL,
+                                   project_id=TENANT_ID, auth_url=AUTH_URL,
                                    use_keyring=True)
 
         # set an token into the keyring
         auth_ref = access.AccessInfo.factory(body=PROJECT_SCOPED_TOKEN)
         future = timeutils.utcnow() + datetime.timedelta(minutes=30)
-        auth_ref['token']['expires'] = timeutils.isotime(future)
+        auth_ref['token']['expires'] = client_utils.isotime(future)
         self.memory_keyring.password = pickle.dumps(auth_ref)
 
         # don't stub get_raw_token so will fail if authenticate happens
@@ -162,7 +163,7 @@ class KeyringTest(utils.TestCase):
 
     def test_set_keyring(self):
         cl = httpclient.HTTPClient(username=USERNAME, password=PASSWORD,
-                                   tenant_id=TENANT_ID, auth_url=AUTH_URL,
+                                   project_id=TENANT_ID, auth_url=AUTH_URL,
                                    use_keyring=True)
 
         # stub and check that a new token is received
diff --git a/keystoneclient/tests/unit/utils.py b/keystoneclient/tests/unit/utils.py
index 2274519..7c6de95 100644
--- a/keystoneclient/tests/unit/utils.py
+++ b/keystoneclient/tests/unit/utils.py
@@ -12,18 +12,18 @@
 
 import logging
 import sys
-import time
 import uuid
 
 import fixtures
 from oslo_serialization import jsonutils
-from oslotest import mockpatch
 import requests
 from requests_mock.contrib import fixture
 import six
 from six.moves.urllib import parse as urlparse
 import testtools
 
+from keystoneclient.tests.unit import client_fixtures
+
 
 class TestCase(testtools.TestCase):
 
@@ -42,10 +42,9 @@ class TestCase(testtools.TestCase):
 
     def setUp(self):
         super(TestCase, self).setUp()
-        self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
-        self.time_patcher = self.useFixture(
-            mockpatch.PatchObject(time, 'time', lambda: 1234)).mock
+        self.deprecations = self.useFixture(client_fixtures.Deprecations())
 
+        self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
         self.requests_mock = self.useFixture(fixture.Fixture())
 
     def stub_url(self, method, parts=None, base_url=None, json=None, **kwargs):
diff --git a/keystoneclient/tests/unit/v2_0/test_access.py b/keystoneclient/tests/unit/v2_0/test_access.py
index e966874..b768150 100644
--- a/keystoneclient/tests/unit/v2_0/test_access.py
+++ b/keystoneclient/tests/unit/v2_0/test_access.py
@@ -45,10 +45,13 @@ class AccessInfoTest(utils.TestCase, testresources.ResourcedTestCase):
         self.assertIsNone(auth_ref.tenant_name)
         self.assertIsNone(auth_ref.tenant_id)
 
-        self.assertIsNone(auth_ref.auth_url)
-        self.assertIsNone(auth_ref.management_url)
+        with self.deprecations.expect_deprecations_here():
+            self.assertIsNone(auth_ref.auth_url)
+        with self.deprecations.expect_deprecations_here():
+            self.assertIsNone(auth_ref.management_url)
 
-        self.assertFalse(auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertFalse(auth_ref.scoped)
         self.assertFalse(auth_ref.domain_scoped)
         self.assertFalse(auth_ref.project_scoped)
         self.assertFalse(auth_ref.trust_scoped)
@@ -98,15 +101,20 @@ class AccessInfoTest(utils.TestCase, testresources.ResourcedTestCase):
         self.assertEqual(auth_ref.tenant_name, auth_ref.project_name)
         self.assertEqual(auth_ref.tenant_id, auth_ref.project_id)
 
-        self.assertEqual(auth_ref.auth_url, ('http://public.com:5000/v2.0',))
-        self.assertEqual(auth_ref.management_url, ('http://admin:35357/v2.0',))
+        with self.deprecations.expect_deprecations_here():
+            self.assertEqual(auth_ref.auth_url,
+                             ('http://public.com:5000/v2.0',))
+        with self.deprecations.expect_deprecations_here():
+            self.assertEqual(auth_ref.management_url,
+                             ('http://admin:35357/v2.0',))
 
         self.assertEqual(auth_ref.project_domain_id, 'default')
         self.assertEqual(auth_ref.project_domain_name, 'Default')
         self.assertEqual(auth_ref.user_domain_id, 'default')
         self.assertEqual(auth_ref.user_domain_name, 'Default')
 
-        self.assertTrue(auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertTrue(auth_ref.scoped)
         self.assertTrue(auth_ref.project_scoped)
         self.assertFalse(auth_ref.domain_scoped)
 
@@ -127,7 +135,8 @@ class AccessInfoTest(utils.TestCase, testresources.ResourcedTestCase):
         self.assertEqual(auth_ref.user_domain_id, 'default')
         self.assertEqual(auth_ref.user_domain_name, 'Default')
         self.assertEqual(auth_ref.role_names, ['role1', 'role2'])
-        self.assertFalse(auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertFalse(auth_ref.scoped)
 
     def test_grizzly_token(self):
         grizzly_token = self.examples.TOKEN_RESPONSES[
diff --git a/keystoneclient/tests/unit/v2_0/test_auth.py b/keystoneclient/tests/unit/v2_0/test_auth.py
index 2c69dc3..5f318ff 100644
--- a/keystoneclient/tests/unit/v2_0/test_auth.py
+++ b/keystoneclient/tests/unit/v2_0/test_auth.py
@@ -67,7 +67,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         self.stub_auth(response_list=[{'json': resp_a, 'headers': headers},
                                       {'json': resp_b, 'headers': headers}])
 
-        cs = client.Client(tenant_id=self.TEST_TENANT_ID,
+        cs = client.Client(project_id=self.TEST_TENANT_ID,
                            auth_url=self.TEST_URL,
                            username=self.TEST_USER,
                            password=self.TEST_TOKEN)
@@ -95,7 +95,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         def client_create_wrapper():
             client.Client(username=self.TEST_USER,
                           password="bad_key",
-                          tenant_id=self.TEST_TENANT_ID,
+                          project_id=self.TEST_TENANT_ID,
                           auth_url=self.TEST_URL)
 
         self.assertRaises(exceptions.Unauthorized, client_create_wrapper)
@@ -110,7 +110,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
 
         cs = client.Client(username=self.TEST_USER,
                            password=self.TEST_TOKEN,
-                           tenant_id=self.TEST_TENANT_ID,
+                           project_id=self.TEST_TENANT_ID,
                            auth_url=self.TEST_URL)
 
         self.assertEqual(cs.management_url,
@@ -125,7 +125,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
 
         cs = client.Client(username=self.TEST_USER,
                            password=self.TEST_TOKEN,
-                           tenant_id=self.TEST_TENANT_ID,
+                           project_id=self.TEST_TENANT_ID,
                            auth_url=self.TEST_URL)
         self.assertEqual(cs.management_url,
                          self.TEST_RESPONSE_DICT["access"]["serviceCatalog"][3]
@@ -162,7 +162,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         json_body = jsonutils.loads(self.requests_mock.last_request.body)
         self.assertEqual(json_body['auth']['token']['id'], fake_token)
 
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
@@ -174,7 +175,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         self.stub_auth(json=self.TEST_RESPONSE_DICT)
 
         cs = client.Client(token=self.TEST_TOKEN,
-                           tenant_id=self.TEST_TENANT_ID,
+                           project_id=self.TEST_TENANT_ID,
                            auth_url=self.TEST_URL)
         self.assertEqual(cs.management_url,
                          self.TEST_RESPONSE_DICT["access"]["serviceCatalog"][3]
@@ -193,7 +194,7 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         self.stub_auth(json=response)
 
         cs = client.Client(token=self.TEST_TOKEN,
-                           tenant_id=self.TEST_TENANT_ID,
+                           project_id=self.TEST_TENANT_ID,
                            trust_id=self.TEST_TRUST_ID,
                            auth_url=self.TEST_URL)
         self.assertTrue(cs.auth_ref.trust_scoped)
@@ -227,13 +228,14 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL)
 
         self.assertEqual(cl.auth_token, self.TEST_TOKEN)
 
         # the token returned from the authentication will be used
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
@@ -242,7 +244,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         # then override that token and the new token shall be used
         cl.auth_token = fake_token
 
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
@@ -251,7 +254,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         # if we clear that overridden token then we fall back to the original
         del cl.auth_token
 
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
diff --git a/keystoneclient/tests/unit/v2_0/test_client.py b/keystoneclient/tests/unit/v2_0/test_client.py
index 379bea4..447c750 100644
--- a/keystoneclient/tests/unit/v2_0/test_client.py
+++ b/keystoneclient/tests/unit/v2_0/test_client.py
@@ -34,7 +34,8 @@ class KeystoneClientTest(utils.TestCase):
                           password='password',
                           auth_url=self.TEST_URL)
         self.assertIsNotNone(c.auth_ref)
-        self.assertFalse(c.auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertFalse(c.auth_ref.scoped)
         self.assertFalse(c.auth_ref.domain_scoped)
         self.assertFalse(c.auth_ref.project_scoped)
         self.assertIsNone(c.auth_ref.trust_id)
@@ -48,10 +49,11 @@ class KeystoneClientTest(utils.TestCase):
 
         c = client.Client(username='exampleuser',
                           password='password',
-                          tenant_name='exampleproject',
+                          project_name='exampleproject',
                           auth_url=self.TEST_URL)
         self.assertIsNotNone(c.auth_ref)
-        self.assertTrue(c.auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertTrue(c.auth_ref.scoped)
         self.assertTrue(c.auth_ref.project_scoped)
         self.assertFalse(c.auth_ref.domain_scoped)
         self.assertIsNone(c.auth_ref.trust_id)
@@ -65,12 +67,13 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL)
         cache = json.dumps(cl.auth_ref)
         new_client = client.Client(auth_ref=json.loads(cache))
         self.assertIsNotNone(new_client.auth_ref)
-        self.assertTrue(new_client.auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertTrue(new_client.auth_ref.scoped)
         self.assertTrue(new_client.auth_ref.project_scoped)
         self.assertFalse(new_client.auth_ref.domain_scoped)
         self.assertIsNone(new_client.auth_ref.trust_id)
@@ -85,15 +88,15 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL)
         cache = json.dumps(cl.auth_ref)
         new_auth_url = "http://new-public:5000/v2.0"
         new_client = client.Client(auth_ref=json.loads(cache),
                                    auth_url=new_auth_url)
         self.assertIsNotNone(new_client.auth_ref)
-        self.assertTrue(new_client.auth_ref.scoped)
-        self.assertTrue(new_client.auth_ref.scoped)
+        with self.deprecations.expect_deprecations_here():
+            self.assertTrue(new_client.auth_ref.scoped)
         self.assertTrue(new_client.auth_ref.project_scoped)
         self.assertFalse(new_client.auth_ref.domain_scoped)
         self.assertIsNone(new_client.auth_ref.trust_id)
@@ -130,7 +133,7 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL)
         self.assertEqual(cl.management_url, admin_url)
 
@@ -144,7 +147,7 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL,
                            region_name='North')
         self.assertEqual(cl.service_catalog.url_for(service_type='image'),
@@ -152,7 +155,7 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL,
                            region_name='South')
         self.assertEqual(cl.service_catalog.url_for(service_type='image'),
@@ -161,7 +164,7 @@ class KeystoneClientTest(utils.TestCase):
     def test_client_without_auth_params(self):
         self.assertRaises(exceptions.AuthorizationFailure,
                           client.Client,
-                          tenant_name='exampleproject',
+                          project_name='exampleproject',
                           auth_url=self.TEST_URL)
 
     def test_client_params(self):
diff --git a/keystoneclient/tests/unit/v2_0/test_tokens.py b/keystoneclient/tests/unit/v2_0/test_tokens.py
index 8a40f82..d60f0f8 100644
--- a/keystoneclient/tests/unit/v2_0/test_tokens.py
+++ b/keystoneclient/tests/unit/v2_0/test_tokens.py
@@ -168,6 +168,9 @@ class TokenTests(utils.TestCase):
         token_fixture = fixture.V2Token(token_id=id_)
         self.stub_url('GET', ['tokens', id_], json=token_fixture)
 
+        token_data = self.client.tokens.get_token_data(id_)
+        self.assertEqual(token_fixture, token_data)
+
         token_ref = self.client.tokens.validate(id_)
         self.assertIsInstance(token_ref, tokens.Token)
         self.assertEqual(id_, token_ref.id)
@@ -178,6 +181,9 @@ class TokenTests(utils.TestCase):
         id_ = uuid.uuid4().hex
         # The server is expected to return 404 if the token is invalid.
         self.stub_url('GET', ['tokens', id_], status_code=404)
+
+        self.assertRaises(exceptions.NotFound,
+                          self.client.tokens.get_token_data, id_)
         self.assertRaises(exceptions.NotFound,
                           self.client.tokens.validate, id_)
 
diff --git a/keystoneclient/tests/unit/v2_0/utils.py b/keystoneclient/tests/unit/v2_0/utils.py
index 475181f..191e8db 100644
--- a/keystoneclient/tests/unit/v2_0/utils.py
+++ b/keystoneclient/tests/unit/v2_0/utils.py
@@ -78,9 +78,7 @@ class TestCase(UnauthenticatedTestCase):
 
     def setUp(self):
         super(TestCase, self).setUp()
-        self.client = client.Client(username=self.TEST_USER,
-                                    token=self.TEST_TOKEN,
-                                    tenant_name=self.TEST_TENANT_NAME,
+        self.client = client.Client(token=self.TEST_TOKEN,
                                     auth_url=self.TEST_URL,
                                     endpoint=self.TEST_URL)
 
diff --git a/keystoneclient/tests/unit/v3/client_fixtures.py b/keystoneclient/tests/unit/v3/client_fixtures.py
index 99e49f0..56eaf7d 100644
--- a/keystoneclient/tests/unit/v3/client_fixtures.py
+++ b/keystoneclient/tests/unit/v3/client_fixtures.py
@@ -16,26 +16,18 @@ import uuid
 from keystoneclient import fixture
 
 
-def unscoped_token():
-    return fixture.V3Token(user_id='c4da488862bd435c9e6c0275a0d0e49a',
-                           user_name='exampleuser',
-                           user_domain_id='4e6893b7ba0b4006840c3845660b86ed',
-                           user_domain_name='exampledomain',
-                           expires='2010-11-01T03:32:15-05:00')
-
-
-def domain_scoped_token():
-    f = fixture.V3Token(user_id='c4da488862bd435c9e6c0275a0d0e49a',
-                        user_name='exampleuser',
-                        user_domain_id='4e6893b7ba0b4006840c3845660b86ed',
-                        user_domain_name='exampledomain',
-                        expires='2010-11-01T03:32:15-05:00',
-                        domain_id='8e9283b7ba0b1038840c3842058b86ab',
-                        domain_name='anotherdomain',
-                        audit_chain_id=uuid.uuid4().hex)
-
-    f.add_role(id='76e72a', name='admin')
-    f.add_role(id='f4f392', name='member')
+def unscoped_token(**kwargs):
+    return fixture.V3Token(**kwargs)
+
+
+def domain_scoped_token(**kwargs):
+    kwargs.setdefault('audit_chain_id', uuid.uuid4().hex)
+    f = fixture.V3Token(**kwargs)
+    if not f.domain_id:
+        f.set_domain_scope()
+
+    f.add_role(name='admin')
+    f.add_role(name='member')
     region = 'RegionOne'
 
     s = f.add_service('volume')
@@ -71,20 +63,15 @@ def domain_scoped_token():
     return f
 
 
-def project_scoped_token():
-    f = fixture.V3Token(user_id='c4da488862bd435c9e6c0275a0d0e49a',
-                        user_name='exampleuser',
-                        user_domain_id='4e6893b7ba0b4006840c3845660b86ed',
-                        user_domain_name='exampledomain',
-                        expires='2010-11-01T03:32:15-05:00',
-                        project_id='225da22d3ce34b15877ea70b2a575f58',
-                        project_name='exampleproject',
-                        project_domain_id='4e6893b7ba0b4006840c3845660b86ed',
-                        project_domain_name='exampledomain',
-                        audit_chain_id=uuid.uuid4().hex)
+def project_scoped_token(**kwargs):
+    kwargs.setdefault('audit_chain_id', uuid.uuid4().hex)
+    f = fixture.V3Token(**kwargs)
 
-    f.add_role(id='76e72a', name='admin')
-    f.add_role(id='f4f392', name='member')
+    if not f.project_id:
+        f.set_project_scope()
+
+    f.add_role(name='admin')
+    f.add_role(name='member')
 
     region = 'RegionOne'
     tenant = '225da22d3ce34b15877ea70b2a575f58'
@@ -122,7 +109,7 @@ def project_scoped_token():
     return f
 
 
-AUTH_SUBJECT_TOKEN = '3e2813b7ba0b4006840c3825860b86ed'
+AUTH_SUBJECT_TOKEN = uuid.uuid4().hex
 
 AUTH_RESPONSE_HEADERS = {
     'X-Subject-Token': AUTH_SUBJECT_TOKEN,
@@ -130,19 +117,11 @@ AUTH_RESPONSE_HEADERS = {
 
 
 def auth_response_body():
-    f = fixture.V3Token(user_id='567',
-                        user_name='test',
-                        user_domain_id='1',
-                        user_domain_name='aDomain',
-                        expires='2010-11-01T03:32:15-05:00',
-                        project_domain_id='123',
-                        project_domain_name='aDomain',
-                        project_id='345',
-                        project_name='aTenant',
-                        audit_chain_id=uuid.uuid4().hex)
-
-    f.add_role(id='76e72a', name='admin')
-    f.add_role(id='f4f392', name='member')
+    f = fixture.V3Token(audit_chain_id=uuid.uuid4().hex)
+    f.set_project_scope()
+
+    f.add_role(name='admin')
+    f.add_role(name='member')
 
     s = f.add_service('compute', name='nova')
     s.add_standard_endpoints(
@@ -175,13 +154,6 @@ def auth_response_body():
 
 
 def trust_token():
-    return fixture.V3Token(user_id='0ca8f6',
-                           user_name='exampleuser',
-                           user_domain_id='4e6893b7ba0b4006840c3845660b86ed',
-                           user_domain_name='exampledomain',
-                           expires='2010-11-01T03:32:15-05:00',
-                           trust_id='fe0aef',
-                           trust_impersonation=False,
-                           trustee_user_id='0ca8f6',
-                           trustor_user_id='bd263c',
-                           audit_chain_id=uuid.uuid4().hex)
+    f = fixture.V3Token(audit_chain_id=uuid.uuid4().hex)
+    f.set_trust_scope()
+    return f
diff --git a/keystoneclient/tests/unit/v3/test_access.py b/keystoneclient/tests/unit/v3/test_access.py
index f069f71..82ed0fb 100644
--- a/keystoneclient/tests/unit/v3/test_access.py
+++ b/keystoneclient/tests/unit/v3/test_access.py
@@ -38,10 +38,10 @@ class AccessInfoTest(utils.TestCase):
         self.assertIn('methods', auth_ref)
         self.assertNotIn('catalog', auth_ref)
 
-        self.assertEqual(auth_ref.auth_token,
-                         '3e2813b7ba0b4006840c3825860b86ed')
-        self.assertEqual(auth_ref.username, 'exampleuser')
-        self.assertEqual(auth_ref.user_id, 'c4da488862bd435c9e6c0275a0d0e49a')
+        self.assertEqual(client_fixtures.AUTH_SUBJECT_TOKEN,
+                         auth_ref.auth_token)
+        self.assertEqual(UNSCOPED_TOKEN.user_name, auth_ref.username)
+        self.assertEqual(UNSCOPED_TOKEN.user_id, auth_ref.user_id)
 
         self.assertEqual(auth_ref.role_ids, [])
         self.assertEqual(auth_ref.role_names, [])
@@ -49,15 +49,18 @@ class AccessInfoTest(utils.TestCase):
         self.assertIsNone(auth_ref.project_name)
         self.assertIsNone(auth_ref.project_id)
 
-        self.assertIsNone(auth_ref.auth_url)
-        self.assertIsNone(auth_ref.management_url)
+        with self.deprecations.expect_deprecations_here():
+            self.assertIsNone(auth_ref.auth_url)
+        with self.deprecations.expect_deprecations_here():
+            self.assertIsNone(auth_ref.management_url)
 
         self.assertFalse(auth_ref.domain_scoped)
         self.assertFalse(auth_ref.project_scoped)
 
-        self.assertEqual(auth_ref.user_domain_id,
-                         '4e6893b7ba0b4006840c3845660b86ed')
-        self.assertEqual(auth_ref.user_domain_name, 'exampledomain')
+        self.assertEqual(UNSCOPED_TOKEN.user_domain_id,
+                         auth_ref.user_domain_id)
+        self.assertEqual(UNSCOPED_TOKEN.user_domain_name,
+                         auth_ref.user_domain_name)
 
         self.assertIsNone(auth_ref.project_domain_id)
         self.assertIsNone(auth_ref.project_domain_name)
@@ -92,24 +95,24 @@ class AccessInfoTest(utils.TestCase):
         self.assertIn('catalog', auth_ref)
         self.assertTrue(auth_ref['catalog'])
 
-        self.assertEqual(auth_ref.auth_token,
-                         '3e2813b7ba0b4006840c3825860b86ed')
-        self.assertEqual(auth_ref.username, 'exampleuser')
-        self.assertEqual(auth_ref.user_id, 'c4da488862bd435c9e6c0275a0d0e49a')
+        self.assertEqual(client_fixtures.AUTH_SUBJECT_TOKEN,
+                         auth_ref.auth_token)
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.user_name, auth_ref.username)
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.user_id, auth_ref.user_id)
 
-        self.assertEqual(auth_ref.role_ids, ['76e72a', 'f4f392'])
-        self.assertEqual(auth_ref.role_names, ['admin', 'member'])
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.role_ids, auth_ref.role_ids)
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.role_names, auth_ref.role_names)
 
-        self.assertEqual(auth_ref.domain_name, 'anotherdomain')
-        self.assertEqual(auth_ref.domain_id,
-                         '8e9283b7ba0b1038840c3842058b86ab')
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.domain_name, auth_ref.domain_name)
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.domain_id, auth_ref.domain_id)
 
         self.assertIsNone(auth_ref.project_name)
         self.assertIsNone(auth_ref.project_id)
 
-        self.assertEqual(auth_ref.user_domain_id,
-                         '4e6893b7ba0b4006840c3845660b86ed')
-        self.assertEqual(auth_ref.user_domain_name, 'exampledomain')
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.user_domain_id,
+                         auth_ref.user_domain_id)
+        self.assertEqual(DOMAIN_SCOPED_TOKEN.user_domain_name,
+                         auth_ref.user_domain_name)
 
         self.assertIsNone(auth_ref.project_domain_id)
         self.assertIsNone(auth_ref.project_domain_name)
@@ -130,36 +133,40 @@ class AccessInfoTest(utils.TestCase):
         self.assertIn('catalog', auth_ref)
         self.assertTrue(auth_ref['catalog'])
 
-        self.assertEqual(auth_ref.auth_token,
-                         '3e2813b7ba0b4006840c3825860b86ed')
-        self.assertEqual(auth_ref.username, 'exampleuser')
-        self.assertEqual(auth_ref.user_id, 'c4da488862bd435c9e6c0275a0d0e49a')
+        self.assertEqual(client_fixtures.AUTH_SUBJECT_TOKEN,
+                         auth_ref.auth_token)
+        self.assertEqual(PROJECT_SCOPED_TOKEN.user_name, auth_ref.username)
+        self.assertEqual(PROJECT_SCOPED_TOKEN.user_id, auth_ref.user_id)
 
-        self.assertEqual(auth_ref.role_ids, ['76e72a', 'f4f392'])
-        self.assertEqual(auth_ref.role_names, ['admin', 'member'])
+        self.assertEqual(PROJECT_SCOPED_TOKEN.role_ids, auth_ref.role_ids)
+        self.assertEqual(PROJECT_SCOPED_TOKEN.role_names, auth_ref.role_names)
 
         self.assertIsNone(auth_ref.domain_name)
         self.assertIsNone(auth_ref.domain_id)
 
-        self.assertEqual(auth_ref.project_name, 'exampleproject')
-        self.assertEqual(auth_ref.project_id,
-                         '225da22d3ce34b15877ea70b2a575f58')
+        self.assertEqual(PROJECT_SCOPED_TOKEN.project_name,
+                         auth_ref.project_name)
+        self.assertEqual(PROJECT_SCOPED_TOKEN.project_id, auth_ref.project_id)
 
         self.assertEqual(auth_ref.tenant_name, auth_ref.project_name)
         self.assertEqual(auth_ref.tenant_id, auth_ref.project_id)
 
-        self.assertEqual(auth_ref.auth_url,
-                         ('http://public.com:5000/v3',))
-        self.assertEqual(auth_ref.management_url,
-                         ('http://admin:35357/v3',))
-
-        self.assertEqual(auth_ref.project_domain_id,
-                         '4e6893b7ba0b4006840c3845660b86ed')
-        self.assertEqual(auth_ref.project_domain_name, 'exampledomain')
-
-        self.assertEqual(auth_ref.user_domain_id,
-                         '4e6893b7ba0b4006840c3845660b86ed')
-        self.assertEqual(auth_ref.user_domain_name, 'exampledomain')
+        with self.deprecations.expect_deprecations_here():
+            self.assertEqual(auth_ref.auth_url,
+                             ('http://public.com:5000/v3',))
+        with self.deprecations.expect_deprecations_here():
+            self.assertEqual(auth_ref.management_url,
+                             ('http://admin:35357/v3',))
+
+        self.assertEqual(PROJECT_SCOPED_TOKEN.project_domain_id,
+                         auth_ref.project_domain_id)
+        self.assertEqual(PROJECT_SCOPED_TOKEN.project_domain_name,
+                         auth_ref.project_domain_name)
+
+        self.assertEqual(PROJECT_SCOPED_TOKEN.user_domain_id,
+                         auth_ref.user_domain_id)
+        self.assertEqual(PROJECT_SCOPED_TOKEN.user_domain_name,
+                         auth_ref.user_domain_name)
 
         self.assertFalse(auth_ref.domain_scoped)
         self.assertTrue(auth_ref.project_scoped)
diff --git a/keystoneclient/tests/unit/v3/test_auth.py b/keystoneclient/tests/unit/v3/test_auth.py
index b3f29d6..8352528 100644
--- a/keystoneclient/tests/unit/v3/test_auth.py
+++ b/keystoneclient/tests/unit/v3/test_auth.py
@@ -229,7 +229,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         body = jsonutils.loads(self.requests_mock.last_request.body)
         self.assertEqual(body['auth']['identity']['token']['id'], fake_token)
 
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
@@ -321,13 +322,14 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL)
 
         self.assertEqual(cl.auth_token, self.TEST_TOKEN)
 
         # the token returned from the authentication will be used
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
@@ -336,7 +338,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         # then override that token and the new token shall be used
         cl.auth_token = fake_token
 
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
@@ -345,7 +348,8 @@ class AuthenticateAgainstKeystoneTests(utils.TestCase):
         # if we clear that overridden token then we fall back to the original
         del cl.auth_token
 
-        resp, body = cl.get(fake_url)
+        with self.deprecations.expect_deprecations_here():
+            resp, body = cl.get(fake_url)
         self.assertEqual(fake_resp, body)
 
         token = self.requests_mock.last_request.headers.get('X-Auth-Token')
diff --git a/keystoneclient/tests/unit/v3/test_auth_manager.py b/keystoneclient/tests/unit/v3/test_auth_manager.py
new file mode 100644
index 0000000..68f00c6
--- /dev/null
+++ b/keystoneclient/tests/unit/v3/test_auth_manager.py
@@ -0,0 +1,72 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import uuid
+
+from keystoneclient.auth.identity import v3
+from keystoneclient import fixture
+from keystoneclient import session
+from keystoneclient.tests.unit.v3 import utils
+from keystoneclient.v3 import auth
+from keystoneclient.v3 import client
+
+
+class AuthProjectsTest(utils.TestCase):
+
+    def setUp(self):
+        super(AuthProjectsTest, self).setUp()
+
+        self.v3token = fixture.V3Token()
+        self.stub_auth(json=self.v3token)
+
+        self.stub_url('GET',
+                      [],
+                      json={'version': fixture.V3Discovery(self.TEST_URL)})
+
+        self.auth = v3.Password(auth_url=self.TEST_URL,
+                                user_id=self.v3token.user_id,
+                                password=uuid.uuid4().hex)
+        self.session = session.Session(auth=self.auth)
+        self.client = client.Client(session=self.session)
+
+    def create_resource(self, id=None, name=None, **kwargs):
+        kwargs['id'] = id or uuid.uuid4().hex
+        kwargs['name'] = name or uuid.uuid4().hex
+        return kwargs
+
+    def test_get_projects(self):
+        body = {'projects': [self.create_resource(),
+                             self.create_resource(),
+                             self.create_resource()]}
+
+        self.stub_url('GET', ['auth', 'projects'], json=body)
+
+        projects = self.client.auth.projects()
+
+        self.assertEqual(3, len(projects))
+
+        for p in projects:
+            self.assertIsInstance(p, auth.Project)
+
+    def test_get_domains(self):
+        body = {'domains': [self.create_resource(),
+                            self.create_resource(),
+                            self.create_resource()]}
+
+        self.stub_url('GET', ['auth', 'domains'], json=body)
+
+        domains = self.client.auth.domains()
+
+        self.assertEqual(3, len(domains))
+
+        for d in domains:
+            self.assertIsInstance(d, auth.Domain)
diff --git a/keystoneclient/tests/unit/v3/test_client.py b/keystoneclient/tests/unit/v3/test_client.py
index c01cac2..6e1c06e 100644
--- a/keystoneclient/tests/unit/v3/test_client.py
+++ b/keystoneclient/tests/unit/v3/test_client.py
@@ -27,71 +27,67 @@ from keystoneclient.v3 import client
 class KeystoneClientTest(utils.TestCase):
 
     def test_unscoped_init(self):
-        self.stub_auth(json=client_fixtures.unscoped_token())
+        token = client_fixtures.unscoped_token()
+        self.stub_auth(json=token)
 
-        c = client.Client(user_domain_name='exampledomain',
-                          username='exampleuser',
+        c = client.Client(user_domain_name=token.user_domain_name,
+                          username=token.user_name,
                           password='password',
                           auth_url=self.TEST_URL)
         self.assertIsNotNone(c.auth_ref)
         self.assertFalse(c.auth_ref.domain_scoped)
         self.assertFalse(c.auth_ref.project_scoped)
-        self.assertEqual(c.auth_user_id,
-                         'c4da488862bd435c9e6c0275a0d0e49a')
+        self.assertEqual(token.user_id, c.auth_user_id)
         self.assertFalse(c.has_service_catalog())
 
-        self.assertEqual('c4da488862bd435c9e6c0275a0d0e49a',
-                         c.get_user_id(session=None))
+        self.assertEqual(token.user_id, c.get_user_id(session=None))
         self.assertIsNone(c.get_project_id(session=None))
 
     def test_domain_scoped_init(self):
-        self.stub_auth(json=client_fixtures.domain_scoped_token())
+        token = client_fixtures.domain_scoped_token()
+        self.stub_auth(json=token)
 
-        c = client.Client(user_id='c4da488862bd435c9e6c0275a0d0e49a',
+        c = client.Client(user_id=token.user_id,
                           password='password',
-                          domain_name='exampledomain',
+                          domain_name=token.domain_name,
                           auth_url=self.TEST_URL)
         self.assertIsNotNone(c.auth_ref)
         self.assertTrue(c.auth_ref.domain_scoped)
         self.assertFalse(c.auth_ref.project_scoped)
-        self.assertEqual(c.auth_user_id,
-                         'c4da488862bd435c9e6c0275a0d0e49a')
-        self.assertEqual(c.auth_domain_id,
-                         '8e9283b7ba0b1038840c3842058b86ab')
+        self.assertEqual(token.user_id, c.auth_user_id)
+        self.assertEqual(token.domain_id, c.auth_domain_id)
 
     def test_project_scoped_init(self):
-        self.stub_auth(json=client_fixtures.project_scoped_token()),
+        token = client_fixtures.project_scoped_token()
+        self.stub_auth(json=token),
 
-        c = client.Client(user_id='c4da488862bd435c9e6c0275a0d0e49a',
+        c = client.Client(user_id=token.user_id,
                           password='password',
-                          user_domain_name='exampledomain',
-                          project_name='exampleproject',
+                          user_domain_name=token.user_domain_name,
+                          project_name=token.project_name,
                           auth_url=self.TEST_URL)
         self.assertIsNotNone(c.auth_ref)
         self.assertFalse(c.auth_ref.domain_scoped)
         self.assertTrue(c.auth_ref.project_scoped)
-        self.assertEqual(c.auth_user_id,
-                         'c4da488862bd435c9e6c0275a0d0e49a')
-        self.assertEqual(c.auth_tenant_id,
-                         '225da22d3ce34b15877ea70b2a575f58')
-        self.assertEqual('c4da488862bd435c9e6c0275a0d0e49a',
-                         c.get_user_id(session=None))
-        self.assertEqual('225da22d3ce34b15877ea70b2a575f58',
-                         c.get_project_id(session=None))
+        self.assertEqual(token.user_id, c.auth_user_id)
+        self.assertEqual(token.project_id, c.auth_tenant_id)
+        self.assertEqual(token.user_id, c.get_user_id(session=None))
+        self.assertEqual(token.project_id, c.get_project_id(session=None))
 
     def test_auth_ref_load(self):
-        self.stub_auth(json=client_fixtures.project_scoped_token())
+        token = client_fixtures.project_scoped_token()
+        self.stub_auth(json=token)
 
-        c = client.Client(user_id='c4da488862bd435c9e6c0275a0d0e49a',
+        c = client.Client(user_id=token.user_id,
                           password='password',
-                          project_id='225da22d3ce34b15877ea70b2a575f58',
+                          project_id=token.project_id,
                           auth_url=self.TEST_URL)
         cache = json.dumps(c.auth_ref)
         new_client = client.Client(auth_ref=json.loads(cache))
         self.assertIsNotNone(new_client.auth_ref)
         self.assertFalse(new_client.auth_ref.domain_scoped)
         self.assertTrue(new_client.auth_ref.project_scoped)
-        self.assertEqual(new_client.username, 'exampleuser')
+        self.assertEqual(token.user_name, new_client.username)
         self.assertIsNone(new_client.password)
         self.assertEqual(new_client.management_url,
                          'http://admin:35357/v3')
@@ -99,13 +95,22 @@ class KeystoneClientTest(utils.TestCase):
     def test_auth_ref_load_with_overridden_arguments(self):
         new_auth_url = 'https://newkeystone.com/v3'
 
-        self.stub_auth(json=client_fixtures.project_scoped_token())
-        self.stub_auth(json=client_fixtures.project_scoped_token(),
-                       base_url=new_auth_url)
+        user_id = uuid.uuid4().hex
+        user_name = uuid.uuid4().hex
+        project_id = uuid.uuid4().hex
 
-        c = client.Client(user_id='c4da488862bd435c9e6c0275a0d0e49a',
+        first = client_fixtures.project_scoped_token(user_id=user_id,
+                                                     user_name=user_name,
+                                                     project_id=project_id)
+        second = client_fixtures.project_scoped_token(user_id=user_id,
+                                                      user_name=user_name,
+                                                      project_id=project_id)
+        self.stub_auth(json=first)
+        self.stub_auth(json=second, base_url=new_auth_url)
+
+        c = client.Client(user_id=user_id,
                           password='password',
-                          project_id='225da22d3ce34b15877ea70b2a575f58',
+                          project_id=project_id,
                           auth_url=self.TEST_URL)
         cache = json.dumps(c.auth_ref)
         new_client = client.Client(auth_ref=json.loads(cache),
@@ -113,28 +118,29 @@ class KeystoneClientTest(utils.TestCase):
         self.assertIsNotNone(new_client.auth_ref)
         self.assertFalse(new_client.auth_ref.domain_scoped)
         self.assertTrue(new_client.auth_ref.project_scoped)
-        self.assertEqual(new_client.auth_url, new_auth_url)
-        self.assertEqual(new_client.username, 'exampleuser')
+        self.assertEqual(new_auth_url, new_client.auth_url)
+        self.assertEqual(user_name, new_client.username)
         self.assertIsNone(new_client.password)
         self.assertEqual(new_client.management_url,
                          'http://admin:35357/v3')
 
     def test_trust_init(self):
-        self.stub_auth(json=client_fixtures.trust_token())
+        token = client_fixtures.trust_token()
+        self.stub_auth(json=token)
 
-        c = client.Client(user_domain_name='exampledomain',
-                          username='exampleuser',
+        c = client.Client(user_domain_name=token.user_domain_name,
+                          username=token.user_name,
                           password='password',
                           auth_url=self.TEST_URL,
-                          trust_id='fe0aef')
+                          trust_id=token.trust_id)
         self.assertIsNotNone(c.auth_ref)
         self.assertFalse(c.auth_ref.domain_scoped)
         self.assertFalse(c.auth_ref.project_scoped)
-        self.assertEqual(c.auth_ref.trust_id, 'fe0aef')
-        self.assertEqual(c.auth_ref.trustee_user_id, '0ca8f6')
-        self.assertEqual(c.auth_ref.trustor_user_id, 'bd263c')
+        self.assertEqual(token.trust_id, c.auth_ref.trust_id)
+        self.assertEqual(token.trustee_user_id, c.auth_ref.trustee_user_id)
+        self.assertEqual(token.trustor_user_id, c.auth_ref.trustor_user_id)
         self.assertTrue(c.auth_ref.trust_scoped)
-        self.assertEqual(c.auth_user_id, '0ca8f6')
+        self.assertEqual(token.user_id, c.auth_user_id)
 
     def test_init_err_no_auth_url(self):
         self.assertRaises(exceptions.AuthorizationFailure,
@@ -190,7 +196,7 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL,
                            region_name='North')
         self.assertEqual(cl.service_catalog.url_for(service_type='image'),
@@ -198,7 +204,7 @@ class KeystoneClientTest(utils.TestCase):
 
         cl = client.Client(username='exampleuser',
                            password='password',
-                           tenant_name='exampleproject',
+                           project_name='exampleproject',
                            auth_url=self.TEST_URL,
                            region_name='South')
         self.assertEqual(cl.service_catalog.url_for(service_type='image'),
diff --git a/keystoneclient/tests/unit/v3/test_domains.py b/keystoneclient/tests/unit/v3/test_domains.py
index 9cc23e7..4dbfd73 100644
--- a/keystoneclient/tests/unit/v3/test_domains.py
+++ b/keystoneclient/tests/unit/v3/test_domains.py
@@ -30,6 +30,12 @@ class DomainTests(utils.TestCase, utils.CrudTests):
         kwargs.setdefault('name', uuid.uuid4().hex)
         return kwargs
 
+    def test_filter_for_default_domain_by_id(self):
+        ref = self.new_ref(id='default')
+        super(DomainTests, self).test_list_by_id(
+            ref=ref,
+            id=ref['id'])
+
     def test_list_filter_name(self):
         super(DomainTests, self).test_list(name='adomain123')
 
diff --git a/keystoneclient/tests/unit/v3/test_federation.py b/keystoneclient/tests/unit/v3/test_federation.py
index 2c209cd..7b7f19d 100644
--- a/keystoneclient/tests/unit/v3/test_federation.py
+++ b/keystoneclient/tests/unit/v3/test_federation.py
@@ -278,6 +278,16 @@ class ProtocolTests(utils.TestCase, utils.CrudTests):
         for obj, ref_obj in zip(returned, expected):
             self.assertEqual(obj.to_dict(), ref_obj)
 
+    def test_list_by_id(self):
+        # The test in the parent class needs to be overridden because it
+        # assumes globally unique IDs, which is not the case with protocol IDs
+        # (which are contextualized per identity provider).
+        ref = self.new_ref()
+        super(ProtocolTests, self).test_list_by_id(
+            ref=ref,
+            identity_provider=ref['identity_provider'],
+            id=ref['id'])
+
     def test_list_params(self):
         request_args = self.new_ref()
         filter_kwargs = {uuid.uuid4().hex: uuid.uuid4().hex}
diff --git a/keystoneclient/tests/unit/v3/test_oauth1.py b/keystoneclient/tests/unit/v3/test_oauth1.py
index b52a759..2ebfa50 100644
--- a/keystoneclient/tests/unit/v3/test_oauth1.py
+++ b/keystoneclient/tests/unit/v3/test_oauth1.py
@@ -14,7 +14,6 @@
 import uuid
 
 import mock
-from oslo_utils import timeutils
 import six
 from six.moves.urllib import parse as urlparse
 from testtools import matchers
@@ -22,13 +21,13 @@ from testtools import matchers
 from keystoneclient import session
 from keystoneclient.tests.unit.v3 import client_fixtures
 from keystoneclient.tests.unit.v3 import utils
+from keystoneclient import utils as client_utils
 from keystoneclient.v3.contrib.oauth1 import access_tokens
 from keystoneclient.v3.contrib.oauth1 import auth
 from keystoneclient.v3.contrib.oauth1 import consumers
 from keystoneclient.v3.contrib.oauth1 import request_tokens
 
 try:
-    import oauthlib
     from oauthlib import oauth1
 except ImportError:
     oauth1 = None
@@ -90,7 +89,7 @@ class TokenTests(BaseTest):
 
     def _new_oauth_token_with_expires_at(self):
         key, secret, token = self._new_oauth_token()
-        expires_at = timeutils.strtime()
+        expires_at = client_utils.strtime()
         params = {'oauth_token': key,
                   'oauth_token_secret': secret,
                   'oauth_expires_at': expires_at}
@@ -103,16 +102,8 @@ class TokenTests(BaseTest):
         """
 
         self.assertThat(auth_header, matchers.StartsWith('OAuth '))
-        auth_header = auth_header[len('OAuth '):]
-        # NOTE(stevemar): In newer versions of oauthlib there is
-        # an additional argument for getting oauth parameters.
-        # Adding a conditional here to revert back to no arguments
-        # if an earlier version is detected.
-        if tuple(oauthlib.__version__.split('.')) > ('0', '6', '1'):
-            header_params = oauth_client.get_oauth_params(None)
-        else:
-            header_params = oauth_client.get_oauth_params()
-        parameters = dict(header_params)
+        parameters = dict(
+            oauth1.rfc5849.utils.parse_authorization_header(auth_header))
 
         self.assertEqual('HMAC-SHA1', parameters['oauth_signature_method'])
         self.assertEqual('1.0', parameters['oauth_version'])
@@ -128,9 +119,6 @@ class TokenTests(BaseTest):
         if oauth_client.callback_uri:
             self.assertEqual(oauth_client.callback_uri,
                              parameters['oauth_callback'])
-        if oauth_client.timestamp:
-            self.assertEqual(oauth_client.timestamp,
-                             parameters['oauth_timestamp'])
         return parameters
 
 
@@ -229,8 +217,8 @@ class AccessTokenTests(TokenTests):
                                      resource_owner_key=request_key,
                                      resource_owner_secret=request_secret,
                                      signature_method=oauth1.SIGNATURE_HMAC,
-                                     verifier=verifier,
-                                     timestamp=expires_at)
+                                     verifier=verifier)
+
         self._validate_oauth_headers(req_headers['Authorization'],
                                      oauth_client)
 
diff --git a/keystoneclient/tests/unit/v3/test_role_assignments.py b/keystoneclient/tests/unit/v3/test_role_assignments.py
index 79d2585..e77bdcc 100644
--- a/keystoneclient/tests/unit/v3/test_role_assignments.py
+++ b/keystoneclient/tests/unit/v3/test_role_assignments.py
@@ -71,6 +71,15 @@ class RoleAssignmentsTests(utils.TestCase, utils.CrudTests):
         self.assertEqual(len(ref_list), len(returned_list))
         [self.assertIsInstance(r, self.model) for r in returned_list]
 
+    def test_list_by_id(self):
+        # It doesn't make sense to "list role assignments by ID" at all, given
+        # that they don't have globally unique IDs in the first place. But
+        # calling RoleAssignmentsManager.list(id=...) should still raise a
+        # TypeError when given an unexpected keyword argument 'id', so we don't
+        # actually have to modify the test in the superclass... I just wanted
+        # to make a note here in case the superclass changes.
+        super(RoleAssignmentsTests, self).test_list_by_id()
+
     def test_list_params(self):
         ref_list = self.TEST_USER_PROJECT_LIST
         self.stub_entity('GET',
diff --git a/keystoneclient/tests/unit/v3/test_tokens.py b/keystoneclient/tests/unit/v3/test_tokens.py
index 2c27fd0..0363a61 100644
--- a/keystoneclient/tests/unit/v3/test_tokens.py
+++ b/keystoneclient/tests/unit/v3/test_tokens.py
@@ -53,6 +53,10 @@ class TokenTests(utils.TestCase, testresources.ResourcedTestCase):
             self.examples.v3_UUID_TOKEN_DEFAULT]
         self.stub_url('GET', ['auth', 'tokens'],
                       headers={'X-Subject-Token': token_id, }, json=token_ref)
+
+        token_data = self.client.tokens.get_token_data(token_id)
+        self.assertEqual(token_data, token_ref)
+
         access_info = self.client.tokens.validate(token_id)
 
         self.assertRequestHeaderEqual('X-Subject-Token', token_id)
@@ -77,6 +81,9 @@ class TokenTests(utils.TestCase, testresources.ResourcedTestCase):
         # When the token is invalid the server typically returns a 404.
         token_id = uuid.uuid4().hex
         self.stub_url('GET', ['auth', 'tokens'], status_code=404)
+
+        self.assertRaises(exceptions.NotFound,
+                          self.client.tokens.get_token_data, token_id)
         self.assertRaises(exceptions.NotFound,
                           self.client.tokens.validate, token_id)
 
@@ -87,6 +94,11 @@ class TokenTests(utils.TestCase, testresources.ResourcedTestCase):
             self.examples.v3_UUID_TOKEN_DEFAULT]
         self.stub_url('GET', ['auth', 'tokens'],
                       headers={'X-Subject-Token': token_id, }, json=token_ref)
+
+        token_data = self.client.tokens.get_token_data(token_id)
+        self.assertQueryStringIs()
+        self.assertIn('catalog', token_data['token'])
+
         access_info = self.client.tokens.validate(token_id)
 
         self.assertQueryStringIs()
@@ -99,6 +111,11 @@ class TokenTests(utils.TestCase, testresources.ResourcedTestCase):
             self.examples.v3_UUID_TOKEN_UNSCOPED]
         self.stub_url('GET', ['auth', 'tokens'],
                       headers={'X-Subject-Token': token_id, }, json=token_ref)
+
+        token_data = self.client.tokens.get_token_data(token_id)
+        self.assertQueryStringIs()
+        self.assertNotIn('catalog', token_data['token'])
+
         access_info = self.client.tokens.validate(token_id,
                                                   include_catalog=False)
 
diff --git a/keystoneclient/tests/unit/v3/utils.py b/keystoneclient/tests/unit/v3/utils.py
index 7f2d633..442c3a9 100644
--- a/keystoneclient/tests/unit/v3/utils.py
+++ b/keystoneclient/tests/unit/v3/utils.py
@@ -129,9 +129,7 @@ class TestCase(UnauthenticatedTestCase):
 
     def setUp(self):
         super(TestCase, self).setUp()
-        self.client = client.Client(username=self.TEST_USER,
-                                    token=self.TEST_TOKEN,
-                                    tenant_name=self.TEST_TENANT_NAME,
+        self.client = client.Client(token=self.TEST_TOKEN,
                                     auth_url=self.TEST_URL,
                                     endpoint=self.TEST_URL)
 
@@ -245,6 +243,20 @@ class CrudTests(object):
 
         return expected_path
 
+    def test_list_by_id(self, ref=None, **filter_kwargs):
+        """Test ``entities.list(id=x)`` being rewritten as ``GET /v3/entities/x``.
+
+        This tests an edge case of each manager's list() implementation, to
+        ensure that it "does the right thing" when users call ``.list()``
+        when they should have used ``.get()``.
+
+        """
+        if 'id' not in filter_kwargs:
+            ref = ref or self.new_ref()
+            filter_kwargs['id'] = ref['id']
+
+        self.assertRaises(TypeError, self.manager.list, **filter_kwargs)
+
     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()]