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 TestInform_RootScopeAcceptInforms() { Random random = new Random(); IPv4Address start = random.GetIPv4Address(); IPv4Address end = random.GetIPv4AddressGreaterThan(start); IPv4Address sourceAddress = random.GetIPv4AddressBetween(start, end); DHCPv4Packet input = GetInformPacket(random, sourceAddress); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); rootScope.Load(new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { AddressProperties = new DHCPv4ScopeAddressProperties(start, end, new List <IPv4Address>(), informsAreAllowd: true), Id = scopeId, }) }); DHCPv4Packet result = rootScope.HandleInform(input); DHCPv4InformHandledEvent domainEvent = TestResult <DHCPv4InformHandledEvent>( input, result, false, true, scopeId, rootScope); Assert.Equal(InformErros.NoError, domainEvent.Error); }
public async Task <DHCPv4RootScope> GetRootScope() { DHCPv4RootScope rootScope = new DHCPv4RootScope(_rootScopeid, Provider.GetRequiredService <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(), Provider.GetRequiredService <ILoggerFactory>()); PseudoDHCPv4RootScope pseudoRootScope = new PseudoDHCPv4RootScope(); await EventStore.HydrateAggragate(pseudoRootScope); List <DomainEvent> eventsToApply = new(); foreach (var scopeId in pseudoRootScope.ScopeIds) { var events = await EventStore.GetEvents <PseudoDHCPv4Scope>(scopeId, 100); eventsToApply.AddRange(events); } foreach (var leaseId in pseudoRootScope.LeaseIds) { var events = await EventStore.GetEvents <PseudoDHCPv4Lease>(leaseId, 100); eventsToApply.AddRange(events); } rootScope.Load(eventsToApply.OrderBy(x => x.Timestamp)); return(rootScope); }
public async Task GetHandledDHCPv4PacketByScopeId() { Random random = new Random(); Guid scopeId = random.NextGuid(); Int32 amount = random.Next(10, 250); List <DHCPv4PacketHandledEntry> response = new List <DHCPv4PacketHandledEntry>(); DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(new[] { new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Id = scopeId, } } }); Mock <IDHCPv4ReadStore> readStoreMock = new Mock <IDHCPv4ReadStore>(MockBehavior.Strict); readStoreMock.Setup(x => x.GetHandledDHCPv4PacketByScopeId(scopeId, amount)).ReturnsAsync(response).Verifiable(); var controller = new DHCPv4StatisticsController(rootScope, readStoreMock.Object); var actionResult = await controller.GetHandledDHCPv4PacketByScopeId(scopeId, amount); var result = actionResult.EnsureOkObjectResult <IEnumerable <DHCPv4PacketHandledEntry> >(true); Assert.NotNull(result); Assert.Equal(response, result); readStoreMock.Verify(); }
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); }
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 TestInform_RandomScopeAcceptInforms() { Random random = new Random(); IPv4Address start = random.GetIPv4Address(); IPv4Address end = random.GetIPv4AddressGreaterThan(start); IPv4Address sourceAddress = random.GetIPv4AddressBetween(start, end); List <Tuple <IPv4Address, IPv4Address> > existingRanges = new List <Tuple <IPv4Address, IPv4Address> > { new Tuple <IPv4Address, IPv4Address>(start, end), }; DHCPv4Packet input = GetInformPacket(random, sourceAddress); Int32 rootScopeAmount = random.Next(3, 10); List <DomainEvent> events = new List <DomainEvent>(); for (int i = 0; i < rootScopeAmount; i++) { Guid rootScopeId = Guid.NewGuid(); Tuple <IPv4Address, IPv4Address> addressRange = random.GenerateUniqueAddressRange(existingRanges); events.Add(new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = rootScopeId, AddressProperties = new DHCPv4ScopeAddressProperties (addressRange.Item1, addressRange.Item2, Array.Empty <IPv4Address>(), informsAreAllowd: true) })); GenerateScopeTree( random.NextDouble(), random, rootScopeId, existingRanges, events); } Int32 randomScopeIndex = random.Next(0, events.Count); DHCPv4ScopeAddedEvent corelatedScopeEvent = (DHCPv4ScopeAddedEvent)events[randomScopeIndex]; corelatedScopeEvent.Instructions.AddressProperties = new DHCPv4ScopeAddressProperties (start, end, Array.Empty <IPv4Address>(), informsAreAllowd: true); Guid scopeId = corelatedScopeEvent.Instructions.Id; DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(events); DHCPv4Packet result = rootScope.HandleInform(input); DHCPv4InformHandledEvent domainEvent = TestResult <DHCPv4InformHandledEvent>( input, result, false, true, scopeId, rootScope); Assert.Equal(InformErros.NoError, domainEvent.Error); }
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 <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(); 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 <DHCPv4RootScope> >()); DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new DomainEvent[] { new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Name = random.GetAlphanumericString(), Description = random.GetAlphanumericString(), Id = parentId, ParentId = null, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, }, ScopeProperties = new DHCPv4ScopeProperties(), AddressProperties = DHCPv4ScopeAddressProperties.Empty, } }, }); var command = new UpdateDHCPv4ScopeParentCommand(scopeId, parentId); var handler = new UpdateDHCPv4ScopeParentCommandHandler(Mock.Of <IDHCPv4StorageEngine>(MockBehavior.Strict), rootScope, Mock.Of <ILogger <UpdateDHCPv4ScopeParentCommandHandler> >()); 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 <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(); scopeResolverMock.Setup(x => x.InitializeResolver(It.Is <CreateScopeResolverInformation>(y => y.Typename == resolverName ))).Returns(Mock.Of <IScopeResolver <DHCPv4Packet, IPv4Address> >()).Verifiable(); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv4RootScope> >()); DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new[] { new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Id = id, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, } } } }); Mock <IDHCPv4StorageEngine> storageMock = new Mock <IDHCPv4StorageEngine>(MockBehavior.Strict); storageMock.Setup(x => x.Save(rootScope)).ReturnsAsync(true).Verifiable(); var command = new DeleteDHCPv4ScopeCommand(id, requestedToDeleteChildrenAsWell); var handler = new DeleteDHCPv4ScopeCommandHandler(storageMock.Object, rootScope, Mock.Of <ILogger <DeleteDHCPv4ScopeCommandHandler> >()); Boolean result = await handler.Handle(command, CancellationToken.None); Assert.True(result); Assert.Single(rootScope.GetChanges()); storageMock.Verify(); }
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); } }
public void DHCPv4Leases_GetSuspenedAddresses() { 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(30, 60); List <IPv4Address> expectedUsedAddress = new List <IPv4Address>(); for (int i = 0; i < leaseAmount; i++) { Guid leaseId = Guid.NewGuid(); IPv4Address address = random.GetIPv4Address(); events.Add(new DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = address, ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), }); Boolean shouldBeSuspended = random.NextDouble() > 0.5; if (shouldBeSuspended == true) { events.Add(new DHCPv4AddressSuspendedEvent( leaseId, address, DateTime.UtcNow.AddHours(12))); expectedUsedAddress.Add(address); } } rootScope.Load(events); DHCPv4Scope scope = rootScope.GetRootScopes().First(); List <IPv4Address> actualAddresses = scope.Leases.GetSuspendedAddresses().ToList(); Assert.Equal(expectedUsedAddress.OrderBy(x => x), actualAddresses.OrderBy(x => x)); }
public void DHCPv4Scope_GetChildScopes() { Random random = new Random(); GenerateScopeTree(random, out Dictionary <Guid, List <Guid> > directChildRelations, out Dictionary <Guid, List <Guid> > allChildRelations, out List <DomainEvent> events); DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(events); foreach (var item in directChildRelations) { DHCPv4Scope scope = rootScope.GetScopeById(item.Key); IEnumerable <DHCPv4Scope> childScopes = scope.GetChildScopes(); List <Guid> childScopesId = childScopes.Select(x => x.Id).ToList(); Assert.Equal(item.Value.OrderBy(x => x), childScopesId.OrderBy(x => x)); } }
public void DHCPv4Scope_GetChildIds() { Random random = new Random(); GenerateScopeTree(random, out Dictionary <Guid, List <Guid> > directChildRelations, out Dictionary <Guid, List <Guid> > allChildRelations, out List <DomainEvent> events); DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(events); foreach (var item in directChildRelations) { DHCPv4Scope scope = rootScope.GetScopeById(item.Key); IEnumerable <Guid> actualDirectIds = scope.GetChildIds(true); Assert.Equal(item.Value.OrderBy(x => x), actualDirectIds.OrderBy(x => x)); IEnumerable <Guid> allChildIds = scope.GetChildIds(false); Assert.Equal(allChildRelations[item.Key].OrderBy(x => x), allChildIds.OrderBy(x => x)); } }
public async Task Handle(Boolean storeResult, Boolean useDynamicTime) { Random random = new Random(); Guid scopeId = random.NextGuid(); Guid leaseId = random.NextGuid(); String name = random.GetAlphanumericString(); String description = random.GetAlphanumericString(); IPv4Address start = random.GetIPv4Address(); IPv4Address end = start + 100; String resolverName = random.GetAlphanumericString(); Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); resolverMock.Setup(x => x.GetValues()).Returns(new Dictionary <String, String>()); Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(); scopeResolverMock.Setup(x => x.IsResolverInformationValid(It.Is <CreateScopeResolverInformation>(y => y.Typename == resolverName ))).Returns(true).Verifiable(); 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 <DHCPv4RootScope> >()); DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new DomainEvent[] { new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Name = random.GetAlphanumericString(), Description = random.GetAlphanumericString(), Id = scopeId, ParentId = null, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, }, ScopeProperties = new DHCPv4ScopeProperties(), AddressProperties = DHCPv4ScopeAddressProperties.Empty, } }, new DHCPv4LeaseCreatedEvent { EntityId = leaseId, Address = start - 100, ScopeId = scopeId, ClientIdenfier = DHCPv4ClientIdentifier.FromDuid(1, new UUIDDUID(random.NextGuid()), random.NextBytes(6)).GetBytes(), }, new DHCPv4LeaseActivatedEvent { EntityId = leaseId, ScopeId = scopeId, } }); Mock <IDHCPv4StorageEngine> storageMock = new Mock <IDHCPv4StorageEngine>(MockBehavior.Strict); storageMock.Setup(x => x.Save(rootScope)).ReturnsAsync(storeResult).Verifiable(); var command = new UpdateDHCPv4ScopeCommand(scopeId, name, description, null, useDynamicTime == false ? new DHCPv4ScopeAddressPropertyReqest { Start = start.ToString(), End = end.ToString(), ExcludedAddresses = Array.Empty <String>(), AcceptDecline = random.NextBoolean(), AddressAllocationStrategy = DHCPv4ScopeAddressPropertyReqest.AddressAllocationStrategies.Next, InformsAreAllowd = random.NextBoolean(), ReuseAddressIfPossible = random.NextBoolean(), SupportDirectUnicast = random.NextBoolean(), PreferredLifetime = TimeSpan.FromDays(0.5), RenewalTime = TimeSpan.FromDays(0.25), LeaseTime = TimeSpan.FromDays(1), MaskLength = (Byte)random.Next(10, 29), } : new DHCPv4ScopeAddressPropertyReqest { Start = start.ToString(), End = end.ToString(), ExcludedAddresses = Array.Empty <String>(), AcceptDecline = random.NextBoolean(), AddressAllocationStrategy = DHCPv4ScopeAddressPropertyReqest.AddressAllocationStrategies.Next, InformsAreAllowd = random.NextBoolean(), ReuseAddressIfPossible = random.NextBoolean(), SupportDirectUnicast = random.NextBoolean(), DynamicRenewTime = new DHCPv4DynamicRenewTimeRequest { Hours = 5, Minutes = 10, MinutesToEndOfLife = 45, MinutesToRebound = 35, }, MaskLength = (Byte)random.Next(10, 29), } , new CreateScopeResolverRequest { PropertiesAndValues = new Dictionary <String, String>(), Typename = resolverName, }, new DHCPv4ScopePropertyRequest[] { new DHCPv4AddressListScopePropertyRequest { OptionCode = 24, Type = DHCPv4ScopePropertyType.AddressList, Addresses = random.GetIPv4Addresses().Select(x => x.ToString()).ToArray(), }, new DHCPv4AddressScopePropertyRequest { OptionCode = 25, Type = DHCPv4ScopePropertyType.Address, Address = random.GetIPv4Address().ToString() }, new DHCPv4BooleanScopePropertyRequest { OptionCode = 26, Type = DHCPv4ScopePropertyType.Boolean, Value = random.NextBoolean() }, new DHCPv4NumericScopePropertyRequest { OptionCode = 27, Type = DHCPv4ScopePropertyType.UInt16, NumericType = DHCPv4NumericValueTypes.UInt16, Value = (UInt16)random.NextUInt16() }, new DHCPv4TextScopePropertyRequest { OptionCode = 28, Type = DHCPv4ScopePropertyType.Text, Value = random.GetAlphanumericString() }, new DHCPv4TimeScopePropertyRequest { OptionCode = 29, Type = DHCPv4ScopePropertyType.Time, Value = TimeSpan.FromSeconds(random.Next(10, 20)) }, new DHCPv4AddressListScopePropertyRequest { OptionCode = 64, MarkAsRemovedInInheritance = true, } } ); var serviceBusMock = new Mock <IServiceBus>(MockBehavior.Strict); serviceBusMock.Setup(x => x.Publish(It.Is <NewTriggerHappendMessage>(y => y.Triggers.Count() == 1 && ((PrefixEdgeRouterBindingUpdatedTrigger)y.Triggers.First()).OldBinding.Prefix == IPv4Address.FromString("fc70::0") ))).Returns(Task.CompletedTask); var handler = new UpdateDHCPv4ScopeCommandHandler(storageMock.Object, serviceBusMock.Object, rootScope, Mock.Of <ILogger <UpdateDHCPv4ScopeCommandHandler> >()); Boolean result = await handler.Handle(command, CancellationToken.None); Assert.Equal(storeResult, result); var scope = rootScope.GetRootScopes().First(); Assert.Equal(name, scope.Name); Assert.Equal(description, scope.Description); Assert.NotNull(scope.Resolver); Assert.Equal(start, scope.AddressRelatedProperties.Start); Assert.True(scope.Properties.IsMarkedAsRemovedFromInheritance(64)); Assert.False(scope.Properties.IsMarkedAsRemovedFromInheritance(24)); if (useDynamicTime == true) { Assert.True(scope.AddressRelatedProperties.UseDynamicRewnewTime); Assert.Equal(5, scope.AddressRelatedProperties.DynamicRenewTime.Hour); } else { Assert.False(scope.AddressRelatedProperties.UseDynamicRewnewTime); } scopeResolverMock.Verify(); storageMock.Verify(); serviceBusMock.Verify(); Assert.Empty(rootScope.GetTriggers()); }
public void TestInform_CheckReponsePacket() { Random random = new Random(); IPv4Address start = random.GetIPv4Address(); IPv4Address end = random.GetIPv4AddressGreaterThan(start); IPv4Address sourceAddress = random.GetIPv4AddressBetween(start, end); IPv4Address destinationAddress = random.GetIPv4AddressBetween(start, end); DHCPv4Packet input = GetInformPacket(random, sourceAddress, destinationAddress); List <DHCPv4ScopeProperty> scopeProperties = random.GenerateProperties(new List <DHCPv4OptionTypes> { DHCPv4OptionTypes.RebindingTimeValue, DHCPv4OptionTypes.RenewalTimeValue, DHCPv4OptionTypes.IPAddressLeaseTime, DHCPv4OptionTypes.ServerIdentifier, DHCPv4OptionTypes.MessageType, }); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); rootScope.Load(new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { AddressProperties = new DHCPv4ScopeAddressProperties(start, end, new List <IPv4Address>(), informsAreAllowd: true, renewalTime: TimeSpan.FromMinutes(random.Next(3, 10)), preferredLifetime: TimeSpan.FromMinutes(random.Next(20, 30)), leaseTime: TimeSpan.FromMinutes(random.Next(40, 60)) ), Id = scopeId, ScopeProperties = new DHCPv4ScopeProperties(scopeProperties) }) }); DHCPv4Packet result = rootScope.HandleInform(input); Assert.NotEqual(DHCPv4Packet.Empty, result); Assert.Equal(sourceAddress, result.Header.Destionation); Assert.Equal(destinationAddress, result.Header.Source); Assert.Equal(DHCPv4MessagesTypes.Acknowledge, result.MessageType); Assert.Equal(input.ClientHardwareAddress, result.ClientHardwareAddress); Assert.Equal(input.HardwareAddressLength, result.HardwareAddressLength); Assert.Equal(input.HardwareType, result.HardwareType); Assert.Equal(0, result.Hops); Assert.Equal(0, result.SecondsElapsed); Assert.Equal(input.TransactionId, result.TransactionId); Assert.Equal(String.Empty, result.FileName); Assert.Equal(String.Empty, result.ServerHostname); Assert.Equal(DHCPv4PacketFlags.Unicast, result.Flags); Assert.Equal(DHCPv4PacketOperationCodes.BootReply, result.OpCode); Assert.Equal(IPv4Address.Empty, result.GatewayIPAdress); Assert.Equal(IPv4Address.Empty, result.YourIPAdress); Assert.Equal(IPv4Address.Empty, result.ServerIPAdress); Assert.Equal(input.ClientIPAdress, result.ClientIPAdress); Assert.Equal(input.ClientIPAdress, result.Header.Destionation); // no time values Assert.False(IsOptionPresentend(result, DHCPv4OptionTypes.RebindingTimeValue)); Assert.False(IsOptionPresentend(result, DHCPv4OptionTypes.RenewalTimeValue)); Assert.False(IsOptionPresentend(result, DHCPv4OptionTypes.IPAddressLeaseTime)); // server identifier Assert.True(IsOptionPresentend(result, DHCPv4OptionTypes.ServerIdentifier)); Assert.True(HasOptionThisIPv4Adress(result, DHCPv4OptionTypes.ServerIdentifier, destinationAddress)); foreach (var item in scopeProperties) { Assert.True(IsOptionPresentend(result, item.OptionIdentifier)); DHCPv4PacketOption existingOption = result.GetOptionByIdentifier(item.OptionIdentifier); Assert.NotEqual(DHCPv4PacketOption.NotPresented, existingOption); ChecKIfPropertyCorrelatesToOption(item, existingOption); } }
public void DHCPv4Leases_IsAddressActive() { 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(30, 60); Dictionary <IPv4Address, Boolean> expectedUsedAddress = new Dictionary <IPv4Address, bool>(); for (int i = 0; i < leaseAmount; i++) { Guid leaseId = Guid.NewGuid(); IPv4Address address = random.GetIPv4Address(); events.Add(new DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = address, ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), }); Boolean addressIsInUse = random.NextDouble() > 0.5; if (addressIsInUse == true) { events.Add(new DHCPv4LeaseActivatedEvent(leaseId)); } expectedUsedAddress.Add(address, addressIsInUse); } rootScope.Load(events); DHCPv4Scope scope = rootScope.GetRootScopes().First(); foreach (var item in expectedUsedAddress) { Boolean actual = scope.Leases.IsAddressActive(item.Key); Assert.Equal(item.Value, actual); } Int32 notExistingAddressesAmount = random.Next(30, 50); for (int i = 0; i < notExistingAddressesAmount; i++) { IPv4Address notExisitingAddress = random.GetIPv4Address(); if (expectedUsedAddress.ContainsKey(notExisitingAddress) == true) { continue; } Boolean actual = scope.Leases.IsAddressActive(notExisitingAddress); Assert.False(actual); } }
public void GetLeasesByScope_OnlyDirect() { Random random = new Random(); Guid scopeId = random.NextGuid(); String scopeName = "Testscope"; DHCPv4LeaseOverview activeLeaseWithoutPrefix = new DHCPv4LeaseOverview { Address = random.GetIPv4Address().ToString(), MacAddress = random.NextBytes(6), ExpectedEnd = DateTime.UtcNow.AddHours(random.Next(10, 20)), Started = DateTime.UtcNow.AddHours(-random.Next(10, 20)), Id = random.NextGuid(), UniqueIdentifier = random.NextBytes(10), State = LeaseStates.Active, Scope = new DHCPv4ScopeOverview { Id = scopeId, Name = scopeName, } }; DHCPv4LeaseOverview expiredLeaseWithPrefix = new DHCPv4LeaseOverview { Address = random.GetIPv4Address().ToString(), MacAddress = random.NextBytes(6), ExpectedEnd = DateTime.UtcNow.AddHours(random.Next(10, 20)), Started = DateTime.UtcNow.AddHours(-random.Next(10, 20)), Id = random.NextGuid(), UniqueIdentifier = Array.Empty <Byte>(), State = LeaseStates.Inactive, Scope = new DHCPv4ScopeOverview { Id = scopeId, Name = scopeName, } }; DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(new List <DomainEvent> { new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { Name = scopeName, Id = scopeId, }), new DHCPv4LeaseCreatedEvent { EntityId = expiredLeaseWithPrefix.Id, Address = IPv4Address.FromString(expiredLeaseWithPrefix.Address.ToString()), ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(expiredLeaseWithPrefix.MacAddress).GetBytes(), ScopeId = scopeId, StartedAt = expiredLeaseWithPrefix.Started, ValidUntil = expiredLeaseWithPrefix.ExpectedEnd, UniqueIdentifier = null, }, new DHCPv4LeaseActivatedEvent { EntityId = expiredLeaseWithPrefix.Id, ScopeId = scopeId, }, new DHCPv4LeaseExpiredEvent { EntityId = expiredLeaseWithPrefix.Id, ScopeId = scopeId, }, new DHCPv4LeaseCreatedEvent { EntityId = activeLeaseWithoutPrefix.Id, Address = IPv4Address.FromString(activeLeaseWithoutPrefix.Address.ToString()), ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(activeLeaseWithoutPrefix.MacAddress).GetBytes(), ScopeId = scopeId, StartedAt = activeLeaseWithoutPrefix.Started, ValidUntil = activeLeaseWithoutPrefix.ExpectedEnd, UniqueIdentifier = activeLeaseWithoutPrefix.UniqueIdentifier }, new DHCPv4LeaseActivatedEvent { EntityId = activeLeaseWithoutPrefix.Id, ScopeId = scopeId, }, });; var controller = new DHCPv4LeaseController(rootScope, Mock.Of <ILogger <DHCPv4LeaseController> >()); var actionResult = controller.GetLeasesByScope(scopeId); var result = actionResult.EnsureOkObjectResult <IEnumerable <DHCPv4LeaseOverview> >(true); Assert.Equal(new[] { activeLeaseWithoutPrefix, expiredLeaseWithPrefix }, result, new LeaseOverviewEqualityComparer()); }
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 void DHCPv4Scope_AddressPropertiesInherientce() { Random random = new Random(); for (int i = 0; i < 100; i++) { IPv4Address grantParentStart = random.GetIPv4Address(); IPv4Address grantParentEnd = random.GetIPv4AddressGreaterThan(grantParentStart); List <IPv4Address> grantParentExcludedAddresses = random.GetIPv4AddressesBetween(grantParentStart, grantParentEnd); TimeSpan grantParentValidLifeTime = TimeSpan.FromMinutes(random.Next()); TimeSpan grantParentPrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next()); TimeSpan grantParentRenewalTimePrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next()); Boolean grantParentReuseAddressIfPossible = random.NextBoolean(); DHCPv4ScopeAddressProperties.AddressAllocationStrategies grantParentAllocationStrategy = DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next; Boolean grantParentSupportDirectUnicast = random.NextBoolean(); Boolean grantParentAcceptDecline = random.NextBoolean(); Boolean grantParentInformsAreAllowd = random.NextBoolean(); Byte grantParentSubnetMask = (Byte)random.Next(18, 25); DHCPv4ScopeAddressProperties grantParentProperties = new DHCPv4ScopeAddressProperties( grantParentStart, grantParentEnd, grantParentExcludedAddresses, grantParentRenewalTimePrefferedValidLifeTime, grantParentPrefferedValidLifeTime, grantParentValidLifeTime, grantParentSubnetMask, grantParentReuseAddressIfPossible, grantParentAllocationStrategy, grantParentInformsAreAllowd, grantParentAcceptDecline, grantParentInformsAreAllowd); IPv4Address parentStart = random.GetIPv4Address(); IPv4Address parentEnd = random.GetIPv4AddressGreaterThan(parentStart); List <IPv4Address> parentExcludedAddresses = random.GetIPv4AddressesBetween(parentStart, parentEnd); TimeSpan?parentValidLifeTime = null; TimeSpan?parentPrefferedValidLifeTime = null; TimeSpan?parentRenewalTimePrefferedValidLifeTime = null; Byte?parentSubnetMask = null; Boolean?parentReuseAddressIfPossible = null; DHCPv4ScopeAddressProperties.AddressAllocationStrategies?parentAllocationStrategy = null; Boolean?parentSupportDirectUnicast = null; Boolean?parentAcceptDecline = null; Boolean?parentInformsAreAllowd = null; if (random.NextBoolean() == true) { parentValidLifeTime = TimeSpan.FromMinutes(random.Next()); } if (random.NextBoolean() == true) { parentPrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next()); } if (random.NextBoolean() == true) { parentRenewalTimePrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next()); } if (random.NextBoolean() == true) { parentSubnetMask = (Byte)random.Next(18, 25); } if (random.NextBoolean() == true) { parentReuseAddressIfPossible = random.NextBoolean(); } if (random.NextBoolean() == true) { parentAllocationStrategy = DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random; } if (random.NextBoolean() == true) { parentSupportDirectUnicast = random.NextBoolean(); } if (random.NextBoolean() == true) { parentAcceptDecline = random.NextBoolean(); } if (random.NextBoolean() == true) { parentInformsAreAllowd = random.NextBoolean(); } DHCPv4ScopeAddressProperties parentProperties = new DHCPv4ScopeAddressProperties( parentStart, parentEnd, parentExcludedAddresses, parentRenewalTimePrefferedValidLifeTime, parentPrefferedValidLifeTime, parentValidLifeTime, parentSubnetMask, parentReuseAddressIfPossible, parentAllocationStrategy, parentInformsAreAllowd, parentAcceptDecline, parentInformsAreAllowd); IPv4Address childStart = random.GetIPv4Address(); IPv4Address childEnd = random.GetIPv4AddressGreaterThan(childStart); List <IPv4Address> childExcludedAddresses = random.GetIPv4AddressesBetween(childStart, childEnd); TimeSpan?childValidLifeTime = null; TimeSpan?childPrefferedValidLifeTime = null; TimeSpan?childRenewalTimePrefferedValidLifeTime = null; Byte?childSubnetMask = null; Boolean?childReuseAddressIfPossible = null; DHCPv4ScopeAddressProperties.AddressAllocationStrategies?childAllocationStrategy = null; Boolean?childSupportDirectUnicast = random.NextDouble() > 0.5; Boolean?childAcceptDecline = random.NextDouble() > 0.5; Boolean?childInformsAreAllowd = random.NextDouble() > 0.5; if (random.NextBoolean() == true) { childValidLifeTime = TimeSpan.FromMinutes(random.Next()); } if (random.NextBoolean() == true) { childPrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next()); } if (random.NextBoolean() == true) { childRenewalTimePrefferedValidLifeTime = TimeSpan.FromMinutes(random.Next()); } if (random.NextBoolean() == true) { childSubnetMask = (Byte)random.Next(18, 25); } if (random.NextBoolean() == true) { childReuseAddressIfPossible = random.NextBoolean(); } if (random.NextBoolean() == true) { childAllocationStrategy = DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Random; } if (random.NextBoolean() == true) { childSupportDirectUnicast = random.NextBoolean(); } if (random.NextBoolean() == true) { childAcceptDecline = random.NextBoolean(); } if (random.NextBoolean() == true) { childInformsAreAllowd = random.NextBoolean(); } DHCPv4ScopeAddressProperties childProperties = new DHCPv4ScopeAddressProperties( childStart, childEnd, childExcludedAddresses, childRenewalTimePrefferedValidLifeTime, childPrefferedValidLifeTime, childValidLifeTime, childSubnetMask, childReuseAddressIfPossible, childAllocationStrategy, childSupportDirectUnicast, childAcceptDecline, childInformsAreAllowd); Guid grantParentId = Guid.NewGuid(); Guid parentId = Guid.NewGuid(); Guid childId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = grantParentId, AddressProperties = grantParentProperties, }), new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = parentId, ParentId = grantParentId, AddressProperties = parentProperties, }), new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = childId, ParentId = parentId, AddressProperties = childProperties, }), }; DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(events); DHCPv4Scope scope = rootScope.GetScopeById(childId); DHCPv4ScopeAddressProperties actualProperties = scope.GetAddressProperties(); DHCPv4ScopeAddressProperties expectedProperties = new DHCPv4ScopeAddressProperties( childStart, childEnd, grantParentExcludedAddresses.Union(parentExcludedAddresses).Union(childExcludedAddresses).Where(x => x.IsBetween(childStart, childEnd)), childRenewalTimePrefferedValidLifeTime.HasValue == true ? childRenewalTimePrefferedValidLifeTime.Value : (parentRenewalTimePrefferedValidLifeTime.HasValue == true ? parentRenewalTimePrefferedValidLifeTime.Value : grantParentRenewalTimePrefferedValidLifeTime), childPrefferedValidLifeTime.HasValue == true ? childPrefferedValidLifeTime.Value : (parentPrefferedValidLifeTime.HasValue == true ? parentPrefferedValidLifeTime.Value : grantParentPrefferedValidLifeTime), childValidLifeTime.HasValue == true ? childValidLifeTime.Value : (parentValidLifeTime.HasValue == true ? parentValidLifeTime.Value : grantParentValidLifeTime), childSubnetMask.HasValue == true ? childSubnetMask.Value : (parentSubnetMask.HasValue == true ? parentSubnetMask.Value : grantParentSubnetMask), childReuseAddressIfPossible.HasValue == true ? childReuseAddressIfPossible.Value : (parentReuseAddressIfPossible.HasValue == true ? parentReuseAddressIfPossible.Value : grantParentReuseAddressIfPossible), childAllocationStrategy.HasValue == true ? childAllocationStrategy.Value : (parentAllocationStrategy.HasValue == true ? parentAllocationStrategy.Value : grantParentAllocationStrategy), childSupportDirectUnicast.HasValue == true ? childSupportDirectUnicast.Value : (parentSupportDirectUnicast.HasValue == true ? parentSupportDirectUnicast.Value : grantParentSupportDirectUnicast), childAcceptDecline.HasValue == true ? childAcceptDecline.Value : (parentAcceptDecline.HasValue == true ? parentAcceptDecline.Value : grantParentAcceptDecline), childInformsAreAllowd.HasValue == true ? childInformsAreAllowd.Value : (parentInformsAreAllowd.HasValue == true ? parentInformsAreAllowd.Value : grantParentInformsAreAllowd) ); Assert.Equal(expectedProperties, actualProperties); } }
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); } }
public async Task Handle_WithChildren(Boolean requestedToDeleteChildrenAsWell) { Random random = new Random(); Guid grantParentId = random.NextGuid(); Guid parentId = random.NextGuid(); Guid childId = random.NextGuid(); String resolverName = random.GetAlphanumericString(); Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(); scopeResolverMock.Setup(x => x.InitializeResolver(It.Is <CreateScopeResolverInformation>(y => y.Typename == resolverName ))).Returns(Mock.Of <IScopeResolver <DHCPv4Packet, IPv4Address> >()).Verifiable(); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv4RootScope> >()); DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(new[] { new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Id = grantParentId, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, }, AddressProperties = new DHCPv4ScopeAddressProperties(IPv4Address.FromString("192.168.0.1"), IPv4Address.FromString("192.168.0.20")), } }, new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Id = parentId, ParentId = grantParentId, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, }, AddressProperties = new DHCPv4ScopeAddressProperties(IPv4Address.FromString("192.168.0.5"), IPv4Address.FromString("192.168.0.8")), } }, new DHCPv4ScopeAddedEvent { Instructions = new DHCPv4ScopeCreateInstruction { Id = childId, ParentId = parentId, ResolverInformation = new CreateScopeResolverInformation { Typename = resolverName, }, AddressProperties = new DHCPv4ScopeAddressProperties(IPv4Address.FromString("192.168.0.7"), IPv4Address.FromString("192.168.0.7")), } }, }); Mock <IDHCPv4StorageEngine> storageMock = new Mock <IDHCPv4StorageEngine>(MockBehavior.Strict); storageMock.Setup(x => x.Save(rootScope)).ReturnsAsync(true).Verifiable(); var command = new DeleteDHCPv4ScopeCommand(parentId, requestedToDeleteChildrenAsWell); var handler = new DeleteDHCPv4ScopeCommandHandler(storageMock.Object, rootScope, Mock.Of <ILogger <DeleteDHCPv4ScopeCommandHandler> >()); Boolean result = await handler.Handle(command, CancellationToken.None); Assert.True(result); var changes = rootScope.GetChanges(); if (requestedToDeleteChildrenAsWell == true) { Assert.Null(rootScope.GetScopeById(childId)); Assert.Equal(2, changes.Count()); var firstEvent = changes.ElementAt(0) as DHCPv4ScopeDeletedEvent; Assert.Equal(childId, firstEvent.EntityId); var secondEvent = changes.ElementAt(1) as DHCPv4ScopeDeletedEvent; Assert.Equal(parentId, secondEvent.EntityId); } else { Assert.Single(changes); } Assert.Null(rootScope.GetScopeById(parentId)); Assert.NotNull(rootScope.GetScopeById(grantParentId)); storageMock.Verify(); }
public void DHCPv4Scope_ScopePropertiesInherientce() { Random random = new Random(); Byte onylGrandParentOptionIdentifier = 47; Byte onlyParentOptionIdentifier = 55; Byte onlyChildOptionIdentifier = 90; Byte overridenByParentOptionIdentifier = 100; Byte overridenByChildOptionIdentifier = 110; Dictionary <Byte, IPv4Address> inputs = new Dictionary <byte, IPv4Address> { { onylGrandParentOptionIdentifier, random.GetIPv4Address() }, { onlyParentOptionIdentifier, random.GetIPv4Address() }, { onlyChildOptionIdentifier, random.GetIPv4Address() }, { overridenByParentOptionIdentifier, random.GetIPv4Address() }, { overridenByChildOptionIdentifier, random.GetIPv4Address() }, }; DHCPv4ScopeProperties grantParentProperties = new DHCPv4ScopeProperties( new DHCPv4AddressScopeProperty(onylGrandParentOptionIdentifier, inputs[onylGrandParentOptionIdentifier]), new DHCPv4AddressScopeProperty(overridenByParentOptionIdentifier, random.GetIPv4Address()), new DHCPv4AddressScopeProperty(overridenByChildOptionIdentifier, random.GetIPv4Address()) ); DHCPv4ScopeProperties parentProperties = new DHCPv4ScopeProperties( new DHCPv4AddressScopeProperty(onlyParentOptionIdentifier, inputs[onlyParentOptionIdentifier]), new DHCPv4AddressScopeProperty(overridenByParentOptionIdentifier, inputs[overridenByParentOptionIdentifier]) ); DHCPv4ScopeProperties childProperties = new DHCPv4ScopeProperties( new DHCPv4AddressScopeProperty(onlyChildOptionIdentifier, inputs[onlyChildOptionIdentifier]), new DHCPv4AddressScopeProperty(overridenByChildOptionIdentifier, inputs[overridenByChildOptionIdentifier]) ); DHCPv4ScopeProperties expectedProperties = new DHCPv4ScopeProperties( new DHCPv4AddressScopeProperty(onylGrandParentOptionIdentifier, inputs[onylGrandParentOptionIdentifier]), new DHCPv4AddressScopeProperty(onlyParentOptionIdentifier, inputs[onlyParentOptionIdentifier]), new DHCPv4AddressScopeProperty(onlyChildOptionIdentifier, inputs[onlyChildOptionIdentifier]), new DHCPv4AddressScopeProperty(overridenByParentOptionIdentifier, inputs[overridenByParentOptionIdentifier]), new DHCPv4AddressScopeProperty(overridenByChildOptionIdentifier, inputs[overridenByChildOptionIdentifier]) ); Guid grantParentId = Guid.NewGuid(); Guid parentId = Guid.NewGuid(); Guid childId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = grantParentId, ScopeProperties = grantParentProperties, }), new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = parentId, ParentId = grantParentId, ScopeProperties = parentProperties, }), new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = childId, ParentId = parentId, ScopeProperties = childProperties, }), }; DHCPv4RootScope rootScope = GetRootScope(); rootScope.Load(events); DHCPv4Scope scope = rootScope.GetScopeById(childId); DHCPv4ScopeProperties actualProperties = scope.GetScopeProperties(); Assert.Equal(expectedProperties, actualProperties); }
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(); IPv4Address start = random.GetIPv4Address(); IPv4Address end = start + 100; var excluded = new[] { start + 1, start + 3 }; DHCPv4ScopeProperties properties = null; if (random.NextBoolean() == true) { DHCPv4AddressListScopeProperty gwAddress = new( DHCPv4OptionTypes.Router, new[] { start + 0, start + 30 }); properties = new DHCPv4ScopeProperties(gwAddress); } else { properties = new(); } events.Add(new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = scopeId, Name = random.GetAlphanumericString(), AddressProperties = new DHCPv4ScopeAddressProperties(start, end, excluded, maskLength: random.NextBoolean() == true ? (Byte)random.Next(0, 32) : null), ScopeProperties = properties })); rootScopeIds.Add(scopeId); GenerateScopeTree( random.NextDouble(), random, new List <Guid> { scopeId }, events); } var scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); scopeResolverMock.Setup(x => x.InitializeResolver(It.IsAny <CreateScopeResolverInformation>())).Returns(Mock.Of <IScopeResolver <DHCPv4Packet, IPv4Address> >()); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv4RootScope> >()); DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(events); var controller = new DHCPv4ScopeController( Mock.Of <IMediator>(MockBehavior.Strict), Mock.Of <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict), rootScope); var actionResult = controller.GetScopesAsList(); var result = actionResult.EnsureOkObjectResult <IEnumerable <DHCPv4ScopeItem> >(true); Assert.Equal(events.Count, result.Count()); for (int i = 0; i < events.Count; i++) { var scope = result.ElementAt(i); var @event = (DHCPv4ScopeAddedEvent)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); Assert.Equal(@event.Instructions.AddressProperties.ExcludedAddresses.Select(x => x.ToString()).ToArray(), scope.ExcludedAddresses); Assert.Equal((@event.Instructions.ScopeProperties?.Properties ?? Array.Empty <DHCPv4ScopeProperty>()).Where(x => x.OptionIdentifier == (Byte)DHCPv4OptionTypes.Router).Cast <DHCPv4AddressListScopeProperty>().Select(x => x.Addresses.First().ToString()).FirstOrDefault(), scope.FirstGatewayAddress); } }
public void GetScopesAsTreeView() { 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(); IPv4Address start = random.GetIPv4Address(); IPv4Address end = start + 100; var excluded = new[] { start + 1, start + 3 }; DHCPv4ScopeProperties properties = null; if (random.NextBoolean() == true) { DHCPv4AddressListScopeProperty gwAddress = new( DHCPv4OptionTypes.Router, new[] { start + 0, start + 30 }); properties = new DHCPv4ScopeProperties(gwAddress); } else { properties = new(); } events.Add(new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = scopeId, Name = random.GetAlphanumericString(), AddressProperties = new DHCPv4ScopeAddressProperties(start, end, excluded, maskLength: random.NextBoolean() == true ? (Byte)random.Next(0, 32) : null), ScopeProperties = properties })); rootScopeIds.Add(scopeId); GenerateScopeTree( random.NextDouble(), random, new List <Guid> { scopeId }, events); } var scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); scopeResolverMock.Setup(x => x.InitializeResolver(It.IsAny <CreateScopeResolverInformation>())).Returns(Mock.Of <IScopeResolver <DHCPv4Packet, IPv4Address> >()); Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict); factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv4RootScope> >()); DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), scopeResolverMock.Object, factoryMock.Object); rootScope.Load(events); var controller = new DHCPv4ScopeController( Mock.Of <IMediator>(MockBehavior.Strict), Mock.Of <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict), rootScope); var actionResult = controller.GetScopesAsTreeView(); var result = actionResult.EnsureOkObjectResult <IEnumerable <DHCPv4ScopeTreeViewItem> >(true); Assert.Equal(rootScopeAmount, result.Count()); Int32 index = 0; foreach (var item in rootScope.GetRootScopes()) { var scope = result.ElementAt(index); CheckTreeItem(item, scope); index++; } }
public void DHCPv4Leases_GetUsedAddresses() { 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(30, 60); List <IPv4Address> expectedUsedAddress = new List <IPv4Address>(); for (int i = 0; i < leaseAmount; i++) { Guid leaseId = Guid.NewGuid(); IPv4Address address = random.GetIPv4Address(); events.Add(new DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = address, ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), }); 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) { events.Add(eventToAdd); } if (addressIsInUse == true) { expectedUsedAddress.Add(address); } } rootScope.Load(events); DHCPv4Scope scope = rootScope.GetRootScopes().First(); List <IPv4Address> actualAddresses = scope.Leases.GetUsedAddresses().ToList(); Assert.Equal(expectedUsedAddress, actualAddresses); }
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 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 async Task GetDashboard() { Random random = new Random(); Guid grantParentScopeId = random.NextGuid(); Guid parentScopeId = random.NextGuid(); Guid childScopeId = random.NextGuid(); DHCPv6RootScope rootScope = GetDHCPv6RootScope(); rootScope.Load(new List <DomainEvent> { new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { Name = "grant parent", Id = grantParentScopeId, }), new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { Name = "parent", Id = parentScopeId, ParentId = grantParentScopeId }), new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent( new DHCPv6ScopeCreateInstruction { Name = "child", Id = childScopeId, ParentId = parentScopeId }), }); DHCPv4RootScope dhcpv4RootScope = GetDHCPv4RootScope(); dhcpv4RootScope.Load(new List <DomainEvent> { new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { Name = "grant parent", Id = grantParentScopeId, }), new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { Name = "parent", Id = parentScopeId, ParentId = grantParentScopeId }), new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { Name = "child", Id = childScopeId, ParentId = parentScopeId }), }); DashboardResponse response = new DashboardResponse { DHCPv6 = new DHCPOverview <DHCPv6LeaseEntry, DHCPv6PacketHandledEntry> { ActiveInterfaces = random.Next(3, 10), }, DHCPv4 = new DHCPOverview <DHCPv4LeaseEntry, DHCPv4PacketHandledEntry> { ActiveInterfaces = random.Next(3, 10), }, }; Int32 expectedPipelineAmount = random.Next(3, 10); Mock <IDHCPv6ReadStore> readStoreMock = new Mock <IDHCPv6ReadStore>(MockBehavior.Strict); readStoreMock.Setup(x => x.GetDashboardOverview()).ReturnsAsync(response).Verifiable(); Mock <INotificationEngine> notificationEngineMock = new Mock <INotificationEngine>(MockBehavior.Strict); notificationEngineMock.Setup(x => x.GetPipelineAmount()).Returns(expectedPipelineAmount).Verifiable(); var controller = new DashboardController(rootScope, dhcpv4RootScope, readStoreMock.Object, notificationEngineMock.Object); var actionResult = await controller.GetDashboard(); var result = actionResult.EnsureOkObjectResult <DashboardResponse>(true); Assert.NotNull(result); Assert.NotNull(result.DHCPv6); Assert.NotNull(result.DHCPv4); Assert.Equal(3, result.DHCPv6.ScopeAmount); Assert.Equal(response.DHCPv6.ActiveInterfaces, result.DHCPv6.ActiveInterfaces); Assert.Equal(expectedPipelineAmount, result.AmountOfPipelines); Assert.Equal(3, result.DHCPv4.ScopeAmount); Assert.Equal(response.DHCPv4.ActiveInterfaces, result.DHCPv4.ActiveInterfaces); readStoreMock.Verify(); }
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); }