Merge "Change server create to use tracked create_server"

tempest/tests/compute/floating_ips/test_floating_ips_actions.py

@@ -33,10 +33,7 @@ class FloatingIPsTestJSON(base.BaseComputeTest):
         cls.servers_client = cls.servers_client
 
         #Server creation
-        resp, server = cls.servers_client.create_server('floating-server',
+        resp, server = cls.create_server(wait_until='ACTIVE')
-                                                        cls.image_ref,
-                                                        cls.flavor_ref)
-        cls.servers_client.wait_for_server_status(server['id'], 'ACTIVE')
         cls.server_id = server['id']
         resp, body = cls.servers_client.get_server(server['id'])
         #Floating IP creation
@@ -55,10 +52,8 @@ class FloatingIPsTestJSON(base.BaseComputeTest):
 
     @classmethod
     def tearDownClass(cls):
-        super(FloatingIPsTestJSON, cls).tearDownClass()
-        #Deleting the server which is created in this method
-        resp, body = cls.servers_client.delete_server(cls.server_id)
         #Deleting the floating IP which is created in this method
+        super(FloatingIPsTestJSON, cls).tearDownClass()
         resp, body = cls.client.delete_floating_ip(cls.floating_ip_id)
 
     @attr(type='positive')

tempest/tests/compute/images/test_image_metadata.py

@@ -30,14 +30,9 @@ class ImagesMetadataTest(base.BaseComputeTest):
         cls.servers_client = cls.servers_client
         cls.client = cls.images_client
 
-        name = rand_name('server')
+        resp, server = cls.create_server(wait_until='ACTIVE')
-        resp, server = cls.servers_client.create_server(name, cls.image_ref,
-                                                        cls.flavor_ref)
         cls.server_id = server['id']
 
-        #Wait for the server to become active
-        cls.servers_client.wait_for_server_status(cls.server_id, 'ACTIVE')
-
         # Snapshot the server once to save time
         name = rand_name('image')
         resp, _ = cls.client.create_image(cls.server_id, name, {})
@@ -49,7 +44,6 @@ class ImagesMetadataTest(base.BaseComputeTest):
     @classmethod
     def tearDownClass(cls):
         cls.client.delete_image(cls.image_id)
-        cls.servers_client.delete_server(cls.server_id)
         super(ImagesMetadataTest, cls).tearDownClass()
 
     def setUp(self):

tempest/tests/compute/images/test_images_whitebox.py

@@ -36,15 +36,8 @@ class ImagesWhiteboxTest(whitebox.ComputeWhiteboxTest, base.BaseComputeTest):
 
     @classmethod
     def tearDownClass(cls):
-        """Terminate test instances created after a test is executed."""
+        """Delete images after a test is executed."""
-
+        super(ImagesWhiteboxTest, cls).tearDownClass()
-        for server in cls.servers:
-            cls.update_state(server['id'], "active", None)
-            resp, body = cls.servers_client.delete_server(server['id'])
-            if resp['status'] == '204':
-                cls.servers.remove(server)
-                cls.servers_client.wait_for_server_termination(server['id'])
-
         for image_id in cls.image_ids:
             cls.client.delete_image(image_id)
             cls.image_ids.remove(image_id)

tempest/tests/compute/servers/test_server_addresses.py

@@ -29,16 +29,7 @@ class ServerAddressesTest(base.BaseComputeTest):
         super(ServerAddressesTest, cls).setUpClass()
         cls.client = cls.servers_client
 
-        cls.name = rand_name('server')
+        resp, cls.server = cls.create_server(wait_until='ACTIVE')
-        resp, cls.server = cls.client.create_server(cls.name,
-                                                    cls.image_ref,
-                                                    cls.flavor_ref)
-        cls.client.wait_for_server_status(cls.server['id'], 'ACTIVE')
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.client.delete_server(cls.server['id'])
-        super(ServerAddressesTest, cls).tearDownClass()
 
     @attr(type='negative', category='server-addresses')
     def test_list_server_addresses_invalid_server_id(self):

tempest/tests/compute/servers/test_server_metadata.py

@@ -32,18 +32,10 @@ class ServerMetadataTestJSON(base.BaseComputeTest):
         resp, tenants = cls.admin_client.list_tenants()
         cls.tenant_id = [tnt['id'] for tnt in tenants if tnt['name'] ==
                          cls.client.tenant_name][0]
-        resp, server = cls.create_server(meta={})
+        resp, server = cls.create_server(meta={}, wait_until='ACTIVE')
 
         cls.server_id = server['id']
 
-        #Wait for the server to become active
-        cls.client.wait_for_server_status(cls.server_id, 'ACTIVE')
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.client.delete_server(cls.server_id)
-        super(ServerMetadataTestJSON, cls).tearDownClass()
-
     def setUp(self):
         super(ServerMetadataTestJSON, self).setUp()
         meta = {'key1': 'value1', 'key2': 'value2'}

tempest/tests/compute/servers/test_virtual_interfaces.py

@@ -30,20 +30,10 @@ class VirtualInterfacesTestJSON(base.BaseComputeTest):
     @classmethod
     def setUpClass(cls):
         super(VirtualInterfacesTestJSON, cls).setUpClass()
-        cls.name = rand_name('server')
         cls.client = cls.servers_client
-        resp, server = cls.servers_client.create_server(cls.name,
+        resp, server = cls.create_server(wait_until='ACTIVE')
-                                                        cls.image_ref,
-                                                        cls.flavor_ref)
         cls.server_id = server['id']
 
-        cls.servers_client.wait_for_server_status(cls.server_id, 'ACTIVE')
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.servers_client.delete_server(cls.server_id)
-        super(VirtualInterfacesTestJSON, cls).tearDownClass()
-
     @attr(type='positive')
     def test_list_virtual_interfaces(self):
         # Positive test:Should be able to GET the virtual interfaces list

tempest/tests/compute/test_authorization.py

@@ -57,10 +57,7 @@ class AuthorizationTest(base.BaseComputeTest):
         cls.alt_security_client = cls.alt_manager.security_groups_client
 
         cls.alt_security_client._set_auth()
-        name = rand_name('server')
+        resp, server = cls.create_server(wait_until='ACTIVE')
-        resp, server = cls.client.create_server(name, cls.image_ref,
-                                                cls.flavor_ref)
-        cls.client.wait_for_server_status(server['id'], 'ACTIVE')
         resp, cls.server = cls.client.get_server(server['id'])
 
         name = rand_name('image')
@@ -92,7 +89,6 @@ class AuthorizationTest(base.BaseComputeTest):
     @classmethod
     def tearDownClass(cls):
         if compute.MULTI_USER:
-            cls.client.delete_server(cls.server['id'])
             cls.images_client.delete_image(cls.image['id'])
             cls.keypairs_client.delete_keypair(cls.keypairname)
             cls.security_client.delete_security_group(cls.security_group['id'])

tempest/tests/compute/volumes/test_attach_volume.py

@@ -43,24 +43,15 @@ class AttachVolumeTestJSON(base.BaseComputeTest):
         self.servers_client.detach_volume(server_id, volume_id)
         self.volumes_client.wait_for_volume_status(volume_id, 'available')
 
-    def _delete(self, server, volume):
+    def _delete(self, volume):
         if self.volume:
             self.volumes_client.delete_volume(self.volume['id'])
             self.volume = None
-        if self.server:
-            self.servers_client.delete_server(self.server['id'])
-            self.server = None
 
     def _create_and_attach(self):
-        name = rand_name('server')
-
         # Start a server and wait for it to become ready
-        resp, server = self.servers_client.create_server(name,
+        resp, server = self.create_server(wait_until='ACTIVE',
-                                                         self.image_ref,
+                                          adminPass='password')
-                                                         self.flavor_ref,
-                                                         adminPass='password')
-        self.server = server
-        self.servers_client.wait_for_server_status(server['id'], 'ACTIVE')
 
         # Record addresses so that we can ssh later
         resp, server['addresses'] = \
@@ -118,7 +109,9 @@ class AttachVolumeTestJSON(base.BaseComputeTest):
         finally:
             if self.attached:
                 self._detach(server['id'], volume['id'])
-            self._delete(self.server, self.volume)
+            # NOTE(maurosr): here we do the cleanup for volume, servers are
+            # dealt on BaseComputeTest.tearDownClass
+            self._delete(self.volume)
 
 
 class AttachVolumeTestXML(AttachVolumeTestJSON):