Implemented FilterList class to filter azure list

Implemented unit test for create volume
Improved code coverage.

cloudbridge/cloud/providers/azure/azure_client.py

@@ -7,7 +7,6 @@ from azure.mgmt.resource import ResourceManagementClient
 from azure.mgmt.resource.subscriptions import SubscriptionClient
 from azure.mgmt.storage import StorageManagementClient
 from azure.storage.blob import BlockBlobService, PublicAccess
-from azure.common import AzureMissingResourceHttpError
 
 log = logging.getLogger(__name__)
 
@@ -104,18 +103,17 @@ class AzureClient(object):
     def delete_security_group(self, name):
         return self.network_management_client.network_security_groups.delete(self.resource_group_name, name)
 
-    def list_containers(self):
-        return self.blob_service.list_containers()
+    def list_containers(self, filters=None):
+        containers = FilterList(self.blob_service.list_containers())
+        containers.filter(filters)
+        return containers
 
     def create_container(self, container_name):
         self.blob_service.create_container(container_name, public_access=PublicAccess.Container)
         return self.blob_service.get_container_properties(container_name)
 
     def get_container(self, container_name):
-        try:
-            return self.blob_service.get_container_properties(container_name)
-        except AzureMissingResourceHttpError:
-            return None
+        return self.blob_service.get_container_properties(container_name)
 
     def delete_container(self, container_name):
         self.blob_service.delete_container(container_name)
@@ -125,10 +123,7 @@ class AzureClient(object):
         return self.blob_service.list_blobs(container_name)
 
     def get_blob(self, container_name, blob_name):
-        try:
-            return self.blob_service.get_blob_properties(container_name, blob_name)
-        except AzureMissingResourceHttpError:
-            return None
+        return self.blob_service.get_blob_properties(container_name, blob_name)
 
     def create_blob_from_text(self, container_name, blob_name, text):
         self.blob_service.create_blob_from_text(container_name, blob_name, text)
@@ -181,4 +176,14 @@ class AzureClient(object):
         return disk_resource
 
     def get_disk(self, disk_name):
-        return self.compute_client.disks.get(self.resource_group_name, disk_name)
+        return self.compute_client.disks.get(self.resource_group_name, disk_name)
+
+
+class FilterList(list):
+    def filter(self, filters):
+        if filters:
+            for obj in self:
+                for key in filters:
+                    print('original value' + str(getattr(obj, key)) + 'key value' + filters[key])
+                    if filters[key] not in str(getattr(obj, key)):
+                        self.remove(obj)

cloudbridge/cloud/providers/azure/mock_azure_client.py

@@ -1,7 +1,11 @@
+from azure.mgmt.compute.models import Disk, CreationData, DiskCreateOption
 from azure.mgmt.network.models import NetworkSecurityGroup
-from azure.storage.blob.models import Container
-from azure.mgmt.resource.resources.models import ResourceGroup
 from azure.mgmt.network.models import SecurityRule
+from azure.mgmt.resource.resources.models import ResourceGroup
+from azure.storage.blob.models import Container, Blob
+
+from cloudbridge.cloud.providers.azure.azure_client import FilterList
+
 
 class MockAzureClient:
     sg_rule1 = SecurityRule(protocol='*', source_address_prefix='100', destination_address_prefix="*", access="Allow",
@@ -21,31 +25,48 @@ class MockAzureClient:
 
 
     sec_gr1 = NetworkSecurityGroup()
-    sec_gr1.name = "sec_group1"
-    sec_gr1.id = "sg1"
+    sec_gr1.name = "sg1"
+    sec_gr1.id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg1"
     sec_gr1.default_security_rules = [sg_rule1]
     sec_gr1.security_rules = [sg_rule2]
 
     sec_gr2 = NetworkSecurityGroup()
-    sec_gr2.name = "sec_group2"
-    sec_gr2.id = "sg2"
+    sec_gr2.name = "sg2"
+    sec_gr2.id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg2"
     sec_gr2.default_security_rules = [sg_rule1]
     sec_gr2.security_rules = [sg_rule2]
 
     sec_gr3 = NetworkSecurityGroup()
-    sec_gr3.name = "sec_group3"
-    sec_gr3.id = "sg3"
+    sec_gr3.name = "sg3"
+    sec_gr3.id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg3"
     sec_gr3.default_security_rules = [sg_rule1]
     sec_gr3.security_rules = [sg_rule2]
 
     security_groups = [sec_gr1, sec_gr2, sec_gr3]
 
+
     container1 = Container()
     container1.name = "container1"
+
     container2 = Container()
     container2.name = "container2"
+
     containers = [container1, container2]
 
+    block1 = Blob()
+    block1.name = "block1"
+    block1.content = "blob1Content"
+
+    block2 = Blob()
+    block2.name = "block2"
+    block2.content = "blob2Content"
+
+    block3 = Blob()
+    block3.name = "block3"
+    block3.content = None
+
+    blocks = [block1, block2, block3]
+
     rg = ResourceGroup(location='westus')
     rg.name = "testResourceGroup"
 
@@ -72,6 +93,12 @@ class MockAzureClient:
                 return True
         return False
 
+    def get_security_group(self, name):
+        for item in self.security_groups:
+            if item.name == name:
+                return item
+        return None
+
     def create_security_group_rule(self, security_group, rule_name, parameters):
         new_sg_rule = SecurityRule(protocol='*',source_address_prefix='100',destination_address_prefix="*",access="Allow",direction = "Inbound")
         new_sg_rule.name = "rule1"
@@ -84,6 +111,8 @@ class MockAzureClient:
         pass
 
     def get_resource_group(self, resource_group_name):
+        if resource_group_name == 'cloudbridge-azure':
+            raise Exception()
         return self.rg
 
     def create_resource_group(self, resource_group_name, params):
@@ -97,12 +126,57 @@ class MockAzureClient:
                 return container
         return None
 
-    def list_containers(self):
-        return self.containers
+    def list_containers(self, filters = None):
+        containers = FilterList(self.containers)
+        containers.filter(filters)
+        return containers
 
     def create_container(self, container_name):
         new_container = Container()
         new_container.name = container_name
         return new_container
 
+    def delete_container(self, container_name):
+        container = self.get_container(container_name)
+        self.containers.remove(container)
+
+    def create_blob_from_text(self, container_name, blob_name, text):
+        blob = self.get_blob(container_name, blob_name)
+        blob.content = text
+
+    def get_blob(self, container_name, blob_name):
+        for blob in self.blocks:
+            if blob.name == blob_name:
+                return blob
+        return None
+
+    def list_blobs(self,container_name):
+        return self.blocks
+
+    def get_blob_content(self, container_name, blob_name):
+        blob = self.get_blob(container_name, blob_name)
+        return blob
+
+    def delete_blob(self,container_name, blob_name):
+        for blob in self.blocks:
+            if blob.name == blob_name:
+                self.blocks.remove(blob)
+
+    def create_blob_from_file(self, container_name, blob_name, file_path):
+        blob = self.get_blob(container_name, blob_name)
+        blob.content = file_path
+
+    def get_blob_url(self, container_name, blob_name):
+        return 'https://cloudbridgeazure.blob.core.windows.net/vhds/block1'
+
+    def create_empty_disk(self, disk_name, size, region=None, snapshot_id=None):
+        volume = Disk(location='eastus',creation_data=None)
+        volume.id='/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure/providers/Microsoft.Compute/disks/SampleVolume'
+        volume.name = disk_name
+        volume.disk_size_gb= size
+        volume.creation_data = CreationData(create_option=DiskCreateOption.empty)
+        volume.time_created = '01-01-2017'
+        volume.owner_id ='/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Compute/virtualMachines/ubuntu-intro1'
+        return volume
+
 

cloudbridge/cloud/providers/azure/resources.py

@@ -5,6 +5,7 @@ import inspect
 import json
 from datetime import datetime
 
+from azure.common import AzureMissingResourceHttpError
 from msrestazure.azure_exceptions import CloudError
 
 from cloudbridge.cloud.base.resources import BaseBucket, BaseSecurityGroup, BaseSecurityGroupRule, BaseBucketObject, \
@@ -279,11 +280,14 @@ class AzureBucket(BaseBucket):
         """
         Retrieve a given object from this bucket.
         """
-        obj =self._provider.azure_client.get_blob(self.name, key)
-        if obj:
-            return AzureBucketObject(self._provider, self, obj)
+        try:
+            obj =self._provider.azure_client.get_blob(self.name, key)
+            if obj:
+                return AzureBucketObject(self._provider, self, obj)
 
-        return None
+            return None
+        except AzureMissingResourceHttpError:
+            return None
 
     def list(self, limit=None, marker=None):
         """
@@ -329,6 +333,7 @@ class AzureVolume(BaseVolume):
         super(AzureVolume, self).__init__(provider)
         self._volume = volume
         self._url_params= TemplateUrlParser.parse(VOLUME_RESOURCE_ID,volume.id)
+        self._description = None
 
     @property
     def id(self):
@@ -353,11 +358,11 @@ class AzureVolume(BaseVolume):
 
     @property
     def description(self):
-        return None
+        return self._description
 
     @description.setter
     def description(self, value):
-        pass
+        self._description = value
 
     @property
     def size(self):
@@ -400,33 +405,6 @@ class AzureVolume(BaseVolume):
         pass
 
 
-class AzureInstance(BaseInstance):
-
-    def __init__(self, provider, vm_instace):
-        super(AzureInstance, self).__init__(provider)
-        self._vm = vm_instace
-        self._url_params = TemplateUrlParser.parse(INSTANCE_RESOURCE_ID,vm_instace.id)
-
-    @property
-    def id(self):
-        """
-        Get the instance identifier.
-        """
-        return self._vm.id
-
-
-class AzureSnapshot(BaseSnapshot):
-
-    def __init__(self, provider, snapshot):
-        super(AzureSnapshot, self).__init__(provider)
-        self._snapshot = snapshot
-        self._url_params = TemplateUrlParser.parse(SNAPSHOT_RESOURCE_ID,snapshot.id)
-
-    @property
-    def id(self):
-        return self._snapshot.id
-
-
 class TemplateUrlParser:
     @staticmethod
     def parse(template_url, original_url):

cloudbridge/cloud/providers/azure/services.py

@@ -1,10 +1,13 @@
 import logging
 
-from cloudbridge.cloud.interfaces.resources import PlacementZone
+from azure.common import AzureMissingResourceHttpError
+from msrestazure.azure_exceptions import CloudError
+
+from cloudbridge.cloud.interfaces.resources import PlacementZone, Snapshot
 from .resources import SUBNET_RESOURCE_ID, NETWORK_NAME, SUBNET_NAME, NETWORK_RESOURCE_ID, \
     INSTANCE_RESOURCE_ID, VM_NAME, IMAGE_RESOURCE_ID, RESOURCE_GROUP_NAME, IMAGE_NAME, SNAPSHOT_RESOURCE_ID, \
     SNAPSHOT_NAME, VOLUME_RESOURCE_ID, VOLUME_NAME, NETWORK_SECURITY_GROUP_RESOURCE_ID, SECURITY_GROUP_NAME, \
-    TemplateUrlParser, AzureVolume, AzureSnapshot
+    TemplateUrlParser, AzureVolume
 
 from cloudbridge.cloud.base.resources import ClientPagedResultList
 from cloudbridge.cloud.base.services import BaseObjectStoreService, BaseSecurityGroupService, BaseSecurityService, \
@@ -31,7 +34,7 @@ class AzureSecurityService(BaseSecurityService):
         :rtype: ``object`` of :class:`.KeyPairService`
         :return: a KeyPairService object
         """
-        return None
+        pass
 
     @property
     def security_groups(self):
@@ -49,34 +52,33 @@ class AzureSecurityGroupService(BaseSecurityGroupService):
         super(AzureSecurityGroupService, self).__init__(provider)
 
     def get(self, sg_id):
-        for item in self.provider.azure_client.list_security_group():
-            if item.id == sg_id:
-                return AzureSecurityGroup(self.provider, item)
-        return None
+        try:
+            params = TemplateUrlParser.parse(NETWORK_SECURITY_GROUP_RESOURCE_ID, sg_id)
+            sgs = self.provider.azure_client.get_security_group(params.get(SECURITY_GROUP_NAME))
+            return AzureSecurityGroup(self.provider, sgs) if sgs else None
+
+        except CloudError:
+            return None
 
     def list(self, limit=None, marker=None):
-        nsg_list = self.provider.azure_client.list_security_group()
-        network_security_group = [AzureSecurityGroup(self.provider, sg)
-                                  for sg in nsg_list]
-        return ClientPagedResultList(self.provider, network_security_group, limit, marker)
+        sgs = [AzureSecurityGroup(self.provider, sg)
+                                  for sg in self.provider.azure_client.list_security_group()]
+        return ClientPagedResultList(self.provider, sgs, limit, marker)
 
-        # network_id is similar to resource group in azure
     def create(self, name, description, network_id):
         parameters = {"location": self.provider.region_name}
-        result = self.provider.azure_client.create_security_group(name, parameters)
-        return AzureSecurityGroup(self.provider, result)
+        sg = self.provider.azure_client.create_security_group(name, parameters)
+        if sg:
+            return AzureSecurityGroup(self.provider, sg)
+        return None
 
     def find(self, name, limit=None, marker=None):
         raise NotImplementedError(
             "AzureSecurityGroupService does not implement this method")
 
     def delete(self, group_id):
-        for item in self.provider.azure_client.list_security_group():
-            if item.id == group_id:
-                sg_name = item.name
-                self.provider.azure_client.delete_security_group(sg_name)
-                return True
-        return False
+        params = TemplateUrlParser.parse(NETWORK_SECURITY_GROUP_RESOURCE_ID, group_id)
+        return self.provider.azure_client.delete_security_group(params.get(SECURITY_GROUP_NAME))
 
 
 class AzureObjectStoreService(BaseObjectStoreService):
@@ -84,31 +86,43 @@ class AzureObjectStoreService(BaseObjectStoreService):
         super(AzureObjectStoreService, self).__init__(provider)
 
     def get(self, bucket_id):
-        log.info("Azure Object Store Service get API with bucket id - " + str(bucket_id))
-        object_store = self.provider.azure_client.get_container(bucket_id)
-        if object_store:
-            return AzureBucket(self.provider, object_store)
-        return None
+        """
+        Returns a bucket given its ID. Returns ``None`` if the bucket
+        does not exist.
+        """
+        try:
+            bucket = self.provider.azure_client.get_container(bucket_id)
+            if bucket:
+                return AzureBucket(self.provider, bucket)
+            else:
+                return None
+        except AzureMissingResourceHttpError:
+            return None
 
     def find(self, name, limit=None, marker=None):
-        object_store = self.provider.azure_client.get_container(name)
-        object_stores = []
-        if object_store:
-            object_stores.append(AzureBucket(self.provider, object_store))
-
-        return ClientPagedResultList(self.provider, object_stores,
+        """
+        Searches for a bucket by a given list of attributes.
+        """
+        buckets = [AzureBucket(self.provider, bucket)
+                   for bucket in self.provider.azure_client.list_containers({'name':name})]
+        return ClientPagedResultList(self.provider, buckets,
                                      limit=limit, marker=marker)
 
     def list(self, limit=None, marker=None):
-        object_stores = [AzureBucket(self.provider, object_store)
-                   for object_store in
-                   self.provider.azure_client.list_containers()]
-        return ClientPagedResultList(self.provider, object_stores,
+        """
+        List all containers.
+        """
+        buckets = [AzureBucket(self.provider, bucket)
+                   for bucket in self.provider.azure_client.list_containers()]
+        return ClientPagedResultList(self.provider, buckets,
                                      limit=limit, marker=marker)
 
     def create(self, name, location=None):
-        object_store = self.provider.azure_client.create_container(name)
-        return AzureBucket(self.provider, object_store)
+        """
+        Create a new bucket.
+        """
+        bucket = self.provider.azure_client.create_container(name)
+        return AzureBucket(self.provider, bucket)
 
 
 class AzureBlockStoreService(BaseBlockStoreService):
@@ -117,7 +131,6 @@ class AzureBlockStoreService(BaseBlockStoreService):
 
         # Initialize provider services
         self._volume_svc = AzureVolumeService(self.provider)
-        #self._snapshot_svc = AzureSnapshotService(self.provider)
 
     @property
     def volumes(self):
@@ -127,6 +140,7 @@ class AzureBlockStoreService(BaseBlockStoreService):
     def snapshots(self):
         pass
 
+
 class AzureVolumeService(BaseVolumeService):
 
     def __init__(self, provider):
@@ -142,7 +156,12 @@ class AzureVolumeService(BaseVolumeService):
         raise NotImplementedError('AzureVolumeService not imeplemented this method')
 
     def create(self, name, size, zone=None, snapshot=None, description=None):
-        region = zone.id if isinstance(zone, PlacementZone) else zone
-        snapshot_id = snapshot.id if isinstance(snapshot, AzureSnapshot) and snapshot else snapshot
-        volume =  self.provider.azure_client.create_empty_disk(name, size, region, snapshot_id)
-        return AzureVolume(self.provider, volume)
+        zone_id = zone.id if isinstance(zone, PlacementZone) else zone
+        snapshot_id = snapshot.id if isinstance(snapshot, Snapshot) and snapshot else snapshot
+        azure_vol =  self.provider.azure_client.create_empty_disk(name, size, zone_id, snapshot_id)
+
+        cb_vol=AzureVolume(self.provider, azure_vol)
+        if description:
+            cb_vol.description = description
+
+        return cb_vol

integration_test/__init__.py

@@ -29,10 +29,12 @@ import cloudbridge
 from integration_test.helpers import ProviderTestCaseGenerator
 from integration_test.test_integration_azure_object_store_service import AzureIntegrationObjectStoreServiceTestCase
 from integration_test.test_integration_azure_security_group import AzureIntegrationSecurityServiceTestCase
+from integration_test.test_integration_azure_volume_service import AzureIntegrationVolumeServiceTestCase
 
 PROVIDER_TESTS ={'azure': [
-     AzureIntegrationObjectStoreServiceTestCase,
-    AzureIntegrationSecurityServiceTestCase
+    #AzureIntegrationObjectStoreServiceTestCase,
+    #AzureIntegrationSecurityServiceTestCase,
+    AzureIntegrationVolumeServiceTestCase
 ]}
 
 

integration_test/test_integration_azure_volume_service.py

@@ -0,0 +1,48 @@
+import os
+import tempfile
+import uuid
+
+import integration_test.helpers as helpers
+
+
+class AzureIntegrationVolumeServiceTestCase(helpers.ProviderTestBase):
+
+    def __init__(self, methodName, provider):
+        super(AzureIntegrationVolumeServiceTestCase, self).__init__(
+            methodName=methodName, provider=provider)
+
+    @helpers.skipIfNoService(['block_store'])
+    def test_azure_volume_service(self):
+        volume_name = '{0}'.format(uuid.uuid4())
+        snapshot_name = '{0}'.format(uuid.uuid4())
+
+        # volumes_count1 = len(self.provider.block_store.volumes.list())
+
+        volume = self.provider.block_store.volumes.create(volume_name, 1)
+        volume_id= volume.id
+        self.assertTrue(volume is not None , 'Volume {0} not created'.format(volume_name))
+
+        # volumes_count2 = len(self.provider.block_store.volumes.list())
+        # self.assertTrue(volumes_count2 > volumes_count1, 'Volume {0} not present in list'.format(volume_name))
+
+        # find_volume = self.provider.block_store.volumes.find(volume_name)
+        # self.assertTrue(len(find_volume) == 1, 'Volume {0} not found'.format(volume_name))
+
+        # get_volume = self.provider.block_store.volumes.get(volume.id)
+        # self.assertTrue(get_volume is not None, 'Unable to get the volume {0}'.format(volume_name))
+
+        volume.attach('/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Compute/virtualMachines/ubuntu-intro2')
+        #TODO: Add logic to verify that disk is attached to instance
+
+        volume.detach()
+        #TODO: Add logic to verify that disk is not in use
+
+        # snapshot = volume.create_snapshot(snapshot_name)
+        # self.assertTrue(snapshot is not None, 'Snapshot {0} not created'.format(snapshot_name))
+
+        volume.refresh()
+        self.assertTrue(volume.id == volume_id, 'Volume id should match on refresh')
+
+        volume.delete()
+        # deleted_volume = self.provider.block_store.volumes.get(volume.id)
+        # self.assertTrue(deleted_volume is None, 'Volume {0} not deleted'.format(volume_name))

setup.py

@@ -24,7 +24,12 @@ REQS_BASE = [
     'retrying>=1.3.3'
 ]
 REQS_AWS = ['boto3']
-REQS_AZURE = ['azure>=2.0.0rc6']
+REQS_AZURE = ['azure-common==1.1.5',
+'azure-mgmt-resource==1.0.0rc1',
+'azure-mgmt-compute==1.0.0rc1',
+'azure-mgmt-network==1.0.0rc1',
+'azure-mgmt-storage==1.0.0rc1',
+'azure-storage==0.34.0']
 REQS_OPENSTACK = [
     'openstacksdk',
     'python-novaclient>=7.0.0',

test/test_azure_object_store_service.py

@@ -15,12 +15,10 @@ class AzureObjectStoreServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['object_store'])
     def test_azure_bucket_create(self):
-        container_name = "container3"
-        container = self.provider.object_store.create(container_name)
-        print(container)
-        self.assertTrue(
-            container.name == container_name,
-            "Name of the container should be {0}".format(container_name))
+        container = self.provider.object_store.create("container3")
+        print("Create - " + str(container))
+        self.assertEqual(
+            str(container) , "<CB-AzureBucket: container3>")
 
     @helpers.skipIfNoService(['object_store'])
     def test_azure_bucket_list(self):
@@ -31,7 +29,7 @@ class AzureObjectStoreServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['object_store'])
     def test_azure_bucket_find_Exist(self):
-        container = self.provider.object_store.find("container1")
+        container = self.provider.object_store.find("container")
         print("Find Exist - " + str(container))
         self.assertEqual(
             len(container) ,1)
@@ -39,7 +37,7 @@ class AzureObjectStoreServiceTestCase(ProviderTestBase):
     @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("container3")
+        container = self.provider.object_store.find("container23")
         print("Find Not Exist - " + str(container))
         self.assertEqual(
             len(container), 0)
@@ -58,3 +56,124 @@ class AzureObjectStoreServiceTestCase(ProviderTestBase):
         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, None)
+
+    @helpers.skipIfNoService(['object_store'])
+    def test_azure_bucket_create_object(self):
+        containers = self.provider.object_store.find("container1")
+        cont = containers[0]
+        contDel = cont.create_object("block1")
+        print("Create object  - " + str(contDel))
+        self.assertEqual(
+            str(contDel), '<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), 2)
+
+
+    @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(
+            str(content),'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(), '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()), 2)
+
+
+    @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(), 'blob2Content')
+
+
+    @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')
+

test/test_azure_provider.py

@@ -0,0 +1,36 @@
+import json
+import unittest
+import uuid
+
+from cloudbridge.cloud.interfaces import TestMockHelperMixin
+
+from test.helpers import ProviderTestBase
+import test.helpers as helpers
+
+
+class AzureProviderTestCase(ProviderTestBase):
+    def __init__(self, methodName, provider):
+        super(AzureProviderTestCase, self).__init__(
+            methodName=methodName, provider=provider)
+
+    def test_azure_provider(self):
+        with self.assertRaises(Exception):
+            compute = self.provider.compute
+            self.assertTrue(compute is not None, 'Compute should not be None')
+
+        with self.assertRaises(Exception):
+            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')
+

test/test_azure_resource_group.py

@@ -22,7 +22,7 @@ class AzureResourceGroupTestCase(ProviderTestBase):
             "Resource Group should be Cloudbridge")
 
     def test_resource_group_get(self):
-        rg = self.provider._azure_client.get_resource_group(self.provider.resource_group)
+        rg = self.provider._azure_client.get_resource_group('MyGroup')
         print("Get Resource - " + str(rg))
         self.assertTrue(
             rg.name == "testResourceGroup",

test/test_azure_security_service.py

@@ -12,18 +12,25 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
     def __init__(self, methodName, provider):
         super(AzureSecurityServiceTestCase, self).__init__(
             methodName=methodName, provider=provider)
+        self.key_pairs = self.provider.security.key_pairs
+        self.security_groups = self.provider.security.security_groups
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_create(self):
         name = "testCreateSecGroup3"
-        sg = self.provider.security.security_groups.create(
+        sg = self.security_groups.create(
             name=name, description=name, network_id="")
         print("Create( " + "Name-" + sg.name + "  Id-" + sg.id + " Rules - " + str(sg.rules) + " )")
         self.assertEqual(name, sg.name)
 
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_find(self):
+        with self.assertRaises(NotImplementedError):
+            sgs = self.security_groups.find("mygroup")
+
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_list(self):
-        sgl = self.provider.security.security_groups.list()
+        sgl = self.security_groups.list()
         found_sg = [g.name for g in sgl]
         for group in sgl:
             print("List( " + "Name-" + group.name + "  Id-" + group.id + " Rules - " + " )")
@@ -33,15 +40,15 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_get_found(self):
-        sgl = self.provider.security.security_groups.get("sg3")
+        sgl = self.security_groups.get("/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg3")
         print("Get ( " + "Name - " + sgl.name + "  Id - " + sgl.id + " )")
         self.assertTrue(
-            sgl.name == "sec_group3",
-            "SG name should be sec_group2")
+            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")
+        sgl = self.security_groups.get("/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg4")
         print(str(sgl))
         self.assertTrue(
             sgl == None,
@@ -49,18 +56,18 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_delete_IdExists(self):
-        sg = self.provider.security.security_groups.delete("sg2")
+        sg = self.security_groups.delete("/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg2")
         print("Delete - ")
         self.assertEqual(sg, True)
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_delete_IdNotExist(self):
-        sg = self.provider.security.security_groups.delete("sg5")
+        sg = self.security_groups.delete("/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers/Microsoft.Network/networkSecurityGroups/sg5")
         self.assertEqual(sg, False)
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_rule_create(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rules = cb.rules
         for rule in rules:
@@ -73,7 +80,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_rule_delete(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rules = cb.rules
         print("Before deleting Rule -  " + str(rules[0]) + " length - " + str(len(rules)))
@@ -84,7 +91,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_rule_delete_Default(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rules = cb.rules
         print("Before deleting Rule -  " + str(rules[0]) + " length - " + str(len(rules)))
@@ -94,7 +101,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_rule_get_exist(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rule = cb.get_rule('*', '25', '1', '100')
         print("Get Rule -  " + str(rule))
@@ -102,7 +109,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_rule_get_notExist(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rule = cb.get_rule('*', '25', '1', '1')
         print("Get Rule -  " + str(rule))
@@ -110,7 +117,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_to_json(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rule = cb.to_json()
         print("Get Rule -  " + str(rule))
@@ -118,7 +125,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_rule_to_json(self):
-        list = self.provider.security.security_groups.list()
+        list = self.security_groups.list()
         cb = list.data[0]
         rules = cb.rules
         rule = rules[0]

test/test_azure_volume_service.py

@@ -0,0 +1,39 @@
+import json
+import unittest
+import uuid
+
+from cloudbridge.cloud.interfaces import TestMockHelperMixin
+
+from test.helpers import ProviderTestBase
+import test.helpers as helpers
+
+
+class AzureVolumeServiceTestCase(ProviderTestBase):
+    def __init__(self, methodName, provider):
+        super(AzureVolumeServiceTestCase, self).__init__(
+            methodName=methodName, provider=provider)
+        self.snapshots = self.provider.block_store.snapshots
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_create(self):
+        volume = self.provider.block_store.volumes.create("MyVolume",1, description='My volume')
+        print("Create - " + str(volume))
+        self.assertTrue(
+            volume.name == "MyVolume" , "Volume name should be MyVolume")
+
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_get(self):
+        with self.assertRaises(NotImplementedError):
+            volume = self.provider.block_store.volumes.get("MyVolume")
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_find(self):
+        with self.assertRaises(NotImplementedError):
+            volumes = self.provider.block_store.volumes.find("MyVolume")
+
+    @helpers.skipIfNoService(['block_store.volumes'])
+    def test_azure_volume_list(self):
+        with self.assertRaises(NotImplementedError):
+            volumes = self.provider.block_store.volumes.list()
+