private async Task VerifyNonDefaultValuesSucceed()
{
// Negative tests for a bug in 5.0.0 that read-only fields have side-effect on the request body
var testStatus = new InstanceViewStatus
{
Code = "test",
DisplayStatus = "test",
Message = "test"
};
string inputAvailabilitySetName = Recording.GenerateAssetName("asnondefault");
var inputAvailabilitySet = new AvailabilitySet(TestEnvironment.Location)
{
Tags =
{
{ "RG", "rg" },
{ "testTag", "1" },
},
PlatformFaultDomainCount = nonDefaultFD,
PlatformUpdateDomainCount = nonDefaultUD
};
var createOrUpdateResponse = (await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet)).Value;
// This call will also delete the Availability Set
await ValidateResults(createOrUpdateResponse, inputAvailabilitySet, resourceGroup1Name, inputAvailabilitySetName, nonDefaultFD, nonDefaultUD);
}
/// <summary>
/// Initializes client properties.
/// </summary>
private void Initialize()
{
Operations = new Operations(this);
AvailabilitySets = new AvailabilitySetsOperations(this);
VirtualMachineExtensionImages = new VirtualMachineExtensionImagesOperations(this);
VirtualMachineExtensions = new VirtualMachineExtensionsOperations(this);
VirtualMachines = new VirtualMachinesOperations(this);
VirtualMachineImages = new VirtualMachineImagesOperations(this);
Usage = new UsageOperations(this);
VirtualMachineSizes = new VirtualMachineSizesOperations(this);
Images = new ImagesOperations(this);
VirtualMachineScaleSets = new VirtualMachineScaleSetsOperations(this);
VirtualMachineScaleSetExtensions = new VirtualMachineScaleSetExtensionsOperations(this);
VirtualMachineScaleSetRollingUpgrades = new VirtualMachineScaleSetRollingUpgradesOperations(this);
VirtualMachineScaleSetVMs = new VirtualMachineScaleSetVMsOperations(this);
LogAnalytics = new LogAnalyticsOperations(this);
VirtualMachineRunCommands = new VirtualMachineRunCommandsOperations(this);
ResourceSkus = new ResourceSkusOperations(this);
Disks = new DisksOperations(this);
Snapshots = new SnapshotsOperations(this);
ContainerServices = new ContainerServicesOperations(this);
BaseUri = new System.Uri("https://management.azure.com");
AcceptLanguage = "en-US";
LongRunningOperationRetryTimeout = 30;
GenerateClientRequestId = true;
SerializationSettings = new JsonSerializerSettings
{
Formatting = Newtonsoft.Json.Formatting.Indented,
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
SerializationSettings.Converters.Add(new TransformationJsonConverter());
DeserializationSettings = new JsonSerializerSettings
{
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
CustomInitialize();
DeserializationSettings.Converters.Add(new TransformationJsonConverter());
DeserializationSettings.Converters.Add(new CloudErrorJsonConverter());
}
private async Task VerifyDefaultValuesSucceed()
{
var inputAvailabilitySetName = Recording.GenerateAssetName("asdefaultvalues");
var inputAvailabilitySet = new AvailabilitySet(TestEnvironment.Location)
{
Tags = new Dictionary <string, string>()
{
{ "RG", "rg" },
{ "testTag", "1" },
},
};
var createOrUpdateResponse = await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet);
// List AvailabilitySets
string expectedAvailabilitySetId = Helpers.GetAvailabilitySetRef(subId, resourceGroup1Name, inputAvailabilitySetName);
var listResponse = AvailabilitySetsOperations.ListAsync(resourceGroup1Name);
var listResponseList = await listResponse.ToEnumerableAsync();
ValidateAvailabilitySet(inputAvailabilitySet, listResponseList.FirstOrDefault(x => x.Name == inputAvailabilitySetName),
inputAvailabilitySetName, expectedAvailabilitySetId, defaultFD, defaultUD);
AvailabilitySetUpdate updateParams = new AvailabilitySetUpdate()
{
Tags = inputAvailabilitySet.Tags
};
string updateKey = "UpdateTag";
updateParams.Tags.Add(updateKey, "updateValue");
createOrUpdateResponse = await AvailabilitySetsOperations.UpdateAsync(resourceGroup1Name, inputAvailabilitySetName, updateParams);
Assert.True(createOrUpdateResponse.Value.Tags.ContainsKey(updateKey));
// This call will also delete the Availability Set
await ValidateResults(createOrUpdateResponse, inputAvailabilitySet, resourceGroup1Name, inputAvailabilitySetName, defaultFD, defaultUD);
}
private async Task ValidateResults(AvailabilitySet outputAvailabilitySet, AvailabilitySet inputAvailabilitySet, string resourceGroupName, string inputAvailabilitySetName, int expectedFD, int expectedUD)
{
string expectedAvailabilitySetId = Helpers.GetAvailabilitySetRef(subId, resourceGroupName, inputAvailabilitySetName);
Assert.True(outputAvailabilitySet.Name == inputAvailabilitySetName);
Assert.True(outputAvailabilitySet.Location.ToLower() == this.TestEnvironment.Location.ToLower() ||
outputAvailabilitySet.Location.ToLower() == inputAvailabilitySet.Location.ToLower());
ValidateAvailabilitySet(inputAvailabilitySet, outputAvailabilitySet, inputAvailabilitySetName, expectedAvailabilitySetId, expectedFD, expectedUD);
// GET AvailabilitySet
var getResponse = await AvailabilitySetsOperations.GetAsync(resourceGroupName, inputAvailabilitySetName);
ValidateAvailabilitySet(inputAvailabilitySet, getResponse, inputAvailabilitySetName, expectedAvailabilitySetId, expectedFD, expectedUD);
// List VM Sizes
var listVMSizesResponse = AvailabilitySetsOperations.ListAvailableSizesAsync(resourceGroupName, inputAvailabilitySetName);
var listVMSizesResp = await listVMSizesResponse.ToEnumerableAsync();
Helpers.ValidateVirtualMachineSizeListResponse(listVMSizesResp);
// Delete AvailabilitySet
await AvailabilitySetsOperations.DeleteAsync(resourceGroupName, inputAvailabilitySetName);
}
private async Task TestVMScenarioOperationsInternal(string methodName, bool hasManagedDisks = false, IList <string> zones = null, string vmSize = "Standard_A0",
string osDiskStorageAccountType = "Standard_LRS", string dataDiskStorageAccountType = "Standard_LRS", bool?writeAcceleratorEnabled = null,
bool hasDiffDisks = false, bool callUpdateVM = false, bool isPpgScenario = false, string diskEncryptionSetId = null)
{
var imageRef = await GetPlatformVMImage(useWindowsImage : true);
const string expectedOSName = "Windows Server 2012 R2 Datacenter", expectedOSVersion = "Microsoft Windows NT 6.3.9600.0", expectedComputerName = ComputerName;
// Create resource group
var rgName = Recording.GenerateAssetName(TestPrefix);
string storageAccountName = Recording.GenerateAssetName(TestPrefix);
string asName = Recording.GenerateAssetName("as");
string ppgName = null;
string expectedPpgReferenceId = null;
if (isPpgScenario)
{
ppgName = Recording.GenerateAssetName("ppgtest");
expectedPpgReferenceId = Helpers.GetProximityPlacementGroupRef(m_subId, rgName, ppgName);
}
VirtualMachine inputVM;
if (!hasManagedDisks)
{
await CreateStorageAccount(rgName, storageAccountName);
}
var returnTwoVM = await CreateVM(rgName, asName, storageAccountName, imageRef, hasManagedDisks : hasManagedDisks, hasDiffDisks : hasDiffDisks, vmSize : vmSize, osDiskStorageAccountType : osDiskStorageAccountType,
dataDiskStorageAccountType : dataDiskStorageAccountType, writeAcceleratorEnabled : writeAcceleratorEnabled, zones : zones, ppgName : ppgName, diskEncryptionSetId : diskEncryptionSetId);
//VirtualMachine outVM = returnTwoVM.Item1;
inputVM = returnTwoVM.Input;
string inputVMName = returnTwoVM.Name;
// Instance view is not completely populated just after VM is provisioned. So we wait here for a few minutes to
// allow GA blob to populate.
WaitMinutes(5);
var getVMWithInstanceViewResponse = (await VirtualMachinesOperations.GetAsync(rgName, inputVMName)).Value;
Assert.True(getVMWithInstanceViewResponse != null, "VM in Get");
if (diskEncryptionSetId != null)
{
Assert.True(getVMWithInstanceViewResponse.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet != null, "OsDisk.ManagedDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getVMWithInstanceViewResponse.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"OsDisk.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
Assert.AreEqual(1, getVMWithInstanceViewResponse.StorageProfile.DataDisks.Count);
Assert.True(getVMWithInstanceViewResponse.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet != null, ".DataDisks.ManagedDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getVMWithInstanceViewResponse.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"DataDisks.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
}
ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse, hasManagedDisks, expectedComputerName, expectedOSName, expectedOSVersion);
var getVMInstanceViewResponse = await VirtualMachinesOperations.InstanceViewAsync(rgName, inputVMName);
Assert.True(getVMInstanceViewResponse != null, "VM in InstanceView");
ValidateVMInstanceView(inputVM, getVMInstanceViewResponse, hasManagedDisks, expectedComputerName, expectedOSName, expectedOSVersion);
bool hasUserDefinedAS = zones == null;
string expectedVMReferenceId = Helpers.GetVMReferenceId(m_subId, rgName, inputVMName);
var listResponse = await(VirtualMachinesOperations.ListAsync(rgName)).ToEnumerableAsync();
ValidateVM(inputVM, listResponse.FirstOrDefault(x => x.Name == inputVMName),
expectedVMReferenceId, hasManagedDisks, hasUserDefinedAS, writeAcceleratorEnabled, hasDiffDisks, expectedPpgReferenceId: expectedPpgReferenceId);
var listVMSizesResponse = await(VirtualMachinesOperations.ListAvailableSizesAsync(rgName, inputVMName)).ToEnumerableAsync();
Helpers.ValidateVirtualMachineSizeListResponse(listVMSizesResponse, hasAZ: zones != null, writeAcceleratorEnabled: writeAcceleratorEnabled, hasDiffDisks: hasDiffDisks);
listVMSizesResponse = await(AvailabilitySetsOperations.ListAvailableSizesAsync(rgName, asName)).ToEnumerableAsync();
Helpers.ValidateVirtualMachineSizeListResponse(listVMSizesResponse, hasAZ: zones != null, writeAcceleratorEnabled: writeAcceleratorEnabled, hasDiffDisks: hasDiffDisks);
if (isPpgScenario)
{
ProximityPlacementGroup outProximityPlacementGroup = await ProximityPlacementGroupsOperations.GetAsync(rgName, ppgName);
string expectedAvSetReferenceId = Helpers.GetAvailabilitySetRef(m_subId, rgName, asName);
Assert.AreEqual(1, outProximityPlacementGroup.VirtualMachines.Count);
Assert.AreEqual(1, outProximityPlacementGroup.AvailabilitySets.Count);
Assert.AreEqual(expectedVMReferenceId, outProximityPlacementGroup.VirtualMachines.First().Id);
Assert.AreEqual(expectedAvSetReferenceId, outProximityPlacementGroup.AvailabilitySets.First().Id);
//Assert.Equal(expectedVMReferenceId, outProximityPlacementGroup.VirtualMachines.First().Id, StringComparer.OrdinalIgnoreCase);
//Assert.Equal(expectedAvSetReferenceId, outProximityPlacementGroup.AvailabilitySets.First().Id, StringComparer.OrdinalIgnoreCase);
}
if (callUpdateVM)
{
VirtualMachineUpdate updateParams = new VirtualMachineUpdate();
updateParams.Tags.InitializeFrom(inputVM.Tags);
string updateKey = "UpdateTag";
updateParams.Tags.Add(updateKey, "UpdateTagValue");
VirtualMachine updateResponse = await WaitForCompletionAsync(await VirtualMachinesOperations.StartUpdateAsync(rgName, inputVMName, updateParams));
Assert.True(updateResponse.Tags.ContainsKey(updateKey));
}
}
private async Task VerifyInvalidFDUDValuesFail()
{
var inputAvailabilitySetName = Recording.GenerateAssetName("invalidfdud");
var inputAvailabilitySet = new AvailabilitySet(TestEnvironment.Location)
{
Tags =
{
{ "RG", "rg" },
{ "testTag", "1" },
},
};
// function to test the limits available.
inputAvailabilitySet.PlatformFaultDomainCount = FDTooLow;
AvailabilitySet createOrUpdateResponse = null;
try
{
createOrUpdateResponse = await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet);
}
catch (Exception ex)
//catch (CloudException ex)
{
Assert.NotNull(ex);
//Assert.True(ex.Response.StatusCode == HttpStatusCode.BadRequest);
}
Assert.True(createOrUpdateResponse == null);
inputAvailabilitySet.PlatformFaultDomainCount = FDTooHi;
try
{
createOrUpdateResponse = await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet);
}
catch (Exception ex)
{
Assert.NotNull(ex);
//Assert.True(ex.Response.StatusCode == HttpStatusCode.BadRequest);
}
Assert.True(createOrUpdateResponse == null);
inputAvailabilitySet.PlatformUpdateDomainCount = UDTooLow;
try
{
createOrUpdateResponse = await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet);
}
catch (Exception ex)
{
Assert.NotNull(ex);
//Assert.True(ex.Response.StatusCode == HttpStatusCode.BadRequest);
}
Assert.True(createOrUpdateResponse == null);
inputAvailabilitySet.PlatformUpdateDomainCount = UDTooHi;
try
{
createOrUpdateResponse = await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet);
}
catch (Exception ex)
{
Assert.NotNull(ex);
//Assert.True(ex.Response.StatusCode == HttpStatusCode.BadRequest);
}
Assert.True(createOrUpdateResponse == null);
}
// Make sure availability sets across resource groups are listed successfully
private async Task VerifyListAvailabilitySetsInSubscription()
{
string resourceGroup2Name = baseResourceGroupName + "_2";
string baseInputAvailabilitySetName = Recording.GenerateAssetName("asdefaultvalues");
string availabilitySet1Name = baseInputAvailabilitySetName + "_1";
string availabilitySet2Name = baseInputAvailabilitySetName + "_2";
//try
//{
AvailabilitySet inputAvailabilitySet1 = new AvailabilitySet(TestEnvironment.Location)
{
Tags =
{
{ "RG1", "rg1" },
{ "testTag", "1" },
},
};
AvailabilitySet outputAvailabilitySet1 = await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
availabilitySet1Name,
inputAvailabilitySet1);
resourceGroup2 = (await ResourceGroupsOperations.CreateOrUpdateAsync(
resourceGroup2Name,
new ResourceGroup(TestEnvironment.Location)
{
Tags = { { resourceGroup2Name, Recording.UtcNow.ToString("u") } }
})).Value;
AvailabilitySet inputAvailabilitySet2 = new AvailabilitySet(TestEnvironment.Location)
{
Tags =
{
{ "RG2", "rg2" },
{ "testTag", "2" },
},
};
AvailabilitySet outputAvailabilitySet2 = (await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup2Name,
availabilitySet2Name,
inputAvailabilitySet2)).Value;
var response = AvailabilitySetsOperations.ListBySubscriptionAsync();
var resp = await response.ToEnumerableAsync();
//Assert.Null(resp.NextPageLink);
foreach (AvailabilitySet availabilitySet in resp)
{
if (availabilitySet.Name == availabilitySet1Name)
{
Assert.AreEqual(inputAvailabilitySet1.Location, availabilitySet.Location);
Assert.IsEmpty(availabilitySet.VirtualMachines);
}
else if (availabilitySet.Name == availabilitySet2Name)
{
Assert.AreEqual(inputAvailabilitySet2.Location, availabilitySet.Location);
Assert.IsEmpty(availabilitySet.VirtualMachines);
}
}
response = AvailabilitySetsOperations.ListBySubscriptionAsync("virtualMachines/$ref");
resp = await response.ToEnumerableAsync();
int validationCount = 0;
foreach (AvailabilitySet availabilitySet in resp)
{
Assert.NotNull(availabilitySet.VirtualMachines);
if (availabilitySet.Name == availabilitySet1Name)
{
Assert.AreEqual(0, availabilitySet.VirtualMachines.Count);
await ValidateResults(outputAvailabilitySet1, inputAvailabilitySet1, resourceGroup1Name, availabilitySet1Name, defaultFD, defaultUD);
validationCount++;
}
else if (availabilitySet.Name == availabilitySet2Name)
{
Assert.AreEqual(0, availabilitySet.VirtualMachines.Count);
await ValidateResults(outputAvailabilitySet2, inputAvailabilitySet2, resourceGroup2Name, availabilitySet2Name, defaultFD, defaultUD);
validationCount++;
}
}
Assert.True(validationCount == 2);
}
