From: Francis Dupont Date: Sun, 19 May 2019 13:14:15 +0000 (+0200) Subject: [295-min-max-lease-time-configuration-options] Added alloc/renew DHCPv4 tests X-Git-Tag: Kea-1.6.0-beta2~247 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=01642f1b5b423a92f76e2fa4340c71c00f06af2a;p=thirdparty%2Fkea.git [295-min-max-lease-time-configuration-options] Added alloc/renew DHCPv4 tests --- diff --git a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc index fb59021308..ac5dea7da2 100644 --- a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc +++ b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc @@ -6,6 +6,8 @@ #include #include +#include +#include #include #include #include @@ -128,6 +130,152 @@ TEST_F(AllocEngine4Test, simpleAlloc4) { EXPECT_TRUE(testStatistics("assigned-addresses", 2, subnet_->getID())); } +// This test checks that simple allocation uses the default valid lifetime. +TEST_F(AllocEngine4Test, defaultAlloc4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(1, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + Lease4Ptr lease = engine->allocateLease4(ctx); + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Check that we got a lease + ASSERT_TRUE(lease); + + // Do all checks on the lease + checkLease4(lease); + + // Check the valid lifetime has the default. + EXPECT_EQ(subnet_->getValid(), lease->valid_lft_); + + // Check that the lease is indeed in LeaseMgr + Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(lease->addr_); + ASSERT_TRUE(from_mgr); + + // Now check that the lease in LeaseMgr has the same parameters + detailCompareLease(lease, from_mgr); +} + +// This test checks that simple allocation uses the specified valid lifetime. +TEST_F(AllocEngine4Test, hintAlloc4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(1, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + // Speficy the valid lifetime we want. + OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 4)); + ctx.query_->addOption(opt); + + Lease4Ptr lease = engine->allocateLease4(ctx); + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Check that we got a lease + ASSERT_TRUE(lease); + + // Do all checks on the lease + checkLease4(lease); + + // Check the valid lifetime has the wanted value. + EXPECT_EQ(opt->getValue(), lease->valid_lft_); + + // Check that the lease is indeed in LeaseMgr + Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(lease->addr_); + ASSERT_TRUE(from_mgr); + + // Now check that the lease in LeaseMgr has the same parameters + detailCompareLease(lease, from_mgr); +} + +// This test checks that simple allocation uses the min valid lifetime. +TEST_F(AllocEngine4Test, minAlloc4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(2, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + // Speficy the valid lifetime we want, as it is lower than the min value + // we'll get this min value instead. + OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 1)); + ctx.query_->addOption(opt); + + Lease4Ptr lease = engine->allocateLease4(ctx); + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Check that we got a lease + ASSERT_TRUE(lease); + + // Do all checks on the lease + checkLease4(lease); + + // Check the valid lifetime has the wanted value. + EXPECT_EQ(subnet_->getValid().getMin(), lease->valid_lft_); + + // Check that the lease is indeed in LeaseMgr + Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(lease->addr_); + ASSERT_TRUE(from_mgr); + + // Now check that the lease in LeaseMgr has the same parameters + detailCompareLease(lease, from_mgr); +} + +// This test checks that simple allocation uses the max valid lifetime. +TEST_F(AllocEngine4Test, maxAlloc4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(1, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + // Speficy the valid lifetime we want, as it is greater than the max value + // we'll get this max value instead. + OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 6)); + ctx.query_->addOption(opt); + + Lease4Ptr lease = engine->allocateLease4(ctx); + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Check that we got a lease + ASSERT_TRUE(lease); + + // Do all checks on the lease + checkLease4(lease); + + // Check the valid lifetime has the wanted value. + EXPECT_EQ(subnet_->getValid().getMax(), lease->valid_lft_); + + // Check that the lease is indeed in LeaseMgr + Lease4Ptr from_mgr = LeaseMgrFactory::instance().getLease4(lease->addr_); + ASSERT_TRUE(from_mgr); + + // Now check that the lease in LeaseMgr has the same parameters + detailCompareLease(lease, from_mgr); +} + // This test checks if the fake allocation (for DHCPDISCOVER) can succeed TEST_F(AllocEngine4Test, fakeAlloc4) { boost::scoped_ptr engine; @@ -367,6 +515,172 @@ TEST_F(AllocEngine4Test, simpleRenew4) { EXPECT_TRUE(testStatistics("assigned-addresses", 1, subnet_->getID())); } +// This test checks simple renewal uses the default valid lifetime. +TEST_F(AllocEngine4Test, defaultRenew4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(1, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + Lease4Ptr lease = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease); + checkLease4(lease); + + // Check the valid lifetime has the default. + EXPECT_EQ(subnet_->getValid(), lease->valid_lft_); + + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Do it again, this should amount to the renew of an existing lease + Lease4Ptr lease2 = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease2); + checkLease4(lease2); + + // Lease already existed, so old_lease should be set. + EXPECT_TRUE(ctx.old_lease_); + + // Check the renewed valid lifetime has the default. + EXPECT_EQ(subnet_->getValid(), lease2->valid_lft_); +} + +// This test checks simple renewal uses the specified valid lifetime. +TEST_F(AllocEngine4Test, hintRenew4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(1, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + // Speficy the valid lifetime we want. + OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 4)); + ctx.query_->addOption(opt); + + Lease4Ptr lease = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease); + checkLease4(lease); + + // Check the valid lifetime has the wanted value. + EXPECT_EQ(opt->getValue(), lease->valid_lft_); + + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Do it again, this should amount to the renew of an existing lease + Lease4Ptr lease2 = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease2); + checkLease4(lease2); + + // Lease already existed, so old_lease should be set. + EXPECT_TRUE(ctx.old_lease_); + + // Check the renewed valid lifetime has the wanted value. + EXPECT_EQ(opt->getValue(), lease2->valid_lft_); +} + +// This test checks simple renewal uses the min valid lifetime. +TEST_F(AllocEngine4Test, minRenew4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(2, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + // Speficy the valid lifetime we want, as it is lower than the min value + // we'll get this min value instead. + OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 1)); + ctx.query_->addOption(opt); + + Lease4Ptr lease = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease); + checkLease4(lease); + + // Check the valid lifetime has the min value. + EXPECT_EQ(subnet_->getValid().getMin(), lease->valid_lft_); + + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Do it again, this should amount to the renew of an existing lease + Lease4Ptr lease2 = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease2); + checkLease4(lease2); + + // Lease already existed, so old_lease should be set. + EXPECT_TRUE(ctx.old_lease_); + + // Check the renewed valid lifetime has the min value. + EXPECT_EQ(subnet_->getValid().getMin(), lease2->valid_lft_); +} + +// This test checks simple renewal uses the max valid lifetime. +TEST_F(AllocEngine4Test, maxRenew4) { + boost::scoped_ptr engine; + ASSERT_NO_THROW(engine.reset(new AllocEngine(AllocEngine::ALLOC_ITERATIVE, + 0, false))); + ASSERT_TRUE(engine); + + AllocEngine::ClientContext4 ctx(subnet_, clientid_, hwaddr_, IOAddress("0.0.0.0"), + false, true, "somehost.example.com.", false); + subnet_->setValid(Triplet(1, 3, 5)); + ctx.query_.reset(new Pkt4(DHCPREQUEST, 1234)); + + // Speficy the valid lifetime we want, as it is greater than the max value + // we'll get this max value instead. + OptionUint32Ptr opt(new OptionUint32(Option::V4, DHO_DHCP_LEASE_TIME, 6)); + ctx.query_->addOption(opt); + + Lease4Ptr lease = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease); + checkLease4(lease); + + // Check the valid lifetime has the max value. + EXPECT_EQ(subnet_->getValid().getMax(), lease->valid_lft_); + + // The new lease has been allocated, so the old lease should not exist. + EXPECT_FALSE(ctx.old_lease_); + + // Do it again, this should amount to the renew of an existing lease + Lease4Ptr lease2 = engine->allocateLease4(ctx); + + // Check that we got a lease and it's sane + ASSERT_TRUE(lease2); + checkLease4(lease2); + + // Lease already existed, so old_lease should be set. + EXPECT_TRUE(ctx.old_lease_); + + // Check the renewed valid lifetime has the max value. + EXPECT_EQ(subnet_->getValid().getMax(), lease2->valid_lft_); +} + // This test verifies that the allocator picks addresses that belong to the // pool TEST_F(AllocEngine4Test, IterativeAllocator) { diff --git a/src/lib/dhcpsrv/tests/alloc_engine_utils.h b/src/lib/dhcpsrv/tests/alloc_engine_utils.h index 80e33cd197..c9da292833 100644 --- a/src/lib/dhcpsrv/tests/alloc_engine_utils.h +++ b/src/lib/dhcpsrv/tests/alloc_engine_utils.h @@ -194,8 +194,18 @@ public: // that it have proper parameters EXPECT_EQ(exp_type, lease->type_); EXPECT_EQ(iaid_, lease->iaid_); - EXPECT_EQ(subnet_->getValid(), lease->valid_lft_); - EXPECT_EQ(subnet_->getPreferred(), lease->preferred_lft_); + if (subnet_->getValid().getMin() == subnet_->getValid().getMax()) { + EXPECT_EQ(subnet_->getValid(), lease->valid_lft_); + } else { + EXPECT_LE(subnet_->getValid().getMin(), lease->valid_lft_); + EXPECT_GE(subnet_->getValid().getMax(), lease->valid_lft_); + } + if (subnet_->getPreferred().getMin() == subnet_->getPreferred().getMax()) { + EXPECT_EQ(subnet_->getPreferred(), lease->preferred_lft_); + } else { + EXPECT_LE(subnet_->getPreferred().getMin(), lease->preferred_lft_); + EXPECT_GE(subnet_->getPreferred().getMax(), lease->preferred_lft_); + } EXPECT_EQ(exp_pd_len, lease->prefixlen_); EXPECT_EQ(fqdn_fwd_, lease->fqdn_fwd_); EXPECT_EQ(fqdn_rev_, lease->fqdn_rev_); @@ -459,7 +469,12 @@ public: EXPECT_TRUE(subnet_->inPool(Lease::TYPE_V4, lease->addr_)); // Check that it has proper parameters - EXPECT_EQ(subnet_->getValid(), lease->valid_lft_); + if (subnet_->getValid().getMin() == subnet_->getValid().getMax()) { + EXPECT_EQ(subnet_->getValid(), lease->valid_lft_); + } else { + EXPECT_LE(subnet_->getValid().getMin(), lease->valid_lft_); + EXPECT_GE(subnet_->getValid().getMax(), lease->valid_lft_); + } if (lease->client_id_ && !clientid_) { ADD_FAILURE() << "Lease4 has a client-id, while it should have none."; } else