Example #1
0
        protected static void CheckRevokedEvent(Int32 index, Guid scopeId, Guid leaseId, DHCPv4RootScope rootScope)
        {
            IEnumerable <DomainEvent> changes = rootScope.GetChanges();
            var @event = changes.ElementAt(index);

            Assert.NotNull(@event);
            Assert.IsAssignableFrom <DHCPv4LeaseRevokedEvent>(@event);

            DHCPv4LeaseRevokedEvent revokedEvent = (DHCPv4LeaseRevokedEvent)@event;

            Assert.Equal(scopeId, revokedEvent.ScopeId);
            Assert.Equal(leaseId, revokedEvent.EntityId);
        }
Example #2
0
        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);
            }
        }
Example #3
0
        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);
        }