/// <summary>
/// Marks a data disk to be detached.
/// </summary>
public static void MarkDataDiskToBeDetached(DataDisk disk, string detachOption = null)
{
Assert.NotNull(disk);
disk.ToBeDetached = true;
if (!string.IsNullOrEmpty(detachOption))
{
disk.DetachOption = detachOption;
}
}
private DataDisk CreateModelDataDisk(Disk disk)
{
var modelDisk = new DataDisk
{
DiskSizeGB = disk.DiskSizeGB,
CreateOption = DiskCreateOptionTypes.Attach
};
return(modelDisk);
}
private VirtualMachineScaleSetVM.Update.IUpdate WithExistingDataDisk(DataDisk dataDisk, int lun)
{
if (TryFindDataDisk(lun, Inner.StorageProfile.DataDisks) != null)
{
throw new System.InvalidOperationException(string.Format("A data disk with lun {0} already attached", lun));
}
else if (TryFindDataDisk(lun, managedDataDisks.ExistingDisksToAttach) != null)
{
throw new System.InvalidOperationException(string.Format("A data disk with lun {0} already scheduled to be attached", lun));
}
managedDataDisks.ExistingDisksToAttach.Add(dataDisk);
return(this);
}
private DataDisk TryFindDataDisk(int lun, IList <DataDisk> dataDisks)
{
DataDisk disk = null;
foreach (DataDisk dataDisk in dataDisks)
{
if (lun == dataDisk.Lun)
{
disk = dataDisk;
break;
}
}
return(disk);
}
public VirtualMachineScaleSetVM.Update.IUpdate WithoutDataDisk(int lun)
{
DataDisk dataDisk = TryFindDataDisk(lun, Inner.StorageProfile.DataDisks);
if (dataDisk == null)
{
throw new System.InvalidOperationException(string.Format("A data disk with lun {0} not found", lun));
}
if (dataDisk.CreateOption != DiskCreateOptionTypes.Attach)
{
throw new System.InvalidOperationException(string.Format("A data disk with lun {0} cannot be detached, as it is part of Virtual Machine Scale Set model", lun));
}
managedDataDisks.DiskLunsToRemove.Add(lun);
return(this);
}
private async Task AttachDataDiskToVMScaleSetVM(VirtualMachineScaleSetVM vmssVM, VirtualMachineScaleSetVM vmModel, int lun)
{
var diskName = TestPrefix + "dataDisk" + lun;
var disk = await CreateDataDisk(diskName);
var dd = new DataDisk(lun, DiskCreateOptionTypes.Attach)
{
Name = diskName,
ManagedDisk = new ManagedDiskParameters()
{
Id = disk.Id,
StorageAccountType = changeType(disk.Sku.Name)
}
};
//(lun, diskName, null, null, null, DiskCreateOptionTypes.Attach, null, new ManagedDiskParameters(disk.Id,disk.Sku.Name,null), null, null, null);
vmssVM.StorageProfile.DataDisks.Add(dd);
// Add the data disk to the model for validation later
vmModel.StorageProfile.DataDisks.Add(CreateModelDataDisk(disk));
}
internal AzureSLA GetDiskSLA(DataDisk datadisk)
{
return(this.GetDiskSLA(datadisk.DiskSizeGB, datadisk.Vhd.Uri));
}
public async Task TestVMDataDiskScenario()
{
EnsureClientsInitialized(DefaultLocation);
ImageReference imgageRef = await GetPlatformVMImage(useWindowsImage : true);
// Create resource group
var rgName = Recording.GenerateAssetName(TestPrefix);
string storageAccountName = Recording.GenerateAssetName(TestPrefix);
string asName = Recording.GenerateAssetName("as");
VirtualMachine inputVM;
bool passed = false;
try
{
// Create Storage Account, so that both the VMs can share it
var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName);
Action <VirtualMachine> addDataDiskToVM = vm =>
{
string containerName = Recording.GenerateAssetName("testvmdatadiskscenario", TestPrefix);
var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName;
var vhduri = vhdContainer + string.Format("/{0}.vhd", Recording.GenerateAssetName("testvmdatadiskscenario", TestPrefix));
vm.HardwareProfile.VmSize = VirtualMachineSizeTypes.StandardA4;
foreach (int index in new int[] { 1, 2 })
{
var diskName = "dataDisk" + index;
var ddUri = vhdContainer + string.Format("/{0}{1}.vhd", diskName, Recording.GenerateAssetName("testvmdatadiskscenario", TestPrefix));
var dd = new DataDisk(1 + index, DiskCreateOptionTypes.Empty)
{
Caching = CachingTypes.None,
Image = null,
DiskSizeGB = 10,
Name = diskName,
Vhd = new VirtualHardDisk
{
Uri = ddUri
}
};
vm.StorageProfile.DataDisks.Add(dd);
}
var testStatus = new InstanceViewStatus
{
Code = "test",
Message = "test"
};
var testStatusList = new List <InstanceViewStatus> {
testStatus
};
// Negative tests for a bug in 5.0.0 that read-only fields have side-effect on the request body
/* vm.InstanceView = new VirtualMachineInstanceView
* {
* Statuses = testStatusList,
* VmAgent = new VirtualMachineAgentInstanceView
* {
* Statuses = testStatusList,
* ExtensionHandlers = {
* new VirtualMachineExtensionHandlerInstanceView
* {
* Status = testStatus,
* Type = "test",
* TypeHandlerVersion = "test"
* }
* },
* VmAgentVersion = "test"
* },
* Disks = {
* new DiskInstanceView
* {
* Statuses = testStatusList,
* Name = "test"
* }
* },
* Extensions = {
* new VirtualMachineExtensionInstanceView
* {
* Statuses = testStatusList
* }
* }
* }; */
};
var returnTwoVM = await CreateVM(rgName, asName, storageAccountOutput, imgageRef, addDataDiskToVM);
VirtualMachine vm1 = returnTwoVM.Item1;
inputVM = returnTwoVM.Item2;
string inputVMName = returnTwoVM.Item3;
var getVMWithInstanceViewResponse = await VirtualMachinesOperations.GetAsync(rgName, inputVMName);
Assert.True(getVMWithInstanceViewResponse != null, "VM in Get");
ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse);
var vm2 = getVMWithInstanceViewResponse;
var vmReCreateResponse = await WaitForCompletionAsync(await VirtualMachinesOperations.StartCreateOrUpdateAsync(rgName, getVMWithInstanceViewResponse.Value.Name, getVMWithInstanceViewResponse));
await WaitForCompletionAsync(await VirtualMachinesOperations.StartDeleteAsync(rgName, inputVMName));
passed = true;
Assert.True(passed);
}
catch (Exception e)
{
throw e;
}
}
public void TestVMDataDiskScenario()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
EnsureClientsInitialized(context);
ImageReference imgageRef = GetPlatformVMImage(useWindowsImage: true);
// Create resource group
var rgName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
string storageAccountName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
string asName = ComputeManagementTestUtilities.GenerateName("as");
VirtualMachine inputVM;
bool passed = false;
try
{
// Create Storage Account, so that both the VMs can share it
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
Action <VirtualMachine> addDataDiskToVM = vm =>
{
string containerName = HttpMockServer.GetAssetName("TestVMDataDiskScenario", TestPrefix);
var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName;
var vhduri = vhdContainer + string.Format("/{0}.vhd", HttpMockServer.GetAssetName("TestVMDataDiskScenario", TestPrefix));
vm.HardwareProfile.VmSize = VirtualMachineSizeTypes.StandardA1V2;
vm.StorageProfile.DataDisks = new List <DataDisk>();
foreach (int index in new int[] { 1, 2 })
{
var diskName = "dataDisk" + index;
var ddUri = vhdContainer + string.Format("/{0}{1}.vhd", diskName, HttpMockServer.GetAssetName("TestVMDataDiskScenario", TestPrefix));
var dd = new DataDisk
{
Caching = CachingTypes.None,
Image = null,
DiskSizeGB = 10,
CreateOption = DiskCreateOptionTypes.Empty,
Lun = 1 + index,
Name = diskName,
Vhd = new VirtualHardDisk
{
Uri = ddUri
}
};
vm.StorageProfile.DataDisks.Add(dd);
}
var testStatus = new InstanceViewStatus
{
Code = "test",
Message = "test"
};
var testStatusList = new List <InstanceViewStatus> {
testStatus
};
// Negative tests for a bug in 5.0.0 that read-only fields have side-effect on the request body
/* vm.InstanceView = new VirtualMachineInstanceView
* {
* Statuses = testStatusList,
* VmAgent = new VirtualMachineAgentInstanceView
* {
* Statuses = testStatusList,
* ExtensionHandlers = new List<VirtualMachineExtensionHandlerInstanceView>
* {
* new VirtualMachineExtensionHandlerInstanceView
* {
* Status = testStatus,
* Type = "test",
* TypeHandlerVersion = "test"
* }
* },
* VmAgentVersion = "test"
* },
* Disks = new List<DiskInstanceView>
* {
* new DiskInstanceView
* {
* Statuses = testStatusList,
* Name = "test"
* }
* },
* Extensions = new List<VirtualMachineExtensionInstanceView>
* {
* new VirtualMachineExtensionInstanceView
* {
* Statuses = testStatusList
* }
* }
* }; */
};
var vm1 = CreateVM(rgName, asName, storageAccountOutput, imgageRef, out inputVM, addDataDiskToVM);
var getVMWithInstanceViewResponse = m_CrpClient.VirtualMachines.Get(rgName, inputVM.Name, InstanceViewTypes.InstanceView);
Assert.True(getVMWithInstanceViewResponse != null, "VM in Get");
ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse);
var vm2 = getVMWithInstanceViewResponse;
var vmReCreateResponse = m_CrpClient.VirtualMachines.CreateOrUpdate(rgName, getVMWithInstanceViewResponse.Name, getVMWithInstanceViewResponse);
m_CrpClient.VirtualMachines.Delete(rgName, inputVM.Name);
passed = true;
}
catch (Exception e)
{
throw e;
}
finally
{
m_ResourcesClient.ResourceGroups.Delete(rgName);
Assert.True(passed);
}
}
}
public void TestVMDataDiskScenario_ManagedDisk_ForceDetach()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION");
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "eastus2euap");
EnsureClientsInitialized(context);
ImageReference imageReference = GetPlatformVMImage(useWindowsImage: true);
string resourceGroupName = TestUtilities.GenerateName(TestPrefix);
string storageAccountForDisksName = TestUtilities.GenerateName(TestPrefix);
string availabilitySetName = TestUtilities.GenerateName(TestPrefix);
try
{
StorageAccount storageAccountForDisks = CreateStorageAccount(resourceGroupName, storageAccountForDisksName);
Action <VirtualMachine> addManagedDataDiskToVM = vm =>
{
vm.HardwareProfile.VmSize = VirtualMachineSizeTypes.StandardA4;
vm.StorageProfile.DataDisks = new List <DataDisk>();
var diskName = "dataDisk" + TestUtilities.GenerateGuid();
var dd = new DataDisk
{
Caching = CachingTypes.None,
DiskSizeGB = 10,
CreateOption = DiskCreateOptionTypes.Empty,
Lun = 0,
Name = diskName,
ManagedDisk = new ManagedDiskParameters()
{
StorageAccountType = StorageAccountType.StandardLRS
}
};
vm.StorageProfile.DataDisks.Add(dd);
var testStatus = new InstanceViewStatus
{
Code = "test",
Message = "test"
};
var testStatusList = new List <InstanceViewStatus> {
testStatus
};
};
VirtualMachine inputVM;
CreateVM(resourceGroupName, availabilitySetName, storageAccountForDisks, imageReference, out inputVM, addManagedDataDiskToVM, hasManagedDisks: true);
VirtualMachine getVMWithInstanceViewResponse = m_CrpClient.VirtualMachines.Get(resourceGroupName, inputVM.Name, InstanceViewTypes.InstanceView);
ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse, hasManagedDisks: true);
DataDisk diskToBeForceDetached = getVMWithInstanceViewResponse.StorageProfile.DataDisks.FirstOrDefault(disk => disk.Lun == 0);
Assert.NotNull(diskToBeForceDetached);
Helpers.MarkDataDiskToBeDetached(diskToBeForceDetached, "ForceDetach");
var forceDetachVMResponse = m_CrpClient.VirtualMachines.CreateOrUpdate(resourceGroupName, getVMWithInstanceViewResponse.Name, getVMWithInstanceViewResponse);
Assert.Equal(0, forceDetachVMResponse.StorageProfile.DataDisks.Count);
}
finally
{
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation);
m_ResourcesClient.ResourceGroups.Delete(resourceGroupName);
}
}
}
private void CreateImageTestHelper(string originalTestLocation, string diskEncryptionSetId)
{
VirtualMachine inputVM = null;
// Create resource group
var rgName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
var imageName = ComputeManagementTestUtilities.GenerateName("imageTest");
// Create a VM, so we can use its OS disk for creating the image
string storageAccountName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
string asName = ComputeManagementTestUtilities.GenerateName("as");
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
try
{
// Create Storage Account
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
// Add data disk to the VM.
Action <VirtualMachine> addDataDiskToVM = vm =>
{
string containerName = HttpMockServer.GetAssetName("TestImageOperations", TestPrefix);
var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName;
var vhduri = vhdContainer + string.Format("/{0}.vhd", HttpMockServer.GetAssetName("TestImageOperations", TestPrefix));
vm.HardwareProfile.VmSize = VirtualMachineSizeTypes.StandardA4;
vm.StorageProfile.DataDisks = new List <DataDisk>();
foreach (int index in new int[] { 1, 2 })
{
var diskName = "dataDisk" + index;
var ddUri = vhdContainer + string.Format("/{0}{1}.vhd", diskName, HttpMockServer.GetAssetName("TestImageOperations", TestPrefix));
var dd = new DataDisk
{
Caching = CachingTypes.None,
Image = null,
DiskSizeGB = 10,
CreateOption = DiskCreateOptionTypes.Empty,
Lun = 1 + index,
Name = diskName,
Vhd = new VirtualHardDisk
{
Uri = ddUri
}
};
vm.StorageProfile.DataDisks.Add(dd);
}
var testStatus = new InstanceViewStatus
{
Code = "test",
Message = "test"
};
var testStatusList = new List <InstanceViewStatus> {
testStatus
};
};
// Create the VM, whose OS disk will be used in creating the image
var createdVM = CreateVM(rgName, asName, storageAccountOutput, imageRef, out inputVM, addDataDiskToVM);
int expectedDiskLunWithDiskEncryptionSet = createdVM.StorageProfile.DataDisks[0].Lun;
// Create the Image
var imageInput = new Image()
{
Location = m_location,
Tags = new Dictionary <string, string>()
{
{ "RG", "rg" },
{ "testTag", "1" },
},
StorageProfile = new ImageStorageProfile()
{
OsDisk = new ImageOSDisk()
{
BlobUri = createdVM.StorageProfile.OsDisk.Vhd.Uri,
DiskEncryptionSet = diskEncryptionSetId == null ? null : new DiskEncryptionSetParameters()
{
Id = diskEncryptionSetId
},
OsState = OperatingSystemStateTypes.Generalized,
OsType = OperatingSystemTypes.Windows,
},
DataDisks = new List <ImageDataDisk>()
{
new ImageDataDisk()
{
BlobUri = createdVM.StorageProfile.DataDisks[0].Vhd.Uri,
DiskEncryptionSet = diskEncryptionSetId == null ? null: new DiskEncryptionSetParameters()
{
Id = diskEncryptionSetId
},
Lun = expectedDiskLunWithDiskEncryptionSet,
}
}
},
HyperVGeneration = HyperVGeneration.V1
};
var image = m_CrpClient.Images.CreateOrUpdate(rgName, imageName, imageInput);
var getImage = m_CrpClient.Images.Get(rgName, imageName);
ValidateImage(imageInput, getImage);
if (diskEncryptionSetId != null)
{
Assert.True(getImage.StorageProfile.OsDisk.DiskEncryptionSet != null, "OsDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getImage.StorageProfile.OsDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"getImage.StorageProfile.OsDisk.DiskEncryptionSet is not matching with expected DiskEncryptionSet resource");
Assert.Equal(1, getImage.StorageProfile.DataDisks.Count);
Assert.True(getImage.StorageProfile.DataDisks[0].DiskEncryptionSet != null, ".DataDisks.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getImage.StorageProfile.DataDisks[0].DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"DataDisks.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
}
ImageUpdate updateParams = new ImageUpdate()
{
Tags = getImage.Tags
};
string tagKey = "UpdateTag";
updateParams.Tags.Add(tagKey, "TagValue");
m_CrpClient.Images.Update(rgName, imageName, updateParams);
getImage = m_CrpClient.Images.Get(rgName, imageName);
Assert.True(getImage.Tags.ContainsKey(tagKey));
var listResponse = m_CrpClient.Images.ListByResourceGroup(rgName);
Assert.Single(listResponse);
m_CrpClient.Images.Delete(rgName, image.Name);
}
finally
{
Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation);
if (inputVM != null)
{
m_CrpClient.VirtualMachines.Delete(rgName, inputVM.Name);
}
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
}
///GENMHASH:8240626CF1A18F6A5466996742289188:6EE441451716A7DCFF423F19975ED54D
internal VirtualMachineDataDiskImpl(DataDisk dataDiskInner) : base(dataDiskInner)
{
}
private DataDisk CreateModelDataDisk(Disk disk)
{
var modelDisk = new DataDisk(0, null, null, null, null, null, DiskCreateOptionTypes.Attach, disk.DiskSizeGB, null, null, null, null);
return(modelDisk);
}
private async Task CreateImageTestHelper(string originalTestLocation, string diskEncryptionSetId)
{
// Create resource group
var rgName = Recording.GenerateAssetName(TestPrefix);
var imageName = Recording.GenerateAssetName("imageTest");
// Create a VM, so we can use its OS disk for creating the image
string storageAccountName = Recording.GenerateAssetName(TestPrefix);
string asName = Recording.GenerateAssetName("as");
ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true);
// Create Storage Account
var storageAccountOutput = await CreateStorageAccount(rgName, storageAccountName);
// Add data disk to the VM.
Action <VirtualMachine> addDataDiskToVM = vm =>
{
string containerName = Recording.GenerateAssetName("testimageoperations", TestPrefix);
var vhdContainer = "https://" + storageAccountName + ".blob.core.windows.net/" + containerName;
var vhduri = vhdContainer + string.Format("/{0}.vhd", Recording.GenerateAssetName("testimageoperations", TestPrefix));
vm.HardwareProfile.VmSize = VirtualMachineSizeTypes.StandardA4;
foreach (int index in new int[] { 1, 2 })
{
var diskName = "dataDisk" + index;
var ddUri = vhdContainer + string.Format("/{0}{1}.vhd", diskName, Recording.GenerateAssetName("testimageoperations", TestPrefix));
var dd = new DataDisk(1 + index, DiskCreateOptionTypes.Empty)
{
Caching = CachingTypes.None,
Image = null,
DiskSizeGB = 10,
Name = diskName,
Vhd = new VirtualHardDisk
{
Uri = ddUri
}
};
vm.StorageProfile.DataDisks.Add(dd);
}
var testStatus = new InstanceViewStatus
{
Code = "test",
Message = "test"
};
var testStatusList = new List <InstanceViewStatus> {
testStatus
};
};
// Create the VM, whose OS disk will be used in creating the image
var returnTwoVM = await CreateVM(rgName, asName, storageAccountOutput, imageRef, addDataDiskToVM);
var createdVM = returnTwoVM.Item1;
int expectedDiskLunWithDiskEncryptionSet = createdVM.StorageProfile.DataDisks[0].Lun;
// Create the Image
var imageInput = new Image(m_location)
{
Tags =
{
{ "RG", "rg" },
{ "testTag", "1" },
},
StorageProfile = new ImageStorageProfile()
{
OsDisk = new ImageOSDisk(OperatingSystemTypes.Windows, OperatingSystemStateTypes.Generalized)
{
BlobUri = createdVM.StorageProfile.OsDisk.Vhd.Uri,
DiskEncryptionSet = diskEncryptionSetId == null ? null : new DiskEncryptionSetParameters()
{
Id = diskEncryptionSetId
},
},
DataDisks =
{
new ImageDataDisk(expectedDiskLunWithDiskEncryptionSet)
{
BlobUri = createdVM.StorageProfile.DataDisks[0].Vhd.Uri,
DiskEncryptionSet = diskEncryptionSetId == null ? null: new DiskEncryptionSetParameters()
{
Id = diskEncryptionSetId
},
}
}
},
HyperVGeneration = HyperVGenerationTypes.V1
};
var image = await WaitForCompletionAsync(await ImagesOperations.StartCreateOrUpdateAsync(rgName, imageName, imageInput));
var getImage = (await ImagesOperations.GetAsync(rgName, imageName)).Value;
ValidateImage(imageInput, getImage);
if (diskEncryptionSetId != null)
{
Assert.True(getImage.StorageProfile.OsDisk.DiskEncryptionSet != null, "OsDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getImage.StorageProfile.OsDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"getImage.StorageProfile.OsDisk.DiskEncryptionSet is not matching with expected DiskEncryptionSet resource");
Assert.AreEqual(1, getImage.StorageProfile.DataDisks.Count);
Assert.True(getImage.StorageProfile.DataDisks[0].DiskEncryptionSet != null, ".DataDisks.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getImage.StorageProfile.DataDisks[0].DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"DataDisks.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
}
ImageUpdate updateParams = new ImageUpdate();
updateParams.Tags.InitializeFrom(getImage.Tags);
string tagKey = "UpdateTag";
updateParams.Tags.Add(tagKey, "TagValue");
await WaitForCompletionAsync(await ImagesOperations.StartUpdateAsync(rgName, imageName, updateParams));
getImage = (await ImagesOperations.GetAsync(rgName, imageName)).Value;
Assert.True(getImage.Tags.ContainsKey(tagKey));
var listResponse = await(ImagesOperations.ListByResourceGroupAsync(rgName)).ToEnumerableAsync();
Assert.IsTrue(listResponse.Count() == 1);
await WaitForCompletionAsync(await ImagesOperations.StartDeleteAsync(rgName, image.Value.Name));
}
public void TestVMDataDiskScenario()
{
using (var context = UndoContext.Current)
{
context.Start();
EnsureClientsInitialized();
ImageReference imgageRef = GetPlatformVMImage(useWindowsImage: true);
// Create resource group
var rgName = TestUtilities.GenerateName(TestPrefix);
string storageAccountName = TestUtilities.GenerateName(TestPrefix);
string asName = TestUtilities.GenerateName("as");
VirtualMachine inputVM;
bool passed = false;
try
{
// Create Storage Account, so that both the VMs can share it
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
Action <VirtualMachine> addDataDiskToVM = vm =>
{
string containerName = TestUtilities.GenerateName(TestPrefix);
var vhdContainer = string.Format(Constants.StorageAccountBlobUriTemplate, storageAccountName) + containerName;
var vhduri = vhdContainer + string.Format("/{0}.vhd", TestUtilities.GenerateName(TestPrefix));
vm.HardwareProfile.VirtualMachineSize = VirtualMachineSizeTypes.StandardA4;
vm.StorageProfile.DataDisks = new List <DataDisk>();
foreach (int index in new int[] { 1, 2 })
{
var diskName = "dataDisk" + index;
var ddUri = vhdContainer + string.Format("/{0}{1}.vhd", diskName, TestUtilities.GenerateName(TestPrefix));
var dd = new DataDisk
{
Caching = CachingTypes.None,
SourceImage = null,
DiskSizeGB = 10,
CreateOption = DiskCreateOptionTypes.Empty,
Lun = 1 + index,
Name = diskName,
VirtualHardDisk = new VirtualHardDisk
{
Uri = ddUri
}
};
vm.StorageProfile.DataDisks.Add(dd);
}
var testStatus = new InstanceViewStatus
{
Code = "test",
Message = "test"
};
var testStatusList = new List <InstanceViewStatus> {
testStatus
};
// Negative tests for a bug in 5.0.0 that read-only fields have side-effect on the request body
vm.InstanceView = new VirtualMachineInstanceView
{
Statuses = testStatusList,
VMAgent = new VirtualMachineAgentInstanceView
{
Statuses = testStatusList,
ExtensionHandlers = new List <VirtualMachineExtensionHandlerInstanceView>
{
new VirtualMachineExtensionHandlerInstanceView
{
Status = testStatus,
Type = "test",
TypeHandlerVersion = "test"
}
},
VMAgentVersion = "test"
},
Disks = new List <DiskInstanceView>
{
new DiskInstanceView
{
Statuses = testStatusList,
Name = "test"
}
},
Extensions = new List <VirtualMachineExtensionInstanceView>
{
new VirtualMachineExtensionInstanceView
{
Statuses = testStatusList
}
}
};
};
var vm1 = CreateVM_NoAsyncTracking(rgName, asName, storageAccountOutput, imgageRef, out inputVM, addDataDiskToVM);
var getVMWithInstanceViewResponse = m_CrpClient.VirtualMachines.GetWithInstanceView(rgName, inputVM.Name);
Assert.True(getVMWithInstanceViewResponse.StatusCode == HttpStatusCode.OK);
Assert.True(getVMWithInstanceViewResponse.VirtualMachine != null, "VM in Get");
ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse.VirtualMachine);
var vm2 = getVMWithInstanceViewResponse.VirtualMachine;
var vmReCreateResponse = m_CrpClient.VirtualMachines.CreateOrUpdate(rgName, getVMWithInstanceViewResponse.VirtualMachine);
Assert.True(vmReCreateResponse.Status != ComputeOperationStatus.Failed);
var lroResponse = m_CrpClient.VirtualMachines.Delete(rgName, inputVM.Name);
Assert.True(lroResponse.Status != OperationStatus.Failed);
passed = true;
}
finally
{
var deleteResourceGroupResponse = m_ResourcesClient.ResourceGroups.Delete(rgName);
Assert.True(deleteResourceGroupResponse.StatusCode == HttpStatusCode.OK);
Assert.True(passed);
}
}
}
public void CreateRpcAndRestorePoints()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
EnsureClientsInitialized(context);
string location = ComputeManagementTestUtilities.DefaultLocation;
var rgName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
VirtualMachine inputVM;
string storageAccountForDisksName = TestUtilities.GenerateName(TestPrefix);
string availabilitySetName = TestUtilities.GenerateName(TestPrefix);
try
{
StorageAccount storageAccountForDisks = CreateStorageAccount(rgName, storageAccountForDisksName);
// create the VM
VirtualMachine createdVM = CreateVM(rgName, availabilitySetName, storageAccountForDisks, imageRef, out inputVM,
(vm) =>
{
vm.DiagnosticsProfile = GetManagedDiagnosticsProfile();
}, hasManagedDisks: true);
DataDisk dataDisk = createdVM.StorageProfile.DataDisks[0];
string dataDiskId = dataDisk.ManagedDisk.Id;
OSDisk osDisk = createdVM.StorageProfile.OsDisk;
string rpName = ComputeManagementTestUtilities.GenerateName("rpClientTest");
string rpcName = ComputeManagementTestUtilities.GenerateName("rpc1ClientTest");
string rpcName2 = ComputeManagementTestUtilities.GenerateName("rpc2ClientTest");
string vmId = createdVM.Id;
string vmSize = createdVM.HardwareProfile.VmSize;
// create two RPCs
Dictionary <string, string> tags = new Dictionary <string, string>()
{
{ "RG", "rg" },
{ "testTag", "testTagValue" },
};
RestorePointCollection createdRpc = CreateRpc(createdVM.Id, rpcName, rgName, location, tags);
VerifyRpc(createdRpc, rpcName, location, vmId);
RestorePointCollection createdRpc2 = CreateRpc(createdVM.Id, rpcName2, rgName, location, tags);
VerifyRpc(createdRpc2, rpcName2, location, vmId);
// for PATCH RPC, only tags are allowed to be updated
Dictionary <string, string> newTags = new Dictionary <string, string>()
{
{ "newTag", "newValue1" },
{ "newtestTag", "newValue2" },
};
UpdateRpc(rgName, rpcName, createdRpc, newTags);
// GET list of all rpc in the resource group.
IEnumerable <RestorePointCollection> rpcs = ListRpcInResourceGroup(rgName);
VerifyReturnedRpcs(rpcs, rpcName, rpcName2, location, vmId);
// GET list of all rpc in subscription.
rpcs = ListRpcInSubscription();
VerifyReturnedRpcs(rpcs, rpcName, rpcName2, location, vmId);
// create RP in the RPC
RestorePoint createdRP = CreateRestorePoint(rgName, rpcName, rpName, osDisk, diskToExclude: dataDiskId);
VerifyRestorePointDetails(createdRP, rpName, osDisk, 1,
excludeDiskId: dataDiskId, vmSize: vmSize);
RestorePoint getRP = GetRP(rgName, rpcName, rpName);
VerifyRestorePointDetails(createdRP, rpName, osDisk, 1,
excludeDiskId: dataDiskId, vmSize: vmSize);
// get RPC without $expand=restorePoints
RestorePointCollection returnedRpc = GetRpc(rgName, rpcName);
VerifyRpc(returnedRpc, rpcName, location, vmId);
// get RPC with $expand=restorePoints
returnedRpc = GetRpc(rgName, rpcName,
RestorePointCollectionExpandOptions.RestorePoints);
VerifyRpc(returnedRpc, rpcName, location, vmId,
shouldRpcContainRestorePoints: true);
// verify the restore point returned from GET RPC with $expand=restorePoints
RestorePoint rpInRpc = returnedRpc.RestorePoints[0];
VerifyRestorePointDetails(rpInRpc, rpName, osDisk, 1,
excludeDiskId: dataDiskId, vmSize: vmSize);
// delete the restore point
DeleteRP(rgName, rpcName, rpName);
// GET of deleted restore point should return 404 not found
try
{
GetRP(rgName, rpcName, rpName);
Assert.False(true);
}
catch (CloudException ex)
{
Assert.True(ex.Response.StatusCode == HttpStatusCode.NotFound);
}
// delete the restore point collection
DeleteRpc(rgName, rpcName);
// GET of deleted RPC should return 404 not found
try
{
GetRpc(rgName, rpcName);
Assert.False(true);
}
catch (CloudException ex)
{
Assert.True(ex.Response.StatusCode == HttpStatusCode.NotFound);
}
}
catch (Exception e)
{
throw e;
}
finally
{
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
}
}
