private void AssertLogicalSubnetsAreSame(LogicalSubnet expected, LogicalSubnet found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.IsPublic, found.IsPublic);
if (expected.IpPools != null)
{
Assert.Equal(expected.IpPools.Count, found.IpPools.Count);
}
else
{
Assert.Null(found.IpPools);
}
if (expected.Metadata != null)
{
Assert.Equal(expected.Metadata.Count, found.Metadata.Count);
}
else
{
Assert.Null(found.Metadata);
}
}
}
private void AssertMacAddressPoolsAreSame(MacAddressPool expected, MacAddressPool found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.NumberOfAllocatedMacAddresses, found.NumberOfAllocatedMacAddresses);
Assert.Equal(expected.NumberOfAvailableMacAddresses, found.NumberOfAvailableMacAddresses);
Assert.Equal(expected.StartMacAddress, found.StartMacAddress);
Assert.Equal(expected.EndMacAddress, found.EndMacAddress);
if (expected.Metadata != null)
{
Assert.Equal(expected.Metadata.Count, found.Metadata.Count);
}
else
{
Assert.Null(found.Metadata);
}
}
}
private void AssertDrivesAreSame(Drive expected, Drive found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.StorageNode, found.StorageNode);
Assert.Equal(expected.SerialNumber, found.SerialNumber);
Assert.Equal(expected.HealthStatus, found.HealthStatus);
Assert.Equal(expected.OperationalStatus, found.OperationalStatus);
Assert.Equal(expected.Usage, found.Usage);
Assert.Equal(expected.PhysicalLocation, found.PhysicalLocation);
Assert.Equal(expected.Model, found.Model);
Assert.Equal(expected.FirmwareVersion, found.FirmwareVersion);
Assert.Equal(expected.IsIndicationEnabled, found.IsIndicationEnabled);
Assert.Equal(expected.Manufacturer, found.Manufacturer);
Assert.Equal(expected.StoragePool, found.StoragePool);
Assert.Equal(expected.MediaType, found.MediaType);
Assert.Equal(expected.CapacityGB, found.CapacityGB);
Assert.Equal(expected.Description, found.Description);
Assert.Equal(expected.Action, found.Action);
}
}
private void AssertLogicalNetworksAreSame(LogicalNetwork expected, LogicalNetwork found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.NetworkVirtualizationEnabled, found.NetworkVirtualizationEnabled);
if (expected.Subnets != null)
{
Assert.Equal(expected.Subnets.Count, found.Subnets.Count);
}
else
{
Assert.Null(found.Subnets);
}
if (expected.Metadata != null)
{
Assert.Equal(expected.Metadata.Count, found.Metadata.Count);
}
else
{
Assert.Null(found.Metadata);
}
}
}
private void AssertScaleUnitNodesAreSame(ScaleUnitNode expected, ScaleUnitNode found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.BiosVersion, found.BiosVersion);
Assert.Equal(expected.BmcAddress, found.BmcAddress);
Assert.Equal(expected.CanPowerOff, found.CanPowerOff);
if (expected.Capacity == null)
{
Assert.Null(found.Capacity);
}
else
{
Assert.Equal(expected.Capacity.Cores, found.Capacity.Cores);
Assert.Equal(expected.Capacity.MemoryGB, found.Capacity.MemoryGB);
}
Assert.Equal(expected.Model, found.Model);
Assert.Equal(expected.PowerState, found.PowerState);
Assert.Equal(expected.ScaleUnitName, found.ScaleUnitName);
Assert.Equal(expected.ScaleUnitNodeStatus, found.ScaleUnitNodeStatus);
Assert.Equal(expected.ScaleUnitUri, found.ScaleUnitUri);
Assert.Equal(expected.SerialNumber, found.SerialNumber);
Assert.Equal(expected.Vendor, found.Vendor);
}
}
private void ValidateLogicalNetwork(LogicalNetwork logicalNetwork)
{
FabricCommon.ValidateResource(logicalNetwork);
Assert.NotNull(logicalNetwork.NetworkVirtualizationEnabled);
Assert.NotNull(logicalNetwork.Subnets);
}
private void ValidateLogicalSubnet(LogicalSubnet logicalSubnet)
{
FabricCommon.ValidateResource(logicalSubnet);
Assert.NotNull(logicalSubnet.IpPools);
Assert.NotNull(logicalSubnet.IsPublic);
}
private void ValiateInfraRoleInstance(InfraRoleInstance instance)
{
FabricCommon.ValidateResource(instance);
Assert.NotNull(instance.ScaleUnit);
Assert.NotNull(instance.ScaleUnitNode);
Assert.NotNull(instance.Size);
Assert.NotNull(instance.State);
}
private void ValidateSlbMuxInstance(SlbMuxInstance instance)
{
FabricCommon.ValidateResource(instance);
Assert.NotNull(instance.BgpPeers);
Assert.NotNull(instance.ConfigurationState);
Assert.NotNull(instance.VirtualServer);
}
private void ValidateEdgeGateway(EdgeGateway gateway)
{
FabricCommon.ValidateResource(gateway);
Assert.NotNull(gateway.AvailableCapacity);
Assert.NotNull(gateway.NumberOfConnections);
Assert.NotNull(gateway.State);
Assert.NotNull(gateway.TotalCapacity);
}
private void ValidateMacAddressPool(MacAddressPool macAddressPool)
{
FabricCommon.ValidateResource(macAddressPool);
Assert.NotNull(macAddressPool.NumberOfAllocatedMacAddresses);
Assert.NotNull(macAddressPool.NumberOfAvailableMacAddresses);
Assert.NotNull(macAddressPool.StartMacAddress);
Assert.NotNull(macAddressPool.EndMacAddress);
}
private void ValidateScaleUnit(ScaleUnit scaleUnit)
{
FabricCommon.ValidateResource(scaleUnit);
Assert.NotNull(scaleUnit.LogicalFaultDomain);
Assert.NotNull(scaleUnit.ScaleUnitType);
Assert.NotNull(scaleUnit.State);
Assert.NotNull(scaleUnit.TotalCapacity);
}
private void ValidateStorageSubSystem(StorageSubSystem instance)
{
FabricCommon.ValidateResource(instance);
Assert.NotNull(instance.TotalCapacityGB);
Assert.NotNull(instance.RemainingCapacityGB);
Assert.NotNull(instance.HealthStatus);
Assert.NotNull(instance.OperationalStatus);
Assert.NotNull(instance.RebalanceStatus);
}
private void ValidateEdgeGatewayPool(EdgeGatewayPool pool)
{
FabricCommon.ValidateResource(pool);
Assert.NotNull(pool.Id);
Assert.NotNull(pool.Location);
Assert.NotNull(pool.Name);
Assert.NotNull(pool.Type);
Assert.NotNull(pool.GatewayType);
Assert.NotNull(pool.PublicIpAddress);
}
private void ValidateScaleUnitNode(ScaleUnitNode scaleUnitNode)
{
FabricCommon.ValidateResource(scaleUnitNode);
Assert.NotNull(scaleUnitNode.CanPowerOff);
Assert.NotNull(scaleUnitNode.Capacity);
Assert.NotNull(scaleUnitNode.PowerState);
Assert.NotNull(scaleUnitNode.ScaleUnitName);
Assert.NotNull(scaleUnitNode.ScaleUnitNodeStatus);
Assert.NotNull(scaleUnitNode.ScaleUnitUri);
}
private void AssertStoragePoolsAreSame(StoragePool expected, StoragePool found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.SizeGB, found.SizeGB);
}
}
private void AssertStorageSystemsAreSame(StorageSystem expected, StorageSystem found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.TotalCapacityGB, found.TotalCapacityGB);
}
}
private void ValidateVolume(Volume instance)
{
FabricCommon.ValidateResource(instance);
Assert.NotNull(instance.TotalCapacityGB);
Assert.NotNull(instance.RemainingCapacityGB);
Assert.NotNull(instance.HealthStatus);
Assert.NotNull(instance.OperationalStatus);
Assert.NotNull(instance.RepairStatus);
Assert.NotNull(instance.Description);
Assert.NotNull(instance.Action);
Assert.NotNull(instance.VolumeLabel);
}
private void ValidateIpPool(IpPool pool)
{
FabricCommon.ValidateResource(pool);
// TODO: Can we test on when this is not supposed to be null?
// This is allowed to be null
//Assert.Null(pool.AddressPrefix, "AddressPrefix is null");
Assert.NotNull(pool.EndIpAddress);
Assert.NotNull(pool.NumberOfAllocatedIpAddresses);
Assert.NotNull(pool.NumberOfIpAddresses);
Assert.NotNull(pool.NumberOfIpAddressesInTransition);
Assert.NotNull(pool.StartIpAddress);
}
private void AssertFileSharesEqual(FileShare expected, FileShare found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.AssociatedVolume, found.AssociatedVolume);
Assert.Equal(expected.UncPath, found.UncPath);
}
}
private void AssertSameEdgeGateway(EdgeGateway expected, EdgeGateway found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.AvailableCapacity, found.AvailableCapacity);
Assert.Equal(expected.NumberOfConnections, found.NumberOfConnections);
Assert.Equal(expected.State, found.State);
Assert.Equal(expected.TotalCapacity, found.TotalCapacity);
}
}
private void AssertStorageSubSystemsAreSame(StorageSubSystem expected, StorageSubSystem found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.TotalCapacityGB, found.TotalCapacityGB);
Assert.Equal(expected.RemainingCapacityGB, found.RemainingCapacityGB);
Assert.Equal(expected.HealthStatus, found.HealthStatus);
Assert.Equal(expected.OperationalStatus, found.OperationalStatus);
Assert.Equal(expected.RebalanceStatus, found.RebalanceStatus);
}
}
private void AssertFabricLocationEqual(FabricLocation expected, FabricLocation found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.Id, found.Id);
Assert.Equal(expected.Location, found.Location);
Assert.Equal(expected.Name, found.Name);
Assert.Equal(expected.Type, found.Type);
}
}
private void AssertInfraRolesAreSame(InfraRole expected, InfraRole found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.Name, found.Name);
Assert.Equal(expected.Id, found.Id);
Assert.Equal(expected.Location, found.Location);
Assert.Equal(expected.Type, found.Type);
Assert.Equal(expected.Instances.Count, found.Instances.Count);
}
}
private void AssertIpPoolsAreSame(IpPool expected, IpPool found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.AddressPrefix, found.AddressPrefix);
Assert.Equal(expected.EndIpAddress, found.EndIpAddress);
Assert.Equal(expected.NumberOfAllocatedIpAddresses, found.NumberOfAllocatedIpAddresses);
Assert.Equal(expected.NumberOfIpAddresses, found.NumberOfIpAddresses);
Assert.Equal(expected.NumberOfIpAddressesInTransition, found.NumberOfIpAddressesInTransition);
Assert.Equal(expected.StartIpAddress, found.StartIpAddress);
}
}
private void ValidateDrive(Drive instance)
{
FabricCommon.ValidateResource(instance);
Assert.NotNull(instance.StorageNode);
Assert.NotNull(instance.SerialNumber);
Assert.NotNull(instance.HealthStatus);
Assert.NotNull(instance.OperationalStatus);
Assert.NotNull(instance.Usage);
Assert.NotNull(instance.CanPool);
Assert.NotNull(instance.CannotPoolReason);
Assert.NotNull(instance.PhysicalLocation);
Assert.NotNull(instance.Model);
Assert.NotNull(instance.MediaType);
Assert.NotNull(instance.CapacityGB);
Assert.NotNull(instance.Description);
Assert.NotNull(instance.Action);
}
private void AssertEdgeGatewayPoolAreSame(EdgeGatewayPool expected, EdgeGatewayPool found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.Name, found.Name);
Assert.Equal(expected.Id, found.Id);
Assert.Equal(expected.Location, found.Location);
Assert.Equal(expected.GatewayType, found.GatewayType);
Assert.Equal(expected.PublicIpAddress, found.PublicIpAddress);
Assert.Equal(expected.NumberOfGateways, found.NumberOfGateways);
}
}
private void AssertVolumesAreSame(Volume expected, Volume found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
Assert.Equal(expected.TotalCapacityGB, found.TotalCapacityGB);
Assert.Equal(expected.RemainingCapacityGB, found.RemainingCapacityGB);
Assert.Equal(expected.HealthStatus, found.HealthStatus);
Assert.Equal(expected.OperationalStatus, found.OperationalStatus);
Assert.Equal(expected.RepairStatus, found.RepairStatus);
Assert.Equal(expected.Description, found.Description);
Assert.Equal(expected.Action, found.Action);
Assert.Equal(expected.VolumeLabel, found.VolumeLabel);
}
}
private void ValidateDrive(Drive instance)
{
FabricCommon.ValidateResource(instance);
Assert.NotNull(instance.StorageNode);
Assert.NotNull(instance.SerialNumber);
Assert.NotNull(instance.HealthStatus);
Assert.NotNull(instance.OperationalStatus);
Assert.NotNull(instance.Usage);
Assert.NotNull(instance.PhysicalLocation);
Assert.NotNull(instance.Model);
Assert.NotNull(instance.FirmwareVersion);
Assert.NotNull(instance.IsIndicationEnabled);
Assert.NotNull(instance.Manufacturer);
Assert.NotNull(instance.StoragePool);
Assert.NotNull(instance.MediaType);
Assert.NotNull(instance.CapacityGB);
Assert.NotNull(instance.Description);
Assert.NotNull(instance.Action);
}
private void AssertSlbMuxInstancesAreSame(SlbMuxInstance expected, SlbMuxInstance found)
{
if (expected == null)
{
Assert.Null(found);
}
else
{
Assert.True(FabricCommon.ResourceAreSame(expected, found));
if (expected.BgpPeers == null)
{
Assert.Null(found.BgpPeers);
}
else
{
Assert.Equal(expected.BgpPeers.Count, found.BgpPeers.Count);
}
Assert.Equal(expected.ConfigurationState, found.ConfigurationState);
Assert.Equal(expected.VirtualServer, found.VirtualServer);
}
}
