protected static DHCPv4Lease CheckLease(
Int32 index, Int32 expectedAmount, IPv4Address expectedAdress,
Guid scopeId, DHCPv4RootScope rootScope, DateTime expectedCreationData, Boolean checkExpires = true,
Byte[] uniqueIdentifier = null, Boolean shouldBePending = true)
{
DHCPv4Scope scope = rootScope.GetScopeById(scopeId);
var leases = scope.Leases.GetAllLeases();
Assert.Equal(expectedAmount, leases.Count());
DHCPv4Lease lease = leases.ElementAt(index);
Assert.NotNull(lease);
Assert.Equal(expectedAdress, lease.Address);
if (checkExpires == true)
{
Int32 expiresInMinutes = (Int32)(lease.End - DateTime.UtcNow).TotalMinutes;
Assert.True(expiresInMinutes >= 60 * 24 - 4 && expiresInMinutes <= 60 * 24);
}
Assert.True((expectedCreationData - lease.Start).TotalMinutes < 2);
Assert.Equal(shouldBePending, lease.IsPending());
if (uniqueIdentifier == null)
{
Assert.Empty(lease.UniqueIdentifier);
}
else
{
Assert.NotNull(lease.UniqueIdentifier);
Assert.Equal(uniqueIdentifier, lease.UniqueIdentifier);
}
return(lease);
}
public void DHCPv4Lease_IsCancelable()
{
Random random = new Random();
DHCPv4RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
rootScope.Load(new[] {
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = scopeId,
}),
});
Dictionary <DHCPv4Lease, Boolean> expectedResults =
AddEventsForCancelableLeases(random, scopeId, rootScope);
DHCPv4Scope scope = rootScope.GetRootScopes().First();
foreach (var item in expectedResults)
{
DHCPv4Lease lease = item.Key;
Boolean actual = lease.IsCancelable();
Assert.Equal(item.Value, actual);
}
}
public void DHCPv4Leases_GetLeaseById()
{
Random random = new Random();
DHCPv4RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(3, 10);
HashSet <Guid> existingIds = new HashSet <Guid>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
events.Add(new DHCPv4LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv4Address(),
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(),
});
existingIds.Add(leaseId);
}
rootScope.Load(events);
DHCPv4Scope scope = rootScope.GetRootScopes().First();
foreach (Guid leaseId in existingIds)
{
DHCPv4Lease lease = scope.Leases.GetLeaseById(leaseId);
Assert.True(lease != DHCPv4Lease.Empty);
}
Int32 notExisitngAmount = random.Next(30, 100);
for (int i = 0; i < notExisitngAmount; i++)
{
Guid id = Guid.NewGuid();
if (existingIds.Contains(id) == true)
{
continue;
}
DHCPv4Lease lease = scope.Leases.GetLeaseById(id);
Assert.True(lease == DHCPv4Lease.Empty);
}
}
public void DHCPv4Lease_IsActive()
{
Random random = new Random();
DHCPv4RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(10, 30);
Dictionary <Guid, Boolean> expectedResults = new Dictionary <Guid, bool>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
events.Add(new DHCPv4LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv4Address(),
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(),
});
Boolean addressIsActive = random.NextDouble() > 0.5;
if (addressIsActive == true)
{
events.Add(new DHCPv4LeaseActivatedEvent(leaseId));
}
expectedResults.Add(leaseId, addressIsActive);
}
rootScope.Load(events);
DHCPv4Scope scope = rootScope.GetRootScopes().First();
foreach (var item in expectedResults)
{
DHCPv4Lease lease = scope.Leases.GetLeaseById(item.Key);
Boolean actual = lease.IsActive();
Assert.Equal(item.Value, actual);
}
}
private DHCPv4LeaseOverview GetLeaseOverview(DHCPv4Lease lease, DHCPv4Scope scope) => new DHCPv4LeaseOverview
{
Address = lease.Address.ToString(),
MacAddress = lease.Identifier.HwAddress,
Started = lease.Start,
ExpectedEnd = lease.End,
Id = lease.Id,
UniqueIdentifier = lease.UniqueIdentifier,
State = lease.State,
Scope = new DHCPv4ScopeOverview
{
Id = scope.Id,
Name = scope.Name,
}
};
protected static void CheckLeaseCreatedEvent(
Int32 index, byte[] clientMacAdress,
Guid scopeId, DHCPv4RootScope rootScope,
IPv4Address expectedAdress, DHCPv4Lease lease,
Byte[] uniqueIdentifier = null, Boolean checkRenewTimes = true
)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.NotNull(changes);
Assert.IsAssignableFrom <DHCPv4LeaseCreatedEvent>(changes.ElementAt(index));
DHCPv4LeaseCreatedEvent createdEvent = (DHCPv4LeaseCreatedEvent)changes.ElementAt(index);
Assert.NotNull(createdEvent);
Assert.Equal(scopeId, createdEvent.ScopeId);
Assert.Equal(expectedAdress, createdEvent.Address);
var clientIdentifier = DHCPv4ClientIdentifier.FromOptionData(createdEvent.ClientIdenfier);
Assert.Equal(clientMacAdress, clientIdentifier.HwAddress);
Assert.Equal(lease.Id, createdEvent.EntityId);
if (uniqueIdentifier == null)
{
Assert.Null(createdEvent.UniqueIdentifier);
}
else
{
Assert.Equal(uniqueIdentifier, createdEvent.UniqueIdentifier);
}
Assert.Equal(lease.Start, createdEvent.StartedAt);
Assert.Equal(lease.End, createdEvent.ValidUntil);
var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties;
if (checkRenewTimes == true)
{
Assert.Equal(addressProperties.RenewalTime.Value, createdEvent.RenewalTime);
Assert.Equal(addressProperties.PreferredLifetime.Value, createdEvent.PreferredLifetime);
}
}
public static DHCPv4Packet AsRequestResponse(
DHCPv4Packet request,
DHCPv4Lease lease,
DHCPv4ScopeAddressProperties addressProperties,
IEnumerable <DHCPv4ScopeProperty> scopeProperties)
{
DHCPv4Packet packet = new DHCPv4Packet(DHCPv4MessagesTypes.Acknowledge, request)
{
YourIPAdress = lease.Address,
_isValid = true,
};
packet.SetIPHeader(request);
packet.AddOption(new DHCPv4PacketAddressOption(DHCPv4OptionTypes.ServerIdentifier, packet.Header.Source));
packet.AddOptions(lease, addressProperties, scopeProperties);
packet.AddOptions82AtTheEnd(request);
return(packet);
}
public void HandleRelease_LeaseExists_AddressIsActive()
{
Random random = new Random();
IPv4Address leasedAddress = IPv4Address.FromString("192.168.178.10");
IPv4HeaderInformation headerInformation =
new IPv4HeaderInformation(leasedAddress, IPv4Address.FromString("192.168.178.1"));
Byte[] clientMacAdress = random.NextBytes(6);
DHCPv4Packet requestPacket = new DHCPv4Packet(
headerInformation, clientMacAdress, (UInt32)random.Next(),
IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty,
DHCPv4PacketFlags.Unicast,
new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Release)
);
Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock =
new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
var resolverInformations = new CreateScopeResolverInformation
{
Typename = nameof(DHCPv4RelayAgentSubnetResolver),
};
Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-1);
DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent(
new DHCPv4ScopeCreateInstruction
{
AddressProperties = new DHCPv4ScopeAddressProperties(
IPv4Address.FromString("192.168.178.1"),
IPv4Address.FromString("192.168.178.255"),
new List <IPv4Address> {
IPv4Address.FromString("192.168.178.1")
},
leaseTime: TimeSpan.FromDays(1)
),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv4LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(clientMacAdress).GetBytes(),
ScopeId = scopeId,
UniqueIdentifier = null,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
},
new DHCPv4LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
},
});
DHCPv4Lease lease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId);
DHCPv4Packet result = rootScope.HandleRelease(requestPacket);
Assert.Equal(DHCPv4Packet.Empty, result);
CheckIfLeaseIsRelease(lease);
CheckEventAmount(2, rootScope);
CheckLeaseReleasedEvent(0, scopeId, rootScope, leaseId);
CheckHandeledEvent(1, ReleaseError.NoError, requestPacket, rootScope);
}
private void CheckIfLeaseIsRelease(DHCPv4Lease lease)
{
Assert.NotEqual(DHCPv4Lease.Empty, lease);
Assert.False(lease.IsActive());
Assert.Equal(LeaseStates.Released, lease.State);
}
public void HandleRelease_LeaseExists_AddressIsActive_NotSentDiscover()
{
Random random = new Random();
IPv4Address leasedAddress = IPv4Address.FromString("192.168.178.10");
IPv4HeaderInformation headerInformation =
new IPv4HeaderInformation(leasedAddress, IPv4Address.FromString("192.168.178.1"));
Byte[] clientMacAdress = random.NextBytes(6);
DHCPv4Packet requestPacket = new DHCPv4Packet(
headerInformation, clientMacAdress, (UInt32)random.Next(),
IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty,
DHCPv4PacketFlags.Unicast,
new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Release)
);
DHCPv4Packet discoverPacket = new DHCPv4Packet(
headerInformation, clientMacAdress, (UInt32)random.Next(),
IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty,
DHCPv4PacketFlags.Broadcast,
new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Discover),
new DHCPv4PacketClientIdentifierOption(DHCPv4ClientIdentifier.FromIdentifierValue("random test client"))
);
Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.PacketMeetsCondition(discoverPacket)).Returns(true);
resolverMock.SetupGet(x => x.HasUniqueIdentifier).Returns(false);
Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock =
new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
var resolverInformations = new CreateScopeResolverInformation
{
Typename = nameof(DHCPv4RelayAgentSubnetResolver),
};
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-1);
DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent(
new DHCPv4ScopeCreateInstruction
{
AddressProperties = new DHCPv4ScopeAddressProperties(
IPv4Address.FromString("192.168.178.1"),
IPv4Address.FromString("192.168.178.255"),
new List <IPv4Address> {
IPv4Address.FromString("192.168.178.1")
},
leaseTime: TimeSpan.FromDays(1),
renewalTime: TimeSpan.FromHours(12),
preferredLifetime: TimeSpan.FromHours(18),
reuseAddressIfPossible: true,
acceptDecline: true,
addressAllocationStrategy: DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next,
supportDirectUnicast: true,
maskLength: 24
),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv4LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdenfier = DHCPv4ClientIdentifier.FromIdentifierValue("random test client").GetBytes(),
ScopeId = scopeId,
UniqueIdentifier = null,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
},
new DHCPv4LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
},
});
DHCPv4Lease existingLease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId);
DHCPv4Packet releaseResult = rootScope.HandleRelease(requestPacket);
Assert.Equal(DHCPv4Packet.Empty, releaseResult);
CheckIfLeaseIsRelease(existingLease);
CheckEventAmount(2, rootScope);
CheckLeaseReleasedEvent(0, scopeId, rootScope, leaseId);
CheckHandeledEvent(1, ReleaseError.NoError, requestPacket, rootScope);
DHCPv4Packet discoveryResult = rootScope.HandleDiscover(discoverPacket);
IPv4Address newAssignedAddress = IPv4Address.FromString("192.168.178.2");
Assert.Equal(newAssignedAddress, discoveryResult.YourIPAdress);
}
public void HandleDecline_AcceptDecline_RequesAddressExits_LeaseExists_LeaseIsPending_AddressIsNotSuspended()
{
Random random = new Random();
IPv4Address leasedAddress = IPv4Address.FromString("192.168.178.3");
DHCPv4Packet requestPacket = GetDeclinePacket(random, leasedAddress);
Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock =
new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
var resolverInformations = new CreateScopeResolverInformation
{
Typename = nameof(DHCPv4RelayAgentSubnetResolver),
};
Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-1);
DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent(
new DHCPv4ScopeCreateInstruction
{
AddressProperties = new DHCPv4ScopeAddressProperties(
IPv4Address.FromString("192.168.178.0"),
IPv4Address.FromString("192.168.178.100"),
new List <IPv4Address> {
IPv4Address.FromString("192.168.178.0")
},
leaseTime: TimeSpan.FromDays(1),
acceptDecline: true),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv4LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(requestPacket.ClientHardwareAddress).GetBytes(),
ScopeId = scopeId,
UniqueIdentifier = null,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
},
});
DHCPv4Packet result = rootScope.HandleDecline(requestPacket);
Assert.Equal(DHCPv4Packet.Empty, result);
DHCPv4Lease lease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId);
Assert.Equal(LeaseStates.Suspended, lease.State);
CheckEventAmount(2, rootScope);
CheckDeclineEvent(0, leaseId, leasedAddress, scopeId, rootScope);
CheckDeclinedEvent(1, DeclineErros.NoError, requestPacket, rootScope, scopeId);
}
public void DHCPv4Lease_AddressesAreInUse()
{
Random random = new Random();
DHCPv4RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
rootScope.Load(new[] { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = scopeId,
}) });
Int32 leaseAmount = random.Next(10, 30);
Dictionary <Guid, Boolean> expectedResults = new Dictionary <Guid, bool>();
Dictionary <Guid, DHCPv4Lease> leases = new Dictionary <Guid, DHCPv4Lease>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
rootScope.Load(new[] {
new DHCPv4LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv4Address(),
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(),
}
});
leases.Add(leaseId, rootScope.GetRootScopes().First().Leases.GetLeaseById(leaseId));
DomainEvent eventToAdd = null;
Boolean addressIsInUse = true;
Double randomValue = random.NextDouble();
Double possiblities = 5.0;
if (randomValue < 1 / possiblities)
{
eventToAdd = new DHCPv4LeaseReleasedEvent(leaseId);
addressIsInUse = false;
}
else if (randomValue < 2 / possiblities)
{
eventToAdd = new DHCPv4LeaseRevokedEvent(leaseId);
addressIsInUse = false;
}
else if (randomValue < 3 / possiblities)
{
eventToAdd = new DHCPv4AddressSuspendedEvent(leaseId, random.GetIPv4Address(), DateTime.UtcNow.AddHours(12));
addressIsInUse = false;
}
if (eventToAdd != null)
{
rootScope.Load(new[] { eventToAdd });
}
expectedResults.Add(leaseId, addressIsInUse);
}
foreach (var item in expectedResults)
{
DHCPv4Lease lease = leases[item.Key];
Boolean actual = lease.AddressIsInUse();
Assert.Equal(item.Value, actual);
}
}
public static Dictionary <DHCPv4Lease, Boolean> AddEventsForCancelableLeases(
Random random,
Guid scopeId,
DHCPv4RootScope scope)
{
Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > cancalableStateBuilder = new Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> >
{
{ LeaseStates.Pending, (id) => null },
{ LeaseStates.Active, (id) => new DHCPv4LeaseActivatedEvent(id) },
};
Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > nonCancalableStateBuilder = new Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> >
{
{ LeaseStates.Inactive, (id) => new DHCPv4LeaseExpiredEvent(id) },
{ LeaseStates.Canceled, (id) => new DHCPv4LeaseCanceledEvent(id) },
{ LeaseStates.Released, (id) => new DHCPv4LeaseReleasedEvent(id) },
{ LeaseStates.Revoked, (id) => new DHCPv4LeaseRevokedEvent(id) },
};
Int32 leaseAmount = random.Next(20, 40);
Dictionary <DHCPv4Lease, Boolean> expectedCancallations = new();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
scope.Load(new[] {
new DHCPv4LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(),
Address = random.GetIPv4Address(),
}
});
DHCPv4Lease lease = scope.GetRootScopes().First().Leases.GetLeaseById(leaseId);
Boolean shouldBeCancelable = random.NextDouble() > 0.5;
Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > eventCreatorDict = null;
if (shouldBeCancelable == true)
{
eventCreatorDict = cancalableStateBuilder;
}
else
{
eventCreatorDict = nonCancalableStateBuilder;
}
var entry = eventCreatorDict.ElementAt(random.Next(0, eventCreatorDict.Count));
DHCPv4ScopeRelatedEvent stateChangingEvent = entry.Value(leaseId);
if (stateChangingEvent != null)
{
stateChangingEvent.ScopeId = scopeId;
scope.Load(new[] { stateChangingEvent });
}
expectedCancallations.Add(lease, shouldBeCancelable);
}
return(expectedCancallations);
}
public void DHCPv4Lease_MatchesUniqueIdentiifer()
{
Random random = new Random();
DHCPv4RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
Byte[] uniqueIdentifier = random.NextBytes(10);
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(3, 10);
Dictionary <Guid, Boolean> expectedResults = new Dictionary <Guid, bool>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
Byte[] identifier = null;
Boolean matches = false;
Double randomValue = random.NextDouble();
if (randomValue > 0.75)
{
identifier = uniqueIdentifier;
matches = true;
}
else if (randomValue > 0.5)
{
identifier = random.NextBytes(12);
}
else if (randomValue > 0.25)
{
identifier = new byte[0];
}
events.Add(new DHCPv4LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
UniqueIdentifier = identifier,
Address = random.GetIPv4Address(),
ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(),
});
expectedResults.Add(leaseId, matches);
}
rootScope.Load(events);
DHCPv4Scope scope = rootScope.GetRootScopes().First();
foreach (var item in expectedResults)
{
DHCPv4Lease lease = scope.Leases.GetLeaseById(item.Key);
Boolean actual = lease.MatchesUniqueIdentiifer(uniqueIdentifier);
Assert.Equal(item.Value, actual);
}
}
private void AddOptions(
DHCPv4Lease lease,
DHCPv4ScopeAddressProperties addressProperties,
IEnumerable <DHCPv4ScopeProperty> scopeProperties)
{
List <DHCPv4ScopeProperty> propertiesToInsert = new List <DHCPv4ScopeProperty>(scopeProperties);
if (addressProperties != null)
{
propertiesToInsert.Add(new DHCPv4AddressScopeProperty(DHCPv4OptionTypes.SubnetMask, IPv4Address.FromByteArray(addressProperties.Mask.GetBytes())));
}
Dictionary <DHCPv4OptionTypes, TimeSpan?> timeRelatedOptions = new Dictionary <DHCPv4OptionTypes, TimeSpan?>();
if (lease != null)
{
timeRelatedOptions.Add(DHCPv4OptionTypes.IPAddressLeaseTime, lease.End - DateTime.UtcNow);
timeRelatedOptions.Add(DHCPv4OptionTypes.RenewalTimeValue, lease.RenewSpan);
timeRelatedOptions.Add(DHCPv4OptionTypes.RebindingTimeValue, lease.RebindingSpan);
}
Int32 timeOptionIndex = 0;
foreach (var item in timeRelatedOptions)
{
if (item.Value.HasValue == false)
{
continue;
}
propertiesToInsert.Insert(timeOptionIndex++, new DHCPv4TimeScopeProperty(item.Key, false, item.Value.Value));
}
foreach (var item in propertiesToInsert)
{
switch (item.ValueType)
{
case DHCPv4ScopePropertyType.Address:
case DHCPv4ScopePropertyType.Subnet:
AddOption(new DHCPv4PacketAddressOption(item.OptionIdentifier, ((DHCPv4AddressScopeProperty)item).Address));
break;
case DHCPv4ScopePropertyType.AddressList:
AddOption(new DHCPv4PacketAddressListOption(item.OptionIdentifier, ((DHCPv4AddressListScopeProperty)item).Addresses));
break;
case DHCPv4ScopePropertyType.Time:
AddOption(new DHCPv4PacketTimeSpanOption(item.OptionIdentifier, ((DHCPv4TimeScopeProperty)item).Value, false));
break;
case DHCPv4ScopePropertyType.TimeOffset:
AddOption(new DHCPv4PacketTimeSpanOption(item.OptionIdentifier, ((DHCPv4TimeScopeProperty)item).Value, true));
break;
case DHCPv4ScopePropertyType.Byte:
AddOption(new DHCPv4PacketByteOption(item.OptionIdentifier, (Byte)(((DHCPv4NumericValueScopeProperty)item).Value)));
break;
case DHCPv4ScopePropertyType.UInt16:
AddOption(new DHCPv4PacketUInt16Option(item.OptionIdentifier, (UInt16)(((DHCPv4NumericValueScopeProperty)item).Value)));
break;
case DHCPv4ScopePropertyType.UInt32:
AddOption(new DHCPv4PacketUInt32Option(item.OptionIdentifier, (UInt32)(((DHCPv4NumericValueScopeProperty)item).Value)));
break;
case DHCPv4ScopePropertyType.Boolean:
AddOption(new DHCPv4PacketBooleanOption(item.OptionIdentifier, ((DHCPv4BooleanScopeProperty)item).Value));
break;
case DHCPv4ScopePropertyType.AddressAndMask:
throw new NotImplementedException();
case DHCPv4ScopePropertyType.Text:
AddOption(new DHCPv4PacketTextOption(item.OptionIdentifier, ((DHCPv4TextScopeProperty)item).Value));
break;
case DHCPv4ScopePropertyType.ByteArray:
//AddOption(new DHCPv4PacketRawByteOption(item.OptionIdentifier, ((DHCPv4RawByteScopeProperty)item).Value));
throw new NotImplementedException();
default:
break;
}
}
}
