public void IsResolverInformationValid_Flat_IsValid(Boolean shouldBeValid)
{
Random random = new Random();
CreateScopeResolverInformation inputModel = new CreateScopeResolverInformation();
Int32 propertyAmount = random.Next(3, 30);
for (int i = 0; i < propertyAmount; i++)
{
inputModel.PropertiesAndValues.Add($"property-{i + 1}", $"{random.Next()}");
}
Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict);
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(serializerMock.Object, Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
Mock <IScopeResolver <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.ArePropertiesAndValuesValid(inputModel.PropertiesAndValues, serializerMock.Object)).Returns(shouldBeValid);
String typeName = $"typname-{random.Next()}";
scopeManager.AddOrUpdateScopeResolver(typeName, () => resolverMock.Object);
inputModel.Typename = typeName;
Boolean actual = scopeManager.IsResolverInformationValid(inputModel);
Assert.Equal(shouldBeValid, actual);
resolverMock.Verify(x => x.ArePropertiesAndValuesValid(inputModel.PropertiesAndValues, serializerMock.Object), Times.Once());
}
protected static CreateScopeResolverInformation GetMockupResolver(
IEnumerable <DHCPv6Packet> packets,
out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock,
Byte[] uniqueIdentifierValue = null
)
{
CreateScopeResolverInformation resolverInformations = new CreateScopeResolverInformation {
Typename = "something"
};
scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
Mock <IScopeResolver <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
foreach (var packet in packets)
{
resolverMock.Setup(x => x.PacketMeetsCondition(packet)).Returns(true);
resolverMock.SetupGet(x => x.HasUniqueIdentifier).Returns(uniqueIdentifierValue != null);
if (uniqueIdentifierValue != null)
{
resolverMock.Setup(x => x.GetUniqueIdentifier(packet)).Returns(uniqueIdentifierValue);
}
}
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
return(resolverInformations);
}
public void HandleInform_InformsAreAllowed()
{
Random random = new Random();
IPv4Address clientAddress = IPv4Address.FromString("192.168.178.10");
IPv4HeaderInformation headerInformation =
new IPv4HeaderInformation(clientAddress, IPv4Address.FromString("192.168.178.1"));
Byte[] clientMacAdress = random.NextBytes(6);
DHCPv4Packet requestPacket = new DHCPv4Packet(
headerInformation, clientMacAdress, (UInt32)random.Next(),
IPv4Address.Empty, IPv4Address.Empty, clientAddress,
DHCPv4PacketFlags.Unicast,
new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Inform)
);
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();
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")
},
informsAreAllowd: true
),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
})
});
DHCPv4Packet result = rootScope.HandleInform(requestPacket);
CheckAcknowledgePacket(clientAddress, result);
CheckEventAmount(1, rootScope);
CheckHandeledEvent(0, InformErros.NoError, requestPacket, result, rootScope);
}
protected static CreateScopeResolverInformation GetMockupPseudoResolver(out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock)
{
CreateScopeResolverInformation resolverInformations = new CreateScopeResolverInformation {
Typename = "something"
};
scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(new DHCPv6PseudoResolver());
return(resolverInformations);
}
public override Boolean UpdateScopeResolver(Guid scopeId, CreateScopeResolverInformation resolverInformation)
{
CheckIfScopeResolverIsValid(scopeId, resolverInformation);
if (CheckIfScopeResolverHasChanged(scopeId, resolverInformation) == false)
{
return(false);
}
base.Apply(new DHCPv6ScopeResolverUpdatedEvent(scopeId, resolverInformation));
CancelAllLeasesBecauseOfChangeOfResolver(scopeId);
return(true);
}
public IScopeResolver <TPacket, TAddress> InitializeResolver(CreateScopeResolverInformation resolverCreateModel)
{
IScopeResolver <TPacket, TAddress> resolver = GetResolverFromCreateModel(resolverCreateModel, true);
if (resolver is IScopeResolverContainingOtherResolvers <TPacket, TAddress> == true)
{
var resolverContainingOthers = (IScopeResolverContainingOtherResolvers <TPacket, TAddress>)resolver;
IEnumerable <CreateScopeResolverInformation> innenrResolvers = resolverContainingOthers.ExtractResolverCreateModels(resolverCreateModel, _serializer);
GenerateResolverTree(innenrResolvers, resolverContainingOthers);
}
return(resolver);
}
public void IsResolverInformationValid_ResolverTypeNotFound()
{
Random random = new Random();
CreateScopeResolverInformation inputModel = new CreateScopeResolverInformation();
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(Mock.Of <ISerializer>(MockBehavior.Strict), Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
String typeName = $"typname-{random.Next()}";
inputModel.Typename = typeName;
Boolean actual = scopeManager.IsResolverInformationValid(inputModel);
Assert.False(actual);
}
public void InitializeResolver_Fail_TypeNotFound()
{
Random random = new Random();
CreateScopeResolverInformation inputModel = new CreateScopeResolverInformation();
Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict);
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(Mock.Of <ISerializer>(MockBehavior.Strict), Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
String typeName = $"typname-{random.Next()}";
inputModel.Typename = typeName;
Exception exp = Assert.Throws <Exception>(() => scopeManager.InitializeResolver(inputModel));
Assert.NotNull(exp);
}
private IScopeResolver <TPacket, TAddress> GetResolverFromCreateModel(CreateScopeResolverInformation resolverCreateModel, Boolean applyValues)
{
String normalizeNamed = GetNormalizedMapperName(resolverCreateModel.Typename);
if (_resolverMapper.ContainsKey(normalizeNamed) == false)
{
throw new Exception();
}
IScopeResolver <TPacket, TAddress> resolver = _resolverMapper[normalizeNamed].Invoke();
if (applyValues == true)
{
resolver.ApplyValues(resolverCreateModel.PropertiesAndValues, _serializer);
}
return(resolver);
}
private static CreateScopeResolverInformation GetMockupResolver(
DHCPv6Packet packet,
out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock
)
{
CreateScopeResolverInformation resolverInformations = new CreateScopeResolverInformation {
Typename = "something"
};
scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
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);
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
return(resolverInformations);
}
public bool IsResolverInformationValid(CreateScopeResolverInformation resolverCreateModel)
{
if (resolverCreateModel == null || String.IsNullOrEmpty(resolverCreateModel.Typename) == true)
{
return(false);
}
String normalizeNamed = GetNormalizedMapperName(resolverCreateModel.Typename);
if (_resolverMapper.ContainsKey(normalizeNamed) == false)
{
return(false);
}
IScopeResolver <TPacket, TAddress> resolver = _resolverMapper[normalizeNamed].Invoke();
Boolean result = resolver.ArePropertiesAndValuesValid(resolverCreateModel.PropertiesAndValues, _serializer);
if (result == true && resolver is IScopeResolverContainingOtherResolvers <TPacket, TAddress> resolvers)
{
var resolverContainingOthers = resolvers;
IEnumerable <CreateScopeResolverInformation> innenrResolvers = resolverContainingOthers.ExtractResolverCreateModels(resolverCreateModel, _serializer);
foreach (CreateScopeResolverInformation item in innenrResolvers)
{
Boolean childResult = IsResolverInformationValid(item);
if (childResult == false)
{
result = false;
break;
}
}
}
return(result);
}
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 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);
}
}
}
public void InitializeResolver_NotMocked()
{
Random random = new Random();
UInt32 enterpriseId = random.NextUInt32();
Int32 relayAgentIndex = random.Next();
CreateScopeResolverInformation createScopeResolverInformation = new CreateScopeResolverInformation
{
Typename = nameof(DHCPv6AndResolver),
PropertiesAndValues = new Dictionary <String, String>
{
{ "InnerResolvers", JsonConvert.SerializeObject(new CreateScopeResolverInformation[]
{
new CreateScopeResolverInformation {
Typename = nameof(DHCPv6AndResolver),
PropertiesAndValues = new Dictionary <String, String>
{
{ "InnerResolvers", JsonConvert.SerializeObject(new CreateScopeResolverInformation[]
{
new CreateScopeResolverInformation {
Typename = nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver),
PropertiesAndValues = new Dictionary <String, String>
{
{ nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver.EnterpriseNumber), enterpriseId.ToString() },
{ nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver.RelayAgentIndex), relayAgentIndex.ToString() },
}
}
}) }
}
}
}) }
}
};
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(
new JSONBasedSerializer(), Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
scopeManager.AddOrUpdateScopeResolver(nameof(DHCPv6AndResolver), () => new DHCPv6AndResolver());
scopeManager.AddOrUpdateScopeResolver(nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver), () => new DHCPv6RemoteIdentifierEnterpriseNumberResolver(Mock.Of <ILogger <DHCPv6RemoteIdentifierEnterpriseNumberResolver> >()));
var firstLevelResolver = scopeManager.InitializeResolver(createScopeResolverInformation);
Assert.NotNull(firstLevelResolver);
Assert.IsAssignableFrom <DHCPv6AndResolver>(firstLevelResolver);
DHCPv6AndResolver firstLevelAndResolver = (DHCPv6AndResolver)firstLevelResolver;
Assert.Single(firstLevelAndResolver.GetScopeResolvers());
var secondLevelResolver = firstLevelAndResolver.GetScopeResolvers().First();
Assert.IsAssignableFrom <DHCPv6AndResolver>(secondLevelResolver);
DHCPv6AndResolver secondLevelAndResolver = (DHCPv6AndResolver)secondLevelResolver;
Assert.Single(secondLevelAndResolver.GetScopeResolvers());
var innerResolver = secondLevelAndResolver.GetScopeResolvers().First();
Assert.IsAssignableFrom <DHCPv6RemoteIdentifierEnterpriseNumberResolver>(innerResolver);
DHCPv6RemoteIdentifierEnterpriseNumberResolver innerCasedResolver = (DHCPv6RemoteIdentifierEnterpriseNumberResolver)innerResolver;
Assert.Equal(enterpriseId, innerCasedResolver.EnterpriseNumber);
Assert.Equal(relayAgentIndex, innerCasedResolver.RelayAgentIndex);
}
public void IsResolverInformationValid_ComplexStructure(Boolean shouldBeValid)
{
for (int seed = 1; seed <= 10; seed++)
{
Random random = new Random(seed);
CreateScopeResolverInformation inputModel = new CreateScopeResolverInformation
{
Typename = $"typename-{random.Next()}",
};
Int32 propertyAmount = random.Next(3, 30);
for (int i = 0; i < propertyAmount; i++)
{
inputModel.PropertiesAndValues.Add($"property-{i + 1}", $"{random.Next()}");
}
Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict);
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(serializerMock.Object, Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.ArePropertiesAndValuesValid(inputModel.PropertiesAndValues, serializerMock.Object)).Returns(true);
Dictionary <String, Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> > mocksWithChildren =
new Dictionary <string, Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> >
{
{
inputModel.Typename,
new Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation>(
resolverMock, inputModel)
}
};
Dictionary <String, Tuple <Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> > mocksWithoutChildren = new Dictionary <string, Tuple <Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> >
();
GenerateResolverTreeForValidation(serializerMock, resolverMock, inputModel, mocksWithChildren, mocksWithoutChildren, random, random.NextDouble());
foreach (var item in mocksWithChildren)
{
scopeManager.AddOrUpdateScopeResolver(item.Key, () => item.Value.Item1.Object);
}
foreach (var item in mocksWithoutChildren)
{
scopeManager.AddOrUpdateScopeResolver(item.Key, () => item.Value.Item1.Object);
}
if (shouldBeValid == false)
{
if (random.NextDouble() > 0.5)
{
var item = mocksWithChildren.ElementAt(random.Next(0, mocksWithChildren.Count));
item.Value.Item1.Setup(x => x.ArePropertiesAndValuesValid(item.Value.Item2.PropertiesAndValues, serializerMock.Object)).Returns(false);
}
else
{
var item = mocksWithoutChildren.ElementAt(random.Next(0, mocksWithoutChildren.Count));
item.Value.Item1.Setup(x => x.ArePropertiesAndValuesValid(item.Value.Item2.PropertiesAndValues, serializerMock.Object)).Returns(false);
}
}
Boolean actual = scopeManager.IsResolverInformationValid(inputModel);
Assert.Equal(shouldBeValid, actual);
var times = Times.AtMost(1);
if (shouldBeValid == true)
{
times = Times.Exactly(1);
}
foreach (var item in mocksWithChildren)
{
item.Value.Item1.Verify(x => x.ArePropertiesAndValuesValid(item.Value.Item2.PropertiesAndValues, serializerMock.Object), times);
item.Value.Item1.Verify(x => x.ExtractResolverCreateModels(item.Value.Item2, serializerMock.Object), times);
}
foreach (var item in mocksWithoutChildren)
{
item.Value.Item1.Verify(x => x.ArePropertiesAndValuesValid(item.Value.Item2.PropertiesAndValues, serializerMock.Object), times);
}
}
}
private void GenerateResolverTreeForValidation(
Mock <ISerializer> seralizerMock,
Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> > parent,
CreateScopeResolverInformation parentCreateModel,
Dictionary <String, Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> > typeNameToResolverContainingOtherMapper,
Dictionary <String, Tuple <Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> > typeNameToResolverMapper,
Random random, Double value)
{
List <CreateScopeResolverInformation> childCreateModels = new List <CreateScopeResolverInformation>();
parent.Setup(x => x.ExtractResolverCreateModels(parentCreateModel, seralizerMock.Object)).Returns(childCreateModels);
if (value > 1)
{
return;
}
Int32 childAmount = random.Next(3, 10);
for (int i = 0; i < childAmount; i++)
{
CreateScopeResolverInformation childCreateModel = new CreateScopeResolverInformation
{
Typename = $"typename-{random.Next()}",
};
childCreateModels.Add(childCreateModel);
Int32 propertyAmount = random.Next(3, 30);
for (int j = 0; j < propertyAmount; j++)
{
childCreateModel.PropertiesAndValues.Add($"property-{j + 1}", $"{random.Next()}");
}
Boolean containingOthers = random.NextDouble() > 0.5;
IScopeResolver <DHCPv6Packet, IPv6Address> childElement = null;
if (containingOthers == true)
{
Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> > child = new Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
child.Setup(x => x.ArePropertiesAndValuesValid(childCreateModel.PropertiesAndValues, seralizerMock.Object)).Returns(true);
childElement = child.Object;
typeNameToResolverContainingOtherMapper.Add(childCreateModel.Typename,
new Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation>(
child,
childCreateModel));
GenerateResolverTreeForValidation(seralizerMock, child, childCreateModel, typeNameToResolverContainingOtherMapper, typeNameToResolverMapper, random, value + random.NextDouble());
}
else
{
Mock <IScopeResolver <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.ArePropertiesAndValuesValid(childCreateModel.PropertiesAndValues, seralizerMock.Object)).Returns(true);
childElement = resolverMock.Object;
typeNameToResolverMapper.Add(childCreateModel.Typename, new Tuple <Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation>(resolverMock, childCreateModel));
}
parent.Setup(x => x.AddResolver(childElement)).Returns(true);
}
}
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 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);
}
public DHCPv4ScopeResolverUpdatedEvent(Guid scopeId, CreateScopeResolverInformation information) : base(scopeId)
{
ResolverInformationen = information;
}
public void InitializeResolver_ComplexStructure()
{
for (int seed = 1; seed <= 10; seed++)
{
Random random = new Random(seed);
CreateScopeResolverInformation inputModel = new CreateScopeResolverInformation
{
Typename = $"typename-{random.Next()}",
};
Int32 propertyAmount = random.Next(3, 30);
for (int i = 0; i < propertyAmount; i++)
{
inputModel.PropertiesAndValues.Add($"property-{i + 1}", $"{random.Next()}");
}
Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict);
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(serializerMock.Object, Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.ApplyValues(inputModel.PropertiesAndValues, serializerMock.Object));
Dictionary <String, Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation, List <IScopeResolver <DHCPv6Packet, IPv6Address> > > > mocksWithChildren =
new Dictionary <string, Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation, List <IScopeResolver <DHCPv6Packet, IPv6Address> > > >
{
{
inputModel.Typename,
new Tuple <Mock <IScopeResolverContainingOtherResolvers <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation, List <IScopeResolver <DHCPv6Packet, IPv6Address> > >(
resolverMock, inputModel, new List <IScopeResolver <DHCPv6Packet, IPv6Address> >())
}
};
Dictionary <String, Tuple <Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> > mocksWithoutChildren =
new Dictionary <string, Tuple <Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >, CreateScopeResolverInformation> >();
GenerateResolverTree(serializerMock, true, resolverMock, inputModel, mocksWithChildren, mocksWithoutChildren, random, random.NextDouble());
foreach (var item in mocksWithChildren)
{
scopeManager.AddOrUpdateScopeResolver(item.Key, () => item.Value.Item1.Object);
}
foreach (var item in mocksWithoutChildren)
{
scopeManager.AddOrUpdateScopeResolver(item.Key, () => item.Value.Item1.Object);
}
IScopeResolver <DHCPv6Packet, IPv6Address> actual = scopeManager.InitializeResolver(inputModel);
Assert.Equal(resolverMock.Object, actual);
foreach (var item in mocksWithChildren)
{
item.Value.Item1.Verify(x => x.ApplyValues(item.Value.Item2.PropertiesAndValues, serializerMock.Object), Times.Once());
item.Value.Item1.Verify(x => x.ExtractResolverCreateModels(item.Value.Item2, serializerMock.Object), Times.Once());
foreach (var scopeResolver in item.Value.Item3)
{
item.Value.Item1.Verify(x => x.AddResolver(scopeResolver), Times.Once());
}
}
foreach (var item in mocksWithoutChildren)
{
item.Value.Item1.Verify(x => x.ApplyValues(item.Value.Item2.PropertiesAndValues, serializerMock.Object), Times.Once());
}
}
}
