public void HasHardwareAddress(Boolean isSet)
{
UUIDDUID duid = new UUIDDUID(Guid.NewGuid());
Random random = new Random();
Byte[] hwAddress = random.NextBytes(12);
UInt32 iaid = 252132525;
DHCPv4ClientIdentifier identifier;
if (isSet == true)
{
identifier = DHCPv4ClientIdentifier.FromDuid(iaid, duid, hwAddress);
}
else
{
identifier = DHCPv4ClientIdentifier.FromDuid(iaid, duid);
}
Boolean actual = identifier.HasHardwareAddress();
Assert.Equal(isSet, actual);
}
private DHCPv6Packet GetReleasePacket(
Random random, out IPv6Address usedAddress, out DUID clientDuid, out UInt32 iaId, Boolean withIdentity, params DHCPv6PacketOption[] options)
{
IPv6HeaderInformation headerInformation =
new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"));
clientDuid = new UUIDDUID(random.NextGuid());
iaId = random.NextBoolean() == false?random.NextUInt32() : 0;
usedAddress = random.GetIPv6Address();
var packetOptions = new List <DHCPv6PacketOption>(options)
{
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid),
};
if (withIdentity == true)
{
packetOptions.Add(new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[]
{
new DHCPv6PacketIdentityAssociationAddressSuboption(usedAddress, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>())
}));
}
DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, random.NextUInt16(),
DHCPv6PacketTypes.RELEASE, packetOptions);
return(packet);
}
public void Construtor()
{
Random random = new Random();
Guid id = random.NextGuid();
UUIDDUID duid = new UUIDDUID(id);
Assert.Equal(DUIDTypes.Uuid, duid.Type);
Assert.Equal(id, duid.UUID);
}
public void Equals_Null()
{
Random random = new Random();
Guid id = random.NextGuid();
UUIDDUID duid1 = new UUIDDUID(id);
UUIDDUID duid2 = null;
Assert.False(duid1.Equals(duid2));
}
public async Task <DHCPv6ServerProperties> GetServerProperties()
{
String content = await Helpers.AsQueryable().Where(x => x.Name == _DHCPv6ServerConfigKey).Select(x => x.Content).FirstOrDefaultAsync();
if (String.IsNullOrEmpty(content) == true)
{
return(new DHCPv6ServerProperties
{
IsInitilized = true,
LeaseLifeTime = TimeSpan.FromDays(15),
HandledLifeTime = TimeSpan.FromDays(15),
MaximumHandldedCounter = 100_000,
ServerDuid = new UUIDDUID(Guid.Parse("bbd541ea-8499-44b4-ad9d-d398c4643e79"))
});
private DHCPv6Packet GetRelayedConfirmPacket(
Random random, out IPv6Address usedAddress, out DUID clientDuid, out UInt32 iaId, out DHCPv6PrefixDelegation prefixDelegation, Boolean withAddress, Boolean withPrefix)
{
IPv6HeaderInformation headerInformation =
new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"));
clientDuid = new UUIDDUID(random.NextGuid());
usedAddress = IPv6Address.Empty;
prefixDelegation = DHCPv6PrefixDelegation.None;
iaId = 0;
var packetOptions = new List <DHCPv6PacketOption>()
{
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid),
};
if (withAddress == true)
{
iaId = random.NextUInt32();
usedAddress = random.GetIPv6Address();
packetOptions.Add(new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[]
{
new DHCPv6PacketIdentityAssociationAddressSuboption(usedAddress, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>())
}));
}
if (withPrefix == true)
{
IPv6Address prefix = IPv6Address.FromString("2acd:adce::0");
UInt32 prefixId = random.NextBoolean() == false?random.NextUInt32() : 0;
Byte mask = (Byte)random.Next(64, 80);
prefixDelegation = DHCPv6PrefixDelegation.FromValues(prefix, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(mask)), prefixId);
packetOptions.Add(new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[]
{
new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.Zero, TimeSpan.Zero, mask, prefix, Array.Empty <DHCPv6PacketSuboption>())
}));
}
DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(random.NextUInt16(),
DHCPv6PacketTypes.CONFIRM, packetOptions);
DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(),
new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)) }, innerPacket);
return(packet);
}
public void LimitLeasesPerClient()
{
Random random = new Random();
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
DUID clientIdentifier = new UUIDDUID(random.NextGuid());
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(20, 40);
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
events.Add(new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv6Address(),
ClientIdentifier = clientIdentifier
});
events.Add(new DHCPv6LeaseActivatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
});
events.Add(new DHCPv6LeaseRevokedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
});
}
rootScope.Load(events);
DHCPv6Scope scope = rootScope.GetRootScopes().First();
var leases = scope.Leases.GetAllLeases();
Assert.Empty(leases);
}
public void GetDUID()
{
Random random = new Random();
DUID expected = new UUIDDUID(random.NextGuid());
Mock <IDHCPv6ReadStore> readStoreMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict);
readStoreMock.Setup(x => x.GetServerProperties()).ReturnsAsync(new DHCPv6ServerProperties {
ServerDuid = expected
}).Verifiable();
DatabaseDHCPv6ServerPropertiesResolver resolver = new DatabaseDHCPv6ServerPropertiesResolver(readStoreMock.Object);
DUID result = resolver.GetServerDuid();
readStoreMock.Verify();
}
public void FromByteArray()
{
Random random = new Random();
Guid id = random.NextGuid();
Byte[] input = new Byte[18];
input[0] = 0;
input[1] = (Byte)DUIDTypes.Uuid;
id.ToByteArray().CopyTo(input, 2);
UUIDDUID duid = UUIDDUID.FromByteArray(input, 0);
Assert.Equal(DUIDTypes.Uuid, duid.Type);
Assert.Equal(id, duid.UUID);
Byte[] asStream = duid.GetAsByteStream();
Assert.Equal(input, asStream);
}
public void GetDuidFromDevice_DeviceNotFound()
{
Random random = new Random();
Guid id = random.NextGuid();
UUIDDUID duid = new UUIDDUID(random.NextGuid());
Device device = new Device {
Id = id, DUID = duid
};
var service = new InMemoryDeviceService(new[] { device });
var actual = service.GetDuidFromDevice(random.NextGuid());
Assert.IsAssignableFrom <UUIDDUID>(actual);
Assert.Equal(Guid.Empty, ((UUIDDUID)actual).UUID);
}
public void AddHWAdress_HwAlreadySet()
{
UUIDDUID duid = new UUIDDUID(Guid.NewGuid());
UInt32 iaid = 252132525;
Random random = new Random();
Byte[] hwAddress = random.NextBytes(12);
Byte[] packetHwAddress = random.NextBytes(12);
DHCPv4ClientIdentifier firstIdentifier = DHCPv4ClientIdentifier.FromDuid(iaid, duid, hwAddress);
DHCPv4ClientIdentifier secondIdentifier = firstIdentifier.AddHardwareAddress(packetHwAddress);
Assert.NotEqual(packetHwAddress, secondIdentifier.HwAddress);
Assert.Equal(hwAddress, secondIdentifier.HwAddress);
Assert.Equal(duid, secondIdentifier.DUID);
Assert.Equal(iaid, secondIdentifier.IaId);
}
public void AddHWAdress_FromDuid()
{
UUIDDUID duid = new UUIDDUID(Guid.NewGuid());
Random random = new Random();
Byte[] hwAddress = random.NextBytes(12);
UInt32 iaid = 252132525;
DHCPv4ClientIdentifier firstIdentifier = DHCPv4ClientIdentifier.FromDuid(iaid, duid);
DHCPv4ClientIdentifier secondIdentifier = firstIdentifier.AddHardwareAddress(hwAddress);
Assert.Equal(hwAddress, secondIdentifier.HwAddress);
Assert.Equal(duid, secondIdentifier.DUID);
Assert.Equal(iaid, secondIdentifier.IaId);
Assert.Equal((Byte)DHCPv4PacketHardwareAddressTypes.Ethernet, secondIdentifier.HardwareAddressType);
Assert.True(String.IsNullOrEmpty(secondIdentifier.IdentifierValue));
}
public async Task Filter_CouldHaveValue_ValueNotMatchesServerDUID()
{
Random random = new Random();
UUIDDUID serverDuid = new UUIDDUID(random.NextGuid());
DHCPv6PacketServerIdentifierFilter filter =
new DHCPv6PacketServerIdentifierFilter(
serverDuid,
Mock.Of <ILogger <DHCPv6PacketServerIdentifierFilter> >());
DHCPv6Packet packet = DHCPv6Packet.AsInner(
1, DHCPv6PacketTypes.INFORMATION_REQUEST, new List <DHCPv6PacketOption>
{
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ServerIdentifer, new UUIDDUID(random.NextGuid())),
});
Boolean result = await filter.ShouldPacketBeFiltered(packet);
Assert.True(result);
}
private DHCPv6Packet GetSolicitPacket(
Random random, out DUID clientDuid, out UInt32 iaId, params DHCPv6PacketOption[] options)
{
IPv6HeaderInformation headerInformation =
new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::1"));
clientDuid = new UUIDDUID(random.NextGuid());
iaId = random.NextUInt32();
var packetOptions = new List <DHCPv6PacketOption>(options)
{
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid),
new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.Zero, TimeSpan.Zero, Array.Empty <DHCPv6PacketSuboption>()),
new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit),
};
DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, random.NextUInt16(),
DHCPv6PacketTypes.Solicit, packetOptions);
return(packet);
}
public void FromOptionData_FromDUID()
{
Random random = new Random();
Guid duidValue = random.NextGuid();
UUIDDUID duid = new UUIDDUID(duidValue);
UInt32 iaid = random.NextUInt32();
Byte[] identifierValue = duid.GetAsByteStream();
Byte[] input = ByteHelper.ConcatBytes(new Byte[] { 0xff }, ByteHelper.GetBytes(iaid), identifierValue);
DHCPv4ClientIdentifier identifier = DHCPv4ClientIdentifier.FromOptionData(input);
Assert.Empty(identifier.HwAddress);
Assert.Equal(duid, identifier.DUID);
Assert.Equal(iaid, identifier.IaId);
Assert.True(String.IsNullOrEmpty(identifier.IdentifierValue));
}
public void GetDuidFromDevice_DeviceFound(Boolean devicesAddedLater)
{
Random random = new Random();
Guid id = random.NextGuid();
UUIDDUID duid = new UUIDDUID(random.NextGuid());
Device device = new Device {
Id = id, DUID = duid
};
var service = new InMemoryDeviceService(devicesAddedLater == true ? null : new[] { device });
if (devicesAddedLater == true)
{
service.AddDevices(new[] { device });
}
var actual = service.GetDuidFromDevice(id);
Assert.IsAssignableFrom <UUIDDUID>(actual);
Assert.Equal(duid, (UUIDDUID)actual);
}
public async Task Filter_ShouldNotHaveValue(Boolean valueIsPresented)
{
Random random = new Random();
UUIDDUID serverDuid = new UUIDDUID(random.NextGuid());
DHCPv6PacketServerIdentifierFilter filter =
new DHCPv6PacketServerIdentifierFilter(
serverDuid,
Mock.Of <ILogger <DHCPv6PacketServerIdentifierFilter> >());
var options = new List <DHCPv6PacketOption>();
if (valueIsPresented == true)
{
options.Add(new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ServerIdentifer, serverDuid));
}
DHCPv6Packet packet = DHCPv6Packet.AsInner(
1, DHCPv6PacketTypes.Solicit, options);
Boolean result = await filter.ShouldPacketBeFiltered(packet);
Assert.False(result);
}
public async Task SaveAndHydrateRootScope_AddAndRemoveLeases()
{
Random random = new Random();
await ExecuteWithStreamErase(random, async (eventStore) =>
{
Mock <IDHCPv6ServerPropertiesResolver> propertyResolverMock;
DHCPv6StorageEngine engine;
PrepareEngine(random, eventStore, out propertyResolverMock, out engine);
DHCPv6RootScope initialRootScope = await engine.GetRootScope();
Guid rootScopeId = random.NextGuid();
initialRootScope.AddScope(new DHCPv6ScopeCreateInstruction
{
AddressProperties = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::0"),
IPv6Address.FromString("fe80::ff"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::1")
},
preferredLifeTime: TimeSpan.FromDays(0.5),
validLifeTime: TimeSpan.FromDays(1),
rapitCommitEnabled: true,
informsAreAllowd: true,
supportDirectUnicast: false,
reuseAddressIfPossible: false,
acceptDecline: true,
t1: DHCPv6TimeScale.FromDouble(0.6),
t2: DHCPv6TimeScale.FromDouble(0.8),
addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next),
ScopeProperties = DHCPv6ScopeProperties.Empty,
ResolverInformation = new CreateScopeResolverInformation
{
Typename = nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver),
PropertiesAndValues = new Dictionary <String, String>
{
{ nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver.EnterpriseNumber), random.NextUInt16().ToString() },
{ nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver.RelayAgentIndex), 0.ToString() },
}
},
Name = "Testscope",
Id = rootScopeId,
});
var clientDuid = new UUIDDUID(random.NextGuid());
DHCPv6Packet solicitPacket = DHCPv6Packet.AsInner(14, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption>
{
new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit),
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid),
new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(15, TimeSpan.Zero, TimeSpan.Zero, new List <DHCPv6PacketSuboption>()),
});
DHCPv6RelayPacket outerSolicitPacket = DHCPv6RelayPacket.AsOuterRelay(new IPv6HeaderInformation(random.GetIPv6Address(), random.GetIPv6Address()),
true, 0, IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::2"), new DHCPv6PacketOption[]
{
new DHCPv6PacketRemoteIdentifierOption(random.NextUInt16(), new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }),
}, solicitPacket);
initialRootScope.HandleSolicit(outerSolicitPacket, propertyResolverMock.Object);
var firstLease = initialRootScope.GetRootScopes().First().Leases.GetAllLeases().First();
await engine.Save(initialRootScope);
initialRootScope = await engine.GetRootScope();
DHCPv6Packet releasePacket = DHCPv6Packet.AsInner(14, DHCPv6PacketTypes.RELEASE, new List <DHCPv6PacketOption>
{
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid),
new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(15, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[]
{
new DHCPv6PacketIdentityAssociationAddressSuboption(firstLease.Address, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>())
})
});
DHCPv6RelayPacket outerreleasePacket = DHCPv6RelayPacket.AsOuterRelay(new IPv6HeaderInformation(random.GetIPv6Address(), random.GetIPv6Address()),
true, 0, IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::2"), new DHCPv6PacketOption[]
{
new DHCPv6PacketRemoteIdentifierOption(random.NextUInt16(), new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }),
}, releasePacket);
firstLease = initialRootScope.GetRootScopes().First().Leases.GetAllLeases().First();
initialRootScope.HandleRelease(outerreleasePacket, propertyResolverMock.Object);
Assert.Equal(LeaseStates.Released, firstLease.State);
Assert.Empty(initialRootScope.GetRootScopes().First().Leases.GetAllLeases());
await engine.Save(initialRootScope);
await Task.Delay(1000);
initialRootScope.DropUnusedLeasesOlderThan(DateTime.Now);
Assert.Empty(initialRootScope.GetRootScopes().First().Leases.GetAllLeases());
await engine.Save(initialRootScope);
var rehydratedRootScope = await engine.GetRootScope();
Assert.Empty(rehydratedRootScope.GetRootScopes().First().Leases.GetAllLeases());
});
}
public void TestNotifcationTriggerForSolicitMessages(Boolean reuse, Boolean prefixRequest, Boolean hadPrefix, Boolean shouldHaveOldBinding, Boolean shouldHaveNewBinding)
{
Random random = new Random();
IPv6HeaderInformation headerInformation =
new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"));
DUID clientDuid = new UUIDDUID(random.NextGuid());
UInt32 iaId = random.NextBoolean() == false?random.NextUInt32() : 0;
IPv6Address leasedAddress = IPv6Address.FromString("fe80::5");
UInt32 prefixIaId = random.NextBoolean() == false?random.NextUInt32() : 0;
Byte exisitngPrefixLength = 62;
DHCPv6PrefixDelegation existingDelegation = DHCPv6PrefixDelegation.FromValues(
IPv6Address.FromString("2a4c::0"), new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(exisitngPrefixLength)), prefixIaId);
var packetOptions = new List <DHCPv6PacketOption>
{
new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid),
new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.Zero, TimeSpan.Zero, Array.Empty <DHCPv6PacketSuboption>()),
};
if (prefixRequest == true)
{
packetOptions.Add(
new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixIaId, TimeSpan.Zero, TimeSpan.Zero, Array.Empty <DHCPv6PacketSuboption>()));
}
DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(random.NextUInt16(),
DHCPv6PacketTypes.REBIND, packetOptions);
DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(),
new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)) }, innerPacket);
CreateScopeResolverInformation resolverInformations = new CreateScopeResolverInformation {
Typename = "something"
};
Mock <IScopeResolver <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.PacketMeetsCondition(packet)).Returns(true);
resolverMock.SetupGet(x => x.HasUniqueIdentifier).Returns(false);
var scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict);
factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >());
var rootScope = new DHCPv6RootScope(Guid.NewGuid(), scopeResolverMock.Object, factoryMock.Object);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
var expetecNewLeaseAddress = IPv6Address.FromString("fe80::0");
var events = new List <DomainEvent> {
new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent(
new DHCPv6ScopeCreateInstruction
{
AddressProperties = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::0"),
IPv6Address.FromString("fe80::ff"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::1")
},
t1: DHCPv6TimeScale.FromDouble(0.5),
t2: DHCPv6TimeScale.FromDouble(0.75),
preferredLifeTime: TimeSpan.FromDays(0.5),
validLifeTime: TimeSpan.FromDays(1),
reuseAddressIfPossible: reuse,
prefixDelgationInfo: DHCPv6PrefixDelgationInfo.FromValues(existingDelegation.NetworkAddress, new IPv6SubnetMaskIdentifier(40), new IPv6SubnetMaskIdentifier(64)),
addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv6LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdentifier = clientDuid,
IdentityAssocationId = iaId,
ScopeId = scopeId,
HasPrefixDelegation = hadPrefix,
UniqueIdentiifer = Array.Empty <Byte>(),
PrefixLength = hadPrefix == true ? exisitngPrefixLength : (Byte)0,
IdentityAssocationIdForPrefix = hadPrefix == true ? prefixIaId : (UInt32)0,
DelegatedNetworkAddress = hadPrefix == true ? existingDelegation.NetworkAddress : IPv6Address.Empty,
StartedAt = DateTime.UtcNow.AddDays(-1),
ValidUntil = DateTime.UtcNow.AddDays(1),
},
new DHCPv6LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
}
};
rootScope.Load(events);
var serverPropertiesResolverMock = new Mock <IDHCPv6ServerPropertiesResolver>(MockBehavior.Strict);
serverPropertiesResolverMock.Setup(x => x.GetServerDuid()).Returns(new UUIDDUID(Guid.NewGuid()));
var _ = rootScope.HandleRebind(packet, serverPropertiesResolverMock.Object);
if (shouldHaveNewBinding == false && shouldHaveOldBinding == false)
{
CheckEmptyTrigger(rootScope);
}
else
{
var trigger = CheckTrigger <PrefixEdgeRouterBindingUpdatedTrigger>(rootScope);
Assert.Equal(scopeId, trigger.ScopeId);
if (shouldHaveNewBinding == true)
{
Assert.NotNull(trigger.NewBinding);
Assert.Equal(64, trigger.NewBinding.Mask.Identifier);
if (reuse == true)
{
Assert.Equal(leasedAddress, trigger.NewBinding.Host);
}
else
{
Assert.Equal(expetecNewLeaseAddress, trigger.NewBinding.Host);
}
}
else
{
Assert.Null(trigger.NewBinding);
}
if (shouldHaveOldBinding == true)
{
Assert.NotNull(trigger.OldBinding);
Assert.Equal(exisitngPrefixLength, trigger.OldBinding.Mask.Identifier);
Assert.Equal(existingDelegation.NetworkAddress, trigger.OldBinding.Prefix);
Assert.Equal(leasedAddress, trigger.OldBinding.Host);
}
else
{
Assert.Null(trigger.OldBinding);
}
}
}
