public void TestInform_CheckReponsePacket()
{
Random random = new Random();
IPv4Address start = random.GetIPv4Address();
IPv4Address end = random.GetIPv4AddressGreaterThan(start);
IPv4Address sourceAddress = random.GetIPv4AddressBetween(start, end);
IPv4Address destinationAddress = random.GetIPv4AddressBetween(start, end);
DHCPv4Packet input = GetInformPacket(random, sourceAddress, destinationAddress);
List <DHCPv4ScopeProperty> scopeProperties = random.GenerateProperties(new List <DHCPv4OptionTypes>
{
DHCPv4OptionTypes.RebindingTimeValue,
DHCPv4OptionTypes.RenewalTimeValue,
DHCPv4OptionTypes.IPAddressLeaseTime,
DHCPv4OptionTypes.ServerIdentifier,
DHCPv4OptionTypes.MessageType,
});
DHCPv4RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
rootScope.Load(new List <DomainEvent> {
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
AddressProperties = new DHCPv4ScopeAddressProperties(start, end, new List <IPv4Address>(),
informsAreAllowd: true,
renewalTime: TimeSpan.FromMinutes(random.Next(3, 10)),
preferredLifetime: TimeSpan.FromMinutes(random.Next(20, 30)),
leaseTime: TimeSpan.FromMinutes(random.Next(40, 60))
),
Id = scopeId,
ScopeProperties = new DHCPv4ScopeProperties(scopeProperties)
})
});
DHCPv4Packet result = rootScope.HandleInform(input);
Assert.NotEqual(DHCPv4Packet.Empty, result);
Assert.Equal(sourceAddress, result.Header.Destionation);
Assert.Equal(destinationAddress, result.Header.Source);
Assert.Equal(DHCPv4MessagesTypes.Acknowledge, result.MessageType);
Assert.Equal(input.ClientHardwareAddress, result.ClientHardwareAddress);
Assert.Equal(input.HardwareAddressLength, result.HardwareAddressLength);
Assert.Equal(input.HardwareType, result.HardwareType);
Assert.Equal(0, result.Hops);
Assert.Equal(0, result.SecondsElapsed);
Assert.Equal(input.TransactionId, result.TransactionId);
Assert.Equal(String.Empty, result.FileName);
Assert.Equal(String.Empty, result.ServerHostname);
Assert.Equal(DHCPv4PacketFlags.Unicast, result.Flags);
Assert.Equal(DHCPv4PacketOperationCodes.BootReply, result.OpCode);
Assert.Equal(IPv4Address.Empty, result.GatewayIPAdress);
Assert.Equal(IPv4Address.Empty, result.YourIPAdress);
Assert.Equal(IPv4Address.Empty, result.ServerIPAdress);
Assert.Equal(input.ClientIPAdress, result.ClientIPAdress);
Assert.Equal(input.ClientIPAdress, result.Header.Destionation);
// no time values
Assert.False(IsOptionPresentend(result, DHCPv4OptionTypes.RebindingTimeValue));
Assert.False(IsOptionPresentend(result, DHCPv4OptionTypes.RenewalTimeValue));
Assert.False(IsOptionPresentend(result, DHCPv4OptionTypes.IPAddressLeaseTime));
// server identifier
Assert.True(IsOptionPresentend(result, DHCPv4OptionTypes.ServerIdentifier));
Assert.True(HasOptionThisIPv4Adress(result, DHCPv4OptionTypes.ServerIdentifier, destinationAddress));
foreach (var item in scopeProperties)
{
Assert.True(IsOptionPresentend(result, item.OptionIdentifier));
DHCPv4PacketOption existingOption = result.GetOptionByIdentifier(item.OptionIdentifier);
Assert.NotEqual(DHCPv4PacketOption.NotPresented, existingOption);
ChecKIfPropertyCorrelatesToOption(item, existingOption);
}
}
public static void ChecKIfPropertyCorrelatesToOption(DHCPv4ScopeProperty property, DHCPv4PacketOption option)
{
Assert.NotNull(property);
Assert.NotNull(option);
Assert.Equal(property.OptionIdentifier, option.OptionType);
if (property is DHCPv4AddressListScopeProperty castedProperty7)
{
Assert.IsAssignableFrom<DHCPv4PacketAddressListOption>(option);
DHCPv4PacketAddressListOption castedOption = (DHCPv4PacketAddressListOption)option;
Assert.Equal(castedProperty7.Addresses.OrderBy(x => x), castedOption.Addresses.OrderBy(x => x));
}
else if (property is DHCPv4AddressScopeProperty castedProperty6)
{
Assert.IsAssignableFrom<DHCPv4PacketAddressOption>(option);
DHCPv4PacketAddressOption castedOption = (DHCPv4PacketAddressOption)option;
Assert.Equal(castedProperty6.Address, castedOption.Address);
}
else if (property is DHCPv4BooleanScopeProperty castedProperty3)
{
Assert.IsAssignableFrom<DHCPv4PacketBooleanOption>(option);
DHCPv4PacketBooleanOption castedOption = (DHCPv4PacketBooleanOption)option;
Assert.Equal(castedProperty3.Value, castedOption.Value);
}
else if (property is DHCPv4BooleanScopeProperty castedProperty2)
{
Assert.IsAssignableFrom<DHCPv4PacketBooleanOption>(option);
DHCPv4PacketBooleanOption castedOption = (DHCPv4PacketBooleanOption)option;
Assert.Equal(castedProperty2.Value, castedOption.Value);
}
else if (property is DHCPv4NumericValueScopeProperty castedProperty)
{
Int64 value = 0;
switch (castedProperty.NumericType)
{
case DHCPv4NumericValueTypes.Byte:
Assert.IsAssignableFrom<DHCPv4PacketByteOption>(option);
value = ((DHCPv4PacketByteOption)option).Value;
break;
case DHCPv4NumericValueTypes.UInt16:
Assert.IsAssignableFrom<DHCPv4PacketUInt16Option>(option);
value = ((DHCPv4PacketUInt16Option)option).Value;
break;
case DHCPv4NumericValueTypes.UInt32:
Assert.IsAssignableFrom<DHCPv4PacketUInt32Option>(option);
value = ((DHCPv4PacketUInt32Option)option).Value;
break;
default:
break;
}
}
else if (property is DHCPv4TextScopeProperty castedProperty4)
{
Assert.IsAssignableFrom<DHCPv4PacketTextOption>(option);
DHCPv4PacketTextOption castedOption = (DHCPv4PacketTextOption)option;
Assert.Equal(castedProperty4.Value, castedOption.Value);
}
else if (property is DHCPv4TimeScopeProperty castedProperty5)
{
Assert.IsAssignableFrom<DHCPv4PacketTimeSpanOption>(option);
DHCPv4PacketTimeSpanOption castedOption = (DHCPv4PacketTimeSpanOption)option;
Assert.Equal(castedProperty5.Value, castedOption.Value);
}
else
{
throw new NotImplementedException();
}
}
