Implemented create method for snapshots

azure_integration_test/test_integration_azure_snapshot_service.py

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

azure_test/test_azure_snapshots_service.py

@@ -1,8 +1,115 @@
 import azure_test.helpers as helpers
 from azure_test.helpers import ProviderTestBase
 
+from cloudbridge.cloud.interfaces import SnapshotState
+
 
 class AzureSnapshotsServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_create_and_get(self):
+        snapshot_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+            '/resourceGroups/cloudbridge-azure'\
+            '/providers/Microsoft.Compute/snapshots/MySnapshot123"
+        snapshot = self.provider.block_store. \
+            snapshots.create("MySnapshot",
+                             snapshot_id)
+        snapshot.description = 'My snapshot'
+        print("Create Snapshot - " + str(snapshot))
+        self.assertTrue(
+            snapshot.name == "MySnapshot",
+            "Snapshot name should be MySnapshot")
+        self.assertIsNotNone(snapshot.description)
+        self.assertIsNotNone(snapshot.name)
+        self.assertIsNotNone(snapshot.size)
+        self.assertIsNotNone(snapshot.volume_id)
+        self.assertIsNotNone(snapshot.create_time)
+        snapshot.name = 'MySnapNewName'
+        with self.assertRaises(NotImplementedError):
+            snapshot = self.provider.block_store.snapshots.get(
+                "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+                '/resourceGroups/cloudbridge-azure'\
+                '/providers/Microsoft.Compute'\
+                /snapshots/MySnapshot")
+            print("Get Snapshot  - " + str(snapshot))
+            self.assertTrue(
+                snapshot.name == "MySnapshot",
+                "Snapshot name should be MySnapshot")
+
+        snapshot.delete()
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_delete(self):
+        volume_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+            '/resourceGroups/cloudbridge-azure'\
+            '/providers/Microsoft.Compute/disks/MyDisk"
+        snapshot = self.provider.block_store. \
+            snapshots.create("MySnapshot",
+                             volume_id, description='My snapshot')
+        snapshot.refresh()
+        print("Create Snapshot - " + str(snapshot))
+        self.assertTrue(
+            snapshot.name == "MySnapshot",
+            "Snapshot name should be MySnapshot")
+        snapshot.delete()
+
+        delete_snapshot = snapshot.delete()
+        self.assertEqual(delete_snapshot, False)
+
+        snapshot.refresh()
+        self.assertEqual(snapshot.state, SnapshotState.UNKNOWN)
+
+        with self.assertRaises(NotImplementedError):
+            snapshot_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+                '/resourceGroups/cloudbridge-azure'\
+                '/providers/Microsoft.Compute/snapshots/MySnapshot"
+            snapshot1 = self.provider.block_store.snapshots.get(snapshot_id)
+            self.assertTrue(
+                snapshot1 is None, "Snapshot still exists")
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_create_volume(self):
+        volume_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+            '/resourceGroups/cloudbridge-azure'\
+            '/providers/Microsoft.Compute/disks/MyDisk"
+        snapshot = self.provider.block_store. \
+            snapshots.create("MySnapshot",
+                             volume_id,
+                             description='My snapshot')
+        self.assertTrue(
+            snapshot.name == "MySnapshot",
+            "Snapshot name should be MySnapshot")
+
+        volume = snapshot.create_volume("MyVolume")
+        self.assertTrue(
+            volume is not None, "Snapshot not created")
+        volume.delete()
+
+        snapshot.delete()
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_get_ifNotExist(self):
+        with self.assertRaises(NotImplementedError):
+            snapshot_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+                '/resourceGroups/cloudbridge-azure'\
+                '/providers/Microsoft.Compute/snapshots/MySnapshot123"
+            snapshot = self.provider.block_store.snapshots.get(snapshot_id)
+            self.assertTrue(
+                snapshot is None, "Snapshot should not be available")
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_find(self):
+        with self.assertRaises(NotImplementedError):
+            snapshots = self.provider.block_store.snapshots.find("Snapshot")
+            self.assertTrue(
+                len(snapshots) == 2, "Snapshot should not be available")
+
+    @helpers.skipIfNoService(['block_store.snapshots'])
+    def test_azure_snapshot_find_ifNotExist(self):
+        with self.assertRaises(NotImplementedError):
+            snapshots = self.provider.block_store.snapshots.find("Snapshot123")
+            self.assertTrue(
+                len(snapshots) == 0, "Snapshot should not be available")
+
     @helpers.skipIfNoService(['block_store.snapshots'])
     def test_azure_snapshots_list(self):
         snapshot_list = self.provider \

azure_test/test_azure_storage_account.py

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

cloudbridge/cloud/providers/azure/azure_client.py

@@ -112,6 +112,11 @@ class AzureClient(object):
             create_or_update(self.resource_group_name, name,
                              parameters).result()
 
+    def update_security_group_tags(self, name, tags):
+        return self.network_management_client.network_security_groups. \
+            create_or_update(self.resource_group_name, name,
+                             {'tags': tags}).result()
+
     def create_security_group_rule(self, security_group,
                                    rule_name, parameters):
         return self.network_management_client.security_rules. \
@@ -281,3 +286,49 @@ class AzureClient(object):
                 virtual_machine,
                 raw=True
             )
+
+    def get_snapshot(self, snapshot_name):
+        return self.compute_client.snapshots.get(self.resource_group_name,
+                                                 snapshot_name)
+
+    def create_snapshot(self, snapshot_name, disk_name,
+                        description=None, region=None):
+
+        managed_disk = self.compute_client.\
+            disks.get(self.resource_group_name,
+                      disk_name)
+        params = {
+                'location': region or self.region_name,
+                'creation_data': {
+                    'create_option': 'Copy',
+                    'source_uri': managed_disk.id
+                }
+            }
+
+        if description:
+            params['tags'] = {'Description': description}
+
+        snapshot_response = self.compute_client.snapshots.create_or_update(
+            self.resource_group_name,
+            snapshot_name,
+            params,
+            raw=True
+        )
+
+        return snapshot_response
+
+    def delete_snapshot(self, snapshot_name):
+        async_delete = self.compute_client.snapshots. \
+            delete(self.resource_group_name, snapshot_name)
+        async_delete.wait()
+
+    def update_snapshot_tags(self, snapshot_name, tags, region=None):
+        snapshot_result = self.compute_client.snapshots.update(
+            self.resource_group_name,
+            snapshot_name,
+            {
+                'tags': tags
+            },
+            raw=True
+        )
+        return snapshot_result

cloudbridge/cloud/providers/azure/mock_azure_client.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from io import BytesIO
 
 from azure.common import AzureException
@@ -99,7 +101,7 @@ class MockAzureClient:
     volume2.time_created = '20-04-2017'
     volume2.owner_id = None
     volume2.provisioning_state = 'Succeeded'
-    volume2.tags = {'Name': 'Volume2'}
+    volume2.tags = None
 
     volumes = [volume1, volume2]
 
@@ -137,11 +139,17 @@ class MockAzureClient:
         sg_create = NetworkSecurityGroup()
         sg_create.name = name
         sg_create.id = name
+        sg_create.tags = parameters.get('tags', None)
         sg_create.default_security_rules = [self.sg_rule1]
         sg_create.security_rules = [self.sg_rule2]
         self.security_groups.append(sg_create)
         return sg_create
 
+    def update_security_group_tags(self, name, tags):
+        sg = self.get_security_group(name)
+        sg.tags = tags
+        return sg
+
     def list_security_group(self):
         return self.security_groups
 
@@ -256,13 +264,10 @@ class MockAzureClient:
         volume.disk_size_gb = size
         volume.creation_data = CreationData(
             create_option=DiskCreateOption.empty)
-        volume.time_created = '01-01-2017'
+        volume.time_created = datetime(year=2017, month=5, day=2)
+        volume.location = 'eastus'
         volume.provisioning_state = 'Succeeded'
-        volume.owner_id = \
-            '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/' \
-            'resourceGroups/CloudBridge-Azure' \
-            's/providers/Microsoft.Compute/virtualMachines/ubuntu-intro1'
-        volume.tags = {'Name': disk_name}
+        volume.tags = {'Name': disk_name, 'Description': description}
         self.volumes.append(volume)
         return volume
 
@@ -278,19 +283,41 @@ class MockAzureClient:
         return self.volumes
 
     def delete_disk(self, disk_name):
-        for disk in self.volumes:
-            if disk.name == disk_name:
-                self.volumes.remove(disk)
-
+        disk = self.get_disk(disk_name)
+        self.volumes.remove(disk)
         return True
 
     def attach_disk(self, vm_name, disk_name, disk_id):
-        return None
+        disk = self.get_disk(disk_name)
+        if disk.owner_id:
+            response = Response()
+            response.status_code = 404
+            raise CloudError(response=response,
+                             error='Resource already in use')
+
+        disk.owner_id = vm_name
 
     def detach_disk(self, disk_id):
-        return None
+        for d in self.volumes:
+            if d.id == disk_id and not d.owner_id:
+                response = Response()
+                response.status_code = 404
+                raise CloudError(response=response,
+                                 error='Resource already available')
+            elif d.id == disk_id:
+                d.owner_id = None
 
     def get_storage_account(self, storage_account_name):
+        if storage_account_name == 'cloudbridgeazure':
+            response = Response()
+            response.status_code = 404
+            raise CloudError(response=response, error='Resource not found')
+
+        storage_account = StorageAccount()
+        storage_account.name = storage_account_name
+        return storage_account
+
+    def create_storage_account(self, storage_account_name, params):
         storage_account = StorageAccount()
         storage_account.name = storage_account_name
         return storage_account
@@ -298,5 +325,62 @@ class MockAzureClient:
     def update_disk_tags(self, disk_name, tags):
         pass
 
+    def create_snapshot(self, snapshot_name, disk_name,
+                        description=None, region=None):
+        snapshot = Snapshot(location='eastus', creation_data=None)
+        snapshot.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96' \
+                      '/resourceGroups/cloudbridge-azure' \
+                      '/providers/Microsoft.Compute/Snapshots/{0}'.format(
+                        disk_name)
+        snapshot.name = snapshot_name
+        snapshot.disk_size_gb = 30
+        snapshot.creation_data = \
+            CreationData(create_option=DiskCreateOption.empty)
+        snapshot.time_created = datetime(year=2017, month=5, day=2)
+        snapshot.creation_data.source_uri = \
+            '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96' \
+            '/resourceGroups/CloudBridge-Azure/providers' \
+            '/Microsoft.Compute/disks/{0}'.format(
+                disk_name)
+        if description:
+            snapshot.tags = {'Description': description}
+        self.snapshots.append(snapshot)
+        return snapshot
+
+    def update_snapshot_tags(self, snapshot_name, tags):
+        snapshot = self.get_snapshot(snapshot_name)
+        snapshot.tags = tags
+        return snapshot
+
+    def get_snapshot(self, name):
+        for snapshot in self.snapshots:
+            if snapshot.name == name:
+                return snapshot
+
+        response = Response()
+        response.status_code = 404
+        raise CloudError(response=response, error='Resource Not found')
+
+    def delete_snapshot(self, name):
+        snapshot = self.get_snapshot(name)
+        self.snapshots.remove(snapshot)
+        return True
+
+    def create_snapshot_disk(self, disk_name, snapshot_id, region=None):
+        volume = Disk(location='eastus', creation_data=None)
+        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 = 50
+        volume.creation_data = CreationData(
+            create_option=DiskCreateOption.copy,
+            source_uri=snapshot_id)
+        volume.time_created = '01-01-2017'
+        volume.tags = {'Name': disk_name}
+        self.volumes.append(volume)
+        return volume
+
     def list_snapshots(self):
         return self.snapshots

cloudbridge/cloud/providers/azure/resources.py

@@ -80,7 +80,9 @@ NETWORK_INTERFACE_NAME = 'networkInterfaceName'
 class AzureSecurityGroup(BaseSecurityGroup):
     def __init__(self, provider, security_group):
         super(AzureSecurityGroup, self).__init__(provider, security_group)
-        self._description = None
+        self._security_group = security_group
+        if not self._security_group.tags:
+            self._security_group.tags = {}
 
     @property
     def network_id(self):
@@ -88,11 +90,14 @@ class AzureSecurityGroup(BaseSecurityGroup):
 
     @property
     def description(self):
-        return self._description
+        return self._security_group.tags.get('Description', None)
 
     @description.setter
     def description(self, value):
-        self._description = value
+        self._security_group.tags.update(Description=value)
+        print(self._security_group.tags)
+        self._provider.azure_client.\
+            update_security_group_tags(self.name, self._security_group.tags)
 
     @property
     def rules(self):
@@ -442,7 +447,8 @@ class AzureVolume(BaseVolume):
         """
         Set the volume name.
         """
-        self._volume.name = value
+        # self._volume.name = value
+        pass
 
     @property
     def description(self):
@@ -565,6 +571,8 @@ class AzureSnapshot(BaseSnapshot):
         self._url_params = azure_helpers.\
             parse_url(SNAPSHOT_RESOURCE_ID, snapshot.id)
         self._status = self._snapshot.provisioning_state
+        if not self._snapshot.tags:
+            self._snapshot.tags = {}
 
     @property
     def id(self):
@@ -585,15 +593,18 @@ class AzureSnapshot(BaseSnapshot):
         """
         Set the snapshot name.
         """
-        self._snapshot.name = value
+        # self._snapshot.name = value
+        pass
 
     @property
     def description(self):
-        return self._description
+        return self._snapshot.tags.get('Description', None)
 
     @description.setter
     def description(self, value):
-        self._description = value
+        self._snapshot.tags.update(Description=value)
+        self._provider.azure_client.\
+            update_snapshot_tags(self.name, self._snapshot.tags)
 
     @property
     def size(self):
@@ -617,17 +628,33 @@ class AzureSnapshot(BaseSnapshot):
         Refreshes the state of this snapshot by re-querying the cloud provider
         for its latest state.
         """
-        pass
+        try:
+            self._snapshot = self._provider.azure_client.\
+                get_snapshot(self.name)
+            self._status = self._snapshot.provisioning_state
+        except (CloudError, ValueError):
+            # The snapshot no longer exists and cannot be refreshed.
+            # set the status to unknown
+            self._status = 'unknown'
 
     def delete(self):
         """
         Delete this snapshot.
         """
-        pass
+        try:
+            self._provider.azure_client.delete_snapshot(self.name)
+            return True
+        except CloudError:
+            return False
 
     def create_volume(self, placement=None,
                       size=None, volume_type=None, iops=None):
         """
         Create a new Volume from this Snapshot.
         """
-        pass
+        self._provider.azure_client.\
+            create_snapshot_disk(self.name + '_disk',
+                                 self.id, region=placement)
+        azure_vol = self._provider.azure_client.get_disk(self.name + '_disk')
+        cb_vol = AzureVolume(self._provider, azure_vol)
+        return cb_vol

cloudbridge/cloud/providers/azure/services.py

@@ -7,7 +7,7 @@ from cloudbridge.cloud.base.services import BaseBlockStoreService, \
     BaseObjectStoreService, BaseSecurityGroupService, \
     BaseSecurityService, BaseSnapshotService, BaseVolumeService
 from cloudbridge.cloud.interfaces.resources import PlacementZone, \
-    Snapshot
+    Snapshot, Volume
 from cloudbridge.cloud.providers.azure import helpers as azure_helpers
 
 from msrestazure.azure_exceptions import CloudError
@@ -73,11 +73,12 @@ class AzureSecurityGroupService(BaseSecurityGroupService):
 
     def create(self, name, description, network_id):
         parameters = {"location": self.provider.region_name}
-        sg = self.provider.azure_client.create_security_group(name, parameters)
-        cb_sg = AzureSecurityGroup(self.provider, sg)
 
         if description:
-            cb_sg.description = description
+            parameters['tags'] = {'Description': description}
+
+        sg = self.provider.azure_client.create_security_group(name, parameters)
+        cb_sg = AzureSecurityGroup(self.provider, sg)
 
         return cb_sg
 
@@ -197,11 +198,9 @@ class AzureVolumeService(BaseVolumeService):
         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)
+            name, size, zone_id, snapshot_id, description=description)
         azure_vol = self.provider.azure_client.get_disk(name)
         cb_vol = AzureVolume(self.provider, azure_vol)
-        if description:
-            cb_vol.description = description
 
         return cb_vol
 
@@ -229,5 +228,12 @@ class AzureSnapshotService(BaseSnapshotService):
         return ClientPagedResultList(self.provider, snaps, limit, marker)
 
     def create(self, name, volume, description=None):
-        raise NotImplementedError('AzureSnapShotService not '
-                                  'implemented this method')
+        volume_id = volume.id if isinstance(volume, Volume) else volume
+        params = azure_helpers.parse_url(VOLUME_RESOURCE_ID, volume_id)
+        self.provider.azure_client. \
+            create_snapshot(name, params.get(VOLUME_NAME),
+                            description=description)
+        azure_snap = self.provider.azure_client.get_snapshot(name)
+        cb_snap = AzureSnapshot(self.provider, azure_snap)
+
+        return cb_snap

test/test_azure_security_service.py

@@ -16,6 +16,21 @@ class AzureSecurityServiceTestCase(ProviderTestBase):
         print("Create - " + str(sg))
         self.assertEqual(name, sg.name)
 
+    @helpers.skipIfNoService(['security.security_groups'])
+    def test_azure_security_group_create_no_description(self):
+        name = "testCreateSecGroup13"
+        sg = self.provider.security.security_groups.create(
+            name=name, description=None, network_id="")
+        print("Create - " + str(sg))
+        self.assertEqual(name, sg.name)
+        sg.description = name
+        self.assertEqual(name, sg.description)
+        self.provider.security.security_groups.delete(
+            "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96'\
+            '/resourceGroups/CloudBridge-Azure'\
+            '/providers/Microsoft.Network'\
+            '/networkSecurityGroups/testCreateSecGroup13")
+
     @helpers.skipIfNoService(['security.security_groups'])
     def test_azure_security_group_find_exists(self):
         sgl = self.provider.security.security_groups.find("sg")

test/test_azure_volume_service.py

@@ -1,6 +1,8 @@
 import azure_test.helpers as helpers
 from azure_test.helpers import ProviderTestBase
 
+from cloudbridge.cloud.interfaces import VolumeState
+
 
 class AzureVolumeServiceTestCase(ProviderTestBase):
     @helpers.skipIfNoService(['block_store.volumes'])
@@ -11,9 +13,19 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
         self.assertTrue(
             volume.name == "MyVolume", "Volume name should be MyVolume")
 
+        self.assertIsNotNone(volume.description)
+        self.assertIsNotNone(volume.name)
+        self.assertIsNotNone(volume.size)
+        self.assertIsNotNone(volume.zone_id)
+        self.assertIsNone(volume.source)
+        self.assertIsNone(volume.attachments)
+        self.assertIsNotNone(volume.create_time)
+        volume.name = 'newname'
+
         volume = self.provider.block_store.volumes.get(
             "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/resourceGroups/cloudbridge-azure/providers'\
             '/Microsoft.Compute/disks/MyVolume")
+        volume.description = 'My Volume desc'
         print("Get Volume  - " + str(volume))
         self.assertTrue(
             volume.name == "MyVolume", "Volume name should be MyVolume")
@@ -22,15 +34,21 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['block_store.volumes'])
     def test_azure_volume_delete(self):
-        volume = self.provider.block_store.volumes.create("MyVolume", 1)
+        volume = self.provider.block_store.volumes.create("MyTestVolume", 1)
         volume.refresh()
         print("Create Volume - " + str(volume))
-        self.assertTrue(volume.name == "MyVolume",
+        self.assertTrue(volume.name == "MyTestVolume",
                         "Volume name should be MyVolume")
         volume.delete()
         volume1_id = "/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96" \
                      "/resourceGroups/cloudbridge-azure/providers" \
                      "/Microsoft.Compute/disks/MyVolume"
+        delete_volume = volume.delete()
+        self.assertEqual(delete_volume, False)
+
+        volume.refresh()
+        self.assertEqual(volume.state, VolumeState.UNKNOWN)
+
         volume1 = self.provider.block_store.volumes.get(volume1_id)
         self.assertTrue(
             volume1 is None, "Volume still exists")
@@ -41,9 +59,19 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
             "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")
+        attached = volume.attach("/subscriptions'\
+        '/7904d702-e01c-4826-8519-f5a25c866a96'\
+        '/resourceGroups/CloudBridge-Azure/providers'\
+        '/Microsoft.Compute/virtualMachines/ubuntu-intro1")
+
+        self.assertEqual(attached, True)
+
+        attach_volume = volume.attach("/subscriptions'\
+        '/7904d702-e01c-4826-8519-f5a25c866a96'\
+        '/resourceGroups/CloudBridge-Azure/providers'\
+        '/Microsoft.Compute/virtualMachines/ubuntu-intro1")
+        self.assertEqual(attach_volume, False)
+
         volume.delete()
 
     @helpers.skipIfNoService(['block_store.volumes'])
@@ -61,10 +89,9 @@ class AzureVolumeServiceTestCase(ProviderTestBase):
             "MyVolume", 1, description='My volume')
         self.assertTrue(
             volume.name == "MyVolume", "Volume name should be MyVolume")
-        with self.assertRaises(NotImplementedError):
-            snapshot = volume.create_snapshot("MySnap")
-            self.assertTrue(
-                snapshot is not None, "Snapshot not created")
+        snapshot = volume.create_snapshot("MySnap")
+        self.assertTrue(
+            snapshot is not None, "Snapshot not created")
 
         volume.delete()