def test_create_too_much_datadisks(self):
        disks = [{'name': 'much_disks_1',
                  'size': 100,
                  'deletable': False,
                  'caching': 'None'
                },{'name': 'much_disks_2',
                   'size': 200,
                   'deletable': False,
                   'caching': 'ReadWrite'
                },{'name': 'much_disks_3',
                   'size': 200,
                   'deletable': False,
                   'caching': 'ReadOnly'
                }]

        test_name = 'test-create-too-much-datadisks'
        ctx = self.mock_ctx(test_name , disks)
        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN create VM test: {}".format(test_name)) 

        instance.create(ctx=ctx)
        
        current_ctx.set(ctx=ctx)
        utils.wait_status(ctx, 'instance', timeout=900)

        current_ctx.set(ctx=ctx)
        datadisks.create(ctx=ctx)

        current_ctx.set(ctx=ctx)
        json_VM = instance.get_json_from_azure(ctx=ctx)

        self.assertIsNotNone(json_VM['properties'][
                                        'storageProfile']['dataDisks'])

        disks_vm = json_VM['properties']['storageProfile']['dataDisks']

        ctx.logger.debug(disks_vm)

        self.assertNotEqual(len(disks), len(disks_vm))

        self.assertEqual(disks[0]['name'], disks_vm[0]['name'])
        self.assertEqual(disks[0]['size'], disks_vm[0]['diskSizeGB'])
        self.assertEqual(disks[0]['caching'], disks_vm[0]['caching'])

        self.assertEqual(disks[1]['name'], disks_vm[1]['name'])
        self.assertEqual(disks[1]['size'], disks_vm[1]['diskSizeGB'])
        self.assertEqual(disks[1]['caching'], disks_vm[1]['caching'])

        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
        instance.delete(ctx=ctx)

        try:
            current_ctx.set(ctx=ctx)
            utils.wait_status(ctx, 'instance', 
                              constants.DELETING, timeout=900)
        except utils.WindowsAzureError:
            pass
    def test_delete_datadisk(self):
        disk = [{'name': 'delete_disk',
                  'size': 100,
                  constants.DELETABLE_KEY: True,
                  'caching': 'None'
                },{'name': 'delete_disk_2',
                  'size': 100,
                  constants.DELETABLE_KEY: False,
                  'caching': 'None'
                }]

        test_name = 'test-delete-datadisk'
        ctx = self.mock_ctx(test_name, disk)

        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN create VM test: {}".format(test_name))
        instance.create(ctx=ctx)

        current_ctx.set(ctx=ctx)
        datadisks.create(ctx=ctx)
        
        current_ctx.set(ctx=ctx)
        utils.wait_status(ctx, 'instance',timeout=900)

        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
        instance.delete(ctx=ctx)

        try:
            current_ctx.set(ctx=ctx)
            utils.wait_status(ctx, 'instance', 
                              constants.DELETING, timeout=900)
        except utils.WindowsAzureError:
            pass

        ctx.logger.info("BEGIN delete datadisk test: {}".format(
                                        disk[0]['name']
                                        )
                        )
        current_ctx.set(ctx=ctx)
        datadisks.delete(ctx=ctx)
        
        list  = datadisks._get_datadisks_from_storage(ctx)
        self.assertFalse(datadisks._is_datadisk_exists(
                                        list,
                                        disk[0]['name']
                                        )
                        )
        ctx.logger.info("Disk {} has been deleted.".format(disk[0]['name']))

        self.assertTrue(datadisks._is_datadisk_exists(
                                        list, 
                                        disk[1]['name']
                                        )
                        )
        ctx.logger.info("Datadisk {} still exists.".format(disk[1]['name']))
    def test_create_datadisk(self):
        disk = [{'name': 'disk_1',
                 'size': 100,
                 'deletable': False,
                 'caching': 'None'
               }]

        test_name = 'test-create-datadisk'
        ctx = self.mock_ctx(test_name, disk)
        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN create VM test: {}".format(test_name)) 

        instance.create(ctx=ctx)
        current_ctx.set(ctx=ctx)
        utils.wait_status(ctx, 'instance', constants.SUCCEEDED, timeout=900)

        current_ctx.set(ctx=ctx)
        datadisks.create(ctx=ctx)

        current_ctx.set(ctx=ctx)
        json_VM = instance.get_json_from_azure(ctx=ctx)

        ctx.logger.debug(json_VM)

        self.assertIsNotNone(json_VM['properties'][
                                        'storageProfile']['dataDisks'])
        
        disks_vm = json_VM['properties']['storageProfile']['dataDisks']

        ctx.logger.debug(disks_vm)

        self.assertEqual(disk[0]['name'], disks_vm[0]['name'])
        self.assertEqual(disk[0]['caching'], disks_vm[0]['caching'])
        self.assertEqual(disk[0]['size'], disks_vm[0]['diskSizeGB'])

        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN delete VM test: {}".format(test_name)) 
        instance.delete(ctx=ctx)

        try:
            current_ctx.set(ctx=ctx)
            utils.wait_status(ctx, 'instance', 
                              constants.DELETING, timeout=900)
        except utils.WindowsAzureError:
            pass
    def test_datadisk_in_storage_account(self):
        disk = [{'name': 'attach_disk',
                  'size': 100,
                  'deletable': False,
                  'caching': 'None'
                }]

        test_name = 'test-datadisk-in-storage-account'
        ctx = self.mock_ctx(test_name, disk)

        current_ctx.set(ctx=ctx)
        ctx.logger.info("CREATE storage account")
        ctx.node.properties[constants.ACCOUNT_TYPE_KEY] = "Standard_LRS"
        ctx.node.properties[constants.STORAGE_ACCOUNT_KEY] = \
            "storageaccountdisk" + self.__random_id
        storage.create(ctx=ctx)
        current_ctx.set(ctx=ctx)
        utils.wait_status(ctx, "storage",constants.SUCCEEDED, timeout=600)

        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN create VM test: {}".format(test_name))

        instance.create(ctx=ctx)
        
        ctx.instance.relationships.append(
                    MockRelationshipContext(
                                'test',
                                {constants.STORAGE_ACCOUNT_KEY: \
                                       'storageaccountdisk' + self.__random_id
                                }, 
                                constants.DISK_CONTAINED_IN_STORAGE_ACCOUNT
                    )
        )
                                            
        current_ctx.set(ctx=ctx)
        datadisks.create(ctx=ctx)

        current_ctx.set(ctx=ctx)
        utils.wait_status(ctx, 'instance',timeout=900)

        jsonInstance = instance.get_json_from_azure(ctx=ctx)

        self.assertIn('storageaccountdisk' + self.__random_id,
                      jsonInstance['properties'
                                   ]['storageProfile'
                                     ]['dataDisks'][0]['vhd']['uri']
                      )

        ctx.logger.info('Disks are located in {}.'.format(
                                    'storageaccountdisk' + self.__random_id,
                                    )
                        )

        current_ctx.set(ctx=ctx)
        ctx.logger.info("BEGIN delete VM test: {}".format(test_name))
        instance.delete(ctx=ctx)

        try:
            current_ctx.set(ctx=ctx)
            utils.wait_status(ctx, 'instance', 
                              constants.DELETING, timeout=900)
        except utils.WindowsAzureError:
            pass

        current_ctx.set(ctx=ctx)
        ctx.logger.info("DELETE storage account")
        ctx.node.properties[constants.ACCOUNT_TYPE_KEY] = "Standard_LRS"
        ctx.node.properties[constants.STORAGE_ACCOUNT_KEY] = \
            "storageaccountdisk" + self.__random_id
        storage.delete(ctx=ctx)