Improved cleanup of test resources

test/helpers/__init__.py

@@ -12,6 +12,9 @@ from cloudbridge.cloud.base.helpers import get_env
 from cloudbridge.cloud.factory import CloudProviderFactory
 from cloudbridge.cloud.interfaces import InstanceState
 from cloudbridge.cloud.interfaces import TestMockHelperMixin
+from cloudbridge.cloud.interfaces.resources import FloatingIpState
+from cloudbridge.cloud.interfaces.resources import NetworkState
+from cloudbridge.cloud.interfaces.resources import SubnetState
 
 
 def parse_bool(val):
@@ -130,14 +133,33 @@ def get_or_create_default_subnet(provider):
         zone=get_provider_test_data(provider, 'placement'))
 
 
-def delete_test_network(network):
+def cleanup_subnet(subnet):
+    if subnet:
+        subnet.delete()
+        subnet.wait_for([SubnetState.UNKNOWN],
+                        terminal_states=[SubnetState.ERROR])
+
+
+def cleanup_network(network):
     """
     Delete the supplied network, first deleting any contained subnets.
     """
-    with cleanup_action(lambda: network.delete()):
-        for sn in network.subnets:
-            with cleanup_action(lambda: sn.delete()):
-                pass
+    if network:
+        try:
+            for sn in network.subnets:
+                with cleanup_action(lambda: cleanup_subnet(sn)):
+                    pass
+        finally:
+            network.delete()
+            network.wait_for([NetworkState.UNKNOWN],
+                             terminal_states=[NetworkState.ERROR])
+
+
+def cleanup_fip(fip):
+    if fip:
+        fip.delete()
+        fip.wait_for([FloatingIpState.UNKNOWN],
+                     terminal_states=[FloatingIpState.ERROR])
 
 
 def get_test_gateway(provider):
@@ -151,7 +173,7 @@ def get_test_gateway(provider):
     return net.gateways.get_or_create_inet_gateway()
 
 
-def delete_test_gateway(gateway):
+def cleanup_gateway(gateway):
     """
     Delete the supplied network and gateway.
     """
@@ -195,7 +217,7 @@ def get_test_fixtures_folder():
     return os.path.join(os.path.dirname(__file__), '../fixtures/')
 
 
-def delete_test_instance(instance):
+def delete_instance(instance):
     if instance:
         instance.delete()
         instance.wait_for([InstanceState.DELETED, InstanceState.UNKNOWN],
@@ -205,12 +227,12 @@ def delete_test_instance(instance):
 def cleanup_test_resources(instance=None, vm_firewall=None,
                            key_pair=None, network=None):
     """Clean up any combination of supplied resources."""
-    with cleanup_action(lambda: delete_test_network(network)
+    with cleanup_action(lambda: cleanup_network(network)
                         if network else None):
         with cleanup_action(lambda: key_pair.delete() if key_pair else None):
             with cleanup_action(lambda: vm_firewall.delete()
                                 if vm_firewall else None):
-                delete_test_instance(instance)
+                delete_instance(instance)
 
 
 def get_uuid():

test/test_compute_service.py

@@ -288,15 +288,14 @@ class CloudComputeServiceTestCase(ProviderTestBase):
                 subnet = helpers.get_or_create_default_subnet(
                     self.provider)
 
-                inst = helpers.create_test_instance(
-                    self.provider,
-                    label,
-                    subnet=subnet,
-                    launch_config=lc)
-
-                with helpers.cleanup_action(lambda:
-                                            helpers.delete_test_instance(
-                                                inst)):
+                inst = None
+                with helpers.cleanup_action(
+                        lambda: helpers.delete_instance(inst)):
+                    inst = helpers.create_test_instance(
+                        self.provider,
+                        label,
+                        subnet=subnet,
+                        launch_config=lc)
                     try:
                         inst.wait_till_ready()
                     except WaitStateException as e:
@@ -361,7 +360,7 @@ class CloudComputeServiceTestCase(ProviderTestBase):
                 router.attach_gateway(gateway)
                 fip = None
 
-                with helpers.cleanup_action(lambda: fip.delete()):
+                with helpers.cleanup_action(lambda: helpers.cleanup_fip(fip)):
                     # check whether adding an elastic ip works
                     fip = gateway.floating_ips.create()
                     self.assertFalse(

test/test_network_service.py

@@ -26,10 +26,11 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
         def cleanup_net(net):
             if net:
                 net.delete()
-                net.refresh()
+                net.wait_for([NetworkState.UNKNOWN],
+                             terminal_states=[NetworkState.ERROR])
                 self.assertTrue(
                     net.state == NetworkState.UNKNOWN,
-                    "Network.state must be unknown when refreshing after "
+                    "Network.state must be unknown after "
                     "a delete but got %s"
                     % net.state)
 
@@ -42,7 +43,7 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
         subnet_label = 'cb-propsubnet-{0}'.format(helpers.get_uuid())
         net = self.provider.networking.networks.create(
             label=label, cidr_block=BaseNetwork.CB_DEFAULT_IPV4RANGE)
-        with helpers.cleanup_action(lambda: net.delete()):
+        with helpers.cleanup_action(lambda: helpers.cleanup_network(net)):
             net.wait_till_ready()
             self.assertEqual(
                 net.state, 'available',
@@ -60,7 +61,7 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                 label=subnet_label, cidr_block=cidr,
                 zone=helpers.get_provider_test_data(self.provider,
                                                     'placement'))
-            with helpers.cleanup_action(lambda: sn.delete()):
+            with helpers.cleanup_action(lambda: helpers.cleanup_subnet(sn)):
                 self.assertTrue(
                     sn in net.subnets,
                     "Subnet ID %s should be listed in network subnets %s."
@@ -110,10 +111,11 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
         def cleanup_subnet(subnet):
             if subnet:
                 subnet.delete()
-                subnet.refresh()
+                subnet.wait_for([SubnetState.UNKNOWN],
+                                terminal_states=[SubnetState.ERROR])
                 self.assertTrue(
                     subnet.state == SubnetState.UNKNOWN,
-                    "Subnet.state must be unknown when refreshing after "
+                    "Subnet.state must be unknown after "
                     "a delete but got %s"
                     % subnet.state)
 
@@ -133,7 +135,7 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                 gw.floating_ips.delete(fip.id)
 
         with helpers.cleanup_action(
-                lambda: helpers.delete_test_gateway(gw)):
+                lambda: helpers.cleanup_gateway(gw)):
             sit.check_crud(self, gw.floating_ips, FloatingIP,
                            "cb-crudfip", create_fip, cleanup_fip,
                            skip_name_check=True)
@@ -144,7 +146,7 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
             self.provider)
         fip = gw.floating_ips.create()
         with helpers.cleanup_action(
-                lambda: helpers.delete_test_gateway(gw)):
+                lambda: helpers.cleanup_gateway(gw)):
             with helpers.cleanup_action(lambda: fip.delete()):
                 fipl = list(gw.floating_ips)
                 self.assertIn(fip, fipl)
@@ -166,10 +168,12 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
     def test_crud_router(self):
 
         def _cleanup(net, subnet, router, gateway):
-            with helpers.cleanup_action(lambda: net.delete()):
+            with helpers.cleanup_action(lambda: helpers.cleanup_network(net)):
                 with helpers.cleanup_action(lambda: router.delete()):
-                    with helpers.cleanup_action(lambda: subnet.delete()):
-                        with helpers.cleanup_action(lambda: gateway.delete()):
+                    with helpers.cleanup_action(
+                            lambda: helpers.cleanup_subnet(subnet)):
+                        with helpers.cleanup_action(
+                                lambda: helpers.cleanup_gateway(gateway)):
                             router.detach_subnet(subnet)
                             router.detach_gateway(gateway)
 
@@ -217,7 +221,7 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
             router.attach_gateway(gteway)
             # TODO: add a check for routes after that's been implemented
 
-        sit.check_delete(self, self.provider.networking.routers, router)
+            sit.check_delete(self, self.provider.networking.routers, router)
 
     @helpers.skipIfNoService(['networking.networks'])
     def test_default_network(self):

test/test_object_life_cycle.py

@@ -13,21 +13,22 @@ class CloudObjectLifeCycleTestCase(ProviderTestBase):
     def test_object_life_cycle(self):
         # Test object life cycle methods by using a volume.
         label = "cb-objlifecycle-{0}".format(helpers.get_uuid())
-        test_vol = self.provider.storage.volumes.create(
-            label, 1,
-            helpers.get_provider_test_data(self.provider, "placement"))
+        test_vol = None
+        with helpers.cleanup_action(lambda: test_vol.delete()):
+            test_vol = self.provider.storage.volumes.create(
+                label, 1,
+                helpers.get_provider_test_data(self.provider, "placement"))
 
-        # Waiting for an invalid timeout should raise an exception
-        with self.assertRaises(AssertionError):
-            test_vol.wait_for([VolumeState.ERROR], timeout=-1, interval=1)
-        with self.assertRaises(AssertionError):
-            test_vol.wait_for([VolumeState.ERROR], timeout=1, interval=-1)
+            # Waiting for an invalid timeout should raise an exception
+            with self.assertRaises(AssertionError):
+                test_vol.wait_for([VolumeState.ERROR], timeout=-1, interval=1)
+            with self.assertRaises(AssertionError):
+                test_vol.wait_for([VolumeState.ERROR], timeout=1, interval=-1)
 
-        # If interval < timeout, an exception should be raised
-        with self.assertRaises(AssertionError):
-            test_vol.wait_for([VolumeState.ERROR], timeout=10, interval=20)
+            # If interval < timeout, an exception should be raised
+            with self.assertRaises(AssertionError):
+                test_vol.wait_for([VolumeState.ERROR], timeout=10, interval=20)
 
-        with helpers.cleanup_action(lambda: test_vol.delete()):
             test_vol.wait_till_ready()
             # Hitting a terminal state should raise an exception
             with self.assertRaises(WaitStateException):