List implementation by resource group

Find by prefix
Flake8 coding style implementation

azure_integration_test/helpers.py

@@ -163,11 +163,12 @@ def delete_test_instance(instance):
 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:
+                        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):
+            with cleanup_action(
+                    lambda:
+                    security_group.delete() if security_group else None):
                 delete_test_instance(instance)
 
 
@@ -192,12 +193,13 @@ class ProviderTestBase(unittest.TestCase):
     def create_provider_instance(self):
         provider_name = os.environ.get("CB_TEST_PROVIDER", "aws")
         use_mock_drivers = parse_bool(
-            os.environ.get("CB_USE_MOCK_PROVIDERS", "True"))
+            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)}
+        config = {
+            'default_wait_interval':
+                self.get_provider_wait_interval(provider_class)}
         return provider_class(config)
 
     @property

cloudbridge/cloud/providers/azure/azure_client.py

@@ -22,11 +22,15 @@ class AzureClient(object):
             tenant=config.get('azure_tenant')
         )
 
-        self._resource_client = ResourceManagementClient(credentials, self.subscription_id)
-        self._storage_client = StorageManagementClient(credentials, self.subscription_id)
-        self._network_management_client = NetworkManagementClient(credentials, self.subscription_id)
+        self._resource_client = ResourceManagementClient(credentials,
+                                                         self.subscription_id)
+        self._storage_client = StorageManagementClient(credentials,
+                                                       self.subscription_id)
+        self._network_management_client = NetworkManagementClient(
+            credentials, self.subscription_id)
         self._subscription_client = SubscriptionClient(credentials)
-        self._compute_client = ComputeManagementClient(credentials, self.subscription_id)
+        self._compute_client = ComputeManagementClient(credentials,
+                                                       self.subscription_id)
 
         self._access_key_result = None
         self._block_blob_service = None
@@ -36,8 +40,8 @@ class AzureClient(object):
     @property
     def access_key_result(self):
         if not self._access_key_result:
-            self._access_key_result = self.storage_client.storage_accounts.list_keys(self.resource_group_name,
-                                                                                     self.storage_account_name)
+            self._access_key_result = self.storage_client.storage_accounts. \
+                list_keys(self.resource_group_name, self.storage_account_name)
         return self._access_key_result
 
     @property
@@ -75,48 +79,60 @@ class AzureClient(object):
     @property
     def blob_service(self):
         if not self._block_blob_service:
-            self._block_blob_service = BlockBlobService(self.storage_account_name, self.access_key_result.keys[0].value)
+            self._block_blob_service = BlockBlobService(
+                self.storage_account_name,
+                self.access_key_result.keys[0].value)
         return self._block_blob_service
 
     def get_resource_group(self, name):
         return self.resource_client.resource_groups.get(name)
 
     def create_resource_group(self, name, parameters):
-        return self.resource_client.resource_groups.create_or_update(name, parameters)
+        return self.resource_client.resource_groups. \
+            create_or_update(name, parameters)
 
     def get_storage_account(self, storage_account_name):
-        return self.storage_client.storage_accounts.get_properties(self.resource_group_name, storage_account_name)
+        return self.storage_client.storage_accounts. \
+            get_properties(self.resource_group_name, storage_account_name)
 
     def create_storage_account(self, name, params):
-        return self.storage_client.storage_accounts.create(self.resource_group_name, name, params).result()
+        return self.storage_client.storage_accounts. \
+            create(self.resource_group_name, name, params).result()
 
     def list_locations(self):
-        return self.subscription_client.subscriptions.list_locations(self.subscription_id)
+        return self.subscription_client.subscriptions. \
+            list_locations(self.subscription_id)
 
     def list_security_group(self):
-        return self.network_management_client.network_security_groups.list(self.resource_group_name)
+        return self.network_management_client.network_security_groups. \
+            list(self.resource_group_name)
 
     def create_security_group(self, name, parameters):
-        return self.network_management_client.network_security_groups.create_or_update(self.resource_group_name,
-                                                                                       name, parameters).result()
+        return self.network_management_client.network_security_groups. \
+            create_or_update(self.resource_group_name, name,
+                             parameters).result()
 
-    def create_security_group_rule(self, security_group, rule_name, parameters):
-        return self.network_management_client.security_rules.create_or_update(self.resource_group_name, security_group,
-                                                                              rule_name, parameters).result()
+    def create_security_group_rule(self, security_group,
+                                   rule_name, parameters):
+        return self.network_management_client.security_rules. \
+            create_or_update(self.resource_group_name, security_group,
+                             rule_name, parameters).result()
 
     def delete_security_group_rule(self, name, security_group):
-        return self.network_management_client.security_rules.delete(self.resource_group_name, security_group,
-                                                                    name).result()
+        return self.network_management_client.security_rules. \
+            delete(self.resource_group_name, security_group, name).result()
 
     def get_security_group(self, name):
-        return self.network_management_client.network_security_groups.get(self.resource_group_name, name)
+        return self.network_management_client.network_security_groups. \
+            get(self.resource_group_name, name)
 
     def delete_security_group(self, name):
-        delete_async = self.network_management_client.network_security_groups.delete(self.resource_group_name, name)
+        delete_async = self.network_management_client.network_security_groups. \
+            delete(self.resource_group_name, name)
         delete_async.wait()
 
-    def list_containers(self):
-        return self.blob_service.list_containers()
+    def list_containers(self, prefix=None):
+        return self.blob_service.list_containers(prefix=prefix)
 
     def create_container(self, container_name):
         self.blob_service.create_container(container_name)
@@ -128,17 +144,19 @@ class AzureClient(object):
     def delete_container(self, container_name):
         self.blob_service.delete_container(container_name)
 
-    def list_blobs(self, container_name):
-        return self.blob_service.list_blobs(container_name)
+    def list_blobs(self, container_name, prefix=None):
+        return self.blob_service.list_blobs(container_name, prefix=prefix)
 
     def get_blob(self, container_name, blob_name):
         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)
+        self.blob_service.create_blob_from_text(container_name,
+                                                blob_name, text)
 
     def create_blob_from_file(self, container_name, blob_name, file_path):
-        self.blob_service.create_blob_from_path(container_name, blob_name, file_path)
+        self.blob_service.create_blob_from_path(container_name,
+                                                blob_name, file_path)
 
     def delete_blob(self, container_name, blob_name):
         self.blob_service.delete_blob(container_name, blob_name)
@@ -148,12 +166,15 @@ class AzureClient(object):
 
     def get_blob_content(self, container_name, blob_name):
         out_stream = BytesIO()
-        self.blob_service.get_blob_to_stream(container_name, blob_name, out_stream)
+        self.blob_service.get_blob_to_stream(container_name,
+                                             blob_name, out_stream)
         return out_stream
 
-    def create_empty_disk(self, disk_name, size, region=None, snapshot_id=None):
+    def create_empty_disk(self, disk_name, size,
+                          region=None, snapshot_id=None):
         if snapshot_id:
-            return self.create_snapshot_disk(disk_name, snapshot_id, region=region)
+            return self.create_snapshot_disk(disk_name,
+                                             snapshot_id, region=region)
 
         async_creation = self.compute_client.disks.create_or_update(
             self.resource_group_name,
@@ -186,13 +207,16 @@ class AzureClient(object):
         return disk_response
 
     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)
 
     def list_disks(self):
-        return self.compute_client.disks.list()
+        return self.compute_client.disks. \
+            list_by_resource_group(self.resource_group_name)
 
     def delete_disk(self, disk_name):
-        async_deletion = self.compute_client.disks.delete(self.resource_group_name, disk_name)
+        async_deletion = self.compute_client.disks. \
+            delete(self.resource_group_name, disk_name)
         async_deletion.wait()
 
     def attach_disk(self, vm_name, disk_name, disk_id):
@@ -219,7 +243,9 @@ class AzureClient(object):
 
     def detach_disk(self, disk_id):
         virtual_machine = None
-        for index, vm in enumerate(self.compute_client.virtual_machines.list_all()):
+        for index, vm in enumerate(
+                self.compute_client.virtual_machines.list(
+                    self.resource_group_name)):
             for index, item in enumerate(vm.storage_profile.data_disks):
                 if item.managed_disk and item.managed_disk.id == disk_id:
                     vm.storage_profile.data_disks.remove(item)
@@ -227,7 +253,7 @@ class AzureClient(object):
                 break
 
         if virtual_machine:
-            async_update = self.compute_client.virtual_machines.create_or_update(
+            self.compute_client.virtual_machines.create_or_update(
                 self.resource_group_name,
                 virtual_machine.name,
                 virtual_machine,

cloudbridge/cloud/providers/azure/mock_azure_client.py

@@ -12,14 +12,16 @@ from requests import Response
 
 
 class MockAzureClient:
-    sg_rule1 = SecurityRule(protocol='*', source_address_prefix='100', destination_address_prefix="*", access="Allow",
+    sg_rule1 = SecurityRule(protocol='*', source_address_prefix='100',
+                            destination_address_prefix="*", access="Allow",
                             direction="Inbound")
     sg_rule1.name = "rule1"
     sg_rule1.id = "r1"
     sg_rule1.destination_port_range = "*"
     sg_rule1.source_port_range = "25-1"
 
-    sg_rule2 = SecurityRule(protocol='*', source_address_prefix='100', destination_address_prefix="*", access="Allow",
+    sg_rule2 = SecurityRule(protocol='*', source_address_prefix='100',
+                            destination_address_prefix="*", access="Allow",
                             direction="Inbound")
     sg_rule2.name = "rule2"
     sg_rule2.id = "r2"
@@ -73,7 +75,8 @@ class MockAzureClient:
     rg.name = "testResourceGroup"
 
     volume1 = Disk(location='eastus', creation_data=None)
-    volume1.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CLOUDBRIDGE-AZURE' \
+    volume1.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/' \
+                 'resourceGroups/CLOUDBRIDGE-AZURE' \
                  '/providers/Microsoft.Compute/disks/Volume1'
     volume1.name = "Volume1"
     volume1.disk_size_gb = 1
@@ -83,7 +86,8 @@ class MockAzureClient:
     volume1.provisioning_state = 'InProgress'
 
     volume2 = Disk(location='eastus', creation_data=None)
-    volume2.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CLOUDBRIDGE-AZURE' \
+    volume2.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/' \
+                 'resourceGroups/CLOUDBRIDGE-AZURE' \
                  '/providers/Microsoft.Compute/disks/Volume2'
     volume2.name = "Volume2"
     volume2.disk_size_gb = 1
@@ -126,8 +130,10 @@ class MockAzureClient:
         response.status_code = 404
         raise CloudError(response=response, error='Resource Not found')
 
-    def create_security_group_rule(self, security_group, rule_name, parameters):
-        new_sg_rule = SecurityRule(protocol='*', source_address_prefix='100', destination_address_prefix="*",
+    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"
         new_sg_rule.id = "r1"
@@ -156,7 +162,13 @@ class MockAzureClient:
                 return container
         raise AzureException()
 
-    def list_containers(self):
+    def list_containers(self, prefix=None):
+        if (prefix is not None):
+            found_containers = []
+            for container in self.containers:
+                if prefix in container.name:
+                    found_containers.append(container)
+            return found_containers
         return self.containers
 
     def create_container(self, container_name):
@@ -180,7 +192,7 @@ class MockAzureClient:
                 return blob
         raise AzureException()
 
-    def list_blobs(self, container_name):
+    def list_blobs(self, container_name, prefix=None):
         return self.blocks.get(container_name)
 
     def get_blob_content(self, container_name, blob_name):
@@ -204,17 +216,22 @@ class MockAzureClient:
     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):
+    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' \
+        volume.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/' \
+                    'resourceGroups/cloudbridge-azure' \
                     '/providers/Microsoft.Compute/disks/{0}'.format(disk_name)
         volume.name = disk_name
         volume.disk_size_gb = size
-        volume.creation_data = CreationData(create_option=DiskCreateOption.empty)
+        volume.creation_data = CreationData(
+            create_option=DiskCreateOption.empty)
         volume.time_created = '01-01-2017'
         volume.provisioning_state = 'Succeeded'
-        volume.owner_id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure' \
-                          's/providers/Microsoft.Compute/virtualMachines/ubuntu-intro1'
+        volume.owner_id = \
+            '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/' \
+            'resourceGroups/CloudBridge-Azure' \
+            's/providers/Microsoft.Compute/virtualMachines/ubuntu-intro1'
         self.volumes.append(volume)
         return volume
 

cloudbridge/cloud/providers/azure/provider.py

@@ -8,7 +8,8 @@ from cloudbridge.cloud.interfaces import TestMockHelperMixin
 
 from cloudbridge.cloud.providers.azure.azure_client import AzureClient
 from cloudbridge.cloud.providers.azure.mock_azure_client import MockAzureClient
-from cloudbridge.cloud.providers.azure.services import AzureSecurityService, AzureObjectStoreService, \
+from cloudbridge.cloud.providers.azure.services \
+    import AzureSecurityService, AzureObjectStoreService, \
     AzureBlockStoreService
 
 log = logging.getLogger(__name__)
@@ -22,8 +23,9 @@ class AzureCloudProvider(BaseCloudProvider):
         self.cloud_type = 'azure'
 
         # mandatory config values
-        self.subscription_id = self._get_config_value(
-            'azure_subscription_id', os.environ.get('AZURE_SUBSCRIPTION_ID', None))
+        self.subscription_id = self. \
+            _get_config_value('azure_subscription_id',
+                              os.environ.get('AZURE_SUBSCRIPTION_ID', None))
         self.client_Id = self._get_config_value(
             'azure_client_Id', os.environ.get('AZURE_CLIENT_ID', None))
         self.secret = self._get_config_value(
@@ -33,14 +35,18 @@ class AzureCloudProvider(BaseCloudProvider):
 
         # optional config values
         self.region_name = self._get_config_value(
-            'azure_region_name', os.environ.get('AZURE_REGION_NAME', 'eastus'))
+            'azure_region_name', os.environ.get('AZURE_REGION_NAME',
+                                                'eastus'))
         self.resource_group = self._get_config_value(
-            'azure_resource_group', os.environ.get('AZURE_RESOURCE_GROUP', 'cloudbridge-azure'))
+            'azure_resource_group', os.environ.get('AZURE_RESOURCE_GROUP',
+                                                   'cloudbridge-azure'))
 
         self.storage_account_name = self._get_config_value(
-            'azure_storage_account_name', os.environ.get('AZURE_STORAGE_ACCOUNT_NAME', 'cloudbridgeazure'))
+            'azure_storage_account_name', os.environ.get
+            ('AZURE_STORAGE_ACCOUNT_NAME', 'cloudbridgeazure'))
 
-        # create a dict with both optional and mandatory configuration values to pass to the azureclient class, rather
+        # create a dict with both optional and mandatory configuration values
+        # to pass to the azureclient class, rather
         # than passing the provider object and taking a dependency.
 
         self.allconfig = {'azure_subscription_id': self.subscription_id,
@@ -49,17 +55,19 @@ class AzureCloudProvider(BaseCloudProvider):
                           'azure_tenant': self.tenant,
                           'azure_region_name': self.region_name,
                           'azure_resource_group': self.resource_group,
-                          'azure_storage_account_name': self.storage_account_name}
+                          'azure_storage_account_name':
+                              self.storage_account_name}
 
         self._azure_client = azureclient or AzureClient(self.allconfig)
         try:
-            rg = self._azure_client.get_resource_group(self.resource_group)
+            self._azure_client.get_resource_group(self.resource_group)
         except CloudError:
             resource_group_params = {'location': self.region_name}
-            self._azure_client.create_resource_group(self.resource_group, resource_group_params)
+            self._azure_client.create_resource_group(self.resource_group,
+                                                     resource_group_params)
 
         try:
-            storage_account = self._azure_client.get_storage_account(self.storage_account_name)
+            self._azure_client.get_storage_account(self.storage_account_name)
         except CloudError:
             storage_account_params = {
                 'sku': {
@@ -68,7 +76,9 @@ class AzureCloudProvider(BaseCloudProvider):
                 'kind': 'storage',
                 'location': self.region_name,
             }
-            self._azure_client.create_storage_account(self.storage_account_name, storage_account_params)
+            self._azure_client. \
+                create_storage_account(self.storage_account_name,
+                                       storage_account_params)
 
         self._security = AzureSecurityService(self)
         self._object_store = AzureObjectStoreService(self)
@@ -103,7 +113,8 @@ class AzureCloudProvider(BaseCloudProvider):
 
 class MockAzureCloudProvider(AzureCloudProvider, TestMockHelperMixin):
     def __init__(self, config):
-        super(MockAzureCloudProvider, self).__init__(config, MockAzureClient(self))
+        super(MockAzureCloudProvider, self).__init__(config,
+                                                     MockAzureClient(self))
 
     def setUpMock(self):
         pass

cloudbridge/cloud/providers/azure/resources.py

@@ -3,43 +3,61 @@ DataTypes used by this provider
 """
 import inspect
 import json
-from datetime import datetime
 
 from cloudbridge.cloud.providers.azure import helpers as azure_helpers
 
-from azure.common import AzureMissingResourceHttpError, AzureException
+from azure.common import AzureException
 from msrestazure.azure_exceptions import CloudError
 
-from cloudbridge.cloud.base.resources import BaseBucket, BaseSecurityGroup, BaseSecurityGroupRule, BaseBucketObject, \
-    ClientPagedResultList, BaseVolume, BaseAttachmentInfo, BaseInstance, BaseSnapshot
-from cloudbridge.cloud.interfaces import VolumeState, SnapshotState, InstanceState
+from cloudbridge.cloud.base.resources import BaseBucket, BaseSecurityGroup, \
+    BaseSecurityGroupRule, BaseBucketObject, \
+    ClientPagedResultList, BaseVolume, BaseAttachmentInfo
+from cloudbridge.cloud.interfaces import VolumeState
 from cloudbridge.cloud.interfaces.resources import Instance
 
-NETWORK_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                      '/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}'
-IMAGE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                    '/providers/Microsoft.Compute/images/{imageName}'
-INSTANCE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                       '/providers/Microsoft.Compute/virtualMachines/{vmName}'
-VOLUME_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                     '/providers/Microsoft.Compute/disks/{diskName}'
-SNAPSHOT_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                       '/providers/Microsoft.Compute/snapshots/{snapshotName}'
-NETWORK_SECURITY_GROUP_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                                     '/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}'
-NETWORK_SECURITY_RULE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                                    '/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}' \
+NETWORK_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                      '{resourceGroupName}/providers/Microsoft.Network/' \
+                      'virtualNetworks/{virtualNetworkName}'
+IMAGE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                    '{resourceGroupName}/providers/Microsoft.Compute/' \
+                    'images/{imageName}'
+INSTANCE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                       '{resourceGroupName}/providers/Microsoft.Compute/' \
+                       'virtualMachines/{vmName}'
+VOLUME_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                     '{resourceGroupName}/providers/Microsoft.Compute/' \
+                     'disks/{diskName}'
+SNAPSHOT_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                       '{resourceGroupName}/providers/Microsoft.Compute/' \
+                       'snapshots/{snapshotName}'
+NETWORK_SECURITY_GROUP_RESOURCE_ID = '/subscriptions/{subscriptionId}/' \
+                                     'resourceGroups/{resourceGroupName}/' \
+                                     'providers/Microsoft.Network/' \
+                                     'networkSecurityGroups/' \
+                                     '{networkSecurityGroupName}'
+NETWORK_SECURITY_RULE_RESOURCE_ID = '/subscriptions/{subscriptionId}/' \
+                                    'resourceGroups/{resourceGroupName}/' \
+                                    'providers/Microsoft.Network/' \
+                                    'networkSecurityGroups/' \
+                                    '{networkSecurityGroupName}' \
                                     '/securityRules/{securityRuleName}'
-SUBNET_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                     '/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}'
-PUBLIC_IP_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                        '/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}'
-ROUTE_TABLE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                          '/providers/Microsoft.Network/routeTables/{routeTableName}'
-ROUTE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                    '/providers/Microsoft.Network/routeTables/{routeTableName}/routes/{routeName}'
-NETWORK_INTERFACE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}' \
-                                '/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}'
+SUBNET_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                     '{resourceGroupName}/providers/Microsoft.Network' \
+                     '/virtualNetworks/{virtualNetworkName}/subnets' \
+                     '/{subnetName}'
+PUBLIC_IP_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups' \
+                        '/{resourceGroupName}/providers/Microsoft.Network' \
+                        '/publicIPAddresses/{publicIpAddressName}'
+ROUTE_TABLE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups' \
+                          '/{resourceGroupName}/providers/Microsoft.Network' \
+                          '/routeTables/{routeTableName}'
+ROUTE_RESOURCE_ID = '/subscriptions/{subscriptionId}/resourceGroups/' \
+                    '{resourceGroupName}/providers/Microsoft.Network' \
+                    '/routeTables/{routeTableName}/routes/{routeName}'
+NETWORK_INTERFACE_RESOURCE_ID = '/subscriptions/{subscriptionId}/' \
+                                'resourceGroups/{resourceGroupName}' \
+                                '/providers/Microsoft.Network/' \
+                                'networkInterfaces/{networkInterfaceName}'
 
 RESOURCE_GROUP_NAME = 'resourceGroupName'
 SUBSCRIPTION_ID = 'subscriptionId'
@@ -78,7 +96,8 @@ class AzureSecurityGroup(BaseSecurityGroup):
     def rules(self):
         security_group_rules = []
         for custom_rule in self._security_group.security_rules:
-            sg_custom_rule = AzureSecurityGroupRule(self._provider, custom_rule, self)
+            sg_custom_rule = AzureSecurityGroupRule(self._provider,
+                                                    custom_rule, self)
             security_group_rules.append(sg_custom_rule)
         return security_group_rules
 
@@ -114,10 +133,11 @@ class AzureSecurityGroup(BaseSecurityGroup):
         if not cidr_ip:
             cidr_ip = '0.0.0.0/0'
 
-        rule = self.get_rule(ip_protocol, from_port, to_port, cidr_ip, src_group)
+        rule = self.get_rule(ip_protocol, from_port,
+                             to_port, cidr_ip, src_group)
         if not rule:
             security_group = self._security_group.name
-            resource_group = self._provider.resource_group
+            # resource_group = self._provider.resource_group
             count = len(self.rules) + 1
             rule_name = "Rule - " + str(count)
             priority = count * 100
@@ -125,11 +145,18 @@ class AzureSecurityGroup(BaseSecurityGroup):
             destination_address_prefix = "*"
             access = "Allow"
             direction = "Inbound"
-            parameters = {"protocol": ip_protocol, "source_port_range": str(from_port) + "-" + str(to_port),
-                          "destination_port_range": destination_port_range, "priority": priority,
-                          "source_address_prefix": cidr_ip, "destination_address_prefix": destination_address_prefix,
+            parameters = {"protocol": ip_protocol,
+                          "source_port_range":
+                              str(from_port) + "-" + str(to_port),
+                          "destination_port_range": destination_port_range,
+                          "priority": priority,
+                          "source_address_prefix": cidr_ip,
+                          "destination_address_prefix":
+                              destination_address_prefix,
                           "access": access, "direction": direction}
-            result = self._provider.azure_client.create_security_group_rule(security_group, rule_name, parameters)
+            result = self._provider.azure_client. \
+                create_security_group_rule(security_group,
+                                           rule_name, parameters)
             self._security_group.security_rules.append(result)
             return AzureSecurityGroupRule(self._provider, result, self)
 
@@ -204,7 +231,8 @@ class AzureSecurityGroupRule(BaseSecurityGroupRule):
 
     def delete(self):
         security_group = self.parent.name
-        sro = self._provider.azure_client.delete_security_group_rule(self.name, security_group)
+        self._provider.azure_client. \
+            delete_security_group_rule(self.name, security_group)
         for i, o in enumerate(self.parent._security_group.security_rules):
             if o.name == self.name:
                 del self.parent._security_group.security_rules[i]
@@ -241,14 +269,16 @@ class AzureBucketObject(BaseBucketObject):
         """
         Get the date and time this object was last modified.
         """
-        return self._key.properties.last_modified.strftime("%Y-%m-%dT%H:%M:%S.%f")
+        return self._key.properties.last_modified. \
+            strftime("%Y-%m-%dT%H:%M:%S.%f")
 
     def iter_content(self):
         """
         Returns this object's content as an
         iterable.
         """
-        content_stream = self._provider.azure_client.get_blob_content(self._container.name, self._key.name)
+        content_stream = self._provider.azure_client. \
+            get_blob_content(self._container.name, self._key.name)
         if content_stream:
             content_stream.seek(0)
         return content_stream
@@ -259,7 +289,8 @@ class AzureBucketObject(BaseBucketObject):
         string.
         """
         try:
-            self._provider.azure_client.create_blob_from_text(self._container.name, self.name, data)
+            self._provider.azure_client.create_blob_from_text(
+                self._container.name, self.name, data)
             return True
         except AzureException:
             return False
@@ -269,7 +300,8 @@ class AzureBucketObject(BaseBucketObject):
         Store the contents of the file pointed by the "path" variable.
         """
         try:
-            self._provider.azure_client.create_blob_from_file(self._container.name, self.name, path)
+            self._provider.azure_client.create_blob_from_file(
+                self._container.name, self.name, path)
             return True
         except AzureException:
             return False
@@ -282,7 +314,8 @@ class AzureBucketObject(BaseBucketObject):
         :return: True if successful
         """
         try:
-            self._provider.azure_client.delete_blob(self._container.name, self.name)
+            self._provider.azure_client.delete_blob(
+                self._container.name, self.name)
             return True
         except AzureException:
             return False
@@ -291,7 +324,8 @@ class AzureBucketObject(BaseBucketObject):
         """
         Generate a URL to this object.
         """
-        return self._provider.azure_client.get_blob_url(self._container.name, self.name)
+        return self._provider.azure_client.get_blob_url(
+            self._container.name, self.name)
 
 
 class AzureBucket(BaseBucket):
@@ -328,8 +362,9 @@ class AzureBucket(BaseBucket):
         :return: List of all available BucketObjects within this bucket.
         """
         objects = [AzureBucketObject(self._provider, self, obj)
-                   for obj in self._provider.azure_client.list_blobs(self.name) if
-                   not prefix or prefix and obj.name.startswith(prefix)]
+                   for obj in
+                   self._provider.azure_client.list_blobs(
+                       self.name, prefix=prefix)]
         return ClientPagedResultList(self._provider, objects,
                                      limit=limit, marker=marker)
 
@@ -344,7 +379,8 @@ class AzureBucket(BaseBucket):
             return False
 
     def create_object(self, name):
-        obj = self._provider.azure_client.create_blob_from_text(self.name, name, '')
+        self._provider.azure_client.create_blob_from_text(
+            self.name, name, '')
         return self.get(name)
 
     def exists(self, name):
@@ -424,7 +460,8 @@ class AzureVolume(BaseVolume):
     @property
     def source(self):
         if self._volume.creation_data.source_uri:
-            return self._provider.block_store.snapshots.get(self._volume.creation_data.source_uri)
+            return self._provider.block_store.snapshots. \
+                get(self._volume.creation_data.source_uri)
         return None
 
     @property
@@ -444,8 +481,10 @@ class AzureVolume(BaseVolume):
             instance_id = instance.id if isinstance(
                 instance,
                 Instance) else instance
-            params = azure_helpers.parse_url(INSTANCE_RESOURCE_ID, instance_id)
-            self._provider.azure_client.attach_disk(params.get(VM_NAME), self.name, self.id)
+            params = azure_helpers.parse_url(INSTANCE_RESOURCE_ID,
+                                             instance_id)
+            self._provider.azure_client.attach_disk(params.get(VM_NAME),
+                                                    self.name, self.id)
             return True
         except CloudError:
             return False

cloudbridge/cloud/providers/azure/services.py

@@ -1,17 +1,16 @@
 import logging
 
-from azure.common import AzureMissingResourceHttpError, AzureException
+from azure.common import AzureException
 from msrestazure.azure_exceptions import CloudError
 
-from cloudbridge.cloud.interfaces.resources import PlacementZone, Snapshot, Volume
+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, \
-    AzureVolume
+from .resources import VOLUME_RESOURCE_ID, VOLUME_NAME, \
+    NETWORK_SECURITY_GROUP_RESOURCE_ID, SECURITY_GROUP_NAME, AzureVolume
 
 from cloudbridge.cloud.base.resources import ClientPagedResultList
-from cloudbridge.cloud.base.services import BaseObjectStoreService, BaseSecurityGroupService, BaseSecurityService, \
+from cloudbridge.cloud.base.services import BaseObjectStoreService, \
+    BaseSecurityGroupService, BaseSecurityService, \
     BaseVolumeService, BaseBlockStoreService, BaseSnapshotService
 
 from cloudbridge.cloud.providers.azure import helpers as azure_helpers
@@ -37,7 +36,8 @@ class AzureSecurityService(BaseSecurityService):
         :rtype: ``object`` of :class:`.KeyPairService`
         :return: a KeyPairService object
         """
-        raise NotImplementedError('AzureSecurityService not implemented this property')
+        raise NotImplementedError('AzureSecurityService '
+                                  'not implemented this property')
 
     @property
     def security_groups(self):
@@ -56,8 +56,10 @@ class AzureSecurityGroupService(BaseSecurityGroupService):
 
     def get(self, sg_id):
         try:
-            params = azure_helpers.parse_url(NETWORK_SECURITY_GROUP_RESOURCE_ID, sg_id)
-            sgs = self.provider.azure_client.get_security_group(params.get(SECURITY_GROUP_NAME))
+            params = azure_helpers.parse_url(
+                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)
 
         except CloudError as cloudError:
@@ -92,8 +94,10 @@ class AzureSecurityGroupService(BaseSecurityGroupService):
                                      limit=limit, marker=marker)
 
     def delete(self, group_id):
-        params = azure_helpers.parse_url(NETWORK_SECURITY_GROUP_RESOURCE_ID, group_id)
-        return self.provider.azure_client.delete_security_group(params.get(SECURITY_GROUP_NAME))
+        params = azure_helpers.parse_url(NETWORK_SECURITY_GROUP_RESOURCE_ID,
+                                         group_id)
+        return self.provider.azure_client.delete_security_group(
+            params.get(SECURITY_GROUP_NAME))
 
 
 class AzureObjectStoreService(BaseObjectStoreService):
@@ -117,9 +121,9 @@ class AzureObjectStoreService(BaseObjectStoreService):
         """
         Searches for a bucket by a given list of attributes.
         """
-        filters = {'name': name}
         buckets = [AzureBucket(self.provider, bucket)
-                   for bucket in azure_helpers.filter(self.provider.azure_client.list_containers(), filters)]
+                   for bucket in
+                   self.provider.azure_client.list_containers(prefix=name)]
         return ClientPagedResultList(self.provider, buckets,
                                      limit=limit, marker=marker)
 
@@ -164,7 +168,8 @@ class AzureVolumeService(BaseVolumeService):
     def get(self, volume_id):
         try:
             params = azure_helpers.parse_url(VOLUME_RESOURCE_ID, volume_id)
-            volume = self.provider.azure_client.get_disk(params.get(VOLUME_NAME))
+            volume = self.provider.azure_client.get_disk(
+                params.get(VOLUME_NAME))
             return AzureVolume(self.provider, volume)
         except CloudError as cloudError:
             log.exception(cloudError.message)
@@ -176,7 +181,8 @@ class AzureVolumeService(BaseVolumeService):
         """
         filters = {'name': name}
         cb_vols = [AzureVolume(self.provider, volume)
-                   for volume in azure_helpers.filter(self.provider.azure_client.list_disks(), filters)]
+                   for volume in azure_helpers.filter(
+                self.provider.azure_client.list_disks(), filters)]
         return ClientPagedResultList(self.provider, cb_vols,
                                      limit=limit, marker=marker)
 
@@ -188,8 +194,10 @@ class AzureVolumeService(BaseVolumeService):
 
     def create(self, name, size, zone=None, snapshot=None, description=None):
         zone_id = zone.id if isinstance(zone, PlacementZone) else zone
-        snapshot_id = snapshot.id if isinstance(snapshot, Snapshot) and snapshot else snapshot
-        self.provider.azure_client.create_empty_disk(name, size, zone_id, snapshot_id)
+        snapshot_id = snapshot.id if isinstance(
+            snapshot, Snapshot) and snapshot else snapshot
+        self.provider.azure_client.create_empty_disk(
+            name, size, zone_id, snapshot_id)
         azure_vol = self.provider.azure_client.get_disk(name)
         cb_vol = AzureVolume(self.provider, azure_vol)
         if description:
@@ -203,13 +211,17 @@ class AzureSnapshotService(BaseSnapshotService):
         super(AzureSnapshotService, self).__init__(provider)
 
     def get(self, ss_id):
-        raise NotImplementedError('AzureSnapShotService not implemented this method')
+        raise NotImplementedError('AzureSnapShotService not '
+                                  'implemented this method')
 
     def find(self, name, limit=None, marker=None):
-        raise NotImplementedError('AzureSnapShotService not implemented this method')
+        raise NotImplementedError('AzureSnapShotService not '
+                                  'implemented this method')
 
     def list(self, limit=None, marker=None):
-        raise NotImplementedError('AzureSnapShotService not implemented this method')
+        raise NotImplementedError('AzureSnapShotService not '
+                                  'implemented this method')
 
     def create(self, name, volume, description=None):
-        raise NotImplementedError('AzureSnapShotService not implemented this method')
+        raise NotImplementedError('AzureSnapShotService not '
+                                  'implemented this method')

integration_test/test_integration_azure_object_store_service.py

@@ -14,37 +14,46 @@ class AzureIntegrationObjectStoreServiceTestCase(helpers.ProviderTestBase):
         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))
+        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))
+                        '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))
+        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))
+        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))
+        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))
+                        '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))
+        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))
+                        'Object {0} content should be {1}'.
+                        format(object_name, obj_content))
 
         file_name = 'mytest.txt'
         file_content = 'defaults'
@@ -60,7 +69,8 @@ class AzureIntegrationObjectStoreServiceTestCase(helpers.ProviderTestBase):
 
             content = obj.iter_content()
             self.assertTrue(content.getvalue().decode('utf-8') == file_content,
-                            'Object {0} content should be {1}'.format(object_name, file_content))
+                            'Object {0} content should be {1}'.
+                            format(object_name, file_content))
 
         finally:
             print('Deleting file')
@@ -72,8 +82,10 @@ class AzureIntegrationObjectStoreServiceTestCase(helpers.ProviderTestBase):
         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))
+                        '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))
+        self.assertTrue(deleted_container is None, 'Container {0} not deleted'.
+                        format(container_name))

integration_test/test_integration_azure_security_group.py

@@ -1,9 +1,5 @@
-import json
-import unittest
 import uuid
 
-from cloudbridge.cloud.interfaces import TestMockHelperMixin
-
 from azure_integration_test.helpers import ProviderTestBase
 import azure_integration_test.helpers as helpers
 
@@ -16,26 +12,29 @@ class AzureIntegrationSecurityServiceTestCase(ProviderTestBase):
 
         listBeforeCreate = self.provider.security.security_groups.list()
         print("Length Before create - " + str(len(listBeforeCreate)))
-        netId = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure'\
-        '/providers/Microsoft.Network/virtualNetworks/SampleNetwork"
-        sg = self.provider.security.security_groups.create(name=sg_name, description="testCreateSecGroup",
-                                                           network_id=netId)
+        # netId = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96
+        # /resourceGroups/CloudBridge-Azure'\
+        # '/providers/Microsoft.Network/virtualNetworks/SampleNetwork"
+        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(
             "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure/providers'\
-            '/Microsoft.Network/networkSecurityGroups/sampleSG")
+            '/Microsoft.Network/networkSecurityGroups/" + sg_name)
         print("Get SG - " + str(get))
         print(str(get.rules))
-        self.assertEqual(get.name, "sampleSG")
+        self.assertEqual(get.name, sg_name)
 
         get_notfound = self.provider.security.security_groups.get(
-            "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure'\
-            '/providers/Microsoft.Network/networkSecurityGroups/SecgrupDontFindMe")
+            "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96"
+            "/resourceGroups/cloudbridge-azure/providers/Microsoft.Network"
+            "/networkSecurityGroups/SecgrupDontFindMe")
         self.assertEqual(get_notfound, None)
 
         find_exists_list = self.provider.security.security_groups.find(sg_name)
@@ -45,44 +44,52 @@ class AzureIntegrationSecurityServiceTestCase(ProviderTestBase):
         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')
+        find_not_exists_list = self.provider.security.security_groups. \
+            find('dontfindme')
         self.assertTrue(find_not_exists_list.total_results == 0)
 
-        cb = listAfterCreate.data[0]
-        lenBeforeCreateRule = len(cb.rules)
-        cb.add_rule('tcp', '1111', '2222', '0.0.0.0/0')
-        lenAfterCreateRule = len(cb.rules)
+        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(str(cb.rules))
-        get_rule = cb.get_rule('tcp', '1111', '2222', '0.0.0.0/0')
+        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.assertEqual(str(get_rule), "<CBSecurityGroupRule: IP: tcp; from: 1111; to: 2222; grp: None>")
+        self.assertIsNotNone(get_rule)
 
-        get_rule_notfound = cb.get_rule('*', '25', '1', '1')
+        get_rule_notfound = sg.get_rule('*', '25', '1', '1')
         self.assertEqual(str(get_rule_notfound), 'None')
 
-        rule_json = cb.rules[1].to_json()
+        rule_json = sg.rules[0].to_json()
         print("Rule json - " + str(rule_json))
-        self.assertEqual(rule_json[2:9], "cidr_ip")
+        self.assertIsNotNone(rule_json)
 
-        sg_json = cb.to_json()
+        sg_json = sg.to_json()
         print("SG json - " + str(sg_json))
-        self.assertEqual(sg_json[2:4], "id")
-
-        with self.assertRaises(Exception):
-            cb.rules[1].delete()
+        self.assertIsNotNone(sg_json)
 
         listBeforeDeleteFound = self.provider.security.security_groups.list()
-        sg_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure/providers'\
-        '/Microsoft.Network/networkSecurityGroups/" + sg_name
-        sg_del = self.provider.security.security_groups.delete(sg_id)
+        sg_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96" \
+                "/resourceGroups/cloudbridge-azure/providers" \
+                "/Microsoft.Network/networkSecurityGroups/" + sg_name
+        self.provider.security.security_groups.delete(sg_id)
         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 = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure/providers'\
-        '/Microsoft.Network/networkSecurityGroups/sg5"
-        sg_del_notfound = self.provider.security.security_groups.delete(sg_id)
+        self.assertEqual(
+            len(listAfterDeleteFound), len(listBeforeDeleteFound) - 1)
+        sg_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96" \
+                "/resourceGroups/cloudbridge-azure/providers" \
+                "/Microsoft.Network/networkSecurityGroups/sg5"
+        self.provider.security.security_groups.delete(sg_id)
         listAfterDeleteNotFound = self.provider.security.security_groups.list()
-        self.assertEqual(len(listAfterDeleteNotFound), len(listAfterDeleteFound))
+        self.assertEqual(
+            len(listAfterDeleteNotFound), len(listAfterDeleteFound))

integration_test/test_integration_azure_volume_service.py

@@ -1,5 +1,3 @@
-import os
-import tempfile
 import uuid
 
 import azure_integration_test.helpers as helpers
@@ -22,7 +20,8 @@ class AzureIntegrationVolumeServiceTestCase(helpers.ProviderTestBase):
         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)
+        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))
@@ -40,11 +39,13 @@ class AzureIntegrationVolumeServiceTestCase(helpers.ProviderTestBase):
         # TODO: Add logic to verify that disk is not in use
 
         with self.assertRaises(NotImplementedError):
-            snapshot = volume.create_snapshot(snapshot_name)
-        # self.assertTrue(snapshot is not None, 'Snapshot {0} not created'.format(snapshot_name))
+            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')
+        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)))
@@ -53,5 +54,5 @@ class AzureIntegrationVolumeServiceTestCase(helpers.ProviderTestBase):
 
         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)
+        self.assertTrue(len(volume_list_after_delete),
+                        len(volume_list_before_delete) - 1)

test/test_azure_helpers.py

@@ -4,12 +4,14 @@ from cloudbridge.cloud.providers.azure import helpers as azure_helpers
 
 class AzureHelpersTestCase(ProviderTestBase):
     def test_parse_url_valid(self):
-        params = azure_helpers.parse_url('/subscriptionId/{subscriptionId}', '/subscriptionId/123-1345')
+        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):
-            params = azure_helpers.parse_url('/subscriptionId/{subscriptionId}', '/123-1345')
+            azure_helpers.parse_url('/subscriptionId/{subscriptionId}',
+                                    '/123-1345')
 
     def test_filter_matched(self):
         ex1 = Expando()

test/test_azure_object_store_service.py

@@ -160,4 +160,5 @@ class AzureObjectStoreServiceTestCase(ProviderTestBase):
         url = block.generate_url()
         print(str(url))
         self.assertEqual(
-            str(url), 'https://cloudbridgeazure.blob.core.windows.net/vhds/block1')
+            str(url),
+            'https://cloudbridgeazure.blob.core.windows.net/vhds/block1')

test/test_azure_provider.py

@@ -12,13 +12,16 @@ class AzureProviderTestCase(ProviderTestBase):
             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')
+        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')
+        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')
+        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

@@ -4,7 +4,9 @@ from 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)
+        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-azure",

test/test_azure_security_service.py

@@ -13,7 +13,7 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
         name = "testCreateSecGroup3"
         sg = self.provider.security.security_groups.create(
             name=name, description=name, network_id="")
-        print("Create( " + "Name-" + sg.name + "  Id-" + sg.id + " Rules - " + str(sg.rules) + " )")
+        print("Create - " + str(sg))
         self.assertEqual(name, sg.name)
 
     @helpers.skipIfNoService(['security.security_groups'])
@@ -31,9 +31,8 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_list(self):
         sgl = self.provider.security.security_groups.list()
-        found_sg = [g.name for g in sgl]
         for group in sgl:
-            print("List( " + "Name-" + group.name + "  Id-" + group.id + " Rules - " + " )")
+            print("List - " + str(group))
         self.assertTrue(
             len(sgl) == 3,
             "Count should be 3")
@@ -80,10 +79,10 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
         rules = cb.rules
         for rule in rules:
             print(str(rule))
-        print("Before creating Rule -  " + str(rules[0]) + " length - " + str(len(rules)))
+        print("Before creating Rule length - " + str(len(rules)))
         cb.add_rule('*', '25', '100', '*')
         rules = cb.rules
-        print("After creating Rule -  " + str(rules[0]) + " length - " + str(len(rules)))
+        print("After creating Rule length - " + str(len(rules)))
         self.assertEqual(len(rules), 3)
 
     @helpers.skipIfNoService(['security.security_groups'])
@@ -91,10 +90,10 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
         list = self.provider.security.security_groups.list()
         cb = list.data[0]
         rules = cb.rules
-        print("Before deleting Rule -  " + str(rules[0]) + " length - " + str(len(rules)))
+        print("Before deleting Rule length - " + str(len(rules)))
         rules[1].delete()
         rules = cb.rules
-        print("After deleting Rule -  " + str(rules[0]) + " length - " + str(len(rules)))
+        print("After deleting Rule length - " + str(len(rules)))
         self.assertEqual(len(rules), 2)
 
     @helpers.skipIfNoService(['security.security_groups'])

test/test_azure_volume_service.py

@@ -5,7 +5,8 @@ from 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')
+        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")
@@ -24,26 +25,31 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
         volume = self.provider.block_store.volumes.create("MyVolume", 1)
         volume.refresh()
         print("Create Volume - " + str(volume))
-        self.assertTrue(volume.name == "MyVolume", "Volume name should be MyVolume")
+        self.assertTrue(volume.name == "MyVolume",
+                        "Volume name should be MyVolume")
         volume.delete()
-        volume1_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure' \
-                     '/providers/Microsoft.Compute/disks/MyVolume"
+        volume1_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96" \
+                     "/resourceGroups/cloudbridge-azure/providers" \
+                     "/Microsoft.Compute/disks/MyVolume"
         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(self):
-        volume = self.provider.block_store.volumes.create("MyVolume", 1, description='My volume')
+        volume = self.provider.block_store.volumes.create(
+            "MyVolume", 1, description='My volume')
         self.assertTrue(
             volume.name == "MyVolume", "Volume name should be MyVolume")
-        volume.attach("/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/CloudBridge-Azure'\
-                      '/providers/Microsoft.Compute/virtualMachines/ubuntu-intro1")
+        volume.attach("/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96"
+                      "/resourceGroups/CloudBridge-Azure/providers"
+                      "/Microsoft.Compute/virtualMachines/ubuntu-intro1")
         volume.delete()
 
     @helpers.skipIfNoService(['block_store.volumes'])
     def test_azure_volume_dettach(self):
-        volume = self.provider.block_store.volumes.create("MyVolume", 1, description='My volume')
+        volume = self.provider.block_store.volumes.create(
+            "MyVolume", 1, description='My volume')
         self.assertTrue(
             volume.name == "MyVolume", "Volume name should be MyVolume")
         volume.detach()
@@ -51,7 +57,8 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['block_store.volumes'])
     def test_azure_volume_create_snapshot(self):
-        volume = self.provider.block_store.volumes.create("MyVolume", 1, description='My volume')
+        volume = self.provider.block_store.volumes.create(
+            "MyVolume", 1, description='My volume')
         self.assertTrue(
             volume.name == "MyVolume", "Volume name should be MyVolume")
         with self.assertRaises(NotImplementedError):
@@ -63,8 +70,9 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['block_store.volumes'])
     def test_azure_volume_get_ifNotExist(self):
-        volume_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure'\
-            '/providers/Microsoft.Compute/disks/MyVolume123"
+        volume_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96" \
+                    "/resourceGroups/cloudbridge-azure/providers" \
+                    "/Microsoft.Compute/disks/MyVolume123"
         volume = self.provider.block_store.volumes.get(volume_id)
         self.assertTrue(
             volume is None, "Volume should not be available")