Fixed up tests

test/helpers/__init__.py

@@ -114,7 +114,7 @@ def delete_test_network(network):
     Delete the supplied network, first deleting any contained subnets.
     """
     with cleanup_action(lambda: network.delete()):
-        for sn in network.subnets():
+        for sn in network.subnets:
             sn.delete()
 
 

test/test_compute_service.py

@@ -16,7 +16,7 @@ import six
 
 class CloudComputeServiceTestCase(ProviderTestBase):
 
-    @helpers.skipIfNoService(['compute.instances', 'network'])
+    @helpers.skipIfNoService(['compute.instances', 'networking.networks'])
     def test_crud_instance(self):
         name = "cb_instcrud-{0}".format(helpers.get_uuid())
         # Declare these variables and late binding will allow
@@ -47,7 +47,7 @@ class CloudComputeServiceTestCase(ProviderTestBase):
             return False
         return True
 
-    @helpers.skipIfNoService(['compute.instances', 'network',
+    @helpers.skipIfNoService(['compute.instances', 'networking.networks',
                               'security.security_groups',
                               'security.key_pairs'])
     def test_instance_properties(self):
@@ -277,7 +277,7 @@ class CloudComputeServiceTestCase(ProviderTestBase):
                         # TODO: Check instance attachments and make sure they
                         # correspond to requested mappings
 
-    @helpers.skipIfNoService(['compute.instances', 'network',
+    @helpers.skipIfNoService(['compute.instances', 'networking.networks',
                               'security.security_groups'])
     def test_instance_methods(self):
         name = "cb_instmethod-{0}".format(helpers.get_uuid())
@@ -312,28 +312,22 @@ class CloudComputeServiceTestCase(ProviderTestBase):
                 (sg, test_inst.security_groups))
 
             # check floating ips
-            router = self.provider.network.create_router(name=name)
+            router = self.provider.networking.routers.create(name, net)
 
             with helpers.cleanup_action(lambda: router.delete()):
-
-                # TODO: Cloud specific code, needs fixing
-                if self.provider.PROVIDER_ID == 'openstack':
-                    for n in self.provider.network:
-                        if n.external:
-                            external_net = n
-                            break
-                else:
-                    external_net = net
-                router.attach_network(external_net.id)
-                router.add_route(subnet.id)
+                router.attach_subnet(subnet)
+                gateway = (self.provider.networking.gateways
+                           .get_or_create_inet_gateway(name))
+                router.attach_gateway(gateway)
 
                 def cleanup_router():
-                    router.remove_route(subnet.id)
-                    router.detach_network()
+                    router.detach_subnet(subnet)
+                    gateway.delete()
 
                 with helpers.cleanup_action(lambda: cleanup_router()):
                     # check whether adding an elastic ip works
-                    fip = self.provider.network.create_floating_ip()
+                    fip = (self.provider.networking.networks
+                           .create_floating_ip())
                     with helpers.cleanup_action(lambda: fip.delete()):
                         test_inst.add_floating_ip(fip.public_ip)
                         test_inst.refresh()

test/test_image_service.py

@@ -8,7 +8,7 @@ from cloudbridge.cloud.interfaces import TestMockHelperMixin
 
 class CloudImageServiceTestCase(ProviderTestBase):
 
-    @helpers.skipIfNoService(['compute.images', 'network',
+    @helpers.skipIfNoService(['compute.images', 'networking.networks',
                               'compute.instances'])
     def test_create_and_list_image(self):
         """

test/test_network_service.py

@@ -87,15 +87,14 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                 % net.cidr_block)
 
             cidr = '10.0.1.0/24'
-            sn = net.create_subnet(
-                cidr_block=cidr, name=subnet_name,
-                zone=helpers.get_provider_test_data(self.provider,
-                                                    'placement'))
+            sn = net.create_subnet(name=subnet_name, cidr_block=cidr,
+                                   zone=helpers.get_provider_test_data(
+                                       self.provider, 'placement'))
             with helpers.cleanup_action(lambda: sn.delete()):
                 self.assertTrue(
-                    sn.id in [s.id for s in net.subnets()],
+                    sn.id in [s.id for s in net.subnets],
                     "Subnet ID %s should be listed in network subnets %s."
-                    % (sn.id, net.subnets()))
+                    % (sn.id, net.subnets))
 
                 self.assertIn(
                     net.id, sn.network_id,
@@ -110,12 +109,13 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
     @helpers.skipIfNoService(['networking.networks.routers'])
     def test_crud_router(self):
 
-        def _cleanup(net, subnet, router):
+        def _cleanup(net, subnet, router, gateway):
             with helpers.cleanup_action(lambda: net.delete()):
                 with helpers.cleanup_action(lambda: subnet.delete()):
                     with helpers.cleanup_action(lambda: router.delete()):
-                        router.remove_route(subnet.id)
-                        router.detach_network()
+                        router.detach_subnet(net)
+                        with helpers.cleanup_action(lambda: gateway.delete()):
+                            pass
 
         name = 'cb_crudrouter-{0}'.format(helpers.get_uuid())
         # Declare these variables and late binding will allow
@@ -124,57 +124,31 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
         sn = None
         router = None
         with helpers.cleanup_action(lambda: _cleanup(net, sn, router)):
-            router = self.provider.networking.networks.create_router(name=name)
             net = self.provider.networking.networks.create(name=name)
+            router = self.provider.networking.routers.create(network=net,
+                                                             name=name)
             cidr = '10.0.1.0/24'
-            sn = net.create_subnet(cidr_block=cidr, name=name,
+            sn = net.create_subnet(name=name, cidr_block=cidr,
                                    zone=helpers.get_provider_test_data(
                                        self.provider, 'placement'))
 
             # Check basic router properties
-            self.assertIn(
-                router, self.provider.networking.networks.routers(),
-                "Router {0} should exist in the router list {1}.".format(
-                    router.id, self.provider.networking.networks.routers()))
-            self.assertIn(
-                router.id, repr(router),
-                "repr(obj) should contain the object id so that the object"
-                " can be reconstructed, but does not.")
-            self.assertEqual(
-                router.name, name,
-                "Router {0} name should be {1}.".format(router.name, name))
+            sit.check_standard_behaviour(
+                self, self.provider.networking.routers, router)
             self.assertEqual(
                 router.state, RouterState.DETACHED,
                 "Router {0} state {1} should be {2}.".format(
                     router.id, router.state, RouterState.DETACHED))
-            self.assertFalse(
-                router.network_id,
-                "Router {0} should not be assoc. with a network {1}".format(
-                    router.id, router.network_id))
-
-            # TODO: Cloud specific code, needs fixing
-            # Check router connectivity
-            # On OpenStack only one network is external and on AWS every
-            # network is external, yet we need to use the one we've created?!
-            if self.provider.PROVIDER_ID == 'openstack':
-                for n in self.provider.networking.networks:
-                    if n.external:
-                        external_net = n
-                        break
-            else:
-                external_net = net
-            router.attach_network(external_net.id)
-            router.refresh()
-            self.assertEqual(
-                router.network_id, external_net.id,
-                "Router should be attached to network {0}, not {1}".format(
-                    external_net.id, router.network_id))
-            router.add_route(sn.id)
+
+#             self.assertFalse(
+#                 router.network_id,
+#                 "Router {0} should not be assoc. with a network {1}".format(
+#                     router.id, router.network_id))
+
+            router.attach_subnet(sn)
+            gateway = (self.provider.networking.gateways
+                       .get_or_create_inet_gateway(name))
+            router.attach_gateway(gateway)
             # TODO: add a check for routes after that's been implemented
 
-        routerl = self.provider.networking.networks.routers()
-        found_router = [r for r in routerl if r.name == name]
-        self.assertEqual(
-            len(found_router), 0,
-            "Router {0} should have been deleted but still exists."
-            .format(name))
+        sit.check_delete(self, self.provider.networking.routers, router)