private void ValidateCapacityReservation(CapacityReservation expectedCR, CapacityReservation actualCR)
{
if (expectedCR == null)
{
Assert.Null(actualCR);
}
else
{
Assert.NotNull(actualCR);
if (expectedCR.VirtualMachinesAssociated == null)
{
Assert.Null(actualCR.VirtualMachinesAssociated);
}
else
{
Assert.NotNull(actualCR);
Assert.True(actualCR.VirtualMachinesAssociated.SequenceEqual(expectedCR.VirtualMachinesAssociated));
}
Assert.Equal(expectedCR.Location, actualCR.Location);
Assert.Equal(expectedCR.Name, actualCR.Name);
Assert.Equal(expectedCR.ReservationId, actualCR.ReservationId);
Assert.NotNull(actualCR.Sku);
Assert.Equal(expectedCR.Sku.Name, actualCR.Sku.Name);
Assert.Equal(expectedCR.Sku.Capacity, actualCR.Sku.Capacity);
if (expectedCR.Zones != null)
{
Assert.Equal(1, actualCR.Zones.Count);
Assert.True(actualCR.Zones.SequenceEqual(expectedCR.Zones));
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.Name, VerbsCommon.New))
{
CapacityReservation capacityReservation = new CapacityReservation();
capacityReservation.Location = this.Location;
capacityReservation.Sku = new Sku();
capacityReservation.Sku.Name = this.Sku;
capacityReservation.Sku.Capacity = this.CapacityToReserve;
if (this.IsParameterBound(c => c.Tag))
{
capacityReservation.Tags = this.Tag.Cast <DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value);
}
if (this.IsParameterBound(c => c.Zone))
{
capacityReservation.Zones = this.Zone;
}
var result = CapacityReservationClient.CreateOrUpdate(this.ResourceGroupName, this.ReservationGroupName, this.Name, capacityReservation);
var psObject = new PSCapacityReservation();
ComputeAutomationAutoMapperProfile.Mapper.Map <CapacityReservation, PSCapacityReservation>(result, psObject);
WriteObject(psObject);
}
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (this.IsParameterBound(c => c.Name))
{
CapacityReservation result = new CapacityReservation();
if (this.InstanceView.IsPresent)
{
result = CapacityReservationClient.Get(this.ResourceGroupName, this.ReservationGroupName, this.Name, "InstanceView");
}
else
{
result = CapacityReservationClient.Get(this.ResourceGroupName, this.ReservationGroupName, this.Name);
}
var psObject = new PSCapacityReservation();
ComputeAutomationAutoMapperProfile.Mapper.Map <CapacityReservation, PSCapacityReservation>(result, psObject);
WriteObject(psObject);
}
else
{
var result = CapacityReservationClient.ListByCapacityReservationGroup(this.ResourceGroupName, this.ReservationGroupName);
var resultList = result.ToList();
var nextPageLink = result.NextPageLink;
while (!string.IsNullOrEmpty(nextPageLink))
{
var pageResult = CapacityReservationClient.ListByCapacityReservationGroupNext(nextPageLink);
foreach (var pageItem in pageResult)
{
resultList.Add(pageItem);
}
nextPageLink = pageResult.NextPageLink;
}
var psObject = new List <PSCapacityReservationList>();
foreach (var r in resultList)
{
psObject.Add(ComputeAutomationAutoMapperProfile.Mapper.Map <CapacityReservation, PSCapacityReservationList>(r));
}
WriteObject(TopLevelWildcardFilter(this.ResourceGroupName, this.Name, psObject), true);
}
});
}
/// <summary>
/// The operation to create or update a capacity reservation. Please note some
/// properties can be set only during capacity reservation creation. Please
/// refer to https://aka.ms/CapacityReservation for more details.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='capacityReservationGroupName'>
/// The name of the capacity reservation group.
/// </param>
/// <param name='capacityReservationName'>
/// The name of the capacity reservation.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Create capacity reservation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <CapacityReservation> CreateOrUpdateAsync(this ICapacityReservationsOperations operations, string resourceGroupName, string capacityReservationGroupName, string capacityReservationName, CapacityReservation parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, capacityReservationGroupName, capacityReservationName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// The operation to create or update a capacity reservation. Please note some
/// properties can be set only during capacity reservation creation. Please
/// refer to https://aka.ms/CapacityReservation for more details.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='capacityReservationGroupName'>
/// The name of the capacity reservation group.
/// </param>
/// <param name='capacityReservationName'>
/// The name of the capacity reservation.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Create capacity reservation.
/// </param>
public static CapacityReservation CreateOrUpdate(this ICapacityReservationsOperations operations, string resourceGroupName, string capacityReservationGroupName, string capacityReservationName, CapacityReservation parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, capacityReservationGroupName, capacityReservationName, parameters).GetAwaiter().GetResult());
}
private void TestVMScenarioOperationsInternal(string methodName, bool hasManagedDisks = false, IList <string> zones = null, string vmSize = "Standard_A1_v2",
string osDiskStorageAccountType = "Standard_LRS", string dataDiskStorageAccountType = "Standard_LRS", bool?writeAcceleratorEnabled = null,
bool hasDiffDisks = false, bool callUpdateVM = false, bool isPpgScenario = false, string diskEncryptionSetId = null, bool?encryptionAtHostEnabled = null,
string securityType = null, bool isAutomaticPlacementOnDedicatedHostGroupScenario = false, ImageReference imageReference = null, bool validateListAvailableSize = true,
bool associateWithCapacityReservation = false, VMDiskSecurityProfile diskSecurityProfile = null)
{
using (MockContext context = MockContext.Start(this.GetType(), methodName))
{
EnsureClientsInitialized(context);
ImageReference imageRef = imageReference ?? 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 = ComputeManagementTestUtilities.GenerateName(TestPrefix);
string storageAccountName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
string asName = ComputeManagementTestUtilities.GenerateName("as");
string ppgName = null, expectedPpgReferenceId = null;
string dedicatedHostGroupName = null, dedicatedHostName = null, dedicatedHostGroupReferenceId = null, dedicatedHostReferenceId = null;
string capacityReservationGroupName = null, capacityReservationGroupReferenceId = null, capacityReservationName = null;
if (isPpgScenario)
{
ppgName = ComputeManagementTestUtilities.GenerateName("ppgtest");
expectedPpgReferenceId = Helpers.GetProximityPlacementGroupRef(m_subId, rgName, ppgName);
}
if (isAutomaticPlacementOnDedicatedHostGroupScenario)
{
dedicatedHostGroupName = ComputeManagementTestUtilities.GenerateName("dhgtest");
dedicatedHostName = ComputeManagementTestUtilities.GenerateName("dhtest");
dedicatedHostGroupReferenceId = Helpers.GetDedicatedHostGroupRef(m_subId, rgName, dedicatedHostGroupName);
dedicatedHostReferenceId = Helpers.GetDedicatedHostRef(m_subId, rgName, dedicatedHostGroupName, dedicatedHostName);
}
if (associateWithCapacityReservation)
{
capacityReservationGroupName = ComputeManagementTestUtilities.GenerateName("crgtest");
capacityReservationName = ComputeManagementTestUtilities.GenerateName("crtest");
CreateCapacityReservationGroup(rgName, capacityReservationGroupName);
CreateCapacityReservation(rgName, capacityReservationGroupName, capacityReservationName, VirtualMachineSizeTypes.StandardDS1V2, reservedCount: 1);
capacityReservationGroupReferenceId = Helpers.GetCapacityReservationGroupRef(m_subId, rgName, capacityReservationGroupName);
}
VirtualMachine inputVM;
try
{
if (!hasManagedDisks)
{
CreateStorageAccount(rgName, storageAccountName);
}
CreateVM(rgName, asName, storageAccountName, imageRef, out inputVM, hasManagedDisks: hasManagedDisks, hasDiffDisks: hasDiffDisks, vmSize: vmSize, osDiskStorageAccountType: osDiskStorageAccountType,
dataDiskStorageAccountType: dataDiskStorageAccountType, writeAcceleratorEnabled: writeAcceleratorEnabled, zones: zones, ppgName: ppgName,
diskEncryptionSetId: diskEncryptionSetId, encryptionAtHostEnabled: encryptionAtHostEnabled, securityType: securityType, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId,
dedicatedHostGroupName: dedicatedHostGroupName, dedicatedHostName: dedicatedHostName, capacityReservationGroupReferenceId: capacityReservationGroupReferenceId,
diskSecurityProfile: diskSecurityProfile);
// 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.
ComputeManagementTestUtilities.WaitMinutes(5);
var getVMWithInstanceViewResponse = m_CrpClient.VirtualMachines.Get(rgName, inputVM.Name, InstanceViewTypes.InstanceView);
Assert.True(getVMWithInstanceViewResponse != null, "VM in Get");
string expectedVMReferenceId = Helpers.GetVMReferenceId(m_subId, rgName, inputVM.Name);
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.Equal(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");
}
if (associateWithCapacityReservation)
{
Assert.True(getVMWithInstanceViewResponse.CapacityReservation.CapacityReservationGroup != null, "CapacityReservation.CapacityReservationGroup is null");
Assert.True(string.Equals(capacityReservationGroupReferenceId, getVMWithInstanceViewResponse.CapacityReservation.CapacityReservationGroup.Id, StringComparison.OrdinalIgnoreCase),
"CapacityReservation.CapacityReservationGroup.Id is not matching with expected CapacityReservationGroup resource");
CapacityReservation capacityReservation =
m_CrpClient.CapacityReservations.Get(rgName, capacityReservationGroupName, capacityReservationName, CapacityReservationInstanceViewTypes.InstanceView);
Assert.True(capacityReservation.VirtualMachinesAssociated.Any(), "capacityReservation.VirtualMachinesAssociated is not empty");
Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.VirtualMachinesAssociated.First().Id, StringComparison.OrdinalIgnoreCase), "capacityReservation.VirtualMachinesAssociated are not matching");
Assert.True(capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.Any(), "InstanceView.UtilizationInfo.VirtualMachinesAllocated is empty");
Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.First().Id, StringComparison.OrdinalIgnoreCase),
"InstanceView.UtilizationInfo.VirtualMachinesAllocated are not matching");
}
ValidateVMInstanceView(inputVM, getVMWithInstanceViewResponse, hasManagedDisks, expectedComputerName, expectedOSName, expectedOSVersion, dedicatedHostReferenceId);
var getVMInstanceViewResponse = m_CrpClient.VirtualMachines.InstanceView(rgName, inputVM.Name);
Assert.True(getVMInstanceViewResponse != null, "VM in InstanceView");
ValidateVMInstanceView(inputVM, getVMInstanceViewResponse, hasManagedDisks, expectedComputerName, expectedOSName, expectedOSVersion, dedicatedHostReferenceId);
bool hasUserDefinedAS = inputVM.AvailabilitySet != null;
var listResponse = m_CrpClient.VirtualMachines.List(rgName);
ValidateVM(inputVM, listResponse.FirstOrDefault(x => x.Name == inputVM.Name),
expectedVMReferenceId, hasManagedDisks, hasUserDefinedAS, writeAcceleratorEnabled, hasDiffDisks, expectedPpgReferenceId: expectedPpgReferenceId,
encryptionAtHostEnabled: encryptionAtHostEnabled, expectedDedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId);
if (validateListAvailableSize)
{
var listVMSizesResponse = m_CrpClient.VirtualMachines.ListAvailableSizes(rgName, inputVM.Name);
Helpers.ValidateVirtualMachineSizeListResponse(listVMSizesResponse, hasAZ: zones != null, writeAcceleratorEnabled: writeAcceleratorEnabled,
hasDiffDisks: hasDiffDisks);
listVMSizesResponse = m_CrpClient.AvailabilitySets.ListAvailableSizes(rgName, asName);
Helpers.ValidateVirtualMachineSizeListResponse(listVMSizesResponse, hasAZ: zones != null, writeAcceleratorEnabled: writeAcceleratorEnabled, hasDiffDisks: hasDiffDisks);
}
if (securityType != null)
{
Assert.True(inputVM.SecurityProfile.UefiSettings.VTpmEnabled);
Assert.True(inputVM.SecurityProfile.UefiSettings.SecureBootEnabled);
}
if (diskSecurityProfile != null)
{
Assert.Equal("ConfidentialVM", inputVM.SecurityProfile.SecurityType);
}
if (isPpgScenario)
{
ProximityPlacementGroup outProximityPlacementGroup = m_CrpClient.ProximityPlacementGroups.Get(rgName, ppgName);
string expectedAvSetReferenceId = Helpers.GetAvailabilitySetRef(m_subId, rgName, asName);
Assert.Equal(1, outProximityPlacementGroup.VirtualMachines.Count);
Assert.Equal(1, outProximityPlacementGroup.AvailabilitySets.Count);
Assert.Equal(expectedVMReferenceId, outProximityPlacementGroup.VirtualMachines.First().Id, StringComparer.OrdinalIgnoreCase);
Assert.Equal(expectedAvSetReferenceId, outProximityPlacementGroup.AvailabilitySets.First().Id, StringComparer.OrdinalIgnoreCase);
}
if (callUpdateVM)
{
VirtualMachineUpdate updateParams = new VirtualMachineUpdate()
{
Tags = inputVM.Tags
};
string updateKey = "UpdateTag";
updateParams.Tags.Add(updateKey, "UpdateTagValue");
VirtualMachine updateResponse = m_CrpClient.VirtualMachines.Update(rgName, inputVM.Name, updateParams);
Assert.True(updateResponse.Tags.ContainsKey(updateKey));
}
}
finally
{
// Fire and forget. No need to wait for RG deletion completion
try
{
m_ResourcesClient.ResourceGroups.BeginDelete(rgName);
}
catch (Exception e)
{
// Swallow this exception so that the original exception is thrown
Console.WriteLine(e);
}
}
}
}
private void TestScaleSetOperationsInternal(MockContext context, string vmSize = null, bool hasManagedDisks = false, bool useVmssExtension = true,
bool hasDiffDisks = false, IList <string> zones = null, int?osDiskSizeInGB = null, bool isPpgScenario = false, bool?enableUltraSSD = false,
Action <VirtualMachineScaleSet> vmScaleSetCustomizer = null, Action <VirtualMachineScaleSet> vmScaleSetValidator = null, string diskEncryptionSetId = null,
bool?encryptionAtHostEnabled = null, bool isAutomaticPlacementOnDedicatedHostGroupScenario = false,
int?faultDomainCount = null, int?capacity = null, bool shouldOverProvision = true, bool validateVmssVMInstanceView = false,
ImageReference imageReference = null, bool validateListSku = true, bool deleteAsPartOfTest = true,
bool associateWithCapacityReservationGroup = false, VirtualMachineScaleSetHardwareProfile hardwareProfile = null)
{
EnsureClientsInitialized(context);
ImageReference imageRef = imageReference ?? GetPlatformVMImage(useWindowsImage: true);
// Create resource group
var rgName = TestUtilities.GenerateName(TestPrefix);
var vmssName = TestUtilities.GenerateName("vmss");
string storageAccountName = TestUtilities.GenerateName(TestPrefix);
VirtualMachineScaleSet inputVMScaleSet;
VirtualMachineScaleSetExtensionProfile extensionProfile = new VirtualMachineScaleSetExtensionProfile()
{
Extensions = new List <VirtualMachineScaleSetExtension>()
{
GetTestVMSSVMExtension(autoUpdateMinorVersion: false),
}
};
try
{
var storageAccountOutput = CreateStorageAccount(rgName, storageAccountName);
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, "VMScaleSetDoesNotExist");
string ppgId = null;
string ppgName = null;
if (isPpgScenario)
{
ppgName = ComputeManagementTestUtilities.GenerateName("ppgtest");
ppgId = CreateProximityPlacementGroup(rgName, ppgName);
}
string dedicatedHostGroupName = null, dedicatedHostName = null, dedicatedHostGroupReferenceId = null, dedicatedHostReferenceId = null;
if (isAutomaticPlacementOnDedicatedHostGroupScenario)
{
dedicatedHostGroupName = ComputeManagementTestUtilities.GenerateName("dhgtest");
dedicatedHostName = ComputeManagementTestUtilities.GenerateName("dhtest");
dedicatedHostGroupReferenceId = Helpers.GetDedicatedHostGroupRef(m_subId, rgName, dedicatedHostGroupName);
dedicatedHostReferenceId = Helpers.GetDedicatedHostRef(m_subId, rgName, dedicatedHostGroupName, dedicatedHostName);
}
bool singlePlacementGroup = true;
string capacityReservationGroupName = null, capacityReservationGroupReferenceId = null, capacityReservationName = null;
if (associateWithCapacityReservationGroup)
{
capacityReservationGroupName = ComputeManagementTestUtilities.GenerateName("crgtest");
capacityReservationName = ComputeManagementTestUtilities.GenerateName("crtest");
CreateCapacityReservationGroup(rgName, capacityReservationGroupName);
CreateCapacityReservation(rgName, capacityReservationGroupName, capacityReservationName, VirtualMachineSizeTypes.StandardDS1V2, reservedCount: 1);
capacityReservationGroupReferenceId = Helpers.GetCapacityReservationGroupRef(m_subId, rgName, capacityReservationGroupName);
singlePlacementGroup = false;
}
VirtualMachineScaleSet getResponse = CreateVMScaleSet_NoAsyncTracking(
rgName,
vmssName,
storageAccountOutput,
imageRef,
out inputVMScaleSet,
useVmssExtension ? extensionProfile : null,
(vmScaleSet) => {
vmScaleSet.Overprovision = shouldOverProvision;
if (!String.IsNullOrEmpty(vmSize))
{
vmScaleSet.Sku.Name = vmSize;
}
vmScaleSetCustomizer?.Invoke(vmScaleSet);
},
createWithManagedDisks: hasManagedDisks,
hasDiffDisks: hasDiffDisks,
zones: zones,
osDiskSizeInGB: osDiskSizeInGB,
ppgId: ppgId,
enableUltraSSD: enableUltraSSD,
diskEncryptionSetId: diskEncryptionSetId,
encryptionAtHostEnabled: encryptionAtHostEnabled,
faultDomainCount: faultDomainCount,
capacity: capacity,
dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId,
dedicatedHostGroupName: dedicatedHostGroupName,
dedicatedHostName: dedicatedHostName,
capacityReservationGroupReferenceId: capacityReservationGroupReferenceId,
singlePlacementGroup: singlePlacementGroup,
hardwareProfile: hardwareProfile);
if (diskEncryptionSetId != null)
{
Assert.True(getResponse.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet != null, "OsDisk.ManagedDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getResponse.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"OsDisk.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
Assert.Equal(1, getResponse.VirtualMachineProfile.StorageProfile.DataDisks.Count);
Assert.True(getResponse.VirtualMachineProfile.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet != null, ".DataDisks.ManagedDisk.DiskEncryptionSet is null");
Assert.True(string.Equals(diskEncryptionSetId, getResponse.VirtualMachineProfile.StorageProfile.DataDisks[0].ManagedDisk.DiskEncryptionSet.Id, StringComparison.OrdinalIgnoreCase),
"DataDisks.ManagedDisk.DiskEncryptionSet.Id is not matching with expected DiskEncryptionSet resource");
}
if (!string.IsNullOrEmpty(capacityReservationGroupReferenceId))
{
Assert.True(getResponse.VirtualMachineProfile.CapacityReservation.CapacityReservationGroup != null, "CapacityReservation.CapacityReservationGroup is null");
Assert.True(string.Equals(capacityReservationGroupReferenceId, getResponse.VirtualMachineProfile.CapacityReservation.CapacityReservationGroup.Id, StringComparison.OrdinalIgnoreCase),
"CapacityReservation.CapacityReservationGroup.Id is not matching with expected CapacityReservationGroup resource");
CapacityReservation capacityReservation =
m_CrpClient.CapacityReservations.Get(rgName, capacityReservationGroupName, capacityReservationName, CapacityReservationInstanceViewTypes.InstanceView);
var queryForVmssVM = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>();
queryForVmssVM.SetFilter(vm => vm.LatestModelApplied == true);
var listVmssVMsResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, queryForVmssVM);
string expectedVMReferenceId = Helpers.GetVMScaleSetVMReferenceId(m_subId, rgName, vmssName, listVmssVMsResponse.First().InstanceId);
Assert.True(capacityReservation.VirtualMachinesAssociated.Any(), "capacityReservation.VirtualMachinesAssociated is not empty");
Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.VirtualMachinesAssociated.First().Id, StringComparison.OrdinalIgnoreCase),
"capacityReservation.VirtualMachinesAssociated are not matching");
/*
* Assert.True(capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.Any(), "InstanceView.UtilizationInfo.VirtualMachinesAllocated is empty");
* Assert.True(string.Equals(expectedVMReferenceId, capacityReservation.InstanceView.UtilizationInfo.VirtualMachinesAllocated.First().Id),
* "InstanceView.UtilizationInfo.VirtualMachinesAllocated are not matching");
*/
}
if (encryptionAtHostEnabled != null)
{
Assert.True(getResponse.VirtualMachineProfile.SecurityProfile.EncryptionAtHost == encryptionAtHostEnabled.Value,
"SecurityProfile.EncryptionAtHost is not same as expected");
}
ValidateVMScaleSet(inputVMScaleSet, getResponse, hasManagedDisks, ppgId: ppgId, dedicatedHostGroupReferenceId: dedicatedHostGroupReferenceId);
var getInstanceViewResponse = m_CrpClient.VirtualMachineScaleSets.GetInstanceView(rgName, vmssName);
Assert.NotNull(getInstanceViewResponse);
ValidateVMScaleSetInstanceView(inputVMScaleSet, getInstanceViewResponse);
if (isPpgScenario)
{
ProximityPlacementGroup outProximityPlacementGroup = m_CrpClient.ProximityPlacementGroups.Get(rgName, ppgName);
Assert.Equal(1, outProximityPlacementGroup.VirtualMachineScaleSets.Count);
string expectedVmssReferenceId = Helpers.GetVMScaleSetReferenceId(m_subId, rgName, vmssName);
Assert.Equal(expectedVmssReferenceId, outProximityPlacementGroup.VirtualMachineScaleSets.First().Id, StringComparer.OrdinalIgnoreCase);
}
var listResponse = m_CrpClient.VirtualMachineScaleSets.List(rgName);
ValidateVMScaleSet(inputVMScaleSet, listResponse.FirstOrDefault(x => x.Name == vmssName), hasManagedDisks);
if (validateListSku)
{
var listSkusResponse = m_CrpClient.VirtualMachineScaleSets.ListSkus(rgName, vmssName);
Assert.NotNull(listSkusResponse);
Assert.False(listSkusResponse.Count() == 0);
}
if (zones != null)
{
var query = new Microsoft.Rest.Azure.OData.ODataQuery <VirtualMachineScaleSetVM>();
query.SetFilter(vm => vm.LatestModelApplied == true);
var listVMsResponse = m_CrpClient.VirtualMachineScaleSetVMs.List(rgName, vmssName, query);
Assert.False(listVMsResponse == null, "VMScaleSetVMs not returned");
Assert.True(listVMsResponse.Count() == inputVMScaleSet.Sku.Capacity);
foreach (var vmScaleSetVM in listVMsResponse)
{
string instanceId = vmScaleSetVM.InstanceId;
var getVMResponse = m_CrpClient.VirtualMachineScaleSetVMs.Get(rgName, vmssName, instanceId);
ValidateVMScaleSetVM(inputVMScaleSet, instanceId, getVMResponse, hasManagedDisks);
}
}
if (validateVmssVMInstanceView)
{
VirtualMachineScaleSetVMInstanceView vmssVMInstanceView = m_CrpClient.VirtualMachineScaleSetVMs.GetInstanceView(rgName, vmssName, "0");
ValidateVMScaleSetVMInstanceView(vmssVMInstanceView, hasManagedDisks, dedicatedHostReferenceId);
}
vmScaleSetValidator?.Invoke(getResponse);
if (deleteAsPartOfTest)
{
m_CrpClient.VirtualMachineScaleSets.Delete(rgName, vmssName);
}
}
finally
{
if (deleteAsPartOfTest)
{
m_ResourcesClient.ResourceGroups.Delete(rgName);
}
else
{
// Fire and forget. No need to wait for RG deletion completion
m_ResourcesClient.ResourceGroups.BeginDelete(rgName);
}
}
}
