Moved azure tests to respective provider directory

cloudbridge/cloud/providers/azure/integration_test/__init__.py

@@ -0,0 +1,9 @@
+"""
+Use ``python setup.py test`` to run these unit tests (alternatively, use
+``python -m unittest test``).
+
+You must set the CB_TEST_PROVIDER environment variable before running the
+tests. Otherwise, the test suite will default to running against the mock
+aws provider. Alternatively, use tox, which will run tests for all available
+provider combinations.
+"""

cloudbridge/cloud/providers/azure/integration_test/helpers.py

@@ -0,0 +1,230 @@
+import functools
+import os
+import sys
+import unittest
+
+from contextlib import contextmanager
+
+from cloudbridge.cloud.factory import CloudProviderFactory
+from cloudbridge.cloud.interfaces import InstanceState
+from cloudbridge.cloud.interfaces import TestMockHelperMixin
+
+from six import reraise
+
+
+def parse_bool(val):
+    if val:
+        return str(val).upper() in ['TRUE', 'YES']
+    else:
+        return False
+
+
+@contextmanager
+def cleanup_action(cleanup_func):
+    """
+    Context manager to carry out a given
+    cleanup action after carrying out a set
+    of tasks, or when an exception occurs.
+    If any errors occur during the cleanup
+    action, those are ignored, and the original
+    traceback is preserved.
+
+    :params func: This function is called if
+    an exception occurs or at the end of the
+    context block. If any exceptions raised
+        by func are ignored.
+    Usage:
+        with cleanup_action(lambda e: print("Oops!")):
+            do_something()
+    """
+    try:
+        yield
+    except Exception:
+        ex_class, ex_val, ex_traceback = sys.exc_info()
+        try:
+            cleanup_func()
+        except Exception as e:
+            print("Error during exception cleanup: {0}".format(e))
+        reraise(ex_class, ex_val, ex_traceback)
+    try:
+        cleanup_func()
+    except Exception as e:
+        print("Error during cleanup: {0}".format(e))
+
+
+def skipIfNoService(services):
+    """
+    A decorator for skipping tests if the provider
+    does not implement a given service.
+    """
+
+    def wrap(func):
+        """
+        The actual wrapper
+        """
+
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            provider = getattr(self, 'provider')
+            if provider:
+                for service in services:
+                    if not provider.has_service(service):
+                        self.skipTest("Skipping test because '%s' service is"
+                                      " not implemented" % (service,))
+            func(self, *args, **kwargs)
+
+        return wrapper
+
+    return wrap
+
+
+TEST_DATA_CONFIG = {
+    "AWSCloudProvider": {
+        "image": os.environ.get('CB_IMAGE_AWS', 'ami-5ac2cd4d'),
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_AWS', 't2.nano'),
+        "placement": os.environ.get('CB_PLACEMENT_AWS', 'us-east-1a'),
+    },
+    "OpenStackCloudProvider": {
+        "image": os.environ.get('CB_IMAGE_OS',
+                                '842b949c-ea76-48df-998d-8a41f2626243'),
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_OS', 'm1.tiny'),
+        "placement": os.environ.get('CB_PLACEMENT_OS', 'nova'),
+    },
+    "AzureCloudProvider": {
+        "placement":
+            os.environ.get('CB_PLACEMENT_AZURE', 'eastus'),
+        "image":
+            os.environ.get('CB_IMAGE_AZURE', 'CbTest-Img'),
+        "instance_type":
+            os.environ.get('CB_INSTANCE_TYPE_AZURE', 'Standard_DS1_v2'),
+    }
+}
+
+
+def get_provider_test_data(provider, key):
+    if "AWSCloudProvider" in provider.name:
+        return TEST_DATA_CONFIG.get("AWSCloudProvider").get(key)
+    elif "OpenStackCloudProvider" in provider.name:
+        return TEST_DATA_CONFIG.get("OpenStackCloudProvider").get(key)
+    elif "AzureCloudProvider" in provider.name:
+        return TEST_DATA_CONFIG.get("AzureCloudProvider").get(key)
+    return None
+
+
+def create_test_network(provider, name):
+    """
+    Create a network with one subnet, returning the network and subnet objects.
+    """
+    net = provider.network.create(name=name)
+    cidr_block = (net.cidr_block).split('/')[0] or '10.0.0.1'
+    sn = net.create_subnet(cidr_block='{0}/28'.format(cidr_block), name=name,
+                           zone=get_provider_test_data(provider, 'placement'))
+    return net, sn
+
+
+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():
+            sn.delete()
+
+
+def create_test_instance(
+        provider, instance_name, subnet, zone=None, launch_config=None,
+        key_pair=None, security_groups=None):
+    return provider.compute.instances.create(
+        instance_name,
+        get_provider_test_data(provider, 'image'),
+        get_provider_test_data(provider, 'instance_type'),
+        subnet=subnet,
+        zone=zone,
+        key_pair=key_pair,
+        security_groups=security_groups,
+        launch_config=launch_config)
+
+
+def get_test_instance(provider, name, key_pair=None, security_groups=None,
+                      subnet=None):
+    launch_config = None
+    instance = create_test_instance(
+        provider,
+        name,
+        subnet=subnet,
+        key_pair=key_pair,
+        security_groups=security_groups,
+        launch_config=launch_config)
+    instance.wait_till_ready()
+    return instance
+
+
+def get_test_fixtures_folder():
+    return os.path.join(os.path.dirname(__file__), 'fixtures/')
+
+
+def delete_test_instance(instance):
+    if instance:
+        instance.terminate()
+        instance.wait_for([InstanceState.TERMINATED, InstanceState.UNKNOWN],
+                          terminal_states=[InstanceState.ERROR])
+
+
+def cleanup_test_resources(instance=None, network=None, security_group=None,
+                           key_pair=None):
+    """Clean up any combination of supplied resources."""
+    with cleanup_action(lambda:
+                        delete_test_network(network) if network else None):
+        with cleanup_action(lambda: key_pair.delete() if key_pair else None):
+            with cleanup_action(
+                    lambda:
+                    security_group.delete() if security_group else None):
+                delete_test_instance(instance)
+
+
+class ProviderTestBase(unittest.TestCase):
+    _provider = None
+
+    def setUp(self):
+        if isinstance(self.provider, TestMockHelperMixin):
+            self.provider.setUpMock()
+
+    def tearDown(self):
+        if isinstance(self.provider, TestMockHelperMixin):
+            self.provider.tearDownMock()
+        self._provider = None
+
+    def get_provider_wait_interval(self, provider_class):
+        if issubclass(provider_class, TestMockHelperMixin):
+            return 0
+        else:
+            return 1
+
+    def create_provider_instance(self):
+        provider_name = os.environ.get("CB_TEST_PROVIDER", "azure")
+        use_mock_drivers = parse_bool(
+            os.environ.get("CB_USE_MOCK_PROVIDERS", "False"))
+        factory = CloudProviderFactory()
+        provider_class = factory.get_provider_class(provider_name,
+                                                    get_mock=use_mock_drivers)
+        config = {'default_wait_interval':
+                  self.get_provider_wait_interval(provider_class),
+                  'azure_subscription_id':
+                      '7904d702-e01c-4826-8519-f5a25c866a96',
+                  'azure_client_id':
+                      '69621fe1-f59f-43de-8799-269007c76b95',
+                  'azure_secret':
+                      'Orcw9U5Kd4cUDntDABg0dygN32RQ4FGBYyLRaJ/BlrM=',
+                  'azure_tenant':
+                      '75ec242e-054d-4b22-98a9-a4602ebb6027',
+                  'azure_resource_group': 'CB-TEST-TEST-RG',
+                  'azure_storage_account': 'cbtestsa134',
+                  'azure_vm_default_user_name': 'cbtestuser'
+                  }
+        return provider_class(config)
+
+    @property
+    def provider(self):
+        if not self._provider:
+            self._provider = self.create_provider_instance()
+        return self._provider

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_image_service.py

@@ -0,0 +1,34 @@
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+from cloudbridge.cloud.providers.azure.integration_test.helpers import  ProviderTestBase
+
+
+class AzureIntegrationImageServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['compute.images'])
+    def test_azure_image_service(self):
+
+        images_list = self.provider.compute.images.list()
+        print("Images List" + str(images_list))
+        print("List count - " + str(len(images_list)))
+
+        print(str(images_list[0].name))
+
+        if images_list.total_results > 0:
+            found_images_list = self.provider.compute.images.\
+                find(images_list[0].name)
+            print("Find Images  count - {0}".
+                  format(str(found_images_list.total_results)))
+            self.assertTrue(found_images_list.total_results > 0)
+            image_get = self.provider.compute.images.get(images_list[0].id)
+            print("Get Image - " + str(image_get))
+            self.assertIsNotNone(image_get)
+
+            # image_get.delete()
+
+            image_get_after_delete = self.provider.compute.images.get(image_get.id)
+            print("Get Image - " + str(image_get_after_delete))
+            self.assertIsNone(image_get_after_delete)
+
+            images_list_after_delete = self.provider.compute.images.list()
+            print("Images List after Delete" + str(images_list_after_delete))
+            print("List count after Delete- " + str(len(images_list_after_delete)))

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_instance_service.py

@@ -0,0 +1,132 @@
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+from cloudbridge.cloud.providers.azure.integration_test.helpers import ProviderTestBase
+
+
+class AzureIntegrationInstanceServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['compute.instances'])
+    def test_azure_instance_service(self):
+        instance_name = 'CbAzure-{0}'.format(uuid.uuid4().hex[:6])
+        image_name = 'CbAzure-img-{0}'.format(uuid.uuid4().hex[:6])
+        security_group_name = 'CbAzure-sg-{0}'.format(uuid.uuid4().hex[:6])
+        network_name = 'CbAzure-net-{0}'.format(uuid.uuid4().hex[:6])
+        subnet_name = 'CbAzure-subnet-{0}'.format(uuid.uuid4().hex[:6])
+        key_pair_name = 'CbAzure-keypair-{0}'.format(uuid.uuid4().hex[:6])
+
+        image_id = 'CbTest-Img'
+
+        img = self.provider.compute.images.get(image_id)
+
+        self.assertIsNotNone(img)
+
+        key_pair = self.provider.security.\
+            key_pairs.create(key_pair_name)
+
+        self.assertIsNotNone(key_pair)
+
+        with open('{0}.pem'.format(key_pair_name), 'w') as f:
+            f.write(key_pair.material)
+
+        inst_type = [t for t in self.provider.compute.instance_types.list()
+                     if t.name == 'Standard_DS2_v2'][0]
+
+        net = self.provider.network.create(network_name)
+
+        self.assertIsNotNone(net)
+
+        subnet = net.create_subnet('10.0.0.0/23', name=subnet_name)
+
+        self.assertIsNotNone(subnet)
+
+        sg = self.provider.security.security_groups.\
+            create(security_group_name,
+                   'A security group used by CloudBridge', '')
+
+        self.assertIsNotNone(sg)
+
+        sg.add_rule('tcp', 22, 22, '0.0.0.0/0')
+
+        new_security_group_name = 'CbAzure-sg-{0}'.format(uuid.uuid4().hex[:6])
+
+        new_sg = self.provider.security.security_groups. \
+            create(new_security_group_name,
+                   'A security group used by CloudBridge', '')
+
+        self.assertIsNotNone(new_sg)
+
+        new_sg.add_rule('*', 0, 65535, '*')
+
+        lc = self.provider.compute.instances.create_launch_config()
+
+        volume = self.provider.block_store.\
+            volumes.create('CbAzure-Vol-{0}'.
+        format(uuid.uuid4().hex[:6]), 30)
+
+        volume.wait_till_ready()
+
+        self.assertIsNotNone(volume)
+
+        snapshot = volume.\
+            create_snapshot('CbAzure-Snap-{0}'.format(uuid.uuid4().hex[:6]))
+
+        snapshot.wait_till_ready()
+
+        self.assertIsNotNone(snapshot)
+
+        lc.add_volume_device(
+            is_root=False,
+            source=volume,
+            size=volume.size,
+            delete_on_terminate=True)
+
+        lc.add_volume_device(
+            is_root=False,
+            source=snapshot,
+            size=snapshot.size,
+            delete_on_terminate=True)
+
+        lc.add_volume_device(
+            is_root=False,
+            source=None,
+            size=40,
+            delete_on_terminate=True)
+
+        inst = self.provider.compute.instances.create(
+            name=instance_name, image=img, instance_type=inst_type,
+            subnet=subnet, zone=None,
+            key_pair=key_pair, security_groups=[sg, new_sg],
+            user_data=None,
+            launch_config=lc)
+
+        inst.wait_till_ready()
+
+        floating_ip = self.provider.network.create_floating_ip()
+
+        self.assertIsNotNone(floating_ip)
+
+        inst.add_floating_ip(floating_ip.public_ip)
+
+        inst.refresh()
+
+        self.assertIsNotNone(inst.public_ips[0])
+
+        img = inst.create_image(image_name)
+
+        self.assertIsNotNone(img)
+
+        inst.terminate()
+
+        subnet.delete()
+
+        net.delete()
+
+        sg.delete()
+
+        new_sg.delete()
+
+        img.delete()
+
+        volume.delete()
+
+        snapshot.delete()

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_instance_type_service.py

@@ -0,0 +1,28 @@
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+from cloudbridge.cloud.providers.azure.integration_test.helpers import ProviderTestBase
+
+
+class AzureIntegrationInstanceTypeServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['compute.images'])
+    def test_azure_instance_type_service(self):
+
+        instance_type_list = self.provider.compute.instance_types.list()
+        print("List Instance Types - " + str(instance_type_list))
+        print("List Instance Type Properties - ")
+        print("Name - " + str(instance_type_list[0].name))
+        print("Id - " + str(instance_type_list[0].id))
+        print("vcpus - " + str(instance_type_list[0].vcpus))
+        print("size_root_disk - " +
+              str(instance_type_list[0].size_root_disk))
+        print("ram - " + str(instance_type_list[0].ram))
+        print("size_ephemeral_disks - " +
+              str(instance_type_list[0].size_ephemeral_disks))
+        print("num_ephemeral_disks - " +
+              str(instance_type_list[0].num_ephemeral_disks))
+        self.assertTrue(instance_type_list.total_results > 0)
+
+        # Test find
+        inst_type = self.provider.compute.instance_types.find(
+            name="Standard_DS1_v2")[0]
+        print(str(inst_type))

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_key_pair_service.py

@@ -0,0 +1,30 @@
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+from cloudbridge.cloud.providers.azure.integration_test.helpers import ProviderTestBase
+
+
+class AzureIntegrationKeyPairServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_key_pair_service(self):
+
+        key_pair_name = '{0}'.format(uuid.uuid4())
+
+        key_pair_create = self.provider.security.key_pairs.\
+            create(key_pair_name)
+        print(key_pair_create.__dict__)
+        self.assertIsNotNone(key_pair_create)
+
+        key_pair_list = self.provider.security.key_pairs.list()
+        print(str(key_pair_list))
+        self.assertTrue(len(key_pair_list) > 0)
+
+        key_pair_find = self.provider.security.key_pairs.find(key_pair_name)
+        print(key_pair_find.__dict__)
+        self.assertTrue(len(key_pair_find) > 0)
+
+        key_pair_get = self.provider.security.key_pairs.get(key_pair_name)
+        print(key_pair_get.__dict__)
+        self.assertIsNotNone(key_pair_get)
+
+        key_pair_create.delete()

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_network_service.py

@@ -0,0 +1,62 @@
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+from cloudbridge.cloud.providers.azure.integration_test.helpers import ProviderTestBase
+
+
+class AzureIntegrationNetworkServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['network'])
+    def test_crud_network_service(self):
+        name = 'intgtestnetworkservice-{0}'.format(uuid.uuid4().hex[:6])
+        net = self.provider.network.create(name=name)
+        with helpers.cleanup_action(
+            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))
+
+            # Check floating IP address
+            ip = self.provider.network.create_floating_ip()
+            ip_id = ip.id
+            with helpers.cleanup_action(lambda: ip.delete()):
+                ipl = self.provider.network.floating_ips()
+                self.assertTrue(
+                    ip in ipl,
+                    "Floating IP address {0} should exist in the list {1}"
+                    .format(ip.id, ipl))
+                self.assertIn(
+                    ip.public_ip, repr(ip),
+                    "repr(obj) should contain the address public IP value.")
+                self.assertFalse(
+                    ip.private_ip,
+                    "Floating IP should not have a private IP value ({0})."
+                    .format(ip.private_ip))
+                self.assertFalse(
+                    ip.in_use(),
+                    "Newly created floating IP address should not be in use.")
+            ipl = self.provider.network.floating_ips()
+            found_ip = [a for a in ipl if a.id == ip_id]
+            self.assertTrue(
+                len(found_ip) == 0,
+                "Floating IP {0} should have been deleted but still exists."
+                .format(ip_id))
+
+        netl = self.provider.network.list()
+        found_net = [n for n in netl if n.name == name]
+        self.assertEqual(
+            len(found_net), 0,
+            "Network {0} should have been deleted but still exists."
+            .format(name))

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_object_store_service.py

@@ -0,0 +1,91 @@
+import os
+import tempfile
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+
+class AzureIntegrationObjectStoreServiceTestCase(helpers.ProviderTestBase):
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_service(self):
+        container_name = '{0}'.format(uuid.uuid4())
+        object_name = '{0}'.format(uuid.uuid4())
+
+        containers_count1 = len(self.provider.object_store.list())
+
+        container = self.provider.object_store.create(container_name)
+        self.assertTrue(container is not None,
+                        'Container {0} not created'.format(container_name))
+
+        containers_count2 = len(self.provider.object_store.list())
+        self.assertTrue(containers_count2 > containers_count1,
+                        'Container {0} not present in list'.
+                        format(container_name))
+
+        find_container = self.provider.object_store.find(container_name)
+        self.assertTrue(len(find_container) == 1,
+                        'Container {0} not found'.format(container_name))
+
+        get_container = self.provider.object_store.get(container.id)
+        self.assertTrue(get_container is not None,
+                        'Unable to get the container {0}'.
+                        format(container_name))
+
+        obj = container.create_object(object_name)
+        self.assertTrue(obj is not None,
+                        'Object {0} not created'.format(container_name))
+
+        obj_count = len(container.list())
+        self.assertTrue(obj_count == 1, 'Object count should be 1')
+
+        get_obj = container.get(object_name)
+        self.assertTrue(get_obj is not None,
+                        'Unable to get object {0} from container {1}.'.
+                        format(object_name, container_name))
+
+        exits = container.exists(object_name)
+        self.assertTrue(exits, 'Object {0} not exists in container {1}'.
+                        format(object_name, container_name))
+
+        obj_content = 'abc'
+        obj.upload(obj_content)
+
+        content = obj.iter_content()
+        self.assertTrue(content.getvalue().decode('utf-8') == obj_content,
+                        'Object {0} content should be {1}'.
+                        format(object_name, obj_content))
+
+        file_name = 'mytest.txt'
+        file_content = 'defaults'
+
+        tmp = os.path.join(tempfile.gettempdir(), file_name)
+
+        try:
+            if not os.path.exists(tmp):
+                with open(tmp, "w") as file:
+                    file.write(file_content)
+
+            obj.upload_from_file(tmp)
+
+            content = obj.iter_content()
+            self.assertTrue(content.getvalue().decode('utf-8') == file_content,
+                            'Object {0} content should be {1}'.
+                            format(object_name, file_content))
+
+        finally:
+            print('Deleting file')
+            os.remove(tmp)
+
+        url = obj.generate_url()
+        self.assertTrue(url is not None, 'Url should not be None')
+
+        obj.delete()
+        delete_obj = container.get(object_name)
+        self.assertTrue(delete_obj is None,
+                        'Object {0} not deleted from container {1}'.
+                        format(object_name, container_name))
+
+        container.delete()
+        deleted_container = self.provider.object_store.get(container.id)
+        self.assertTrue(deleted_container is None, 'Container {0} not deleted'.
+                        format(container_name))

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_region_service.py

@@ -0,0 +1,39 @@
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+from cloudbridge.cloud.providers.azure.resources import AzureRegion
+
+
+class AzureIntegrationRegionServiceTestCase(helpers.ProviderTestBase):
+    def test_azure_integration_region_service_list(self):
+        regions = self.provider.compute.regions.list()
+        self.assertIsNotNone(regions)
+        for region in regions:
+            print(region.id)
+            print(region.name)
+            print(region.zones)
+            self.assertIsInstance(
+                region,
+                AzureRegion,
+                "regions.list() should return a cloudbridge Region")
+            self.assertTrue(
+                region.name,
+                "Region name should be a non-empty string")
+
+    def test_azure_integration_region_service_get(self):
+        region_id = "koreasouth"
+        region = self.provider.compute.regions.get(region_id)
+        self.assertIsNotNone(region)
+        self.assertEqual(region.name, "koreasouth")
+
+    def test_azure_integration_region_service_get_invalid_region_id(self):
+        region_id = "invalid"
+        region = self.provider.compute.regions.get(region_id)
+        self.assertIsNone(region)
+
+    def test_azure_integration_region_service_current(self):
+        current_region_name = self.provider.region_name
+        print("current region: " + current_region_name)
+        region = self.provider.compute.regions.current
+        self.assertIsNotNone(region)
+        print("Region service returned Region name:" + region.name)
+        self.assertEqual(region.name, current_region_name)

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_security_group.py

@@ -0,0 +1,84 @@
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+from cloudbridge.cloud.providers.azure.integration_test.helpers import ProviderTestBase
+
+
+class AzureIntegrationSecurityServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group(self):
+        sg_name = '{0}'.format(uuid.uuid4())
+        print("SG guid - " + sg_name)
+
+        listBeforeCreate = self.provider.security.security_groups.list()
+        print("Length Before create - " + str(len(listBeforeCreate)))
+
+        sg = self.provider.security.security_groups.create(
+            name=sg_name, description="testCreateSecGroup", network_id='')
+        self.assertEqual(sg_name, sg.name)
+
+        print(str(sg))
+        listAfterCreate = self.provider.security.security_groups.list()
+        print("Length After create - " + str(len(listAfterCreate)))
+        self.assertEqual(len(listAfterCreate), len(listBeforeCreate) + 1)
+
+        get = self.provider.security.security_groups.get(sg_name)
+        print("Get SG - " + str(get))
+        print(str(get.rules))
+        self.assertEqual(get.name, sg_name)
+
+        get_notfound = self.provider.security.\
+            security_groups.get("SecgrupDontFindMe")
+        self.assertEqual(get_notfound, None)
+
+        find_exists_list = self.provider.security.security_groups.find(sg_name)
+        for sg in find_exists_list:
+            self.assertTrue(sg_name in sg.name)
+        print("Find - " + str(find_exists_list))
+        print("Find Total Results- " + str(find_exists_list.total_results))
+        self.assertTrue(find_exists_list.total_results > 0)
+
+        find_not_exists_list = self.provider.security.security_groups. \
+            find('dontfindme')
+        self.assertTrue(find_not_exists_list.total_results == 0)
+
+        lenBeforeCreateRule = len(sg.rules)
+        sg.add_rule('tcp', '1111', '2222', '0.0.0.0/0')
+        lenAfterCreateRule = len(sg.rules)
+        print("Length before create rule - " + str(lenBeforeCreateRule))
+        print("Length after create rule - " + str(lenAfterCreateRule))
+        self.assertEqual(lenAfterCreateRule, lenBeforeCreateRule + 1)
+
+        print("create second rule ")
+        sg.add_rule('tcp', '1111', '2222', '0.0.0.0/0')
+        print("Length before second create rule - " + str(lenBeforeCreateRule))
+        print("Length after second create rule - " + str(lenAfterCreateRule))
+
+        print(str(sg.rules))
+        get_rule = sg.get_rule('tcp', '1111', '2222', '0.0.0.0/0')
+        print("Get Rule - " + str(get_rule))
+        self.assertIsNotNone(get_rule)
+
+        get_rule_notfound = sg.get_rule('*', '25', '1', '1')
+        self.assertEqual(str(get_rule_notfound), 'None')
+
+        rule_json = sg.rules[0].to_json()
+        print("Rule json - " + str(rule_json))
+        self.assertIsNotNone(rule_json)
+
+        sg_json = sg.to_json()
+        print("SG json - " + str(sg_json))
+        self.assertIsNotNone(sg_json)
+
+        listBeforeDeleteFound = self.provider.security.security_groups.list()
+        self.provider.security.security_groups.delete(sg_name)
+        listAfterDeleteFound = self.provider.security.security_groups.list()
+        print("Length before delete - " + str(len(listBeforeDeleteFound)))
+        print("Length after delete - " + str(len(listAfterDeleteFound)))
+        self.assertEqual(
+            len(listAfterDeleteFound), len(listBeforeDeleteFound) - 1)
+        sg_id = "sg5"
+        self.provider.security.security_groups.delete(sg_id)
+        listAfterDeleteNotFound = self.provider.security.security_groups.list()
+        self.assertEqual(
+            len(listAfterDeleteNotFound), len(listAfterDeleteFound))

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_snapshot_service.py

@@ -0,0 +1,70 @@
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+
+class AzureIntegrationSnapshotServiceTestCase(helpers.ProviderTestBase):
+
+    @helpers.skipIfNoService(['block_store'])
+    def test_azure_snapshot_service(self):
+        snapshot_name = '{0}'.format(uuid.uuid4().hex[:6])
+        volume_name = '{0}'.format(uuid.uuid4().hex[:6])
+
+        snapshot_list_before_create = \
+            self.provider.block_store.snapshots.list()
+        print(str(len(snapshot_list_before_create)))
+
+        vol = self.provider.block_store.volumes.create(volume_name, 1)
+        vol.wait_till_ready()
+
+        self.assertTrue(vol is not None, 'Volume not created')
+
+        snapshot = self.provider.block_store.\
+            snapshots.create(snapshot_name, vol)
+        snapshot.wait_till_ready()
+        self.assertTrue(snapshot is not None, 'Snapshot not created')
+
+        snapshot_id = snapshot.id
+
+        snapshot_list_after_create = \
+            self.provider.block_store.snapshots.list()
+        print(str(len(snapshot_list_after_create)))
+
+        self.assertTrue(len(snapshot_list_after_create),
+                        len(snapshot_list_before_create) + 1)
+
+        snapshot = self.provider.block_store.snapshots.get(snapshot_id)
+        print("Get Snapshot  - " + str(snapshot))
+        self.assertTrue(
+            snapshot.name == snapshot_name,
+            "Snapshot name should be MySnapshot")
+
+        snapshot_find = self.provider.block_store. \
+            snapshots.find(snapshot_name)
+        print("Find Snapshot  - " + str(snapshot))
+        self.assertEqual(
+            len(snapshot_find), 1)
+
+        volume = snapshot.create_volume()
+        volume.wait_till_ready()
+        self.assertTrue(volume is not None, 'Volume not created')
+
+        snapshot.refresh()
+        self.assertTrue(snapshot.id == snapshot_id,
+                        'Snapshot id should match on refresh')
+
+        snapshot_list_before_delete = \
+            self.provider.block_store.snapshots.list()
+        print(str(len(snapshot_list_before_delete)))
+
+        snapshot.delete()
+
+        snapshot_list_after_delete = \
+            self.provider.block_store.snapshots.list()
+        print(str(len(snapshot_list_after_delete)))
+
+        self.assertEqual(len(snapshot_list_after_delete),
+                         len(snapshot_list_before_delete) - 1)
+
+        volume.delete()
+        vol.delete()

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_subnet_service.py

@@ -0,0 +1,55 @@
+import uuid
+
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+
+class AzureIntegrationSubnetServiceTestCase(helpers.ProviderTestBase):
+    @helpers.skipIfNoService(['network'])
+    def test_azure_subnet_service(self):
+        subnet_name = '{0}'.format(uuid.uuid4().hex[:6])
+        network_name = '{0}'.format(uuid.uuid4().hex[:6])
+
+        subnet_list_before_create = \
+            self.provider.network.subnets.list()
+        print(str(len(subnet_list_before_create)))
+
+        net = self.provider.network.create(name=network_name)
+        net.wait_till_ready()
+
+        self.assertTrue(net is not None, 'Network not created')
+
+        subnet = self.provider.network. \
+            subnets.create(network=net, name=subnet_name,
+                           cidr_block='10.0.0.0/24')
+        self.assertTrue(subnet is not None, 'Subnet not created')
+
+        subnet_id = subnet.id
+
+        subnet_list_after_create = \
+            self.provider.network.subnets.list()
+        print(str(len(subnet_list_after_create)))
+
+        self.assertTrue(len(subnet_list_after_create),
+                        len(subnet_list_before_create) + 1)
+
+        subnet = self.provider.network.subnets.get(subnet_id)
+        print("Get Subnet  - " + str(subnet))
+        self.assertTrue(
+            subnet.name == subnet_name,
+            "Subnet name should be {0}".format(subnet_name))
+
+        subnet_list_before_delete = \
+            self.provider.network.subnets.list()
+        print(str(len(subnet_list_before_delete)))
+
+        subnet.delete()
+
+        subnet_list_after_delete = \
+            self.provider.network.subnets.list()
+        print(str(len(subnet_list_after_delete)))
+
+        self.assertEqual(len(subnet_list_after_delete),
+                         len(subnet_list_before_delete) - 1)
+
+        subnet.delete()
+        net.delete()

cloudbridge/cloud/providers/azure/integration_test/test_integration_azure_volume_service.py

@@ -0,0 +1,68 @@
+import uuid
+
+from cloudbridge.cloud.interfaces import VolumeState
+from cloudbridge.cloud.providers.azure.integration_test import helpers
+
+
+class AzureIntegrationVolumeServiceTestCase(helpers.ProviderTestBase):
+    @helpers.skipIfNoService(['block_store'])
+    def test_azure_volume_service(self):
+        volume_name = '{0}'.format(uuid.uuid4().hex[:6])
+        snapshot_name = '{0}'.format(uuid.uuid4().hex[:6])
+        instance_id = 'TEST-INST'
+
+        volume_list_before_create = self.provider.block_store.volumes.list()
+        print(str(len(volume_list_before_create)))
+
+        volume = self.provider.block_store.volumes.create(volume_name, 1)
+        volume.wait_till_ready()
+        self.assertTrue(volume is not None, 'Volume not created')
+        volume_id = volume.id
+
+        volume_list_after_create = self.provider.block_store.volumes.list()
+        print(str(len(volume_list_after_create)))
+
+        self.assertTrue(
+            len(volume_list_after_create), len(volume_list_before_create) + 1)
+
+        volume = self.provider.block_store.volumes.get(volume_id)
+        print("Get Volume  - " + str(volume))
+        self.assertTrue(
+            volume.name == volume_name, "Volume name should be MyVolume")
+
+        volume_find = self.provider.block_store.volumes.find(volume_name)
+        print("Find Volume  - " + str(volume))
+        self.assertEqual(
+            len(volume_find), 1)
+
+        volume.attach(instance_id)
+        volume.wait_for(
+            [VolumeState.IN_USE],
+            terminal_states=[VolumeState.ERROR, VolumeState.DELETED])
+        self.assertTrue(volume.state == VolumeState.IN_USE)
+
+        volume.detach()
+        volume.wait_for(
+            [VolumeState.AVAILABLE],
+            terminal_states=[VolumeState.ERROR, VolumeState.DELETED])
+        self.assertTrue(volume.state == VolumeState.AVAILABLE)
+
+        snapshot = volume.create_snapshot(snapshot_name)
+        self.assertTrue(snapshot is not None,
+                        'Snapshot {0} not created'.format(snapshot_name))
+
+        snapshot.delete()
+
+        volume.refresh()
+        self.assertTrue(volume.id == volume_id,
+                        'Volume id should match on refresh')
+
+        volume_list_before_delete = self.provider.block_store.volumes.list()
+        print(str(len(volume_list_before_delete)))
+
+        volume.delete()
+
+        volume_list_after_delete = self.provider.block_store.volumes.list()
+        print(str(len(volume_list_after_delete)))
+        self.assertTrue(len(volume_list_after_delete),
+                        len(volume_list_before_delete) - 1)

cloudbridge/cloud/providers/azure/test/__init__.py

@@ -0,0 +1,9 @@
+"""
+Use ``python setup.py test`` to run these unit tests (alternatively, use
+``python -m unittest test``).
+
+You must set the CB_TEST_PROVIDER environment variable before running the
+tests. Otherwise, the test suite will default to running against the mock
+aws provider. Alternatively, use tox, which will run tests for all available
+provider combinations.
+"""

cloudbridge/cloud/providers/azure/test/helpers.py

@@ -0,0 +1,209 @@
+import functools
+import os
+import sys
+import unittest
+
+from contextlib import contextmanager
+
+from cloudbridge.cloud.factory import CloudProviderFactory
+from cloudbridge.cloud.interfaces import InstanceState
+from cloudbridge.cloud.interfaces import TestMockHelperMixin
+
+from six import reraise
+
+
+def parse_bool(val):
+    if val:
+        return str(val).upper() in ['TRUE', 'YES']
+    else:
+        return False
+
+
+@contextmanager
+def cleanup_action(cleanup_func):
+    """
+    Context manager to carry out a given
+    cleanup action after carrying out a set
+    of tasks, or when an exception occurs.
+    If any errors occur during the cleanup
+    action, those are ignored, and the original
+    traceback is preserved.
+
+    :params func: This function is called if
+    an exception occurs or at the end of the
+    context block. If any exceptions raised
+        by func are ignored.
+    Usage:
+        with cleanup_action(lambda e: print("Oops!")):
+            do_something()
+    """
+    try:
+        yield
+    except Exception:
+        ex_class, ex_val, ex_traceback = sys.exc_info()
+        try:
+            cleanup_func()
+        except Exception as e:
+            print("Error during exception cleanup: {0}".format(e))
+        reraise(ex_class, ex_val, ex_traceback)
+    try:
+        cleanup_func()
+    except Exception as e:
+        print("Error during cleanup: {0}".format(e))
+
+
+def skipIfNoService(services):
+    """
+    A decorator for skipping tests if the provider
+    does not implement a given service.
+    """
+
+    def wrap(func):
+        """
+        The actual wrapper
+        """
+
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            provider = getattr(self, 'provider')
+            if provider:
+                for service in services:
+                    if not provider.has_service(service):
+                        self.skipTest("Skipping test because '%s' service is"
+                                      " not implemented" % (service,))
+            func(self, *args, **kwargs)
+
+        return wrapper
+
+    return wrap
+
+
+TEST_DATA_CONFIG = {
+    "AWSCloudProvider": {
+        "image": os.environ.get('CB_IMAGE_AWS', 'ami-5ac2cd4d'),
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_AWS', 't2.nano'),
+        "placement": os.environ.get('CB_PLACEMENT_AWS', 'us-east-1a'),
+    },
+    "OpenStackCloudProvider": {
+        "image": os.environ.get('CB_IMAGE_OS',
+                                '842b949c-ea76-48df-998d-8a41f2626243'),
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_OS', 'm1.tiny'),
+        "placement": os.environ.get('CB_PLACEMENT_OS', 'nova'),
+    }
+}
+
+
+def get_provider_test_data(provider, key):
+    if "AWSCloudProvider" in provider.name:
+        return TEST_DATA_CONFIG.get("AWSCloudProvider").get(key)
+    elif "OpenStackCloudProvider" in provider.name:
+        return TEST_DATA_CONFIG.get("OpenStackCloudProvider").get(key)
+    return None
+
+
+def create_test_network(provider, name):
+    """
+    Create a network with one subnet, returning the network and subnet objects.
+    """
+    net = provider.network.create(name=name)
+    cidr_block = (net.cidr_block).split('/')[0] or '10.0.0.1'
+    sn = net.create_subnet(cidr_block='{0}/28'.format(cidr_block), name=name,
+                           zone=get_provider_test_data(provider, 'placement'))
+    return net, sn
+
+
+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():
+            sn.delete()
+
+
+def create_test_instance(
+        provider, instance_name, subnet, zone=None, launch_config=None,
+        key_pair=None, security_groups=None):
+    return provider.compute.instances.create(
+        instance_name,
+        get_provider_test_data(provider, 'image'),
+        get_provider_test_data(provider, 'instance_type'),
+        subnet=subnet,
+        zone=zone,
+        key_pair=key_pair,
+        security_groups=security_groups,
+        launch_config=launch_config)
+
+
+def get_test_instance(provider, name, key_pair=None, security_groups=None,
+                      subnet=None):
+    launch_config = None
+    instance = create_test_instance(
+        provider,
+        name,
+        subnet=subnet,
+        key_pair=key_pair,
+        security_groups=security_groups,
+        launch_config=launch_config)
+    instance.wait_till_ready()
+    return instance
+
+
+def get_test_fixtures_folder():
+    return os.path.join(os.path.dirname(__file__), 'fixtures/')
+
+
+def delete_test_instance(instance):
+    if instance:
+        instance.terminate()
+        instance.wait_for([InstanceState.TERMINATED, InstanceState.UNKNOWN],
+                          terminal_states=[InstanceState.ERROR])
+
+
+def cleanup_test_resources(instance=None, network=None, security_group=None,
+                           key_pair=None):
+    """Clean up any combination of supplied resources."""
+    with cleanup_action(
+            lambda: delete_test_network(network)
+            if network else None):
+        with cleanup_action(lambda: key_pair.delete() if key_pair else None):
+            with cleanup_action(
+                    lambda: security_group.delete()
+                    if security_group else None):
+                delete_test_instance(instance)
+
+
+class ProviderTestBase(unittest.TestCase):
+    _provider = None
+
+    def setUp(self):
+        if isinstance(self.provider, TestMockHelperMixin):
+            self.provider.setUpMock()
+
+    def tearDown(self):
+        if isinstance(self.provider, TestMockHelperMixin):
+            self.provider.tearDownMock()
+        self._provider = None
+
+    def get_provider_wait_interval(self, provider_class):
+        if issubclass(provider_class, TestMockHelperMixin):
+            return 0
+        else:
+            return 1
+
+    def create_provider_instance(self):
+        provider_name = os.environ.get("CB_TEST_PROVIDER", "azure")
+        use_mock_drivers = parse_bool(
+            os.environ.get("CB_USE_MOCK_PROVIDERS", "True"))
+        factory = CloudProviderFactory()
+        provider_class = factory.get_provider_class(provider_name,
+                                                    get_mock=use_mock_drivers)
+        config = {'default_wait_interval': self.get_provider_wait_interval(
+            provider_class)}
+        return provider_class(config)
+
+    @property
+    def provider(self):
+        if not self._provider:
+            self._provider = self.create_provider_instance()
+        return self._provider

cloudbridge/cloud/providers/azure/test/test_azure_helpers.py

@@ -0,0 +1,46 @@
+from cloudbridge.cloud.providers.azure import helpers as azure_helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureHelpersTestCase(ProviderTestBase):
+    def test_parse_url_valid(self):
+        params = azure_helpers.parse_url('/subscriptionId/{subscriptionId}',
+                                         '/subscriptionId/123-1345')
+        self.assertTrue(len(params) == 1, 'Parameter count should be 1')
+
+    def test_parse_url_invalid(self):
+        with self.assertRaises(Exception):
+            azure_helpers.parse_url('/subscriptionId/{subscriptionId}',
+                                    '/123-1345')
+
+    def test_filter_matched(self):
+        ex1 = Expando()
+        ex1.tags = {'Name': 'test'}
+
+        ex2 = Expando()
+        ex2.tags = {'Name': 'abc'}
+
+        result = azure_helpers.filter([ex1, ex2], {'Name': 'test'})
+        self.assertTrue(len(result) == 1, 'Result count should be one')
+
+    def test_filter_not_matched(self):
+        ex1 = Expando()
+        ex1.tags = {'Name': 'pqr'}
+
+        ex2 = Expando()
+        ex2.tags = {'Name': 'abc'}
+        result = azure_helpers.filter([ex1, ex2], {'Name': 'test123'})
+        self.assertTrue(len(result) == 0, 'Result count should be zero')
+
+    def test_filter_None(self):
+        ex1 = Expando()
+        ex1.tags = {'Name': 'test'}
+
+        ex2 = Expando()
+        ex2.tags = {'Name': 'abc'}
+        result = azure_helpers.filter([ex1, ex2], None)
+        self.assertTrue(len(result) == 2, 'Result count should be two')
+
+
+class Expando(object):
+    pass

cloudbridge/cloud/providers/azure/test/test_azure_image_service.py

@@ -0,0 +1,48 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureImageServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_images_list(self):
+        images_list = self.provider.compute.images.list()
+        print("List Images - " + str(images_list))
+        self.assertTrue(images_list.total_results > 0)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_images_get_exist(self):
+        image1_id = 'image1'
+        image_get = self.provider.compute.images.get(image1_id)
+        print("Get Image Exist - " + str(image_get))
+        print(str(image_get.min_disk))
+        print(str(image_get.state))
+        self.assertIsNone(image_get.description)
+        image_get.name = 'newname'
+        self.assertEqual(image_get.name, 'newname')
+        image_get.description = 'newdesc'
+        self.assertEqual(image_get.description, 'newdesc')
+        image_get.refresh()
+        image_get.delete()
+        image_get.refresh()
+        self.assertIsNotNone(image_get)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_images_get_notExist(self):
+        image1_id = 'imageNotExist'
+        image_get = self.provider.compute.images.get(image1_id)
+        print("Get Image Not Exist- " + str(image_get))
+        self.assertIsNone(image_get)
+
+    @helpers.skipIfNoService(['compute.images'])
+    def test_azure_image_find_exists(self):
+        images = self.provider.compute.images.find("image1")
+        for image in images:
+            self.assertTrue("image" in image.name)
+            print("Find Image  - " + str(image))
+        print(images.total_results)
+        self.assertTrue(images.total_results > 0)
+
+    @helpers.skipIfNoService(['compute.images'])
+    def test_azure_image_find_not_exists(self):
+        images = self.provider.compute.images.find('dontfindme')
+        self.assertTrue(images.total_results == 0)

cloudbridge/cloud/providers/azure/test/test_azure_instance_service.py

@@ -0,0 +1,84 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureInstanceServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_instances_list(self):
+        instances_list = self.provider.compute.instances.list()
+        print("List Instances - " + str(instances_list))
+        self.assertTrue(instances_list.total_results > 0)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_instances_get_exist(self):
+        instance_get = self.provider.compute.instances.get('VM1')
+        print("Get Instance - " + str(instance_get))
+        self.assertIsNotNone(instance_get)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_instances_get_Not_exist(self):
+        instance_get = self.provider.compute.instances.get('VM_dontfindme')
+        print("Get Instance Not Exist - " + str(instance_get))
+        self.assertIsNone(instance_get)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_instances_find(self):
+        instance_find = self.provider.compute.instances. \
+            find('VM1')
+        print("Find Instance - " + str(instance_find))
+        self.assertIsNotNone(instance_find)
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_instance_create_and_get(self):
+        image_id = 'image3'
+
+        img = self.provider.compute.images.get(image_id)
+
+        self.assertIsNotNone(img)
+
+        # TODO: Add logic to get key pair
+        key_pair = self.provider.security.key_pairs.get('KeyPair1')
+        self.assertIsNotNone(key_pair)
+
+        inst_type = [t for t in self.provider.compute.instance_types.list()
+                     if t.name == 'Standard_DS1_v2'][0]
+        sg_id = 'sg2'
+        sg = self.provider.security.\
+            security_groups.get(sg_id)
+
+        subnet = self.provider.network.subnets.list()[0]
+
+        lc = self.provider.compute.instances.create_launch_config()
+
+        lc.add_volume_device(
+            is_root=True,
+            source=img,
+            size=img.min_disk if img and img.min_disk else 2,
+            delete_on_terminate=True)
+
+        inst = self.provider.compute.instances.create(
+            name='test', image=img, instance_type=inst_type,
+            subnet=subnet, zone=None,
+            key_pair=key_pair, security_groups=[sg], user_data=None,
+            launch_config=lc)
+
+        self.assertIsNotNone(inst)
+
+        inst.reboot()
+
+        inst.name = 'newvmname'
+
+        self.assertEqual(inst.name, 'newvmname')
+
+        inst.add_security_group(sg)
+        inst.refresh()
+
+        # Check removing a security group from a running instance
+        inst.remove_security_group(sg)
+        inst.refresh()
+
+        img = inst.create_image('test_image')
+
+        self.assertIsNotNone(img)
+
+        inst.terminate()

cloudbridge/cloud/providers/azure/test/test_azure_instance_type_service.py

@@ -0,0 +1,31 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureInstanceTypeServiceTestCase(ProviderTestBase):
+
+    @helpers.skipIfNoService(['compute.instance_types'])
+    def test_azure_instance_type_list(self):
+        instance_type_list = self.provider.compute.instance_types.list()
+        print("List Instance Types - " + str(instance_type_list))
+        print("List Instance Type Properties - ")
+        print("Name - " + str(instance_type_list[0].name))
+        print("Id - " + str(instance_type_list[0].id))
+        print("vcpus - " + str(instance_type_list[0].vcpus))
+        print("size_root_disk - " +
+              str(instance_type_list[0].size_root_disk))
+        print("ram - " + str(instance_type_list[0].ram))
+        print("size_ephemeral_disks - " +
+              str(instance_type_list[0].size_ephemeral_disks))
+        print("num_ephemeral_disks - " +
+              str(instance_type_list[0].num_ephemeral_disks))
+        print("Family - " +
+              str(instance_type_list[0].family))
+        print("Extra data - " +
+              str(instance_type_list[0].extra_data))
+        self.assertTrue(instance_type_list.total_results > 0)
+
+        # Test find
+        inst_type = self.provider.compute. \
+            instance_types.find(name="Standard_DS1_v2")[0]
+        print(str(inst_type))

cloudbridge/cloud/providers/azure/test/test_azure_key_pair_service.py

@@ -0,0 +1,49 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureKeyPairServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_keypair_create(self):
+        key_pair_create = self.provider.security.key_pairs.create('NewKeyPair')
+        print("Create Key Pair - " + str(key_pair_create))
+        self.assertIsNotNone(key_pair_create)
+        self.assertIsNotNone(key_pair_create)
+        self.assertIsNotNone(key_pair_create.id)
+        self.assertIsNotNone(key_pair_create.material)
+
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_keypair_create_Exist(self):
+        with self.assertRaises(Exception) as context:
+            self.provider.security.key_pairs.create('KeyPair1')
+            self.assertTrue(
+                'Keypair already exists' in context.exception)
+
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_keypair_list(self):
+        key_pair_list = self.provider.security.key_pairs.list()
+        print("List Key Pairs - " + str(key_pair_list))
+        self.assertTrue(key_pair_list.total_results > 0)
+
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_keypair_get_exist_and_delete(self):
+        keypair_id = 'KeyPair1'
+        keypair_get = self.provider.security.key_pairs.get(keypair_id)
+        print("Get Key Pair - " + str(keypair_get))
+        self.assertIsNotNone(keypair_get)
+        keypair_get.delete()
+
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_keypair_get_notExist(self):
+        keypair_id = 'KeyPairNotExist'
+        keypair_get_not_exist = self.provider.security.\
+            key_pairs.get(keypair_id)
+        print("Get Key Pair Not Exist - " + str(keypair_get_not_exist))
+        self.assertIsNone(keypair_get_not_exist)
+
+    @helpers.skipIfNoService(['security.key_pairs'])
+    def test_azure_keypair_find(self):
+        keypair_name = 'KeyPair1'
+        keypair_find = self.provider.security.key_pairs.find(keypair_name)
+        print("Find Key Pair - " + str(keypair_find))
+        self.assertTrue(len(keypair_find) > 0)

cloudbridge/cloud/providers/azure/test/test_azure_network_service.py

@@ -0,0 +1,134 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureNetworkServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_list(self):
+        networks = self.provider.network.list()
+        for network in networks:
+            print("List( " + "Name: " + network.name + ", Id: " +
+                  str(network.id) + ", State: " + network.state +
+                  ", Cidr_Block: " + str(network.cidr_block) + " )")
+        self.assertTrue(len(networks) == 3, "Count should be 3")
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_list_check_values(self):
+        networks = self.provider.network.list()
+        for network in networks:
+            print("List( " + "Name: " + network.name + ", Id: " +
+                  str(network.id) + ", State: " + network.state +
+                  ", Cidr_Block: " + str(network.cidr_block) + " )")
+        self.assertTrue(len(networks) == 3, "Count should be 3")
+        self.assertEqual(networks[0].id, 'CloudBridgeNet1')
+        self.assertEqual(networks[0].name, "CloudBridgeNet1")
+        self.assertEqual(networks[0].cidr_block,
+                         '10.0.0.0/16')
+        self.assertEqual(networks[0].state, "available")
+        self.assertEqual(networks[1].id, 'CloudBridgeNet2')
+        self.assertEqual(networks[1].name, "CloudBridgeNet2")
+        self.assertEqual(networks[1].cidr_block,
+                         '10.0.0.0/16')
+        self.assertEqual(networks[1].state, "unknown")
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_get_exist(self):
+        network = self.provider.network.get('CloudBridgeNet1')
+        print("get exist: " + str(network))
+        self.assertEqual(network.id, 'CloudBridgeNet1')
+        self.assertEqual(network.name, "CloudBridgeNet1")
+        self.assertEqual(network.cidr_block,
+                         '10.0.0.0/16')
+        self.assertEqual(network.state, "available")
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_get_doesnt_exist(self):
+        network = self.provider.network.get('CloudBridgeNet10')
+        print("get does not exist: " + str(network))
+        self.assertEqual(
+            str(network), 'None')
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_get_with_invaid_networkid_throws(self):
+        with self.assertRaises(Exception) as context:
+            network = self.provider.network \
+                .get('invalidNetworkId')
+            print("Get with invalid network id: " + str(network))
+            self.assertTrue(
+                'Invalid url parameter passed' in context.exception)
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_create(self):
+        network = self.provider.network.create("CloudBridgeNet1")
+        network.refresh()
+        print("create: " + str(network))
+        self.assertIsNotNone(network.id)
+        self.assertEqual(network.name, "CloudBridgeNet1")
+        self.assertEqual(network.cidr_block,
+                         '10.0.0.0/16')
+        self.assertEqual(network.state, "available")
+        self.assertTrue(network.external)
+        network.name = 'newname'
+        self.assertEqual(network.name, 'newname')
+        deleted = network.delete()
+        self.assertTrue(deleted)
+        deleted = network.delete()
+        self.assertFalse(deleted)
+        network.refresh()
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_delete_networkid_exists(self):
+        isdeleted = self.provider.network.delete('CloudBridgeNet3')
+
+        print("Delete Network Id exist: " + str(isdeleted))
+        self.assertEqual(isdeleted, True)
+
+        # Calling get network to make sure network was actually deleted
+        network = self.provider.network.get('CloudBridgeNet3')
+        print("get does not exist: " + str(network))
+
+        self.assertEqual(
+            str(network), 'None')
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_delete_networkid_does_not_exist(self):
+        isdeleted = self.provider.network.delete('CloudBridgeNet10')
+
+        print("Delete Network Id does not exist: " + str(isdeleted))
+        self.assertEqual(isdeleted, False)
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_delete_with_invaid_networkid_throws(self):
+        with self.assertRaises(Exception) as context:
+            isdeleted = self.provider.network \
+                .delete('invalidNetworkId')
+            print("Delete with invalid network id: " + str(isdeleted))
+            self.assertTrue(
+                'Invalid url parameter passed' in context.exception)
+
+    def test_network_create_and_list_subnet(self):
+        network = self.provider.network.get('CloudBridgeNet1')
+
+        subnet = network.create_subnet('10.0.0.0/24')
+        self.assertIsNotNone(subnet)
+        subnets = network.subnets()
+        self.assertTrue(len(subnets) > 0)
+        subnet.delete()
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_crud_floating_ips(self):
+        floating_ips = self.provider.network.floating_ips()
+        self.assertTrue(len(floating_ips) == 3, "Count should be 3")
+
+        floating_ip = self.provider.network.create_floating_ip()
+        print("create: " + str(floating_ip))
+        self.assertEqual(floating_ip.public_ip, '13.82.104.38')
+        self.assertEqual(floating_ip.private_ip, None)
+
+        floating_ips = self.provider.network.floating_ips()
+        self.assertTrue(len(floating_ips) == 4, "Count should be 4")
+
+        floating_ip.delete()
+
+        floating_ips = self.provider.network.floating_ips()
+        self.assertTrue(len(floating_ips) == 3, "Count should be 3")

cloudbridge/cloud/providers/azure/test/test_azure_object_store_service.py

@@ -0,0 +1,186 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureObjectStoreServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_create(self):
+        container = self.provider.object_store.create("container3")
+        print("Create - " + str(container))
+        self.assertEqual(
+            str(container), "<CB-AzureBucket: container3>")
+        self.assertIsNotNone(container.id)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_list(self):
+        containerList = self.provider.object_store.list()
+        print("List Container - " + str(containerList))
+        self.assertEqual(
+            len(containerList), 2)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_find_Exist(self):
+        container = self.provider.object_store.find("container")
+        print("Find Exist - " + str(container))
+        self.assertEqual(
+            len(container), 2)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_find_NotExist(self):
+        # For testing the case when container does not exist
+        container = self.provider.object_store.find("container23")
+        print("Find Not Exist - " + str(container))
+        self.assertEqual(
+            len(container), 0)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_get_Exist(self):
+        container = self.provider.object_store.get("container2")
+        print("Get Exist - " + str(container))
+        self.assertTrue(
+            str(container) == "<CB-AzureBucket: container2>",
+            "Object find returned value should be container3")
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_get_NotExist(self):
+        container = self.provider.object_store.get("container23")
+        print("Get Not Exist - " + str(container))
+        self.assertEqual(
+            str(container), 'None')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_delete(self):
+        containers = self.provider.object_store.find("container1")
+        cont = containers[0]
+        contDel = cont.delete()
+        print("Bucket delete - " + str(contDel))
+        self.assertEqual(
+            contDel, True)
+        contDel = cont.delete()
+        self.assertEqual(
+            contDel, False)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_create_object(self):
+        containers = self.provider.object_store.find("container1")
+        cont = containers[0]
+        obj = cont.create_object("block1")
+        self.assertIsNotNone(obj.id)
+        self.assertIsNotNone(obj.size)
+        self.assertIsNotNone(obj.last_modified)
+        print("Create object  - " + str(obj))
+        self.assertEqual(
+            str(obj), '<CB-AzureBucketObject: block1>')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_exists__internalE(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        contDel = cont.exists("block2")
+        print("List object  - " + str(contDel))
+        self.assertEqual(
+            str(contDel), 'True')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_exists__internalNE(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        contDel = cont.exists("blob3")
+        print("List object  - " + str(contDel))
+        self.assertEqual(
+            str(contDel), 'False')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_list(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        contDel = cont.list()
+        print("List object  - " + str(contDel))
+        self.assertEqual(
+            len(contDel), 3)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_get(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        contDel = cont.get("block2")
+        print("List object  - " + str(contDel))
+        self.assertEqual(
+            str(contDel), "<CB-AzureBucketObject: block2>")
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_iter_content(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        blocks = cont.list()
+        block = blocks[0]
+        content = block.iter_content()
+        print("Iter content  - " + str(content))
+        self.assertEqual(
+            content.getvalue(), b'blob2Content')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_iter_content_ifBlobNotExists(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        block = cont.get('block3')
+        content = block.iter_content()
+        self.assertEqual(
+            content, None, 'content should be None')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_upload(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        blocks = cont.list()
+        block = blocks[0]
+        block.upload('blob1Content')
+        self.assertEqual(
+            block.iter_content().getvalue(), b'blob1Content')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_delete(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        blocks = cont.list()
+        block = blocks[0]
+        block.delete()
+        self.assertEqual(
+            len(cont.list()), 3)
+        deleted = block.delete()
+        self.assertEqual(deleted, False)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_upload_from_file(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        blocks = cont.list()
+        block = blocks[0]
+        block.upload_from_file('blob2Content')
+        self.assertEqual(
+            block.iter_content().getvalue(), b'blob2Content')
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_upload_exception(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        blob = cont.create_object('block4')
+        uploaded = blob.upload_from_file('E:\\blob2Content.txt')
+        self.assertEqual(uploaded, False)
+
+        uploaded = blob.upload('blob2Content')
+        self.assertEqual(uploaded, False)
+
+        blob.delete()
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_object_generate_url(self):
+        containers = self.provider.object_store.find("container2")
+        cont = containers[0]
+        blocks = cont.list()
+        block = blocks[0]
+        url = block.generate_url()
+        print(str(url))
+        self.assertEqual(
+            str(url),
+            'https://cloudbridgeazure.blob.core.windows.net/vhds/block1')

cloudbridge/cloud/providers/azure/test/test_azure_provider.py

@@ -0,0 +1,38 @@
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureProviderTestCase(ProviderTestBase):
+    def test_azure_provider(self):
+        compute = self.provider.compute
+        self.assertTrue(compute is not None, 'Compute should not be None')
+
+        self.assertTrue(compute.images is not None,
+                        'Images should not be none')
+
+        self.assertTrue(compute.instances is not None,
+                        'Instances should not be none')
+
+        self.assertTrue(compute.instance_types is not None,
+                        'Instance types should not be none')
+
+        self.assertTrue(compute.regions is not None,
+                        'Regions should not be none')
+
+        network = self.provider.network
+        self.assertTrue(network is not None,
+                        'Network should not be None')
+
+        block_store = self.provider.block_store
+        self.assertTrue(block_store is not None,
+                        'Block Store should not be None')
+
+        block_store = self.provider.block_store
+        self.assertTrue(block_store is not None,
+                        'Block Store should not be None')
+
+        object_store = self.provider.object_store
+        self.assertTrue(object_store is not None,
+                        'Object Store should not be None')
+
+        security = self.provider.security
+        self.assertTrue(security is not None, 'Security should not be None')

cloudbridge/cloud/providers/azure/test/test_azure_region_service.py

@@ -0,0 +1,44 @@
+from cloudbridge.cloud.providers.azure.resources import AzureRegion
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureRegionServiceTestCase(ProviderTestBase):
+    def test_azure_region_service_list(self):
+        regions = self.provider.compute.regions.list()
+        self.assertIsNotNone(regions)
+        self.assertEqual(
+            len(regions), 3)
+        print("Region List - " + str(regions))
+        for region in regions:
+            print(region.id)
+            print(region.name)
+            print(region.zones)
+            self.assertIsInstance(
+                region,
+                AzureRegion,
+                "regions.list() should return a cloudbridge Region")
+            self.assertTrue(
+                region.name,
+                "Region name should be a non-empty string")
+
+    def test_azure_region_service_get(self):
+        region_id = "westus2"
+        region = self.provider.compute.regions.get(region_id)
+        self.assertIsNotNone(region)
+        self.assertEqual(region.name, "westus2")
+        self.assertEqual(region.zones[0].id, region.id)
+        self.assertEqual(region.zones[0].name, region.name)
+        self.assertEqual(region.zones[0].region_name, region.name)
+
+    def test_azure_region_service_get_invalid_region_id(self):
+        region_id = "invalid"
+        region = self.provider.compute.regions.get(region_id)
+        self.assertIsNone(region)
+
+    def test_azure_region_service_current(self):
+        current_region_name = self.provider.region_name
+        print("current region: " + current_region_name)
+        region = self.provider.compute.regions.current
+        self.assertIsNotNone(region)
+        print("Region service returned Region name:" + region.name)
+        self.assertEqual(region.name, current_region_name)

cloudbridge/cloud/providers/azure/test/test_azure_resource_group.py

@@ -0,0 +1,20 @@
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureResourceGroupTestCase(ProviderTestBase):
+    def test_resource_group_create(self):
+        resource_group_params = {'location': self.provider.region_name}
+        rg = self.provider.azure_client. \
+            create_resource_group(self.provider.resource_group,
+                                  resource_group_params)
+        print("Create Resource - " + str(rg))
+        self.assertTrue(
+            rg.name == "cloudbridge",
+            "Resource Group should be Cloudbridge")
+
+    def test_resource_group_get(self):
+        rg = self.provider.azure_client.get_resource_group('MyGroup')
+        print("Get Resource - " + str(rg))
+        self.assertTrue(
+            rg.name == "testResourceGroup",
+            "Resource Group should be Cloudbridge")

cloudbridge/cloud/providers/azure/test/test_azure_security_service.py

@@ -0,0 +1,153 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureSecurityServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_create(self):
+        name = "testCreateSecGroup3"
+        sg = self.provider.security.security_groups.create(
+            name=name, description=name, network_id="")
+        print("Create - " + str(sg))
+        self.assertEqual(name, sg.name)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_create_and_delete(self):
+        name = "testCreateSecGroup10"
+        sg = self.provider.security.security_groups.create(
+            name=name, description=name, network_id="")
+        print("Create - " + str(sg))
+        self.assertEqual(name, sg.name)
+        deleted = sg.delete()
+        self.assertTrue(deleted)
+        deleted = sg.delete()
+        self.assertFalse(deleted)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_create_no_description(self):
+        name = "testCreateSecGroup13"
+        sg = self.provider.security.security_groups.create(
+            name=name, description=None, network_id="")
+        print("Create - " + str(sg))
+        self.assertEqual(name, sg.name)
+        sg.description = name
+        sg.name = 'NewName'
+        self.assertEqual(name, sg.description)
+        self.provider.security.security_groups.delete('testCreateSecGroup13')
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_find_exists(self):
+        sgl = self.provider.security.security_groups.find("sg3")
+        for sg in sgl:
+            self.assertTrue("sg" in sg.name)
+        self.assertTrue(sgl.total_results > 0)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_find_not_exists(self):
+        sgl = self.provider.security.security_groups.find('dontfindme')
+        self.assertTrue(sgl.total_results == 0)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_list(self):
+        sgl = self.provider.security.security_groups.list()
+        for group in sgl:
+            print("List - " + str(group))
+        self.assertTrue(
+            len(sgl) == 3,
+            "Count should be 3")
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_get_found(self):
+        sgl = self.provider.security.security_groups.get('sg3')
+        print("Get ( " + "Name - " + sgl.name + "  Id - " + sgl.id + " )")
+        self.assertTrue(
+            sgl.name == "sg3",
+            "SG name should be sg3")
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_get_not_found(self):
+        sgl = self.provider.security.security_groups.get('sg4')
+        print(str(sgl))
+        self.assertTrue(
+            sgl is None,
+            "Security group does not exist. Should return None.")
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_delete_IdExists(self):
+        deleted = self.provider.security.security_groups.delete('sg2')
+        print("Delete - ")
+        self.assertEqual(deleted, True)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_delete_IdNotExist(self):
+        deleted = self.provider.security.security_groups.delete('sg5')
+        self.assertEqual(deleted, False)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_rule_create(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        rules = cb.rules
+        for rule in rules:
+            print(str(rule))
+        print("Before creating Rule length - " + str(len(rules)))
+        cb.add_rule('*', '25', '100', '*')
+        rules = cb.rules
+        print("After creating Rule length - " + str(len(rules)))
+        self.assertEqual(len(rules), 3)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_rule_create_twice(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        first_rule = cb.add_rule('*', '25', '100')
+        second_rule = cb.add_rule('*', '25', '100')
+        self.assertEqual(first_rule, second_rule)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_rule_delete(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        rules = cb.rules
+        print("Before deleting Rule length - " + str(len(rules)))
+        rules[1].delete()
+        rules = cb.rules
+        print("After deleting Rule length - " + str(len(rules)))
+        self.assertEqual(len(rules), 4)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_rule_get_exist(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        rule = cb.get_rule('*', '25', '1', '100')
+        print("Get Rule -  " + str(rule))
+        self.assertIsNotNone(rule)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_rule_get_notExist(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        rule = cb.get_rule('*', '25', '1', '1')
+        print("Get Rule -  " + str(rule))
+        self.assertEqual(str(rule), 'None')
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_to_json(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        rule = cb.to_json()
+        print("Get Rule -  " + str(rule))
+        self.assertIsNotNone(rule)
+        cb = list.data[1]
+        rule = cb.to_json()
+        self.assertIsNotNone(rule)
+
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_rule_to_json(self):
+        list = self.provider.security.security_groups.list()
+        cb = list.data[0]
+        rules = cb.rules
+        rule = rules[0]
+        json = rule.to_json()
+        print("Get Rule -  " + str(json))
+        self.assertEqual(json[2:9], "cidr_ip")

cloudbridge/cloud/providers/azure/test/test_azure_snapshots_service.py

@@ -0,0 +1,100 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.interfaces import SnapshotState
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureSnapshotsServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_create_and_get(self):
+        volume_id = "Volume1"
+        snapshot = self.provider.block_store. \
+            snapshots.create("MySnapshot",
+                             volume_id)
+        snapshot.description = 'My snapshot'
+        print("Create Snapshot - " + str(snapshot))
+        self.assertTrue(
+            snapshot.name == "MySnapshot",
+            "Snapshot name should be MySnapshot")
+        self.assertIsNotNone(snapshot.description)
+        self.assertIsNotNone(snapshot.name)
+        self.assertIsNotNone(snapshot.size)
+        self.assertIsNotNone(snapshot.volume_id)
+        self.assertIsNotNone(snapshot.create_time)
+        snapshot.name = 'MySnapNewName'
+        snapshot = self.provider.block_store.snapshots.get(snapshot.id)
+        print("Get Snapshot  - " + str(snapshot))
+        self.assertTrue(
+            snapshot.name == "MySnapNewName",
+            "Snapshot name should be MySnapshot")
+
+        snapshot.delete()
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_delete(self):
+        volume_id = "Volume1"
+        snapshot = self.provider.block_store. \
+            snapshots.create("MySnapshot",
+                             volume_id, description='My snapshot')
+        snapshot.refresh()
+        print("Create Snapshot - " + str(snapshot))
+        self.assertTrue(
+            snapshot.name == "MySnapshot",
+            "Snapshot name should be MySnapshot")
+        snapshot.delete()
+
+        delete_snapshot = snapshot.delete()
+        self.assertEqual(delete_snapshot, False)
+
+        snapshot.refresh()
+        self.assertEqual(snapshot.state, SnapshotState.UNKNOWN)
+
+        snapshot_id = "MySnapshot"
+        snapshot1 = self.provider.block_store.snapshots.get(snapshot_id)
+        self.assertTrue(
+            snapshot1 is None, "Snapshot still exists")
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_create_volume(self):
+        volume_id = "Volume1"
+        snapshot = self.provider.block_store. \
+            snapshots.create("MySnapshot",
+                             volume_id,
+                             description='My snapshot')
+        self.assertTrue(
+            snapshot.name == "MySnapshot",
+            "Snapshot name should be MySnapshot")
+
+        volume = snapshot.create_volume()
+        self.assertTrue(
+            volume is not None, "Snapshot not created")
+        volume.delete()
+
+        snapshot.delete()
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_get_ifNotExist(self):
+        snapshot_id = "MySnapshot123"
+        snapshot = self.provider.block_store.snapshots.get(snapshot_id)
+        self.assertTrue(
+            snapshot is None, "Snapshot should not be available")
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshots_list(self):
+        snapshot_list = self.provider \
+            .block_store.snapshots.list()
+        print("Snapshot List - " + str(snapshot_list))
+        self.assertTrue(
+            snapshot_list.total_results > 0)
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_find_exists(self):
+        snapshots = self.provider.block_store.snapshots.find("snapshot1")
+        for snapshot in snapshots:
+            self.assertTrue("snapshot" in snapshot.name)
+        print(snapshots.total_results)
+        self.assertTrue(snapshots.total_results > 0)
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_find_not_exists(self):
+        snapshots = self.provider.block_store.snapshots.find('dontfindme')
+        self.assertTrue(snapshots.total_results == 0)

cloudbridge/cloud/providers/azure/test/test_azure_storage_account.py

@@ -0,0 +1,25 @@
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureStorageAccountTestCase(ProviderTestBase):
+    def test_storage_account_create(self):
+        storage_account_params = {
+            'sku': {
+                'name': 'Standard_LRS'
+            },
+            'kind': 'storage',
+            'location': 'eastus',
+        }
+        rg = self.provider.azure_client. \
+            create_storage_account('cloudbridgeazure',
+                                   storage_account_params)
+        print("Create Resource - " + str(rg))
+        self.assertTrue(
+            rg.name == "cloudbridgeazure",
+            "Storage account name should be cloudbridgeazure")
+
+    def test_storage_account_get(self):
+        sa = self.provider.azure_client.get_storage_account('MyGroup')
+        self.assertTrue(
+            sa.name == "MyGroup",
+            "storage account should be MyGroup")

cloudbridge/cloud/providers/azure/test/test_azure_subnet_service.py

@@ -0,0 +1,82 @@
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureSubnetServiceTestCase(ProviderTestBase):
+    def test_azure_subnet_service_list(self):
+        subnets = self.provider.network.subnets.list()
+        self.assertIsNotNone(subnets)
+        for subnet in subnets:
+            print(subnet.name)
+            print(subnet.id)
+            print(subnet.cidr_block)
+            print("network_id" + subnet.network_id)
+
+    def test_azure_subnet_service_list_filter_network_id(self):
+        network_id = 'CloudBridgeNet4'
+        subnets = self.provider.network.subnets.list(network_id)
+        self.assertIsNotNone(subnets)
+        for subnet in subnets:
+            print(subnet.name)
+            print(subnet.id)
+            print(subnet.cidr_block)
+            print("network_id" + subnet.network_id)
+
+    def test_azure_subnet_service_list_filter_network_object(self):
+        network_id = 'CloudBridgeNet4'
+        network = self.provider.network.get(network_id)
+        subnets = self.provider.network.subnets.list(network)
+        self.assertIsNotNone(subnets)
+        for subnet in subnets:
+            print(subnet.name)
+            print(subnet.id)
+            print(subnet.cidr_block)
+            print("network_id" + subnet.network_id)
+
+    def test_azure_subnet_service_get(self):
+        subnet_id = 'CloudBridgeNet4|$|MySN1'
+        subnet = self.provider.network.subnets.get(subnet_id)
+        self.assertIsNotNone(subnet)
+        if subnet:
+            print("Subnet found")
+            print(subnet.id)
+            print(subnet.name)
+            print(subnet.cidr_block)
+            print("network_id" + subnet.network_id)
+
+    def test_azure_subnet_service_get_invalid_subnet(self):
+        subnet_id = 'CloudBridgeNet4|$|MySN'
+        subnet = self.provider.network.subnets.get(subnet_id)
+        self.assertIsNone(subnet)
+
+    def test_azure_create_and_delete_from_resource_subnet(self):
+        network_id = 'CloudBridgeNet4'
+        subnet = self.provider.network.\
+            subnets.create(network=network_id,
+                           cidr_block='10.0.0.0/24')
+        self.assertIsNotNone(subnet.zone)
+        self.assertIsNotNone(subnet)
+        deleted = subnet.delete()
+        self.assertTrue(deleted)
+        deleted = subnet.delete()
+        self.assertFalse(deleted)
+
+    def test_azure_create_and_delete_from_service_subnet(self):
+        network_id = 'CloudBridgeNet4'
+        subnet = self.provider.network.\
+            subnets.create(network=network_id,
+                           name='test', cidr_block='10.0.0.0/24')
+        self.assertIsNotNone(subnet)
+        deleted = self.provider.network.subnets.delete(subnet)
+        self.assertTrue(deleted)
+        deleted = self.provider.network.subnets.delete(subnet)
+        self.assertFalse(deleted)
+
+    def test_azure_create_or_get_default_subnet(self):
+        subnet = self.provider.network.\
+            subnets.get_or_create_default()
+        self.assertIsNotNone(subnet)
+        subnet = self.provider.network. \
+            subnets.get_or_create_default()
+        self.assertIsNotNone(subnet)
+        subnet.delete()
+        self.provider.network.delete(subnet.network_id)

cloudbridge/cloud/providers/azure/test/test_azure_volume_service.py

@@ -0,0 +1,115 @@
+import cloudbridge.cloud.providers.azure.test.helpers as helpers
+from cloudbridge.cloud.interfaces import VolumeState
+from cloudbridge.cloud.providers.azure.test.helpers import ProviderTestBase
+
+
+class AzureVolumeServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_create_and_get(self):
+        volume = self.provider.block_store.volumes.create(
+            "MyVolume", 1, description='My volume')
+        print("Create Volume - " + str(volume))
+        self.assertTrue(
+            volume.name == "MyVolume", "Volume name should be MyVolume")
+
+        self.assertIsNotNone(volume.description)
+        self.assertIsNotNone(volume.name)
+        self.assertIsNotNone(volume.size)
+        self.assertIsNotNone(volume.zone_id)
+        self.assertIsNone(volume.source)
+        self.assertIsNone(volume.attachments)
+        self.assertIsNotNone(volume.create_time)
+        volume.name = 'newname'
+
+        volume = self.provider.block_store.volumes.get(
+            volume.id)
+        volume.description = 'My Volume desc'
+        print("Get Volume  - " + str(volume))
+        self.assertTrue(
+            volume.description == "My Volume desc",
+            "Volume description should be My Volume desc")
+
+        volume.delete()
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_delete(self):
+        volume = self.provider.block_store.volumes.create("MyTestVolume", 1)
+        volume.refresh()
+        print("Create Volume - " + str(volume))
+        self.assertTrue(volume.name == "MyTestVolume",
+                        "Volume name should be MyVolume")
+        volume.delete()
+        volume1_id = "MyVolume"
+        delete_volume = volume.delete()
+        self.assertEqual(delete_volume, False)
+
+        volume.refresh()
+        self.assertEqual(volume.state, VolumeState.UNKNOWN)
+
+        volume1 = self.provider.block_store.volumes.get(volume1_id)
+        self.assertTrue(
+            volume1 is None, "Volume still exists")
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_attach_and_detach(self):
+        volume = self.provider.block_store.volumes.create(
+            "attach", 1, description='My volume')
+        self.assertTrue(
+            volume.name == "attach", "Volume name should be MyVolume")
+        instance_id = 'VM1'
+        attached = volume.attach(instance_id)
+
+        self.assertEqual(attached, True)
+        self.assertIsNotNone(volume.attachments)
+        instance_id = instance_id + '1'
+        attach_volume = volume.attach(instance_id)
+        self.assertEqual(attach_volume, False)
+
+        detached = volume.detach()
+        self.assertEqual(detached, True)
+
+        detached = volume.detach()
+        self.assertEqual(detached, False)
+
+        volume.delete()
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_create_snapshot(self):
+        volume = self.provider.block_store.volumes.create(
+            "MyVolume", 1, description='My volume')
+        self.assertTrue(
+            volume.name == "MyVolume", "Volume name should be MyVolume")
+        snapshot = volume.create_snapshot("MySnap")
+        self.assertTrue(
+            snapshot is not None, "Snapshot not created")
+
+        volume.delete()
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_get_ifNotExist(self):
+        volume_id = "MyVolume123"
+        volume = self.provider.block_store.volumes.get(volume_id)
+        self.assertTrue(
+            volume is None, "Volume should not be available")
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_find(self):
+        volumes = self.provider.block_store.volumes.find("Volume1")
+        print(len(volumes))
+        print('after find')
+        self.assertTrue(
+            len(volumes) == 1, "Volume should not be available")
+        self.assertIsNotNone(volumes[0].source)
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_find_ifNotExist(self):
+        volumes = self.provider.block_store.volumes.find("Volume123")
+        self.assertTrue(
+            len(volumes) == 0, "Volume should not be available")
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_list(self):
+        volume_list = self.provider.block_store.volumes.list()
+        print("Volume List - " + str(volume_list))
+        self.assertEqual(
+            len(volume_list), 2)