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 DHCPv4StatisticsController(
DHCPv4RootScope rootScope,
IDHCPv4ReadStore storage)
{
_rootScope = rootScope ?? throw new ArgumentNullException(nameof(rootScope));
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
}
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 async Task GetIncomingDHCPv4MessagesTypes()
{
Random random = new Random();
DHCPv4RootScope rootScope = GetRootScope();
var response = new Dictionary <DateTime, IDictionary <DHCPv4MessagesTypes, 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 <IDHCPv4ReadStore> readStoreMock = new Mock <IDHCPv4ReadStore>(MockBehavior.Strict);
readStoreMock.Setup(x => x.GetIncomingDHCPv4PacketTypes(start, end, groupBy)).ReturnsAsync(response).Verifiable();
var controller = new DHCPv4StatisticsController(rootScope, readStoreMock.Object);
var actionResult = await controller.GetIncomingDHCPv4PacketTypes(new GroupedTimeSeriesFilterRequest
{
Start = start,
End = end,
GroupbBy = groupBy,
});
var result = actionResult.EnsureOkObjectResult <IDictionary <DateTime, IDictionary <DHCPv4MessagesTypes, Int32> > >(true);
Assert.NotNull(result);
Assert.Equal(response, result);
readStoreMock.Verify();
}
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);
}
}
protected static DHCPv4Lease CheckLease(
Int32 index, Int32 expectedAmount, IPv4Address expectedAdress,
Guid scopeId, DHCPv4RootScope rootScope, DateTime expectedCreationData, Boolean checkExpires = true,
Byte[] uniqueIdentifier = null, Boolean shouldBePending = true)
{
DHCPv4Scope scope = rootScope.GetScopeById(scopeId);
var leases = scope.Leases.GetAllLeases();
Assert.Equal(expectedAmount, leases.Count());
DHCPv4Lease lease = leases.ElementAt(index);
Assert.NotNull(lease);
Assert.Equal(expectedAdress, lease.Address);
if (checkExpires == true)
{
Int32 expiresInMinutes = (Int32)(lease.End - DateTime.UtcNow).TotalMinutes;
Assert.True(expiresInMinutes >= 60 * 24 - 4 && expiresInMinutes <= 60 * 24);
}
Assert.True((expectedCreationData - lease.Start).TotalMinutes < 2);
Assert.Equal(shouldBePending, lease.IsPending());
if (uniqueIdentifier == null)
{
Assert.Empty(lease.UniqueIdentifier);
}
else
{
Assert.NotNull(lease.UniqueIdentifier);
Assert.Equal(uniqueIdentifier, lease.UniqueIdentifier);
}
return(lease);
}
protected static DHCPv4RootScope GetRootScope(Mock<IScopeResolverManager<DHCPv4Packet, IPv4Address>> mock)
{
Mock<ILoggerFactory> factoryMock = new Mock<ILoggerFactory>(MockBehavior.Strict);
factoryMock.Setup(x => x.CreateLogger(It.IsAny<String>())).Returns(Mock.Of<ILogger<DHCPv4RootScope>>());
var rootScope = new DHCPv4RootScope(Guid.NewGuid(), mock.Object, factoryMock.Object);
return rootScope;
}
public CreateDHCPv4ScopeCommandHandler(
IDHCPv4StorageEngine store, DHCPv4RootScope rootScope,
ILogger <CreateDHCPv4ScopeCommandHandler> logger)
{
_store = store;
_rootScope = rootScope;
_logger = logger;
}
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 UpdateDHCPv4ScopeParentCommandHandler(
IDHCPv4StorageEngine store,
DHCPv4RootScope rootScope,
ILogger <UpdateDHCPv4ScopeParentCommandHandler> logger)
{
_store = store;
_rootScope = rootScope;
_logger = logger;
}
public DHCPv4ScopeController(
IMediator mediator,
IScopeResolverManager <DHCPv4Packet, IPv4Address> resolverManager,
DHCPv4RootScope rootScope)
{
this._mediator = mediator;
this._resolverManager = resolverManager;
_rootScope = 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 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 DHCPv4ScopeAddressPropertyReqest();
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 <DHCPv4RootScope> >());
DHCPv4RootScope rootScope = new DHCPv4RootScope(random.NextGuid(), Mock.Of <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict), factoryMock.Object);
Mock <IMediator> mediatorMock = new Mock <IMediator>(MockBehavior.Strict);
mediatorMock.Setup(x => x.Send(It.Is <UpdateDHCPv4ScopeCommand>(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 CreateOrUpdateDHCPv4ScopeRequest
{
Name = name,
Description = description,
AddressProperties = addressProperties,
ParentId = parentId,
Resolver = resolverInfo,
};
var controller = new DHCPv4ScopeController(mediatorMock.Object,
Mock.Of <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(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();
}
protected static void DHCPv4ScopeAddressesAreExhaustedEvent(int index, DHCPv4RootScope rootScope, Guid scopeId)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.IsAssignableFrom <DHCPv4ScopeAddressesAreExhaustedEvent>(changes.ElementAt(index));
DHCPv4ScopeAddressesAreExhaustedEvent castedEvent = (DHCPv4ScopeAddressesAreExhaustedEvent)changes.ElementAt(index);
Assert.Equal(castedEvent.EntityId, scopeId);
}
public DeleteDHCPv4ScopeCommandHandler(
IDHCPv4StorageEngine storageEngine,
DHCPv4RootScope rootScope,
ILogger <DeleteDHCPv4ScopeCommandHandler> logger
)
{
this.rootScope = rootScope;
this.storageEngine = storageEngine;
this.logger = logger;
}
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 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 UpdateDHCPv4ScopeCommandHandler(
IDHCPv4StorageEngine store,
IServiceBus serviceBus,
DHCPv4RootScope rootScope,
ILogger <UpdateDHCPv4ScopeCommandHandler> logger)
{
_store = store;
this._serviceBus = serviceBus;
_rootScope = rootScope;
_logger = logger;
}
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 async Task GetHandledDHCPv4PacketByScopeId_NotFound()
{
Random random = new Random();
Guid scopeId = random.NextGuid();
Int32 amount = random.Next(10, 250);
DHCPv4RootScope rootScope = GetRootScope();
var controller = new DHCPv4StatisticsController(rootScope, Mock.Of <IDHCPv4ReadStore>(MockBehavior.Strict));
var actionResult = await controller.GetHandledDHCPv4PacketByScopeId(scopeId, amount);
actionResult.EnsureNotFoundObjectResult("scope not found");
}
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 TestInform_ScopeNotFound()
{
Random random = new Random();
IPv4Address sourceAddress = random.GetIPv4Address();
DHCPv4Packet input = GetInformPacket(random, sourceAddress);
DHCPv4RootScope rootScope = GetRootScope();
DHCPv4Packet result = rootScope.HandleInform(input);
DHCPv4InformHandledEvent domainEvent = TestResult <DHCPv4InformHandledEvent>(
input, result, true, false, new Guid?(), rootScope);
Assert.Equal(InformErros.ScopeNotFound, domainEvent.Error);
}
public static T TestResult<T>(
DHCPv4Packet input,
DHCPv4Packet result,
Boolean emptyResponseExpected,
Boolean expectedSuccessfullHandling,
Guid? scopeId,
DHCPv4RootScope rootScope) where T : DHCPv4PacketHandledEvent
{
var changes = rootScope.GetChanges();
Assert.Single(changes);
DomainEvent domainEvent = changes.First();
Assert.IsAssignableFrom<T>(domainEvent);
T castedDomainEvents = (T)domainEvent;
if (scopeId.HasValue == false)
{
Assert.False(castedDomainEvents.ScopeId.HasValue);
}
else
{
Assert.True(castedDomainEvents.ScopeId.HasValue);
Assert.Equal(scopeId.Value, castedDomainEvents.ScopeId.Value);
}
Assert.Equal(input, castedDomainEvents.Request);
if (emptyResponseExpected == true)
{
Assert.Equal(DHCPv4Packet.Empty, result);
Assert.Equal(DHCPv4Packet.Empty, castedDomainEvents.Response);
}
else
{
Assert.NotEqual(DHCPv4Packet.Empty, result);
Assert.NotEqual(DHCPv4Packet.Empty, castedDomainEvents.Response);
Assert.Equal(result, castedDomainEvents.Response);
}
if (expectedSuccessfullHandling == false)
{
Assert.False(castedDomainEvents.WasSuccessfullHandled);
}
else
{
Assert.True(castedDomainEvents.WasSuccessfullHandled);
}
return castedDomainEvents;
}
private static void CheckLeaseReleasedEvent(Int32 index,
Guid scopeId, DHCPv4RootScope rootScope,
Guid leaseId
)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.NotNull(changes);
Assert.IsAssignableFrom <DHCPv4LeaseReleasedEvent>(changes.ElementAt(index));
DHCPv4LeaseReleasedEvent createdEvent = (DHCPv4LeaseReleasedEvent)changes.ElementAt(index);
Assert.NotNull(createdEvent);
Assert.Equal(scopeId, createdEvent.ScopeId);
Assert.Equal(leaseId, createdEvent.EntityId);
}
protected static void CheckLeaseCreatedEvent(
Int32 index, byte[] clientMacAdress,
Guid scopeId, DHCPv4RootScope rootScope,
IPv4Address expectedAdress, DHCPv4Lease lease,
Byte[] uniqueIdentifier = null, Boolean checkRenewTimes = true
)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.NotNull(changes);
Assert.IsAssignableFrom <DHCPv4LeaseCreatedEvent>(changes.ElementAt(index));
DHCPv4LeaseCreatedEvent createdEvent = (DHCPv4LeaseCreatedEvent)changes.ElementAt(index);
Assert.NotNull(createdEvent);
Assert.Equal(scopeId, createdEvent.ScopeId);
Assert.Equal(expectedAdress, createdEvent.Address);
var clientIdentifier = DHCPv4ClientIdentifier.FromOptionData(createdEvent.ClientIdenfier);
Assert.Equal(clientMacAdress, clientIdentifier.HwAddress);
Assert.Equal(lease.Id, createdEvent.EntityId);
if (uniqueIdentifier == null)
{
Assert.Null(createdEvent.UniqueIdentifier);
}
else
{
Assert.Equal(uniqueIdentifier, createdEvent.UniqueIdentifier);
}
Assert.Equal(lease.Start, createdEvent.StartedAt);
Assert.Equal(lease.End, createdEvent.ValidUntil);
var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties;
if (checkRenewTimes == true)
{
Assert.Equal(addressProperties.RenewalTime.Value, createdEvent.RenewalTime);
Assert.Equal(addressProperties.PreferredLifetime.Value, createdEvent.PreferredLifetime);
}
}
public 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));
}
}
