Added missing methods list and get to aws compute service and improved

tests.

cloudbridge/providers/aws/services.py

@@ -409,3 +409,32 @@ class AWSComputeService(ComputeService):
             instance = AWSInstance(self.provider, reservation.instances[0])
             instance.name = name
         return instance
+
+    def get_instance(self, instance_id):
+        """
+        Returns an instance given its id. Returns None
+        if the object does not exist.
+        """
+        reservation = self.provider.ec2_conn.get_all_reservations(
+            instance_ids=[instance_id])
+        if reservation:
+            return AWSInstance(self.provider, reservation.instances[0])
+
+    def find_instance(self, name):
+        """
+        Searches for an instance by a given list of attributes.
+
+        :rtype: ``object`` of :class:`.Instance`
+        :return: an Instance object
+        """
+        raise NotImplementedError(
+            'find_instance not implemented by this provider')
+
+    def list_instances(self):
+        """
+        List all instances.
+        """
+        reservations = self.provider.ec2_conn.get_all_reservations()
+        return [AWSInstance(self.provider, inst)
+                for res in reservations
+                for inst in res.instances]

test/helpers.py

@@ -29,32 +29,43 @@ def exception_action(cleanup_func):
         ex_class, ex_val, ex_traceback = sys.exc_info()
         try:
             cleanup_func()
-        except:
-            pass
-        # raise the original exception
+        except Exception as e:
+            print("Error during cleanup: {0}".format(e))
         reraise(ex_class, ex_val, ex_traceback)
 
-
-def create_test_instance(provider):
-    instance_name = "HelloCloudBridge-{0}".format(provider.name)
+TEST_DATA_CONFIG = {
+    "AWSCloudProvider": {
+        "image": os.environ.get('CB_IMAGE_AWS', 'ami-d85e75b0'),
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_AWS',
+                                        't1.micro'),
+        "placement": os.environ.get('CB_PLACEMENT_AWS', 'us-east-1a'),
+    },
+    "OpenStackCloudProvider": {
+        "image": os.environ.get('CB_IMAGE_OS',
+                                'd57696ba-5ed2-43fe-bf78-a587829973a9'),
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_OS', 'm2.xsmall'),
+        "placement": os.environ.get('CB_PLACEMENT_OS', 'NCI'),
+    }
+}
+
+
+def get_provider_test_data(provider, key):
     if "AWSCloudProvider" in provider.name:
-        ami = os.environ.get('CB_AMI', 'ami-d85e75b0')
-        instance_type = os.environ.get('CB_INSTANCE_TYPE', 't1.micro')
-        return provider.compute.create_instance(
-            instance_name, ami, instance_type)
+        return TEST_DATA_CONFIG.get("AWSCloudProvider").get(key)
     elif "OpenStackCloudProvider" in provider.name:
-        image_id = os.environ.get(
-            'CB_IMAGE',
-            "d57696ba-5ed2-43fe-bf78-a587829973a9")
-        instance_type = os.environ.get('CB_FLAVOR', "m2.xsmall")
-        return provider.compute.create_instance(
-            "{0}-{1}".format(instance_name, provider.name),
-            image_id,
-            instance_type)
-
-
-def get_test_instance(provider):
-    instance = create_test_instance(provider)
+        return TEST_DATA_CONFIG.get("OpenStackCloudProvider").get(key)
+    return None
+
+
+def create_test_instance(provider, instance_name):
+    return provider.compute.create_instance(
+        instance_name,
+        get_provider_test_data(provider, 'image'),
+        get_provider_test_data(provider, 'instance_type'))
+
+
+def get_test_instance(provider, name):
+    instance = create_test_instance(provider, name)
     instance.wait_till_ready()
     return instance
 

test/test_compute_service.py

@@ -1,5 +1,9 @@
+import socket
+import uuid
+
+from cloudbridge.providers.interfaces import InstanceState
 from test.helpers import ProviderTestBase
-import test.helpers
+import test.helpers as helpers
 
 
 class ProviderComputeServiceTestCase(ProviderTestBase):
@@ -8,14 +12,56 @@ class ProviderComputeServiceTestCase(ProviderTestBase):
         super(ProviderComputeServiceTestCase, self).__init__(
             methodName=methodName, provider=provider)
 
-    def setUp(self):
-        self.instance = test.helpers.get_test_instance(self.provider)
+    def test_crud_instance(self):
+        name = "CBInstCrud-{0}-{1}".format(
+            self.provider.name,
+            uuid.uuid4())
+        inst = helpers.create_test_instance(self.provider, name)
+        with helpers.exception_action(lambda: inst.terminate()):
+            inst.wait_till_ready()
+            all_instances = self.provider.compute.list_instances()
+            found_instances = [i for i in all_instances if i.name == name]
+            self.assertTrue(
+                len(found_instances) == 1,
+                "List instances does not return the expected instance %s" %
+                name)
+            inst.terminate()
+            inst.wait_for(
+                [InstanceState.TERMINATED, InstanceState.UNKNOWN],
+                terminal_states=[InstanceState.ERROR])
+            all_instances = self.provider.compute.list_instances()
+            found_instances = [i for i in all_instances if i.name == name]
+            self.assertTrue(
+                len(found_instances) == 0,
+                "List instances does not return the expected instance %s" %
+                name)
 
-    def tearDown(self):
-        self.instance.terminate()
+    def _is_valid_ip(self, address):
+        try:
+            socket.inet_pton(socket.AF_INET, address)
+        except socket.error:  # not a valid address
+            try:
+                socket.inet_pton(socket.AF_INET, address)
+            except socket.error:  # still not a valid address
+                return False
+        return True
 
-    def test_instance_status(self):
-        """
-        instance_state should return an object of type InstanceState
-        """
-        pass
+    def test_instance_properties(self):
+        instance_name = "CBInstProps-{0}-{1}".format(
+            self.provider.name,
+            uuid.uuid4())
+        test_instance = helpers.get_test_instance(self.provider,
+                                                  instance_name)
+        with helpers.exception_action(lambda: test_instance.terminate()):
+            self.assertEqual(
+                test_instance.name, instance_name,
+                "Instance name {0} is not equal to the expected name"
+                " {1}".format(test_instance.name, instance_name))
+            image_id = helpers.get_provider_test_data(self.provider, "image")
+            self.assertEqual(test_instance.image_id, image_id,
+                             "Image id {0} is not equal to the expected id"
+                             " {1}".format(test_instance.image_id, image_id))
+            self.assertIsInstance(test_instance.public_ips, list)
+            self.assertIsInstance(test_instance.private_ips, list)
+            self.assertTrue(
+                self._is_valid_ip(self.test_instance.private_ips[0]))