Merge "Correct addCleanup use in functests"

functional/tests/identity/v2/test_identity.py

@@ -67,13 +67,13 @@ class IdentityTests(test.TestCase):
             '--description %(description)s '
             '--enable %(name)s' % {'description': project_description,
                                    'name': project_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.PROJECT_FIELDS)
         project = self.parse_show_as_object(raw_output)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'project delete %s' % project['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.PROJECT_FIELDS)
         return project_name
 
     def _create_dummy_user(self, add_clean_up=True):
@@ -90,47 +90,47 @@ class IdentityTests(test.TestCase):
                           'email': email,
                           'password': password,
                           'name': username})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.USER_FIELDS)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'user delete %s' % self.parse_show_as_object(raw_output)['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.USER_FIELDS)
         return username
 
     def _create_dummy_role(self, add_clean_up=True):
         role_name = data_utils.rand_name('TestRole')
         raw_output = self.openstack('role create %s' % role_name)
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.ROLE_FIELDS)
         role = self.parse_show_as_object(raw_output)
-        self.assertEqual(role_name, role['name'])
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'role delete %s' % role['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+        self.assertEqual(role_name, role['name'])
         return role_name
 
     def _create_dummy_ec2_credentials(self, add_clean_up=True):
         raw_output = self.openstack('ec2 credentials create')
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.EC2_CREDENTIALS_FIELDS)
         ec2_credentials = self.parse_show_as_object(raw_output)
         access_key = ec2_credentials['access']
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'ec2 credentials delete %s' % access_key)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.EC2_CREDENTIALS_FIELDS)
         return access_key
 
     def _create_dummy_token(self, add_clean_up=True):
         raw_output = self.openstack('token issue')
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.TOKEN_FIELDS)
         token = self.parse_show_as_object(raw_output)
         if add_clean_up:
             self.addCleanup(self.openstack,
                             'token revoke %s' % token['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.TOKEN_FIELDS)
         return token['id']
 
     def _create_dummy_service(self, add_clean_up=True):
@@ -144,12 +144,12 @@ class IdentityTests(test.TestCase):
             '%(type)s' % {'name': service_name,
                           'description': description,
                           'type': type_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.SERVICE_FIELDS)
         if add_clean_up:
             service = self.parse_show_as_object(raw_output)
             self.addCleanup(self.openstack,
                             'service delete %s' % service['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_FIELDS)
         return service_name
 
     def _create_dummy_endpoint(self, add_clean_up=True):
@@ -169,11 +169,11 @@ class IdentityTests(test.TestCase):
                              'internalurl': internal_url,
                              'region': region_id,
                              'service': service_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
         endpoint = self.parse_show_as_object(raw_output)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'endpoint delete %s' % endpoint['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
         return endpoint['id']

functional/tests/identity/v2/test_role.py

@@ -40,8 +40,17 @@ class RoleTests(test_identity.IdentityTests):
             '%(role)s' % {'project': project_name,
                           'user': username,
                           'role': role_name})
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            '--project %(project)s '
+            '--user %(user)s '
+            '%(role)s' % {'project': project_name,
+                          'user': username,
+                          'role': role_name})
         items = self.parse_show(raw_output)
         self.assert_show_fields(items, self.ROLE_FIELDS)
+
         raw_output = self.openstack(
             'role list '
             '--project %(project)s '
@@ -51,14 +60,6 @@ class RoleTests(test_identity.IdentityTests):
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, test_identity.BASIC_LIST_HEADERS)
         self.assertEqual(1, len(items))
-        self.addCleanup(
-            self.openstack,
-            'role remove '
-            '--project %(project)s '
-            '--user %(user)s '
-            '%(role)s' % {'project': project_name,
-                          'user': username,
-                          'role': role_name})
 
     def test_role_show(self):
         role_name = self._create_dummy_role()
@@ -76,8 +77,6 @@ class RoleTests(test_identity.IdentityTests):
             '%(role)s' % {'project': self.project_name,
                           'user': username,
                           'role': role_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.ROLE_FIELDS)
         self.addCleanup(
             self.openstack,
             'role remove '
@@ -86,24 +85,26 @@ class RoleTests(test_identity.IdentityTests):
             '%(role)s' % {'project': self.project_name,
                           'user': username,
                           'role': role_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
 
     def test_role_remove(self):
         role_name = self._create_dummy_role()
         username = self._create_dummy_user()
-        raw_output = self.openstack(
+        add_raw_output = self.openstack(
             'role add '
             '--project %(project)s '
             '--user %(user)s '
             '%(role)s' % {'project': self.project_name,
                           'user': username,
                           'role': role_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.ROLE_FIELDS)
-        raw_output = self.openstack(
+        del_raw_output = self.openstack(
             'role remove '
             '--project %(project)s '
             '--user %(user)s '
             '%(role)s' % {'project': self.project_name,
                           'user': username,
                           'role': role_name})
-        self.assertEqual(0, len(raw_output))
+        items = self.parse_show(add_raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+        self.assertEqual(0, len(del_raw_output))

functional/tests/identity/v3/test_domain.py

@@ -21,13 +21,13 @@ class DomainTests(test_identity.IdentityTests):
     def test_domain_create(self):
         domain_name = data_utils.rand_name('TestDomain')
         raw_output = self.openstack('domain create %s' % domain_name)
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.DOMAIN_FIELDS)
         # disable domain first before deleting it
         self.addCleanup(self.openstack,
                         'domain delete %s' % domain_name)
         self.addCleanup(self.openstack,
                         'domain set --disable %s' % domain_name)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.DOMAIN_FIELDS)
 
     def test_domain_list(self):
         self._create_dummy_domain()

functional/tests/identity/v3/test_group.py

@@ -93,11 +93,6 @@ class GroupTests(test_identity.IdentityTests):
                                     'user_domain': self.domain_name,
                                     'group': group_name,
                                     'user': username})
-        self.assertOutput(
-            '%(user)s added to group %(group)s\n' % {'user': username,
-                                                     'group': group_name},
-            raw_output
-        )
         self.addCleanup(
             self.openstack,
             'group remove user '
@@ -107,6 +102,11 @@ class GroupTests(test_identity.IdentityTests):
                                     'user_domain': self.domain_name,
                                     'group': group_name,
                                     'user': username})
+        self.assertOutput(
+            '%(user)s added to group %(group)s\n' % {'user': username,
+                                                     'group': group_name},
+            raw_output
+        )
 
     def test_group_contains_user(self):
         group_name = self._create_dummy_group()
@@ -119,6 +119,15 @@ class GroupTests(test_identity.IdentityTests):
                                     'user_domain': self.domain_name,
                                     'group': group_name,
                                     'user': username})
+        self.addCleanup(
+            self.openstack,
+            'group remove user '
+            '--group-domain %(group_domain)s '
+            '--user-domain %(user_domain)s '
+            '%(group)s %(user)s' % {'group_domain': self.domain_name,
+                                    'user_domain': self.domain_name,
+                                    'group': group_name,
+                                    'user': username})
         self.assertOutput(
             '%(user)s added to group %(group)s\n' % {'user': username,
                                                      'group': group_name},
@@ -136,21 +145,20 @@ class GroupTests(test_identity.IdentityTests):
             '%(user)s in group %(group)s\n' % {'user': username,
                                                'group': group_name},
             raw_output)
-        self.addCleanup(
-            self.openstack,
-            'group remove user '
+
+    def test_group_remove_user(self):
+        group_name = self._create_dummy_group()
+        username = self._create_dummy_user()
+        add_raw_output = self.openstack(
+            'group add user '
             '--group-domain %(group_domain)s '
             '--user-domain %(user_domain)s '
             '%(group)s %(user)s' % {'group_domain': self.domain_name,
                                     'user_domain': self.domain_name,
                                     'group': group_name,
                                     'user': username})
-
-    def test_group_remove_user(self):
-        group_name = self._create_dummy_group()
-        username = self._create_dummy_user()
-        raw_output = self.openstack(
-            'group add user '
+        remove_raw_output = self.openstack(
+            'group remove user '
             '--group-domain %(group_domain)s '
             '--user-domain %(user_domain)s '
             '%(group)s %(user)s' % {'group_domain': self.domain_name,
@@ -160,19 +168,11 @@ class GroupTests(test_identity.IdentityTests):
         self.assertOutput(
             '%(user)s added to group %(group)s\n' % {'user': username,
                                                      'group': group_name},
-            raw_output
+            add_raw_output
         )
-        raw_output = self.openstack(
-            'group remove user '
-            '--group-domain %(group_domain)s '
-            '--user-domain %(user_domain)s '
-            '%(group)s %(user)s' % {'group_domain': self.domain_name,
-                                    'user_domain': self.domain_name,
-                                    'group': group_name,
-                                    'user': username})
         self.assertOutput(
             '%(user)s removed from '
             'group %(group)s\n' % {'user': username,
                                    'group': group_name},
-            raw_output
+            remove_raw_output
         )

functional/tests/identity/v3/test_identity.py

@@ -115,25 +115,25 @@ class IdentityTests(test.TestCase):
                           'password': password,
                           'description': description,
                           'name': username})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.USER_FIELDS)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'user delete %s' % self.parse_show_as_object(raw_output)['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.USER_FIELDS)
         return username
 
     def _create_dummy_role(self, add_clean_up=True):
         role_name = data_utils.rand_name('TestRole')
         raw_output = self.openstack('role create %s' % role_name)
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.ROLE_FIELDS)
         role = self.parse_show_as_object(raw_output)
-        self.assertEqual(role_name, role['name'])
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'role delete %s' % role['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ROLE_FIELDS)
+        self.assertEqual(role_name, role['name'])
         return role_name
 
     def _create_dummy_group(self, add_clean_up=True):
@@ -146,8 +146,6 @@ class IdentityTests(test.TestCase):
             '%(name)s' % {'domain': self.domain_name,
                           'description': description,
                           'name': group_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.GROUP_FIELDS)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
@@ -155,6 +153,8 @@ class IdentityTests(test.TestCase):
                 '--domain %(domain)s '
                 '%(name)s' % {'domain': self.domain_name,
                               'name': group_name})
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.GROUP_FIELDS)
         return group_name
 
     def _create_dummy_domain(self, add_clean_up=True):
@@ -208,11 +208,11 @@ class IdentityTests(test.TestCase):
             '%(id)s' % {'parent_region_arg': parent_region_arg,
                         'description': description,
                         'id': region_id})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.REGION_FIELDS)
         if add_clean_up:
             self.addCleanup(self.openstack,
                             'region delete %s' % region_id)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.REGION_FIELDS)
         return region_id
 
     def _create_dummy_service(self, add_clean_up=True):
@@ -227,12 +227,12 @@ class IdentityTests(test.TestCase):
             '%(type)s' % {'name': service_name,
                           'description': description,
                           'type': type_name})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.SERVICE_FIELDS)
         if add_clean_up:
             service = self.parse_show_as_object(raw_output)
             self.addCleanup(self.openstack,
                             'service delete %s' % service['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_FIELDS)
         return service_name
 
     def _create_dummy_endpoint(self, interface='public', add_clean_up=True):
@@ -249,13 +249,13 @@ class IdentityTests(test.TestCase):
                          'service': service_name,
                          'interface': interface,
                          'url': endpoint_url})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
         endpoint = self.parse_show_as_object(raw_output)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'endpoint delete %s' % endpoint['id'])
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.ENDPOINT_FIELDS)
         return endpoint['id']
 
     def _create_dummy_idp(self, add_clean_up=True):
@@ -267,12 +267,12 @@ class IdentityTests(test.TestCase):
             '--description %(description)s '
             '--enable ' % {'name': identity_provider,
                            'description': description})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.IDENTITY_PROVIDER_FIELDS)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'identity provider delete %s' % identity_provider)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.IDENTITY_PROVIDER_FIELDS)
         return identity_provider
 
     def _create_dummy_sp(self, add_clean_up=True):
@@ -286,10 +286,10 @@ class IdentityTests(test.TestCase):
             '--service-provider-url https://sp.example.com:5000 '
             '--enable ' % {'name': service_provider,
                            'description': description})
-        items = self.parse_show(raw_output)
-        self.assert_show_fields(items, self.SERVICE_PROVIDER_FIELDS)
         if add_clean_up:
             self.addCleanup(
                 self.openstack,
                 'service provider delete %s' % service_provider)
+        items = self.parse_show(raw_output)
+        self.assert_show_fields(items, self.SERVICE_PROVIDER_FIELDS)
         return service_provider

functional/tests/identity/v3/test_role.py

@@ -45,6 +45,18 @@ class RoleTests(test_identity.IdentityTests):
                           'user': username,
                           'user_domain': self.domain_name,
                           'role': role_name})
+        self.addCleanup(
+            self.openstack,
+            'role remove '
+            '--project %(project)s '
+            '--project-domain %(project_domain)s '
+            '--user %(user)s '
+            '--user-domain %(user_domain)s '
+            '%(role)s' % {'project': self.project_name,
+                          'project_domain': self.domain_name,
+                          'user': username,
+                          'user_domain': self.domain_name,
+                          'role': role_name})
         self.assertEqual(0, len(raw_output))
         raw_output = self.openstack(
             'role list '
@@ -59,18 +71,6 @@ class RoleTests(test_identity.IdentityTests):
         items = self.parse_listing(raw_output)
         self.assert_table_structure(items, test_identity.BASIC_LIST_HEADERS)
         self.assertEqual(1, len(items))
-        self.addCleanup(
-            self.openstack,
-            'role remove '
-            '--project %(project)s '
-            '--project-domain %(project_domain)s '
-            '--user %(user)s '
-            '--user-domain %(user_domain)s '
-            '%(role)s' % {'project': self.project_name,
-                          'project_domain': self.domain_name,
-                          'user': username,
-                          'user_domain': self.domain_name,
-                          'role': role_name})
 
     def test_role_show(self):
         role_name = self._create_dummy_role()
@@ -102,7 +102,6 @@ class RoleTests(test_identity.IdentityTests):
                           'user': username,
                           'user_domain': self.domain_name,
                           'role': role_name})
-        self.assertEqual(0, len(raw_output))
         self.addCleanup(
             self.openstack,
             'role remove '
@@ -115,11 +114,12 @@ class RoleTests(test_identity.IdentityTests):
                           'user': username,
                           'user_domain': self.domain_name,
                           'role': role_name})
+        self.assertEqual(0, len(raw_output))
 
     def test_role_remove(self):
         role_name = self._create_dummy_role()
         username = self._create_dummy_user()
-        raw_output = self.openstack(
+        add_raw_output = self.openstack(
             'role add '
             '--project %(project)s '
             '--project-domain %(project_domain)s '
@@ -130,8 +130,7 @@ class RoleTests(test_identity.IdentityTests):
                           'user': username,
                           'user_domain': self.domain_name,
                           'role': role_name})
-        self.assertEqual(0, len(raw_output))
-        raw_output = self.openstack(
+        remove_raw_output = self.openstack(
             'role remove '
             '--project %(project)s '
             '--project-domain %(project_domain)s '
@@ -142,4 +141,5 @@ class RoleTests(test_identity.IdentityTests):
                           'user': username,
                           'user_domain': self.domain_name,
                           'role': role_name})
-        self.assertEqual(0, len(raw_output))
+        self.assertEqual(0, len(add_raw_output))
+        self.assertEqual(0, len(remove_raw_output))