Refactored tests and extracted standard interface tests

cloudbridge/cloud/interfaces/services.py

@@ -530,6 +530,16 @@ class NetworkService(PageableObjectMixin, CloudService):
         """
         pass
 
+    @abstractmethod
+    def find(self, name):
+        """
+        Searches for a network by a given list of attributes.
+
+        :rtype: List of ``object`` of :class:`.Network`
+        :return: A list of Network objects matching the supplied attributes.
+        """
+        pass
+
     @abstractmethod
     def create(self, name=None):
         """

test/helpers.py → test/helpers/__init__.py

@@ -146,7 +146,7 @@ def get_test_instance(provider, name, key_pair=None, security_groups=None,
 
 
 def get_test_fixtures_folder():
-    return os.path.join(os.path.dirname(__file__), 'fixtures/')
+    return os.path.join(os.path.dirname(__file__), '../fixtures/')
 
 
 def delete_test_instance(instance):

test/helpers/standard_interface_tests.py

@@ -0,0 +1,104 @@
+"""
+Standard tests for behaviour common across the whole of cloudbridge.
+This includes:
+   1. Checking that every resource has an id property
+   2. Checking for object equality and repr
+   3. Checking standard behaviour for list, iter, find, get, delete
+"""
+
+
+def check_repr(test, obj):
+    test.assertTrue(
+        obj.id in repr(obj),
+        "repr(obj) for %s contain the object id so that the object"
+        " can be reconstructed, but does not. eval(repr(obj)) == obj"
+        % (type(obj).__name__,))
+
+
+def check_list(test, service, obj):
+    objects = service.list()
+    list_objs = [o for o in objects if o.id == obj.id]
+    test.assertTrue(
+        len(list_objs) == 1,
+        "List objects for %s does not return the expected object id %s"
+        % (type(obj).__name__, obj.id))
+    return list_objs
+
+
+def check_iter(test, service, obj):
+    # check iteration
+    iter_objs = [o for o in service if o.id == obj.id]
+    test.assertTrue(
+        len(iter_objs) == 1,
+        "Iter objects for %s does not return the expected object id %s"
+        % (type(obj).__name__, obj.id))
+    return iter_objs
+
+
+def check_find(test, service, obj):
+    # check find
+    find_objs = service.find(name=obj.name)
+    test.assertTrue(
+        len(find_objs) == 1,
+        "Find objects for %s does not return the expected object: %s"
+        % (type(obj).__name__, obj.name))
+    return find_objs
+
+
+def check_find_non_existent(test, service):
+    # check find
+    find_objs = service.find(name="random_imagined_obj_name")
+    test.assertTrue(
+        len(find_objs) == 0,
+        "Find non-existent object for %s returned unexpected objects: %s"
+        % (type(service).__name__, find_objs))
+
+
+def check_get(test, service, obj):
+    get_obj = service.get(obj.id)
+    test.assertEqual(get_obj, obj)
+    return get_obj
+
+
+def check_delete(test, service, obj, perform_delete=False):
+    if perform_delete:
+        obj.delete()
+
+    objs = service.list()
+    found_objs = [o for o in objs if obj.id == obj.id]
+    test.assertTrue(
+        len(found_objs) == 0,
+        "Object %s in service %s should have been deleted but still exists."
+        % (type(obj).__name__, found_objs))
+
+
+def check_standard_behaviour(test, service, obj):
+    check_repr(test, obj)
+    objs_list = check_list(test, service, obj)
+    objs_iter = check_iter(test, service, obj)
+    objs_find = check_find(test, service, obj)
+    check_find_non_existent(test, service)
+    obj_get = check_get(test, service, obj)
+
+    test.assertTrue(
+        obj == objs_list[0] == objs_iter[0] == objs_find[0] == obj_get,
+        "Objects returned by list: {0}, iter: {1}, find: {2} and get: {3} "
+        " are not as expected: {4}" .format(objs_list[0].id, objs_iter[0].id,
+                                            objs_find[0].id, obj_get.id,
+                                            obj.id))
+
+    test.assertTrue(
+        obj.id == objs_list[0].id == objs_iter[0].id ==
+        objs_find[0].id == obj_get.id,
+        "Object Ids returned by list: {0}, iter: {1}, find: {2} and get: {3} "
+        " are not as expected: {4}" .format(objs_list[0].id, objs_iter[0].id,
+                                            objs_find[0].id, obj_get.id,
+                                            obj.id))
+
+    test.assertTrue(
+        obj.name == objs_list[0].name == objs_iter[0].name ==
+        objs_find[0].name == obj_get.name,
+        "Names returned by list: {0}, iter: {1}, find: {2} and get: {3} "
+        " are not as expected: {4}" .format(objs_list[0].id, objs_iter[0].id,
+                                            objs_find[0].id, obj_get.id,
+                                            obj.id))

test/test_block_store_service.py

@@ -3,6 +3,7 @@ import uuid
 
 from test import helpers
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 
 from cloudbridge.cloud.interfaces import SnapshotState
 from cloudbridge.cloud.interfaces import VolumeState
@@ -32,63 +33,10 @@ class CloudBlockStoreServiceTestCase(ProviderTestBase):
 
         with helpers.cleanup_action(lambda: cleanup_vol(test_vol)):
             test_vol.wait_till_ready()
-            self.assertTrue(
-                test_vol.id in repr(test_vol),
-                "repr(obj) should contain the object id so that the object"
-                " can be reconstructed, but does not. eval(repr(obj)) == obj")
-            volumes = self.provider.block_store.volumes.list()
-            list_volumes = [vol for vol in volumes if vol.name == name]
-            self.assertTrue(
-                len(list_volumes) == 1,
-                "List volumes does not return the expected volume %s" %
-                name)
+            sit.check_standard_behaviour(
+                self, self.provider.block_store.volumes, test_vol)
 
-            # check iteration
-            iter_volumes = [vol for vol in self.provider.block_store.volumes
-                            if vol.name == name]
-            self.assertTrue(
-                len(iter_volumes) == 1,
-                "Iter volumes does not return the expected volume %s" %
-                name)
-
-            # check find
-            find_vols = self.provider.block_store.volumes.find(name=name)
-            self.assertTrue(
-                len(find_vols) == 1,
-                "Find volumes does not return the expected volume %s" %
-                name)
-
-            # check non-existent find
-            # TODO: Moto has a bug with filters causing the following test
-            # to fail. Need to add tag based filtering support for volumes
-#             find_vols = self.provider.block_store.volumes.find(
-#                 name="non_existent_vol")
-#             self.assertTrue(
-#                 len(find_vols) == 0,
-#                 "Find() for a non-existent volume returned %s" % find_vols)
-
-            get_vol = self.provider.block_store.volumes.get(
-                test_vol.id)
-            self.assertTrue(
-                list_volumes[0] ==
-                get_vol == test_vol,
-                "Ids returned by list: {0} and get: {1} are not as "
-                " expected: {2}" .format(list_volumes[0].id,
-                                         get_vol.id,
-                                         test_vol.id))
-            self.assertTrue(
-                list_volumes[0].name ==
-                get_vol.name == test_vol.name,
-                "Names returned by list: {0} and get: {1} are not as "
-                " expected: {2}" .format(list_volumes[0].name,
-                                         get_vol.name,
-                                         test_vol.name))
-        volumes = self.provider.block_store.volumes.list()
-        found_volumes = [vol for vol in volumes if vol.name == name]
-        self.assertTrue(
-            len(found_volumes) == 0,
-            "Volume %s should have been deleted but still exists." %
-            name)
+        sit.check_delete(self, self.provider.block_store.volumes, test_vol)
 
     @helpers.skipIfNoService(['block_store.volumes'])
     def test_attach_detach_volume(self):
@@ -211,62 +159,8 @@ class CloudBlockStoreServiceTestCase(ProviderTestBase):
 
             with helpers.cleanup_action(lambda: cleanup_snap(test_snap)):
                 test_snap.wait_till_ready()
-                self.assertTrue(
-                    test_snap.id in repr(test_snap),
-                    "repr(obj) should contain the object id so that the object"
-                    " can be reconstructed, but does not.")
-
-                snaps = self.provider.block_store.snapshots.list()
-                list_snaps = [snap for snap in snaps
-                              if snap.name == snap_name]
-                self.assertTrue(
-                    len(list_snaps) == 1,
-                    "List snapshots does not return the expected volume %s" %
-                    name)
-
-                # check iteration
-                iter_snaps = [
-                    snap for snap in self.provider.block_store.snapshots
-                    if snap.name == snap_name]
-                self.assertTrue(
-                    len(iter_snaps) == 1,
-                    "Iter snapshots does not return the expected volume %s" %
-                    name)
-
-                # check find
-                find_snap = self.provider.block_store.snapshots.find(
-                    name=snap_name)
-                self.assertTrue(
-                    len(find_snap) == 1,
-                    "Find snaps does not return the expected snapshot %s" %
-                    name)
-
-                # check non-existent find
-                # TODO: Moto has a bug with filters causing the following test
-                # to fail. Need to add tag based filtering support for snaps
-#                 find_snap = self.provider.block_store.snapshots.find(
-#                     name="non_existent_snap")
-#                 self.assertTrue(
-#                     len(find_snap) == 0,
-#                     "Find() for a non-existent snap returned %s" %
-#                     find_snap)
-
-                get_snap = self.provider.block_store.snapshots.get(
-                    test_snap.id)
-                self.assertTrue(
-                    list_snaps[0] ==
-                    get_snap == test_snap,
-                    "Ids returned by list: {0} and get: {1} are not as "
-                    " expected: {2}" .format(list_snaps[0].id,
-                                             get_snap.id,
-                                             test_snap.id))
-                self.assertTrue(
-                    list_snaps[0].name ==
-                    get_snap.name == test_snap.name,
-                    "Names returned by list: {0} and get: {1} are not as "
-                    " expected: {2}" .format(list_snaps[0].name,
-                                             get_snap.name,
-                                             test_snap.name))
+                sit.check_standard_behaviour(
+                    self, self.provider.block_store.snapshots, test_snap)
 
                 # Test volume creation from a snapshot (via VolumeService)
                 sv_name = "CBUnitTestSnapVol-{0}".format(name)
@@ -284,13 +178,8 @@ class CloudBlockStoreServiceTestCase(ProviderTestBase):
                 with helpers.cleanup_action(lambda: snap_vol2.delete()):
                     snap_vol2.wait_till_ready()
 
-            snaps = self.provider.block_store.snapshots.list()
-            found_snaps = [snap for snap in snaps
-                           if snap.name == snap_name]
-            self.assertTrue(
-                len(found_snaps) == 0,
-                "Snapshot %s should have been deleted but still exists." %
-                snap_name)
+            sit.check_delete(
+                self, self.provider.block_store.snapshots, test_snap)
 
             # Test creation of a snap via SnapshotService
             snap_too_name = "CBSnapToo-{0}".format(name)

test/test_compute_service.py

@@ -3,6 +3,7 @@ import uuid
 
 from test import helpers
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 
 from cloudbridge.cloud.interfaces import InstanceState
 from cloudbridge.cloud.interfaces import InvalidConfigurationException
@@ -31,52 +32,8 @@ class CloudComputeServiceTestCase(ProviderTestBase):
             inst = helpers.get_test_instance(self.provider, name,
                                              subnet=subnet)
 
-            all_instances = self.provider.compute.instances.list()
-
-            list_instances = [i for i in all_instances if i.name == name]
-            self.assertTrue(
-                len(list_instances) == 1,
-                "List instances does not return the expected instance %s" %
-                name)
-
-            # check iteration
-            iter_instances = [i for i in self.provider.compute.instances
-                              if i.name == name]
-            self.assertTrue(
-                len(iter_instances) == 1,
-                "Iter instances does not return the expected instance %s" %
-                name)
-
-            # check find
-            find_instances = self.provider.compute.instances.find(name=name)
-            self.assertTrue(
-                len(find_instances) == 1,
-                "Find instances does not return the expected instance %s" %
-                name)
-
-            # check non-existent find
-            find_instances = self.provider.compute.instances.find(
-                name="non_existent")
-            self.assertTrue(
-                len(find_instances) == 0,
-                "Find() for a non-existent image returned %s" % find_instances)
-
-            get_inst = self.provider.compute.instances.get(
-                inst.id)
-            self.assertTrue(
-                list_instances[0] ==
-                get_inst == inst,
-                "Objects returned by list: {0} and get: {1} are not as "
-                " expected: {2}" .format(list_instances[0].id,
-                                         get_inst.id,
-                                         inst.id))
-            self.assertTrue(
-                list_instances[0].name ==
-                get_inst.name == inst.name,
-                "Names returned by list: {0} and get: {1} are not as "
-                " expected: {2}" .format(list_instances[0].name,
-                                         get_inst.name,
-                                         inst.name))
+            sit.check_standard_behaviour(
+                self, self.provider.compute.instances, inst)
         deleted_inst = self.provider.compute.instances.get(
             inst.id)
         self.assertTrue(

test/test_image_service.py

@@ -2,12 +2,11 @@ import uuid
 
 from test import helpers
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 
 from cloudbridge.cloud.interfaces import MachineImageState
 from cloudbridge.cloud.interfaces import TestMockHelperMixin
 
-import six
-
 
 class CloudImageServiceTestCase(ProviderTestBase):
 
@@ -44,74 +43,15 @@ class CloudImageServiceTestCase(ProviderTestBase):
 
             with helpers.cleanup_action(lambda: cleanup_img(test_image)):
                 test_image.wait_till_ready()
+                sit.check_standard_behaviour(
+                    self, self.provider.compute.images, test_image)
 
-                self.assertTrue(
-                    test_instance.id in repr(test_instance),
-                    "repr(obj) should contain the object id so that the object"
-                    " can be reconstructed, but does not.")
-
-                self.assertTrue(
-                    test_image.description is None or isinstance(
-                        test_image.description, six.string_types),
-                    "Image description must be None or a string")
-
-                # This check won't work when >50 images are available
-                # images = self.provider.compute.images.list()
-                # list_images = [image for image in images
-                #                if image.name == name]
-                # self.assertTrue(
-                #     len(list_images) == 1,
-                #     "List images does not return the expected image %s" %
-                #     name)
-
-                # check iteration
-                iter_images = [image for image in self.provider.compute.images
-                               if image.name == name]
-                self.assertTrue(
-                    name in [ii.name for ii in iter_images],
-                    "Iter images (%s) does not contain the expected image %s" %
-                    (iter_images, name))
-
-                # find image
-                found_images = self.provider.compute.images.find(name=name)
-                self.assertTrue(
-                    name in [fi.name for fi in found_images],
-                    "Find images error: expected image %s but found: %s" %
-                    (name, found_images))
-
-                # check non-existent find
-                ne_images = self.provider.compute.images.find(
-                    name="non_existent")
-                self.assertTrue(
-                    len(ne_images) == 0,
-                    "Find() for a non-existent image returned %s" %
-                    ne_images)
-
-                get_img = self.provider.compute.images.get(
-                    test_image.id)
-                self.assertTrue(
-                    found_images[0] == get_img == test_image,
-                    "Objects returned by list: {0} and get: {1} are not as "
-                    " expected: {2}" .format(found_images[0].id,
-                                             get_img.id,
-                                             test_image.id))
-                self.assertTrue(
-                    found_images[0].name == get_img.name == test_image.name,
-                    "Names returned by find: {0} and get: {1} are"
-                    " not as expected: {2}" .format(found_images[0].name,
-                                                    get_img.name,
-                                                    test_image.name))
                 # TODO: Fix moto so that the BDM is populated correctly
                 if not isinstance(self.provider, TestMockHelperMixin):
                     # check image size
-                    self.assertGreater(get_img.min_disk, 0, "Minimum disk size"
-                                       " required by image is invalid")
+                    test_image.refresh()
+                    self.assertGreater(test_image.min_disk, 0, "Minimum disk"
+                                       " size required by image is invalid")
             # TODO: Images take a long time to deregister on EC2. Needs
             # investigation
-            images = self.provider.compute.images.list()
-            found_images = [image for image in images
-                            if image.name == name]
-            self.assertTrue(
-                len(found_images) == 0,
-                "Image %s should have been deleted but still exists." %
-                name)
+            sit.check_delete(self, self.provider.compute.images, test_image)

test/test_instance_types_service.py

@@ -1,6 +1,7 @@
 from test import helpers
 
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 
 from cloudbridge.cloud.interfaces.resources import InstanceType
 
@@ -17,10 +18,7 @@ class CloudInstanceTypesServiceTestCase(ProviderTestBase):
         self.assertListEqual(iter_instance_types, instance_types)
 
         for inst_type in instance_types:
-            self.assertTrue(
-                inst_type.id in repr(inst_type),
-                "repr(obj) should contain the object id so that the object"
-                " can be reconstructed, but does not. eval(repr(obj)) == obj")
+            sit.check_repr(self, inst_type)
             self.assertIsNotNone(
                 inst_type.id,
                 "InstanceType id must have a value")

test/test_network_service.py

@@ -1,6 +1,8 @@
 import test.helpers as helpers
 import uuid
+
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 
 from cloudbridge.cloud.interfaces.resources import RouterState
 
@@ -16,20 +18,8 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
             lambda:
                 self.provider.network.delete(network_id=net.id)
         ):
-            # test list method
-            netl = self.provider.network.list()
-            list_netl = [n for n in netl if n.name == name]
-            self.assertTrue(
-                len(list_netl) == 1,
-                "List networks does not return the expected network %s" %
-                name)
-
-            # check get
-            get_net = self.provider.network.get(network_id=net.id)
-            self.assertTrue(
-                get_net == net,
-                "Get network did not return the expected network {0}."
-                .format(name))
+            sit.check_standard_behaviour(
+                self, self.provider.network, net)
 
             # check subnet
             subnet = self.provider.network.subnets.create(
@@ -110,10 +100,7 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                 net.state, 'available',
                 "Network in state '%s', yet should be 'available'" % net.state)
 
-            self.assertIn(
-                net.id, repr(net),
-                "repr(obj) should contain the object id so that the object"
-                " can be reconstructed, but does not.")
+            sit.check_repr(self, net)
 
             self.assertIn(
                 net.cidr_block, ['', '10.0.0.0/16'],

test/test_object_store_service.py

@@ -7,6 +7,7 @@ from datetime import datetime
 from io import BytesIO
 from test import helpers
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 from unittest import skip
 
 from cloudbridge.cloud.interfaces.resources import BucketObject
@@ -25,50 +26,10 @@ class CloudObjectStoreServiceTestCase(ProviderTestBase):
         name = "cbtestcreatebucket-{0}".format(uuid.uuid4())
         test_bucket = self.provider.object_store.create(name)
         with helpers.cleanup_action(lambda: test_bucket.delete()):
-            self.assertTrue(
-                test_bucket.id in repr(test_bucket),
-                "repr(obj) should contain the object id so that the object"
-                " can be reconstructed, but does not. eval(repr(obj)) == obj")
-
-            buckets = self.provider.object_store.list()
+            sit.check_standard_behaviour(
+                self, self.provider.object_store, test_bucket)
 
-            list_buckets = [c for c in buckets if c.name == name]
-            self.assertTrue(
-                len(list_buckets) == 1,
-                "List buckets does not return the expected bucket %s" %
-                name)
-
-            # check iteration
-            iter_buckets = [c for c in self.provider.object_store
-                            if c.name == name]
-            self.assertTrue(
-                len(iter_buckets) == 1,
-                "Iter buckets does not return the expected bucket %s" %
-                name)
-
-            # check find
-            find_buckets = self.provider.object_store.find(name=name)
-            self.assertTrue(
-                len(find_buckets) == 1,
-                "Find buckets does not return the expected bucket %s" %
-                name)
-
-            get_bucket = self.provider.object_store.get(
-                test_bucket.id)
-            self.assertTrue(
-                list_buckets[0] ==
-                get_bucket == test_bucket,
-                "Objects returned by list: {0} and get: {1} are not as "
-                " expected: {2}" .format(list_buckets[0].id,
-                                         get_bucket.id,
-                                         test_bucket.name))
-
-        buckets = self.provider.object_store.list()
-        found_buckets = [c for c in buckets if c.name == name]
-        self.assertTrue(
-            len(found_buckets) == 0,
-            "Bucket %s should have been deleted but still exists." %
-            name)
+        sit.check_delete(self, self.provider.object_store, test_bucket)
 
     @helpers.skipIfNoService(['object_store'])
     def test_crud_bucket_objects(self):
@@ -116,20 +77,7 @@ class CloudObjectStoreServiceTestCase(ProviderTestBase):
                 iter_objs = list(test_bucket)
                 self.assertListEqual(iter_objs, objs)
 
-                found_objs = [o for o in objs if o.name == obj_name]
-                self.assertTrue(
-                    len(found_objs) == 1,
-                    "List bucket objects does not return the expected"
-                    " object %s" % obj_name)
-
-                get_bucket_obj = test_bucket.get(obj_name)
-                self.assertTrue(
-                    found_objs[0] ==
-                    get_bucket_obj == obj,
-                    "Objects returned by list: {0} and get: {1} are not as "
-                    " expected: {2}" .format(found_objs[0].id,
-                                             get_bucket_obj.id,
-                                             obj.id))
+                sit.check_standard_behaviour(self, test_bucket, obj)
 
                 obj_too = test_bucket.get(obj_name)
                 self.assertTrue(
@@ -143,12 +91,7 @@ class CloudObjectStoreServiceTestCase(ProviderTestBase):
                     'with and without a prefix, are expected to be equal, '
                     'but its detected otherwise.')
 
-            objs = test_bucket.list()
-            found_objs = [o for o in objs if o.name == obj_name]
-            self.assertTrue(
-                len(found_objs) == 0,
-                "Object %s should have been deleted but still exists." %
-                obj_name)
+            sit.check_delete(self, test_bucket, obj)
 
     @helpers.skipIfNoService(['object_store'])
     def test_upload_download_bucket_content(self):

test/test_security_service.py

@@ -5,6 +5,7 @@ import uuid
 
 from test import helpers
 from test.helpers import ProviderTestBase
+from test.helpers import standard_interface_tests as sit
 
 from cloudbridge.cloud.interfaces import TestMockHelperMixin
 
@@ -19,49 +20,14 @@ class CloudSecurityServiceTestCase(ProviderTestBase):
             lambda:
                 self.provider.security.key_pairs.delete(key_pair_id=kp.id)
         ):
-            # test list method
-            kpl = self.provider.security.key_pairs.list()
-            list_kpl = [i for i in kpl if i.name == name]
-            self.assertTrue(
-                len(list_kpl) == 1,
-                "List key pairs does not return the expected key pair %s" %
-                name)
-
-            # check iteration
-            iter_kpl = [i for i in self.provider.security.key_pairs
-                        if i.name == name]
-            self.assertTrue(
-                len(iter_kpl) == 1,
-                "Iter key pairs does not return the expected key pair %s" %
-                name)
-
-            # check find
-            find_kp = self.provider.security.key_pairs.find(name=name)[0]
-            self.assertTrue(
-                find_kp == kp,
-                "Find key pair did not return the expected key {0}."
-                .format(name))
-
-            # check get
-            get_kp = self.provider.security.key_pairs.get(name)
-            self.assertTrue(
-                get_kp == kp,
-                "Get key pair did not return the expected key {0}."
-                .format(name))
+            sit.check_standard_behaviour(
+                self, self.provider.security.key_pairs, kp)
 
             # Recreating existing keypair should raise an exception
             with self.assertRaises(Exception):
                 self.provider.security.key_pairs.create(name=name)
-        kpl = self.provider.security.key_pairs.list()
-        found_kp = [k for k in kpl if k.name == name]
-        self.assertTrue(
-            len(found_kp) == 0,
-            "Key pair {0} should have been deleted but still exists."
-            .format(name))
-        no_kp = self.provider.security.key_pairs.find(name='bogus_kp')
-        self.assertFalse(
-            no_kp,
-            "Found a key pair {0} that should not exist?".format(no_kp))
+
+        sit.check_delete(self, self.provider.security.key_pairs, kp)
 
     @helpers.skipIfNoService(['security.key_pairs'])
     def test_key_pair(self):
@@ -119,50 +85,16 @@ class CloudSecurityServiceTestCase(ProviderTestBase):
 
             self.assertEqual(name, sg.description)
 
-            # test list method
-            sgl = self.provider.security.security_groups.list()
-            found_sgl = [i for i in sgl if i.name == name]
-            self.assertTrue(
-                len(found_sgl) == 1,
-                "List security groups does not return the expected group %s" %
-                name)
-
-            # check iteration
-            found_sgl = [i for i in self.provider.security.security_groups
-                         if i.name == name]
-            self.assertTrue(
-                len(found_sgl) == 1,
-                "Iter security groups does not return the expected group %s" %
-                name)
-
-            # check find
-            find_sg = self.provider.security.security_groups.find(name=sg.name)
-            self.assertTrue(
-                len(find_sg) == 1,
-                "List security groups returned {0} when expected was: {1}."
-                .format(find_sg, sg.name))
-
-            # check get
-            get_sg = self.provider.security.security_groups.get(sg.id)
-            self.assertTrue(
-                get_sg == sg,
-                "Get SecurityGroup did not return the expected key {0}."
-                .format(name))
+            sit.check_standard_behaviour(
+                self, self.provider.security.security_groups, sg)
 
-            self.assertTrue(
-                sg.id in repr(sg),
-                "repr(obj) should contain the object id so that the object"
-                " can be reconstructed, but does not. eval(repr(obj)) == obj")
+        # sit.check_delete(self, self.provider.security.security_groups, sg)
         sgl = self.provider.security.security_groups.list()
         found_sg = [g for g in sgl if g.name == name]
         self.assertTrue(
             len(found_sg) == 0,
             "Security group {0} should have been deleted but still exists."
             .format(name))
-        no_sg = self.provider.security.security_groups.find(name='bogus_sg')
-        self.assertTrue(
-            len(no_sg) == 0,
-            "Found a bogus security group?!?".format(no_sg))
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_security_group(self):
@@ -215,6 +147,7 @@ class CloudSecurityServiceTestCase(ProviderTestBase):
 #                 "JSON SG representation {0} does not match expected {1}"
 #                 .format(sg.to_json(), json_repr))
 
+        # sit.check_delete(self, self.provider.security.security_groups, sg)
         sgl = self.provider.security.security_groups.list()
         found_sg = [g for g in sgl if g.name == name]
         self.assertTrue(