Added more tests for the factory and provider interfaces.

cloudbridge/providers/base.py

@@ -16,7 +16,7 @@ class BaseCloudProvider(CloudProvider):
         Checks whether this provider supports a given service.
 
         :type service_type: str or :class:``.CloudProviderServiceType``
-        :param service_type: Type of service the check support for.
+        :param service_type: Type of service to check support for.
 
         :rtype: bool
         :return: ``True`` if the service type is supported.

test/__init__.py

@@ -23,9 +23,13 @@ unittest and nose2's automatic discovery.
 """
 
 from test.helpers import ProviderTestCaseGenerator
-from test.testprovidersecurityservice import ProviderSecurityServiceTestCase
+from test.test_provider_security_service import ProviderSecurityServiceTestCase
+from test.test_provider_interface import ProviderInterfaceTestCase
 
-PROVIDER_TESTS = [ProviderSecurityServiceTestCase]
+PROVIDER_TESTS = [
+    ProviderSecurityServiceTestCase,
+    ProviderInterfaceTestCase
+]
 
 
 def load_tests(loader=None, tests=None, pattern=None):

test/test_provider_factory.py

@@ -0,0 +1,41 @@
+import unittest
+from cloudbridge.providers import factory
+from cloudbridge.providers import interfaces
+from cloudbridge.providers.factory import CloudProviderFactory
+
+
+class ProviderFactoryTestCase(unittest.TestCase):
+
+    def test_create_provider_valid(self):
+        """
+        Creating a provider with a known name should return
+        a valid implementation
+        """
+        self.assertIsInstance(CloudProviderFactory().create_provider(factory.ProviderList.EC2, {}, version=1),
+                              interfaces.CloudProvider,
+                              "create_provider did not return a valid instance type")
+
+    def test_create_provider_invalid(self):
+        """
+        Creating a provider with an invalid name should raise a NotImplementedError
+        """
+        with self.assertRaises(NotImplementedError):
+            CloudProviderFactory().create_provider("ec23", {})
+        with self.assertRaises(NotImplementedError):
+            CloudProviderFactory().create_provider(factory.ProviderList.EC2, {}, version=100)
+
+    def test_find_provider_impl_valid(self):
+        """
+        Searching for a provider with a known name or version should return a valid implementation
+        """
+        self.assertTrue(CloudProviderFactory().find_provider_impl(factory.ProviderList.EC2))
+        self.assertEquals(CloudProviderFactory().find_provider_impl(factory.ProviderList.EC2, version=1),
+                          "cloudbridge.providers.ec2.EC2CloudProviderV1")
+
+    def test_find_provider_impl_invalid(self):
+        """
+        Searching for a provider with an invalid name or version should return None
+        """
+        self.assertIsNone(CloudProviderFactory().find_provider_impl("openstack1"))
+        self.assertIsNone(CloudProviderFactory().find_provider_impl(
+            factory.ProviderList.EC2, version=100))

test/test_provider_interface.py

@@ -0,0 +1,32 @@
+from cloudbridge.providers import interfaces
+from test.helpers import ProviderTestBase
+
+
+class ProviderInterfaceTestCase(ProviderTestBase):
+
+    def __init__(self, methodName, provider):
+        super(ProviderInterfaceTestCase, self).__init__(
+            methodName=methodName, provider=provider)
+
+    def test_name_property(self):
+        """
+        Name should always return a value and should not raise an exception
+        """
+        assert self.provider.name
+
+    def test_has_service_valid_service_type(self):
+        """
+        has_service with a valid service type should return
+        a boolean and raise no exceptions
+        """
+        for key, value in interfaces.CloudProviderServiceType.__dict__.items():
+            if not key.startswith("__"):
+                self.provider.has_service(value)
+
+    def test_has_service_invalid_service_type(self):
+        """
+        has_service with an invalid service type should return False
+        """
+        self.assertFalse(
+            self.provider.has_service("NON_EXISTENT_SERVICE"),
+            "has_service should not return True for a non-existent service")

test/testprovidersecurityservice.py → test/test_provider_security_service.py

@@ -1,6 +1,3 @@
-import unittest
-from cloudbridge.providers.factory import CloudProviderFactory
-from cloudbridge.providers.factory import ProviderList
 from cloudbridge.providers import interfaces
 from test.helpers import ProviderTestBase