public async Task <DHCPv6RootScope> GetRootScope() { DHCPv6RootScope rootScope = new DHCPv6RootScope(_rootScopeid, Provider.GetRequiredService <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(), Provider.GetRequiredService <ILoggerFactory>()); PseudoDHCPv6RootScope pseudoRootScope = new PseudoDHCPv6RootScope(); await EventStore.HydrateAggragate(pseudoRootScope); List <DomainEvent> eventsToApply = new(); foreach (var scopeId in pseudoRootScope.ScopeIds) { var events = await EventStore.GetEvents <PseudoDHCPv6Scope>(scopeId, 100); eventsToApply.AddRange(events); } foreach (var leaseId in pseudoRootScope.LeaseIds) { var events = await EventStore.GetEvents <PseudoDHCPv6Lease>(leaseId, 100); eventsToApply.AddRange(events); } rootScope.Load(eventsToApply.OrderBy(x => x.Timestamp)); return(rootScope); }
protected static void CheckLeaseRenewdEvent( Guid scopeId, DHCPv6RootScope rootScope, DHCPv6Lease lease, Boolean expectReset, Boolean expectedPrefixReset) { IEnumerable <DomainEvent> changes = rootScope.GetChanges(); Assert.NotNull(changes); Assert.Equal(2, changes.Count()); Assert.IsAssignableFrom <DHCPv6LeaseRenewedEvent>(changes.First()); DHCPv6LeaseRenewedEvent createdEvent = (DHCPv6LeaseRenewedEvent)changes.First(); Assert.NotNull(createdEvent); Assert.Equal(scopeId, createdEvent.ScopeId); Assert.NotEqual(Guid.Empty, lease.Id); Assert.Equal(lease.Id, createdEvent.EntityId); Assert.Equal(expectReset, createdEvent.Reset); Assert.Equal(expectedPrefixReset, createdEvent.ResetPrefix); Assert.Equal(lease.End, createdEvent.End); var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties; Assert.True(Math.Abs(((addressProperties.T1.Value * addressProperties.ValidLeaseTime.Value) - createdEvent.RenewSpan).TotalSeconds) < 20); Assert.True(Math.Abs(((addressProperties.T2.Value * addressProperties.ValidLeaseTime.Value) - createdEvent.ReboundSpan).TotalSeconds) < 20); }
public async Task GetIncomingDHCPv6PacketTypes() { Random random = new Random(); DHCPv6RootScope rootScope = GetRootScope(); var response = new Dictionary <DateTime, IDictionary <DHCPv6PacketTypes, Int32> >(); DateTime start = DateTime.UtcNow.AddHours(-random.Next(5, 10)); DateTime end = DateTime.UtcNow.AddHours(-random.Next(1, 2)); GroupStatisticsResultBy groupBy = random.GetEnumValue <GroupStatisticsResultBy>(); Mock <IDHCPv6ReadStore> readStoreMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict); readStoreMock.Setup(x => x.GetIncomingDHCPv6PacketTypes(start, end, groupBy)).ReturnsAsync(response).Verifiable(); var controller = new DHCPv6StatisticsController(rootScope, readStoreMock.Object); var actionResult = await controller.GetIncomingDHCPv6PacketTypes(new GroupedTimeSeriesFilterRequest { Start = start, End = end, GroupbBy = groupBy, }); var result = actionResult.EnsureOkObjectResult <IDictionary <DateTime, IDictionary <DHCPv6PacketTypes, Int32> > >(true); Assert.NotNull(result); Assert.Equal(response, result); readStoreMock.Verify(); }
public async Task GetHandledDHCPv6PacketByScopeId() { Random random = new Random(); Guid scopeId = random.NextGuid(); Int32 amount = random.Next(10, 250); List <DHCPv6PacketHandledEntry> response = new List <DHCPv6PacketHandledEntry>(); DHCPv6RootScope rootScope = GetRootScope(); rootScope.Load(new[] { new DHCPv6ScopeAddedEvent { Instructions = new DHCPv6ScopeCreateInstruction { Id = scopeId, } } }); Mock <IDHCPv6ReadStore> readStoreMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict); readStoreMock.Setup(x => x.GetHandledDHCPv6PacketByScopeId(scopeId, amount)).ReturnsAsync(response).Verifiable(); var controller = new DHCPv6StatisticsController(rootScope, readStoreMock.Object); var actionResult = await controller.GetHandledDHCPv6PacketByScopeId(scopeId, amount); var result = actionResult.EnsureOkObjectResult <IEnumerable <DHCPv6PacketHandledEntry> >(true); Assert.NotNull(result); Assert.Equal(response, result); readStoreMock.Verify(); }
public async Task GetErrorCodesPerDHCPV6RequestType() { Random random = new Random(); DHCPv6RootScope rootScope = GetRootScope(); var response = new Dictionary <Int32, Int32>(); DateTime start = DateTime.UtcNow.AddHours(-random.Next(5, 10)); DateTime end = DateTime.UtcNow.AddHours(-random.Next(1, 2)); DHCPv6PacketTypes packetType = random.GetEnumValue <DHCPv6PacketTypes>(); Mock <IDHCPv6ReadStore> readStoreMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict); readStoreMock.Setup(x => x.GetErrorCodesPerDHCPV6RequestType(start, end, packetType)).ReturnsAsync(response).Verifiable(); var controller = new DHCPv6StatisticsController(rootScope, readStoreMock.Object); var actionResult = await controller.GetErrorCodesPerDHCPV6RequestType(new DHCPv6PacketTypeBasedTimeSeriesFilterRequest { Start = start, End = end, PacketType = packetType, }); var result = actionResult.EnsureOkObjectResult <IDictionary <Int32, Int32> >(true); Assert.NotNull(result); Assert.Equal(response, result); readStoreMock.Verify(); }
public void GetScopesAsList() { Random random = new Random(); var events = new List <DomainEvent>(); Int32 rootScopeAmount = random.Next(10, 30); List <Guid> rootScopeIds = new List <Guid>(rootScopeAmount); for (int i = 0; i < rootScopeAmount; i++) { Guid scopeId = Guid.NewGuid(); IPv6Address start = random.GetIPv6Address(); IPv6Address end = start + 100; events.Add(new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction { Id = scopeId, Name = random.GetAlphanumericString(), AddressProperties = new DHCPv6ScopeAddressProperties(start, end), })); rootScopeIds.Add(scopeId); GenerateScopeTree( random.NextDouble(), random, new List <Guid> { scopeId }, events); } var scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict); scopeResolverMock.Setup(x => x.InitializeResolver(It.IsAny <CreateScopeResolverInformation>())).Returns(Mock.Of <IScopeResolver <DHCPv6Packet, IPv6Address> >()); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >()); DHCPv6RootScope rootScope = new DHCPv6RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(events); var controller = new DHCPv6ScopeController( Mock.Of <IMediator>(MockBehavior.Strict), Mock.Of <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict), rootScope); var actionResult = controller.GetScopesAsList(); var result = actionResult.EnsureOkObjectResult <IEnumerable <DHCPv6ScopeItem> >(true); Assert.Equal(events.Count, result.Count()); for (int i = 0; i < events.Count; i++) { var scope = result.ElementAt(i); var @event = (DHCPv6ScopeAddedEvent)events[i]; Assert.Equal(@event.Instructions.Name, scope.Name); Assert.Equal(@event.Instructions.Id, scope.Id); Assert.Equal(@event.Instructions.AddressProperties.Start.ToString(), scope.StartAddress); Assert.Equal(@event.Instructions.AddressProperties.End.ToString(), scope.EndAddress); } }
public DHCPv6StatisticsController( DHCPv6RootScope rootScope, IDHCPv6ReadStore storage) { _rootScope = rootScope ?? throw new ArgumentNullException(nameof(rootScope)); _storage = storage ?? throw new ArgumentNullException(nameof(storage)); }
public void HandleRequest_ScopeNotFound(Boolean withPrefixDelegation) { Random random = new Random(); UInt32 prefixId = random.NextUInt32(); Byte prefixLength = (Byte)random.Next(20, 60); IPv6Address prefixNetworkAddress = IPv6Address.FromString("fd01::0"); DHCPv6PacketOption[] options = Array.Empty <DHCPv6PacketOption>(); if (withPrefixDelegation == true) { options = new DHCPv6PacketOption[] { new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] { new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), prefixLength, prefixNetworkAddress, Array.Empty <DHCPv6PacketSuboption>()) }) }; } var packet = GetRequestPacket(random, out _, out DUID _, out UInt32 _, true, options); GetMockupResolver(DHCPv6Packet.Empty, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock); DHCPv6Packet result = rootScope.HandleRequest(packet, GetServerPropertiesResolver()); Assert.Equal(DHCPv6Packet.Empty, result); CheckEventAmount(1, rootScope); CheckHandeledEvent(0, packet, result, rootScope, null, DHCPv6RequestHandledEvent.RequestErrors.ScopeNotFound); }
public async Task HandlePacket_Solicit() { Random random = new Random(); DHCPv6RootScope rootScope = GetRootScope(random, out DHCPv6Packet request); Mock <IDHCPv6StorageEngine> storageMock = new Mock <IDHCPv6StorageEngine>(MockBehavior.Strict); storageMock.Setup(x => x.Save(rootScope)).ReturnsAsync(true).Verifiable(); Mock <IDHCPv6ServerPropertiesResolver> propertyResolver = new Mock <IDHCPv6ServerPropertiesResolver>(MockBehavior.Strict); propertyResolver.Setup(x => x.GetServerDuid()).Returns(new UUIDDUID(Guid.NewGuid())).Verifiable(); Mock <IServiceBus> serviceBusMock = new Mock <IServiceBus>(); serviceBusMock.Setup(x => x.Publish(It.Is <NewTriggerHappendMessage>(y => y.Triggers.Count() == 1))).Returns(Task.FromResult(true)); DHCPv6LeaseEngine engine = new DHCPv6LeaseEngine( storageMock.Object, rootScope, propertyResolver.Object, serviceBusMock.Object, Mock.Of <ILogger <DHCPv6LeaseEngine> >()); var response = await engine.HandlePacket(request); Assert.NotEqual(DHCPv6Packet.Empty, response); storageMock.Verify(); propertyResolver.Verify(); serviceBusMock.Verify(); }
public void HandleRequest_OnlyPrefix_LeaseFound_LeaseIsPending() { Random random = new Random(); UInt32 prefixId = random.NextUInt32(); Byte prefixLength = (Byte)random.Next(20, 60); IPv6Address prefixNetworkAddress = IPv6Address.FromString("fd01::0"); var packet = GetRequestPacket(random, out IPv6Address leasedAddress, out DUID clientDuid, out UInt32 iaId, false, new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] { new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), prefixLength, prefixNetworkAddress, Array.Empty <DHCPv6PacketSuboption>()) })); var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); Guid scopeId = random.NextGuid(); Guid leaseId = random.NextGuid(); DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(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") }, preferredLifeTime: TimeSpan.FromDays(0.5), validLifeTime: TimeSpan.FromDays(1), addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), new DHCPv6LeaseCreatedEvent { EntityId = leaseId, Address = leasedAddress, ClientIdentifier = clientDuid, IdentityAssocationId = iaId, ScopeId = scopeId, StartedAt = DateTime.UtcNow, ValidUntil = DateTime.UtcNow.AddDays(1), HasPrefixDelegation = true, PrefixLength = prefixLength, IdentityAssocationIdForPrefix = prefixId, DelegatedNetworkAddress = prefixNetworkAddress, }, }); DHCPv6Packet result = rootScope.HandleRequest(packet, GetServerPropertiesResolver()); CheckErrorPacket(packet, leasedAddress, 0, result, DHCPv6PrefixDelegation.FromValues(prefixNetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId), DHCPv6StatusCodes.NoAddrsAvail); CheckEventAmount(1, rootScope); CheckHandeledEvent(0, packet, result, rootScope, scopeId, DHCPv6RequestHandledEvent.RequestErrors.LeasePendingButOnlyPrefixRequested); }
public CreateDHCPv6ScopeCommandHandler( IDHCPv6StorageEngine store, DHCPv6RootScope rootScope, ILogger <CreateDHCPv6ScopeCommandHandler> logger) { _store = store; _rootScope = rootScope; _logger = logger; }
public DHCPv6ScopeController( IMediator mediator, IScopeResolverManager <DHCPv6Packet, IPv6Address> resolverManager, DHCPv6RootScope rootScope) { this._mediator = mediator; this._resolverManager = resolverManager; _rootScope = rootScope; }
public DHCPv6ScopeIdNotificationCondition( DHCPv6RootScope rootScope, ISerializer serializer, ILogger <DHCPv6ScopeIdNotificationCondition> logger) { this._rootScope = rootScope; _serializer = serializer; this._logger = logger; }
public UpdateDHCPv6ScopeParentCommandHandler( IDHCPv6StorageEngine store, DHCPv6RootScope rootScope, ILogger <UpdateDHCPv6ScopeParentCommandHandler> logger) { _store = store; _rootScope = rootScope; _logger = logger; }
public async Task UpdateScope(Boolean mediatorResultShouldBeSuccessful) { Random random = new Random(); Guid id = random.NextGuid(); String name = random.GetAlphanumericString(); String description = random.GetAlphanumericString(); Guid? parentId = random.NextBoolean() == true?random.NextGuid() : new Guid?(); var addressProperties = new DHCPv6ScopeAddressPropertyReqest(); var resolverInfo = new CreateScopeResolverRequest { Typename = random.GetAlphanumericString(), PropertiesAndValues = new Dictionary <String, String>() }; Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >()); DHCPv6RootScope rootScope = new DHCPv6RootScope(random.NextGuid(), Mock.Of <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict), factoryMock.Object); Mock <IMediator> mediatorMock = new Mock <IMediator>(MockBehavior.Strict); mediatorMock.Setup(x => x.Send(It.Is <UpdateDHCPv6ScopeCommand>(y => y.ScopeId == id && y.Name == name && y.Description == description && y.ParentId == parentId && y.AddressProperties == addressProperties && y.Resolver == resolverInfo ), It.IsAny <CancellationToken>())).ReturnsAsync(mediatorResultShouldBeSuccessful).Verifiable(); var request = new CreateOrUpdateDHCPv6ScopeRequest { Name = name, Description = description, AddressProperties = addressProperties, ParentId = parentId, Resolver = resolverInfo, }; var controller = new DHCPv6ScopeController(mediatorMock.Object, Mock.Of <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict), rootScope); var actionResult = await controller.UpdateScope(request, id); if (mediatorResultShouldBeSuccessful == true) { actionResult.EnsureNoContentResult(); } else { actionResult.EnsureBadRequestObjectResult("unable to execute service operation"); } mediatorMock.Verify(); }
public void HandleConfirm_LeaseNotFound(Boolean withAddress, Boolean withPrefix) { Random random = new Random(); var packet = GetRelayedConfirmPacket(random, out IPv6Address leasedAddress, out DUID _, out UInt32 iaId, out DHCPv6PrefixDelegation prefix, withAddress, withPrefix); var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); Guid scopeId = random.NextGuid(); Guid leaseId = random.NextGuid(); DateTime leaseCreatedAt = DateTime.UtcNow; DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(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: true), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), new DHCPv6LeaseCreatedEvent { EntityId = leaseId, Address = leasedAddress, ClientIdentifier = new UUIDDUID(random.NextGuid()), IdentityAssocationId = iaId, ScopeId = scopeId, StartedAt = leaseCreatedAt, ValidUntil = DateTime.UtcNow.AddDays(1), HasPrefixDelegation = withPrefix, PrefixLength = withPrefix == false ? (Byte)0 : prefix.Mask.Identifier, DelegatedNetworkAddress = withPrefix == false ? IPv6Address.Empty : prefix.NetworkAddress, IdentityAssocationIdForPrefix = withPrefix == false ? 0 : prefix.IdentityAssociation, }, }); DHCPv6Packet result = rootScope.HandleConfirm(packet, GetServerPropertiesResolver()); Assert.Equal(DHCPv6Packet.Empty, result); CheckEventAmount(1, rootScope); CheckHandeledEvent(0, packet, result, rootScope, scopeId, DHCPv6ConfirmHandledEvent.ConfirmErrors.LeaseNotFound); }
public void GetLeaseById() { Random random = new Random(); DHCPv6RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction { 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 DHCPv6LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = random.GetIPv6Address(), ClientIdentifier = new UUIDDUID(random.NextGuid()), }); existingIds.Add(leaseId); } rootScope.Load(events); DHCPv6Scope scope = rootScope.GetRootScopes().First(); foreach (Guid leaseId in existingIds) { DHCPv6Lease lease = scope.Leases.GetLeaseById(leaseId); Assert.True(lease != DHCPv6Lease.Empty); } Int32 notExisitngAmount = random.Next(30, 100); for (int i = 0; i < notExisitngAmount; i++) { Guid id = Guid.NewGuid(); if (existingIds.Contains(id) == true) { continue; } DHCPv6Lease lease = scope.Leases.GetLeaseById(id); Assert.True(lease == DHCPv6Lease.Empty); } }
protected DHCPv6RootScope GetDHCPv6RootScope() { Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >()); var scope = new DHCPv6RootScope(Guid.NewGuid(), Mock.Of <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(), factoryMock.Object); return(scope); }
public DeleteDHCPv6ScopeCommandHandler( IDHCPv6StorageEngine storageEngine, DHCPv6RootScope rootScope, ILogger <DeleteDHCPv6ScopeCommandHandler> logger ) { this.rootScope = rootScope; this.storageEngine = storageEngine; this.logger = logger; }
protected static void DHCPv6ScopeAddressesAreExhaustedEvent(int index, DHCPv6RootScope rootScope, Guid scopeId) { IEnumerable <DomainEvent> changes = rootScope.GetChanges(); Assert.IsAssignableFrom <DHCPv6ScopeAddressesAreExhaustedEvent>(changes.ElementAt(index)); DHCPv6ScopeAddressesAreExhaustedEvent castedEvent = (DHCPv6ScopeAddressesAreExhaustedEvent)changes.ElementAt(index); Assert.Equal(castedEvent.EntityId, scopeId); }
public UpdateDHCPv6ScopeCommandHandler( IDHCPv6StorageEngine store, IServiceBus serviceBus, DHCPv6RootScope rootScope, ILogger <UpdateDHCPv6ScopeCommandHandler> logger) { _store = store; this._serviceBus = serviceBus; _rootScope = rootScope; _logger = logger; }
public DashboardController( DHCPv6RootScope rootScope, DHCPv4RootScope dhcpv4RootScope, IDHCPv6ReadStore storage, INotificationEngine notificationEngine) { _rootScope = rootScope ?? throw new ArgumentNullException(nameof(rootScope)); _dhcpv4RootScope = dhcpv4RootScope ?? throw new ArgumentNullException(nameof(dhcpv4RootScope)); _storage = storage ?? throw new ArgumentNullException(nameof(storage)); _notificationEngine = notificationEngine ?? throw new ArgumentNullException(nameof(notificationEngine)); }
public void HandleRenew_OnlyPrefix(Boolean isUnicast) { Random random = new Random(); UInt32 prefixId = random.NextUInt32(); Byte prefixLength = (Byte)random.Next(34, 64); IPv6Address prefixNetworkAddress = IPv6Address.FromString("fd01::0"); DHCPv6PacketOption[] options = new DHCPv6PacketOption[] { new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] { new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), prefixLength, prefixNetworkAddress, Array.Empty <DHCPv6PacketSuboption>()) }) }; var packet = isUnicast == true? GetRenewPacket(random, out IPv6Address _, out DUID _, out UInt32 _, false, options) : GetRelayedRenewPacket(random, out IPv6Address _, out DUID _, out UInt32 _, false, options); var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock); Guid scopeId = random.NextGuid(); DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(new List <DomainEvent> { new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { AddressProperties = new DHCPv6ScopeAddressProperties( IPv6Address.FromString("fe80::01"), IPv6Address.FromString("fe80::ff"), new List <IPv6Address> { IPv6Address.FromString("fe80::02") }, preferredLifeTime: TimeSpan.FromDays(0.5), validLifeTime: TimeSpan.FromDays(1), reuseAddressIfPossible: false, prefixDelgationInfo: DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2140:1::0"), new IPv6SubnetMaskIdentifier(32), new IPv6SubnetMaskIdentifier(prefixLength)), addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), }); DHCPv6Packet result = rootScope.HandleRenew(packet, GetServerPropertiesResolver()); CheckErrorPacket(packet, IPv6Address.Empty, 0, result, DHCPv6PrefixDelegation.FromValues(prefixNetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId), DHCPv6StatusCodes.NoBinding); CheckEventAmount(1, rootScope); CheckHandeledEvent(0, packet, result, rootScope, scopeId, DHCPv6RenewHandledEvent.RenewErrors.OnlyPrefixIsNotAllowed); }
public async Task Handle_ScopeNotFound() { Random random = new(); Guid scopeId = random.NextGuid(); Guid parentId = random.NextGuid(); String name = random.GetAlphanumericString(); String description = random.GetAlphanumericString(); String resolverName = random.GetAlphanumericString(); Mock <IScopeResolver <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict); Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(); scopeResolverMock.Setup(x => x.InitializeResolver(It.Is <CreateScopeResolverInformation>(y => y.Typename == resolverName ))).Returns(resolverMock.Object).Verifiable(); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >()); DHCPv6RootScope rootScope = new DHCPv6RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new DomainEvent[] { new DHCPv6ScopeAddedEvent { Instructions = new DHCPv6ScopeCreateInstruction { Name = random.GetAlphanumericString(), Description = random.GetAlphanumericString(), Id = parentId, ParentId = null, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, }, ScopeProperties = new DHCPv6ScopeProperties(), AddressProperties = DHCPv6ScopeAddressProperties.Empty, } }, }); var command = new UpdateDHCPv6ScopeParentCommand(scopeId, parentId); var handler = new UpdateDHCPv6ScopeParentCommandHandler(Mock.Of <IDHCPv6StorageEngine>(MockBehavior.Strict), rootScope, Mock.Of <ILogger <UpdateDHCPv6ScopeParentCommandHandler> >()); Boolean result = await handler.Handle(command, CancellationToken.None); Assert.False(result); scopeResolverMock.Verify(); }
public async Task Handle_HasNoChildren(Boolean requestedToDeleteChildrenAsWell) { Random random = new Random(); Guid id = random.NextGuid(); String resolverName = random.GetAlphanumericString(); Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> >(); scopeResolverMock.Setup(x => x.InitializeResolver(It.Is <CreateScopeResolverInformation>(y => y.Typename == resolverName ))).Returns(Mock.Of <IScopeResolver <DHCPv6Packet, IPv6Address> >()).Verifiable(); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6RootScope> >()); DHCPv6RootScope rootScope = new DHCPv6RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new[] { new DHCPv6ScopeAddedEvent { Instructions = new DHCPv6ScopeCreateInstruction { Id = id, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, } } } }); Mock <IDHCPv6StorageEngine> storageMock = new Mock <IDHCPv6StorageEngine>(MockBehavior.Strict); storageMock.Setup(x => x.Save(rootScope)).ReturnsAsync(true).Verifiable(); var command = new DeleteDHCPv6ScopeCommand(id, requestedToDeleteChildrenAsWell); var handler = new DeleteDHCPv6ScopeCommandHandler(storageMock.Object, rootScope, Mock.Of <ILogger <DeleteDHCPv6ScopeCommandHandler> >()); Boolean result = await handler.Handle(command, CancellationToken.None); Assert.True(result); Assert.Single(rootScope.GetChanges()); storageMock.Verify(); }
protected static DHCPv6Lease CheckLease( Int32 index, Int32 expectedAmount, IPv6Address expectedAdress, Guid scopeId, DHCPv6RootScope rootScope, DateTime expectedCreationData, DUID clientDuid, UInt32 iaId, Boolean shouldBePending, Boolean shouldHavePrefix, Byte[] uniqueIdentifier = null, Boolean checkExpire = true) { DHCPv6Scope scope = rootScope.GetScopeById(scopeId); var leases = scope.Leases.GetAllLeases(); Assert.Equal(expectedAmount, leases.Count()); DHCPv6Lease lease = leases.ElementAt(index); Assert.NotNull(lease); Assert.Equal(expectedAdress, lease.Address); if (checkExpire == 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); if (shouldBePending == true) { Assert.True(lease.IsPending()); } else { Assert.True(lease.IsActive()); } Assert.Equal(clientDuid, lease.ClientDUID); Assert.Equal(iaId, lease.IdentityAssocicationId); if (uniqueIdentifier == null) { Assert.Empty(lease.UniqueIdentifier); } else { Assert.NotNull(lease.UniqueIdentifier); Assert.Equal(uniqueIdentifier, lease.UniqueIdentifier); } if (shouldHavePrefix == false) { Assert.Equal(DHCPv6PrefixDelegation.None, lease.PrefixDelegation); } return(lease); }
protected static void CheckLeaseCreatedEvent( Int32 index, DUID clientDuid, UInt32 iaId, Guid scopeId, DHCPv6RootScope rootScope, IPv6Address expectedAdress, DHCPv6Lease lease, Byte[] uniqueIdentifier = null, Guid?ancestorId = null, Boolean checkLeaseTimes = true ) { IEnumerable <DomainEvent> changes = rootScope.GetChanges(); Assert.NotNull(changes); Assert.IsAssignableFrom <DHCPv6LeaseCreatedEvent>(changes.ElementAt(index)); DHCPv6LeaseCreatedEvent createdEvent = (DHCPv6LeaseCreatedEvent)changes.ElementAt(index); Assert.NotNull(createdEvent); Assert.Equal(scopeId, createdEvent.ScopeId); Assert.Equal(expectedAdress, createdEvent.Address); Assert.Equal(clientDuid, createdEvent.ClientIdentifier); Assert.Equal(iaId, createdEvent.IdentityAssocationId); Assert.Equal(lease.Id, createdEvent.EntityId); Assert.Equal(ancestorId, createdEvent.AncestorId); if (uniqueIdentifier == null) { Assert.Null(createdEvent.UniqueIdentiifer); } else { Assert.Equal(uniqueIdentifier, createdEvent.UniqueIdentiifer); } Assert.Equal(lease.Start, createdEvent.StartedAt); Assert.Equal(lease.End, createdEvent.ValidUntil); var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties; if (checkLeaseTimes == true) { Assert.Equal(addressProperties.T1.Value * addressProperties.ValidLeaseTime.Value, createdEvent.RenewalTime); Assert.Equal(addressProperties.T2.Value * addressProperties.ValidLeaseTime.Value, createdEvent.PreferredLifetime); } if (lease.PrefixDelegation == DHCPv6PrefixDelegation.None) { Assert.Equal(IPv6Address.Empty, createdEvent.DelegatedNetworkAddress); Assert.Equal(0, createdEvent.PrefixLength); Assert.False(createdEvent.HasPrefixDelegation); } }
public async Task GetHandledDHCPv6PacketByScopeId_NotFound() { Random random = new Random(); Guid scopeId = random.NextGuid(); Int32 amount = random.Next(10, 250); DHCPv6RootScope rootScope = GetRootScope(); var controller = new DHCPv6StatisticsController(rootScope, Mock.Of <IDHCPv6ReadStore>(MockBehavior.Strict)); var actionResult = await controller.GetHandledDHCPv6PacketByScopeId(scopeId, amount); actionResult.EnsureNotFoundObjectResult("scope not found"); }
public void IsActive() { Random random = new Random(); DHCPv6RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction { 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 DHCPv6LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = random.GetIPv6Address(), ClientIdentifier = new UUIDDUID(random.NextGuid()), }); Boolean addressIsActive = random.NextDouble() > 0.5; if (addressIsActive == true) { events.Add(new DHCPv6LeaseActivatedEvent(leaseId)); } expectedResults.Add(leaseId, addressIsActive); } rootScope.Load(events); DHCPv6Scope scope = rootScope.GetRootScopes().First(); foreach (var item in expectedResults) { DHCPv6Lease lease = scope.Leases.GetLeaseById(item.Key); Boolean actual = lease.IsActive(); Assert.Equal(item.Value, actual); } }
public void GetSuspenedAddresses() { Random random = new Random(); DHCPv6RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction { Id = scopeId, }), }; Int32 leaseAmount = random.Next(30, 60); List <IPv6Address> expectedUsedAddress = new List <IPv6Address>(); for (int i = 0; i < leaseAmount; i++) { Guid leaseId = Guid.NewGuid(); IPv6Address address = random.GetIPv6Address(); events.Add(new DHCPv6LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = address, ClientIdentifier = new UUIDDUID(random.NextGuid()), }); Boolean shouldBeSuspended = random.NextDouble() > 0.5; if (shouldBeSuspended == true) { events.Add(new DHCPv6AddressSuspendedEvent( leaseId, address, DateTime.UtcNow.AddHours(12))); expectedUsedAddress.Add(address); } } rootScope.Load(events); DHCPv6Scope scope = rootScope.GetRootScopes().First(); List <IPv6Address> actualAddresses = scope.Leases.GetSuspendedAddresses().ToList(); Assert.Equal(expectedUsedAddress.OrderBy(x => x), actualAddresses.OrderBy(x => x)); }