Merge "Use UUID values in v3 test fixtures"

4 files changed, 125 insertions, 136 deletions

diff --git a/keystoneclient/fixture/v3.py b/keystoneclient/fixture/v3.py
index bda5e19..d27a93b 100644
--- a/keystoneclient/fixture/v3.py
+++ b/keystoneclient/fixture/v3.py
@@ -325,6 +325,14 @@ class Token(dict):
     def audit_chain_id(self, value):
         self.root['audit_ids'] = [self.audit_id, value]
 
+    @property
+    def role_ids(self):
+        return [r['id'] for r in self.root.get('roles', [])]
+
+    @property
+    def role_names(self):
+        return [r['name'] for r in self.root.get('roles', [])]
+
     def validate(self):
         project = self.root.get('project')
         domain = self.root.get('domain')
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 74e4438..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, [])
@@ -57,9 +57,10 @@ class AccessInfoTest(utils.TestCase):
         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)
@@ -94,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)
@@ -132,20 +133,20 @@ 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)
@@ -157,13 +158,15 @@ class AccessInfoTest(utils.TestCase):
             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(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(auth_ref.user_domain_id,
-                         '4e6893b7ba0b4006840c3845660b86ed')
-        self.assertEqual(auth_ref.user_domain_name, 'exampledomain')
+        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_client.py b/keystoneclient/tests/unit/v3/test_client.py
index 8f665ac..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,