protected void ValidateVM(VirtualMachine vm, VirtualMachine vmOut, string expectedVMReferenceId)
{
Assert.True(!string.IsNullOrEmpty(vmOut.ProvisioningState));
Assert.True(vmOut.HardwareProfile.VirtualMachineSize
== vm.HardwareProfile.VirtualMachineSize);
Assert.True(vmOut.StorageProfile.OSDisk != null);
if (vm.StorageProfile.OSDisk != null)
{
Assert.True(vmOut.StorageProfile.OSDisk.Name
== vm.StorageProfile.OSDisk.Name);
Assert.True(vmOut.StorageProfile.OSDisk.VirtualHardDisk.Uri
== vm.StorageProfile.OSDisk.VirtualHardDisk.Uri);
Assert.True(vmOut.StorageProfile.OSDisk.Caching
== vm.StorageProfile.OSDisk.Caching);
}
if (vm.StorageProfile.DataDisks != null &&
vm.StorageProfile.DataDisks.Any())
{
foreach (var dataDisk in vm.StorageProfile.DataDisks)
{
var dataDiskOut = vmOut.StorageProfile.DataDisks.FirstOrDefault(
d => string.Equals(dataDisk.Name, d.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(dataDiskOut);
Assert.NotNull(dataDiskOut.VirtualHardDisk);
Assert.NotNull(dataDiskOut.VirtualHardDisk.Uri);
if (dataDisk.SourceImage != null && dataDisk.SourceImage.Uri != null)
{
Assert.NotNull(dataDiskOut.SourceImage);
Assert.Equal(dataDisk.SourceImage.Uri, dataDiskOut.SourceImage.Uri);
}
}
}
if (vm.OSProfile != null &&
vm.OSProfile.Secrets != null &&
vm.OSProfile.Secrets.Any())
{
foreach (var secret in vm.OSProfile.Secrets)
{
var secretOut = vmOut.OSProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.ReferenceUri, s.SourceVault.ReferenceUri));
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
}
}
Assert.NotNull(vmOut.AvailabilitySetReference);
Assert.True(vm.AvailabilitySetReference.ReferenceUri.ToLowerInvariant() == vmOut.AvailabilitySetReference.ReferenceUri.ToLowerInvariant());
ValidatePlan(vm.Plan, vmOut.Plan);
// TODO: it's null somtimes.
//Assert.NotNull(vmOut.Properties.Id);
//Assert.True(expectedVMReferenceId.ToLowerInvariant() == vmOut.Properties.Id.ToLowerInvariant());
}
protected void ValidateVMScaleSetVM(VirtualMachineScaleSetVM vmScaleSetVM, string skuName, VirtualMachineScaleSetVM vmScaleSetVMOut, bool hasManagedDisks = false)
{
Assert.True(!string.IsNullOrEmpty(vmScaleSetVMOut.ProvisioningState));
Assert.True(skuName
== vmScaleSetVMOut.Sku.Name);
Assert.NotNull(vmScaleSetVMOut.StorageProfile.OsDisk);
if (hasManagedDisks)
{
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.ManagedDisk != null);
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.ManagedDisk.Id != null);
if (vmScaleSetVM.StorageProfile.DataDisks != null)
{
Assert.Equal(vmScaleSetVM.StorageProfile.DataDisks.Count,
vmScaleSetVMOut.StorageProfile.DataDisks.Count);
foreach (var dataDiskOut in vmScaleSetVM.StorageProfile.DataDisks)
{
var dataDisk =
vmScaleSetVM.StorageProfile.DataDisks.FirstOrDefault(d => d.Lun == dataDiskOut.Lun);
Assert.Equal(dataDisk.CreateOption, dataDiskOut.CreateOption);
Assert.Equal(dataDisk.DiskSizeGB, dataDiskOut.DiskSizeGB);
}
}
}
else
{
if (vmScaleSetVM.StorageProfile.OsDisk.Image != null)
{
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.Image.Uri
== vmScaleSetVM.StorageProfile.OsDisk.Image.Uri);
}
Assert.True(vmScaleSetVMOut.StorageProfile.OsDisk.Caching
== vmScaleSetVM.StorageProfile.OsDisk.Caching);
}
if (vmScaleSetVM.OsProfile.Secrets != null &&
vmScaleSetVM.OsProfile.Secrets.Any())
{
foreach (var secret in vmScaleSetVM.OsProfile.Secrets)
{
Assert.NotNull(secret.VaultCertificates);
var secretOut = vmScaleSetVMOut.OsProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.Id, s.SourceVault.Id));
Assert.NotNull(secretOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(secretOut.VaultCertificates);
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
// ReSharper enable PossibleNullReferenceException
}
}
}
protected void ValidateVMScaleSet(VirtualMachineScaleSet vmScaleSet, VirtualMachineScaleSet vmScaleSetOut, bool hasManagedDisks = false)
{
Assert.True(!string.IsNullOrEmpty(vmScaleSetOut.ProvisioningState));
Assert.True(vmScaleSetOut.Sku.Name
== vmScaleSet.Sku.Name);
Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk);
if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk?.DiskSizeGB != null)
{
Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.DiskSizeGB);
Assert.Equal(vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.DiskSizeGB, vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.DiskSizeGB);
}
if (!hasManagedDisks)
{
Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Name
== vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Name);
if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image != null)
{
Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Image.Uri
== vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image.Uri);
}
Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Caching
== vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Caching);
}
else
{
Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.ManagedDisk);
if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk != null)
{
VirtualMachineScaleSetOSDisk osDisk = vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk;
VirtualMachineScaleSetOSDisk osDiskOut =
vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk;
if (osDisk.Caching != null)
{
Assert.True(osDisk.Caching == osDiskOut.Caching);
}
else
{
Assert.NotNull(osDiskOut.Caching);
}
if (osDisk.DiffDiskSettings != null)
{
Assert.True(osDisk.DiffDiskSettings.Option == osDiskOut.DiffDiskSettings.Option);
}
Assert.NotNull(osDiskOut.ManagedDisk);
if (osDisk.ManagedDisk != null && osDisk.ManagedDisk.StorageAccountType != null)
{
Assert.True(osDisk.ManagedDisk.StorageAccountType == osDiskOut.ManagedDisk.StorageAccountType);
}
else
{
Assert.NotNull(osDiskOut.ManagedDisk.StorageAccountType);
}
if (osDisk.Name != null)
{
Assert.Equal(osDiskOut.Name, osDisk.Name);
}
Assert.True(osDiskOut.CreateOption == DiskCreateOptionTypes.FromImage);
}
if (vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks != null &&
vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks.Count > 0)
{
Assert.Equal(
vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks.Count,
vmScaleSetOut.VirtualMachineProfile.StorageProfile.DataDisks.Count);
foreach (VirtualMachineScaleSetDataDisk dataDisk in vmScaleSet.VirtualMachineProfile.StorageProfile.DataDisks)
{
VirtualMachineScaleSetDataDisk matchingDataDisk
= vmScaleSetOut.VirtualMachineProfile.StorageProfile.DataDisks.FirstOrDefault(disk => disk.Lun == dataDisk.Lun);
Assert.NotNull(matchingDataDisk);
if (dataDisk.Caching != null)
{
Assert.True(dataDisk.Caching == matchingDataDisk.Caching);
}
else
{
Assert.NotNull(matchingDataDisk.Caching);
}
if (dataDisk.ManagedDisk != null && dataDisk.ManagedDisk.StorageAccountType != null)
{
Assert.True(dataDisk.ManagedDisk.StorageAccountType == matchingDataDisk.ManagedDisk.StorageAccountType);
}
else
{
Assert.NotNull(matchingDataDisk.ManagedDisk.StorageAccountType);
}
if (dataDisk.Name != null)
{
Assert.Equal(dataDisk.Name, matchingDataDisk.Name);
}
Assert.True(dataDisk.CreateOption == matchingDataDisk.CreateOption);
}
}
}
if (vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy != null)
{
bool expectedDisableAutomaticRollbackValue = vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy.DisableAutomaticRollback ?? false;
Assert.True(vmScaleSetOut.UpgradePolicy.AutomaticOSUpgradePolicy.DisableAutomaticRollback == expectedDisableAutomaticRollbackValue);
bool expectedEnableAutomaticOSUpgradeValue = vmScaleSet.UpgradePolicy.AutomaticOSUpgradePolicy.EnableAutomaticOSUpgrade ?? false;
Assert.True(vmScaleSetOut.UpgradePolicy.AutomaticOSUpgradePolicy.EnableAutomaticOSUpgrade == expectedEnableAutomaticOSUpgradeValue);
}
if (vmScaleSet.VirtualMachineProfile.OsProfile.Secrets != null &&
vmScaleSet.VirtualMachineProfile.OsProfile.Secrets.Any())
{
foreach (var secret in vmScaleSet.VirtualMachineProfile.OsProfile.Secrets)
{
Assert.NotNull(secret.VaultCertificates);
var secretOut = vmScaleSetOut.VirtualMachineProfile.OsProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.Id, s.SourceVault.Id));
Assert.NotNull(secretOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(secretOut.VaultCertificates);
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
// ReSharper enable PossibleNullReferenceException
}
}
if (vmScaleSet.VirtualMachineProfile.ExtensionProfile != null &&
vmScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions.Any())
{
foreach (var vmExtension in vmScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions)
{
var vmExt = vmScaleSetOut.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(s => String.Compare(s.Name, vmExtension.Name, StringComparison.OrdinalIgnoreCase) == 0);
Assert.NotNull(vmExt);
}
}
if (vmScaleSet.VirtualMachineProfile.NetworkProfile != null)
{
if (vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations != null && vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count > 0)
{
Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations);
Assert.Equal(
vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count,
vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count);
foreach (var nicconfig in vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations)
{
var outnicconfig =
vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.First(
nc => string.Equals(nc.Name, nicconfig.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(outnicconfig);
CompareVmssNicConfig(nicconfig, outnicconfig);
}
}
}
else
{
Assert.True((vmScaleSetOut.VirtualMachineProfile.NetworkProfile == null) || (vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count == 0));
}
if (vmScaleSet.Zones != null)
{
Assert.True(vmScaleSet.Zones.SequenceEqual(vmScaleSetOut.Zones), "Zones don't match");
if (vmScaleSet.ZoneBalance.HasValue)
{
Assert.Equal(vmScaleSet.ZoneBalance, vmScaleSetOut.ZoneBalance);
}
else
{
if (vmScaleSet.Zones.Count > 1)
{
Assert.True(vmScaleSetOut.ZoneBalance.HasValue);
}
else
{
Assert.False(vmScaleSetOut.ZoneBalance.HasValue);
}
}
if (vmScaleSet.PlatformFaultDomainCount.HasValue)
{
Assert.Equal(vmScaleSet.PlatformFaultDomainCount, vmScaleSetOut.PlatformFaultDomainCount);
}
else
{
Assert.True(vmScaleSetOut.PlatformFaultDomainCount.HasValue);
}
}
else
{
Assert.Null(vmScaleSetOut.Zones);
Assert.Null(vmScaleSetOut.ZoneBalance);
Assert.Null(vmScaleSetOut.PlatformFaultDomainCount);
}
}
protected void ValidateVM(VirtualMachine vm, VirtualMachine vmOut, string expectedVMReferenceId)
{
Assert.True(vmOut.LicenseType == vm.LicenseType);
Assert.True(!string.IsNullOrEmpty(vmOut.ProvisioningState));
Assert.True(vmOut.HardwareProfile.VmSize
== vm.HardwareProfile.VmSize);
Assert.NotNull(vmOut.StorageProfile.OsDisk);
if (vm.StorageProfile.OsDisk != null)
{
Assert.True(vmOut.StorageProfile.OsDisk.Name
== vm.StorageProfile.OsDisk.Name);
Assert.True(vmOut.StorageProfile.OsDisk.Vhd.Uri
== vm.StorageProfile.OsDisk.Vhd.Uri);
Assert.True(vmOut.StorageProfile.OsDisk.Caching
== vm.StorageProfile.OsDisk.Caching);
}
if (vm.StorageProfile.DataDisks != null &&
vm.StorageProfile.DataDisks.Any())
{
foreach (var dataDisk in vm.StorageProfile.DataDisks)
{
var dataDiskOut = vmOut.StorageProfile.DataDisks.FirstOrDefault(
d => string.Equals(dataDisk.Name, d.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(dataDiskOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(dataDiskOut.Vhd);
Assert.NotNull(dataDiskOut.Vhd.Uri);
if (dataDisk.Image != null && dataDisk.Image.Uri != null)
{
Assert.NotNull(dataDiskOut.Image);
Assert.Equal(dataDisk.Image.Uri, dataDiskOut.Image.Uri);
}
// ReSharper enable PossibleNullReferenceException
}
}
if (vm.OsProfile != null &&
vm.OsProfile.Secrets != null &&
vm.OsProfile.Secrets.Any())
{
foreach (var secret in vm.OsProfile.Secrets)
{
Assert.NotNull(secret.VaultCertificates);
var secretOut = vmOut.OsProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.Id, s.SourceVault.Id));
Assert.NotNull(secretOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(secretOut.VaultCertificates);
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
// ReSharper enable PossibleNullReferenceException
}
}
Assert.NotNull(vmOut.AvailabilitySet);
Assert.True(vm.AvailabilitySet.Id.ToLowerInvariant() == vmOut.AvailabilitySet.Id.ToLowerInvariant());
ValidatePlan(vm.Plan, vmOut.Plan);
Assert.NotNull(vmOut.VmId);
}
protected void ValidateVM(VirtualMachine vm, VirtualMachine vmOut, string expectedVMReferenceId)
{
Assert.True(!string.IsNullOrEmpty(vmOut.ProvisioningState));
Assert.True(vmOut.HardwareProfile.VirtualMachineSize
== vm.HardwareProfile.VirtualMachineSize);
Assert.NotNull(vmOut.StorageProfile.OSDisk);
if (vm.StorageProfile.OSDisk != null)
{
Assert.True(vmOut.StorageProfile.OSDisk.Name
== vm.StorageProfile.OSDisk.Name);
Assert.True(vmOut.StorageProfile.OSDisk.VirtualHardDisk.Uri
== vm.StorageProfile.OSDisk.VirtualHardDisk.Uri);
Assert.True(vmOut.StorageProfile.OSDisk.Caching
== vm.StorageProfile.OSDisk.Caching);
Assert.True(vmOut.StorageProfile.OSDisk.DiskSizeGB
== vm.StorageProfile.OSDisk.DiskSizeGB);
if (vm.StorageProfile.OSDisk.EncryptionSettings != null)
{
var encryptionSettings = vm.StorageProfile.OSDisk.EncryptionSettings;
Assert.NotNull(vmOut.StorageProfile.OSDisk.EncryptionSettings);
var actualEncryptionSettings = vmOut.StorageProfile.OSDisk.EncryptionSettings;
Assert.Equal(encryptionSettings.DiskEncryptionKey.SourceVault.ReferenceUri, actualEncryptionSettings.DiskEncryptionKey.SourceVault.ReferenceUri);
Assert.Equal(encryptionSettings.DiskEncryptionKey.SecretUrl, actualEncryptionSettings.DiskEncryptionKey.SecretUrl);
if (encryptionSettings.KeyEncryptionKey != null)
{
Assert.NotNull(encryptionSettings.KeyEncryptionKey);
Assert.Equal(encryptionSettings.KeyEncryptionKey.SourceVault.ReferenceUri, actualEncryptionSettings.KeyEncryptionKey.SourceVault.ReferenceUri);
Assert.Equal(encryptionSettings.KeyEncryptionKey.KeyUrl, actualEncryptionSettings.KeyEncryptionKey.KeyUrl);
}
}
}
if (vm.StorageProfile.DataDisks != null &&
vm.StorageProfile.DataDisks.Any())
{
foreach (var dataDisk in vm.StorageProfile.DataDisks)
{
var dataDiskOut = vmOut.StorageProfile.DataDisks.FirstOrDefault(
d => string.Equals(dataDisk.Name, d.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(dataDiskOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(dataDiskOut.VirtualHardDisk);
Assert.NotNull(dataDiskOut.VirtualHardDisk.Uri);
if (dataDisk.SourceImage != null && dataDisk.SourceImage.Uri != null)
{
Assert.NotNull(dataDiskOut.SourceImage);
Assert.Equal(dataDisk.SourceImage.Uri, dataDiskOut.SourceImage.Uri);
}
// ReSharper enable PossibleNullReferenceException
Assert.True(dataDiskOut.DiskSizeGB == dataDisk.DiskSizeGB);
}
}
if (vm.OSProfile != null &&
vm.OSProfile.Secrets != null &&
vm.OSProfile.Secrets.Any())
{
foreach (var secret in vm.OSProfile.Secrets)
{
Assert.NotNull(secret.VaultCertificates);
var secretOut = vmOut.OSProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.ReferenceUri, s.SourceVault.ReferenceUri));
Assert.NotNull(secretOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(secretOut.VaultCertificates);
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
// ReSharper enable PossibleNullReferenceException
}
}
if (vm.DiagnosticsProfile != null)
{
Assert.Equal(vm.DiagnosticsProfile.BootDiagnostics.Enabled, vmOut.DiagnosticsProfile.BootDiagnostics.Enabled);
Assert.Equal(vm.DiagnosticsProfile.BootDiagnostics.StorageUri, vmOut.DiagnosticsProfile.BootDiagnostics.StorageUri);
}
Assert.NotNull(vmOut.AvailabilitySetReference);
Assert.True(vm.AvailabilitySetReference.ReferenceUri.ToLowerInvariant() == vmOut.AvailabilitySetReference.ReferenceUri.ToLowerInvariant());
ValidatePlan(vm.Plan, vmOut.Plan);
// TODO: it's null somtimes.
//Assert.NotNull(vmOut.Properties.Id);
//Assert.True(expectedVMReferenceId.ToLowerInvariant() == vmOut.Properties.Id.ToLowerInvariant());
}
protected void ValidateVMScaleSet(VirtualMachineScaleSet vmScaleSet, VirtualMachineScaleSet vmScaleSetOut)
{
Assert.True(!string.IsNullOrEmpty(vmScaleSetOut.ProvisioningState));
Assert.True(vmScaleSetOut.Sku.Name
== vmScaleSet.Sku.Name);
Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk);
Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Name
== vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Name);
if (vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image != null)
{
Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Image.Uri
== vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Image.Uri);
}
Assert.True(vmScaleSetOut.VirtualMachineProfile.StorageProfile.OsDisk.Caching
== vmScaleSet.VirtualMachineProfile.StorageProfile.OsDisk.Caching);
if (vmScaleSet.VirtualMachineProfile.OsProfile.Secrets != null &&
vmScaleSet.VirtualMachineProfile.OsProfile.Secrets.Any())
{
foreach (var secret in vmScaleSet.VirtualMachineProfile.OsProfile.Secrets)
{
Assert.NotNull(secret.VaultCertificates);
var secretOut = vmScaleSetOut.VirtualMachineProfile.OsProfile.Secrets.FirstOrDefault(s => string.Equals(secret.SourceVault.Id, s.SourceVault.Id));
Assert.NotNull(secretOut);
// Disabling resharper null-ref check as it doesn't seem to understand the not-null assert above.
// ReSharper disable PossibleNullReferenceException
Assert.NotNull(secretOut.VaultCertificates);
var VaultCertComparer = new VaultCertComparer();
Assert.True(secretOut.VaultCertificates.SequenceEqual(secret.VaultCertificates, VaultCertComparer));
// ReSharper enable PossibleNullReferenceException
}
}
if (vmScaleSet.VirtualMachineProfile.ExtensionProfile != null &&
vmScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions.Any())
{
foreach (var vmExtension in vmScaleSet.VirtualMachineProfile.ExtensionProfile.Extensions)
{
var vmExt = vmScaleSetOut.VirtualMachineProfile.ExtensionProfile.Extensions.FirstOrDefault(s => String.Compare(s.Name, vmExtension.Name, StringComparison.OrdinalIgnoreCase) == 0);
Assert.NotNull(vmExt);
}
}
if (vmScaleSet.VirtualMachineProfile.NetworkProfile != null)
{
if (vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations != null && vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count > 0)
{
Assert.NotNull(vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations);
Assert.Equal(
vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count,
vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count);
foreach (var nicconfig in vmScaleSet.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations)
{
var outnicconfig =
vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.First(
nc => string.Equals(nc.Name, nicconfig.Name, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(outnicconfig);
CompareVmssNicConfig(nicconfig, outnicconfig);
}
}
}
else
{
Assert.True((vmScaleSetOut.VirtualMachineProfile.NetworkProfile == null) || (vmScaleSetOut.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Count == 0));
}
}
