BIND 10 trac3359, updated. 516b7c2ffbd3a0c50eb21edd7210e67846882257 [3359] Changes after review:
BIND 10 source code commits
bind10-changes at lists.isc.org
Mon Mar 10 19:24:00 UTC 2014
The branch, trac3359 has been updated
via 516b7c2ffbd3a0c50eb21edd7210e67846882257 (commit)
from 32900a49231b47f2535519272e1618886fdc845c (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 516b7c2ffbd3a0c50eb21edd7210e67846882257
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Mon Mar 10 20:23:39 2014 +0100
[3359] Changes after review:
- GenericLeaseMgrTest class moved to a separate file
- @todo added for disabled tests in memfile (with explanations)
- Added several comments
-----------------------------------------------------------------------
Summary of changes:
src/lib/dhcpsrv/tests/Makefile.am | 1 +
...test_utils.cc => generic_lease_mgr_unittest.cc} | 68 +-
.../{test_utils.h => generic_lease_mgr_unittest.h} | 55 +-
src/lib/dhcpsrv/tests/lease_mgr_unittest.cc | 1 +
.../dhcpsrv/tests/memfile_lease_mgr_unittest.cc | 22 +-
src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc | 2 +-
src/lib/dhcpsrv/tests/test_utils.cc | 1343 +-------------------
src/lib/dhcpsrv/tests/test_utils.h | 216 +---
8 files changed, 57 insertions(+), 1651 deletions(-)
copy src/lib/dhcpsrv/tests/{test_utils.cc => generic_lease_mgr_unittest.cc} (95%)
copy src/lib/dhcpsrv/tests/{test_utils.h => generic_lease_mgr_unittest.h} (86%)
-----------------------------------------------------------------------
diff --git a/src/lib/dhcpsrv/tests/Makefile.am b/src/lib/dhcpsrv/tests/Makefile.am
index 037db46..c55ed85 100644
--- a/src/lib/dhcpsrv/tests/Makefile.am
+++ b/src/lib/dhcpsrv/tests/Makefile.am
@@ -59,6 +59,7 @@ libdhcpsrv_unittests_SOURCES += dbaccess_parser_unittest.cc
libdhcpsrv_unittests_SOURCES += lease_unittest.cc
libdhcpsrv_unittests_SOURCES += lease_mgr_factory_unittest.cc
libdhcpsrv_unittests_SOURCES += lease_mgr_unittest.cc
+libdhcpsrv_unittests_SOURCES += generic_lease_mgr_unittest.cc
libdhcpsrv_unittests_SOURCES += memfile_lease_mgr_unittest.cc
libdhcpsrv_unittests_SOURCES += dhcp_parsers_unittest.cc
if HAVE_MYSQL
diff --git a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc
new file mode 100644
index 0000000..1d24cf8
--- /dev/null
+++ b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc
@@ -0,0 +1,1366 @@
+// Copyright (C) 2014 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
+#include <dhcpsrv/tests/test_utils.h>
+#include <asiolink/io_address.h>
+#include <gtest/gtest.h>
+#include <sstream>
+
+using namespace std;
+using namespace isc::asiolink;
+
+namespace isc {
+namespace dhcp {
+namespace test {
+
+// IPv4 and IPv6 addresses used in the tests
+const char* ADDRESS4[] = {
+ "192.0.2.0", "192.0.2.1", "192.0.2.2", "192.0.2.3",
+ "192.0.2.4", "192.0.2.5", "192.0.2.6", "192.0.2.7",
+ NULL
+};
+const char* ADDRESS6[] = {
+ "2001:db8::0", "2001:db8::1", "2001:db8::2", "2001:db8::3",
+ "2001:db8::4", "2001:db8::5", "2001:db8::6", "2001:db8::7",
+ NULL
+};
+
+// Lease types that correspond to ADDRESS6 leases
+static const Lease::Type LEASETYPE6[] = {
+ Lease::TYPE_NA, Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA,
+ Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA, Lease::TYPE_TA
+};
+
+GenericLeaseMgrTest::GenericLeaseMgrTest()
+ : lmptr_(NULL) {
+ // Initialize address strings and IOAddresses
+ for (int i = 0; ADDRESS4[i] != NULL; ++i) {
+ string addr(ADDRESS4[i]);
+ straddress4_.push_back(addr);
+ IOAddress ioaddr(addr);
+ ioaddress4_.push_back(ioaddr);
+ }
+
+ for (int i = 0; ADDRESS6[i] != NULL; ++i) {
+ string addr(ADDRESS6[i]);
+ straddress6_.push_back(addr);
+ IOAddress ioaddr(addr);
+ ioaddress6_.push_back(ioaddr);
+
+ /// Let's create different lease types. We use LEASETYPE6 values as
+ /// a template
+ leasetype6_.push_back(LEASETYPE6[i]);
+ }
+}
+
+GenericLeaseMgrTest::~GenericLeaseMgrTest() {
+ // Does nothing. The derived classes are expected to clean up, i.e.
+ // remove the lmptr_ pointer.
+}
+
+Lease4Ptr
+GenericLeaseMgrTest::initializeLease4(std::string address) {
+ Lease4Ptr lease(new Lease4());
+
+ // Set the address of the lease
+ lease->addr_ = IOAddress(address);
+
+ // Initialize unused fields.
+ lease->ext_ = 0; // Not saved
+ lease->t1_ = 0; // Not saved
+ lease->t2_ = 0; // Not saved
+ lease->fixed_ = false; // Unused
+ lease->comments_ = std::string(""); // Unused
+
+ // Set other parameters. For historical reasons, address 0 is not used.
+ if (address == straddress4_[0]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x08);
+ lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 0x42)));
+ lease->valid_lft_ = 8677;
+ lease->cltt_ = 168256;
+ lease->subnet_id_ = 23;
+ lease->fqdn_rev_ = true;
+ lease->fqdn_fwd_ = false;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress4_[1]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x19);
+ lease->client_id_ = ClientIdPtr(
+ new ClientId(vector<uint8_t>(8, 0x53)));
+ lease->valid_lft_ = 3677;
+ lease->cltt_ = 123456;
+ lease->subnet_id_ = 73;
+ lease->fqdn_rev_ = true;
+ lease->fqdn_fwd_ = true;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress4_[2]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x2a);
+ lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 0x64)));
+ lease->valid_lft_ = 5412;
+ lease->cltt_ = 234567;
+ lease->subnet_id_ = 73; // Same as lease 1
+ lease->fqdn_rev_ = false;
+ lease->fqdn_fwd_ = false;
+ lease->hostname_ = "";
+
+ } else if (address == straddress4_[3]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x19); // Same as lease 1
+ lease->client_id_ = ClientIdPtr(
+ new ClientId(vector<uint8_t>(8, 0x75)));
+
+ // The times used in the next tests are deliberately restricted - we
+ // should be able to cope with valid lifetimes up to 0xffffffff.
+ // However, this will lead to overflows.
+ // @TODO: test overflow conditions when code has been fixed
+ lease->valid_lft_ = 7000;
+ lease->cltt_ = 234567;
+ lease->subnet_id_ = 37;
+ lease->fqdn_rev_ = true;
+ lease->fqdn_fwd_ = true;
+ lease->hostname_ = "otherhost.example.com.";
+
+ } else if (address == straddress4_[4]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x4c);
+ // Same ClientId as straddr4_[1]
+ lease->client_id_ = ClientIdPtr(
+ new ClientId(vector<uint8_t>(8, 0x53))); // Same as lease 1
+ lease->valid_lft_ = 7736;
+ lease->cltt_ = 222456;
+ lease->subnet_id_ = 85;
+ lease->fqdn_rev_ = true;
+ lease->fqdn_fwd_ = true;
+ lease->hostname_ = "otherhost.example.com.";
+
+ } else if (address == straddress4_[5]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x19); // Same as lease 1
+ // Same ClientId and IAID as straddress4_1
+ lease->client_id_ = ClientIdPtr(
+ new ClientId(vector<uint8_t>(8, 0x53))); // Same as lease 1
+ lease->valid_lft_ = 7832;
+ lease->cltt_ = 227476;
+ lease->subnet_id_ = 175;
+ lease->fqdn_rev_ = false;
+ lease->fqdn_fwd_ = false;
+ lease->hostname_ = "otherhost.example.com.";
+ } else if (address == straddress4_[6]) {
+ lease->hwaddr_ = vector<uint8_t>(6, 0x6e);
+ // Same ClientId as straddress4_1
+ lease->client_id_ = ClientIdPtr(
+ new ClientId(vector<uint8_t>(8, 0x53))); // Same as lease 1
+ lease->valid_lft_ = 1832;
+ lease->cltt_ = 627476;
+ lease->subnet_id_ = 112;
+ lease->fqdn_rev_ = false;
+ lease->fqdn_fwd_ = true;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress4_[7]) {
+ lease->hwaddr_ = vector<uint8_t>(); // Empty
+ lease->client_id_ = ClientIdPtr(); // Empty
+ lease->valid_lft_ = 7975;
+ lease->cltt_ = 213876;
+ lease->subnet_id_ = 19;
+ lease->fqdn_rev_ = true;
+ lease->fqdn_fwd_ = true;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else {
+ // Unknown address, return an empty pointer.
+ lease.reset();
+
+ }
+
+ return (lease);
+}
+
+Lease6Ptr
+GenericLeaseMgrTest::initializeLease6(std::string address) {
+ Lease6Ptr lease(new Lease6());
+
+ // Set the address of the lease
+ lease->addr_ = IOAddress(address);
+
+ // Initialize unused fields.
+ lease->t1_ = 0; // Not saved
+ lease->t2_ = 0; // Not saved
+ lease->fixed_ = false; // Unused
+ lease->comments_ = std::string(""); // Unused
+
+ // Set other parameters. For historical reasons, address 0 is not used.
+ if (address == straddress6_[0]) {
+ lease->type_ = leasetype6_[0];
+ lease->prefixlen_ = 4;
+ lease->iaid_ = 142;
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x77)));
+ lease->preferred_lft_ = 900;
+ lease->valid_lft_ = 8677;
+ lease->cltt_ = 168256;
+ lease->subnet_id_ = 23;
+ lease->fqdn_fwd_ = true;
+ lease->fqdn_rev_ = true;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress6_[1]) {
+ lease->type_ = leasetype6_[1];
+ lease->prefixlen_ = 0;
+ lease->iaid_ = 42;
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
+ lease->preferred_lft_ = 3600;
+ lease->valid_lft_ = 3677;
+ lease->cltt_ = 123456;
+ lease->subnet_id_ = 73;
+ lease->fqdn_fwd_ = false;
+ lease->fqdn_rev_ = true;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress6_[2]) {
+ lease->type_ = leasetype6_[2];
+ lease->prefixlen_ = 7;
+ lease->iaid_ = 89;
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x3a)));
+ lease->preferred_lft_ = 1800;
+ lease->valid_lft_ = 5412;
+ lease->cltt_ = 234567;
+ lease->subnet_id_ = 73; // Same as lease 1
+ lease->fqdn_fwd_ = false;
+ lease->fqdn_rev_ = false;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress6_[3]) {
+ lease->type_ = leasetype6_[3];
+ lease->prefixlen_ = 28;
+ lease->iaid_ = 0xfffffffe;
+ vector<uint8_t> duid;
+ for (uint8_t i = 31; i < 126; ++i) {
+ duid.push_back(i);
+ }
+ lease->duid_ = DuidPtr(new DUID(duid));
+
+ // The times used in the next tests are deliberately restricted - we
+ // should be able to cope with valid lifetimes up to 0xffffffff.
+ // However, this will lead to overflows.
+ // @TODO: test overflow conditions when code has been fixed
+ lease->preferred_lft_ = 7200;
+ lease->valid_lft_ = 7000;
+ lease->cltt_ = 234567;
+ lease->subnet_id_ = 37;
+ lease->fqdn_fwd_ = true;
+ lease->fqdn_rev_ = false;
+ lease->hostname_ = "myhost.example.com.";
+
+ } else if (address == straddress6_[4]) {
+ // Same DUID and IAID as straddress6_1
+ lease->type_ = leasetype6_[4];
+ lease->prefixlen_ = 15;
+ lease->iaid_ = 42;
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
+ lease->preferred_lft_ = 4800;
+ lease->valid_lft_ = 7736;
+ lease->cltt_ = 222456;
+ lease->subnet_id_ = 671;
+ lease->fqdn_fwd_ = true;
+ lease->fqdn_rev_ = true;
+ lease->hostname_ = "otherhost.example.com.";
+
+ } else if (address == straddress6_[5]) {
+ // Same DUID and IAID as straddress6_1
+ lease->type_ = leasetype6_[5];
+ lease->prefixlen_ = 24;
+ lease->iaid_ = 42; // Same as lease 4
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
+ // Same as lease 4
+ lease->preferred_lft_ = 5400;
+ lease->valid_lft_ = 7832;
+ lease->cltt_ = 227476;
+ lease->subnet_id_ = 175;
+ lease->fqdn_fwd_ = false;
+ lease->fqdn_rev_ = true;
+ lease->hostname_ = "hostname.example.com.";
+
+ } else if (address == straddress6_[6]) {
+ // Same DUID as straddress6_1
+ lease->type_ = leasetype6_[6];
+ lease->prefixlen_ = 24;
+ lease->iaid_ = 93;
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
+ // Same as lease 4
+ lease->preferred_lft_ = 5400;
+ lease->valid_lft_ = 1832;
+ lease->cltt_ = 627476;
+ lease->subnet_id_ = 112;
+ lease->fqdn_fwd_ = false;
+ lease->fqdn_rev_ = true;
+ lease->hostname_ = "hostname.example.com.";
+
+ } else if (address == straddress6_[7]) {
+ // Same IAID as straddress6_1
+ lease->type_ = leasetype6_[7];
+ lease->prefixlen_ = 24;
+ lease->iaid_ = 42;
+ lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0xe5)));
+ lease->preferred_lft_ = 5600;
+ lease->valid_lft_ = 7975;
+ lease->cltt_ = 213876;
+ lease->subnet_id_ = 19;
+ lease->fqdn_fwd_ = false;
+ lease->fqdn_rev_ = true;
+ lease->hostname_ = "hostname.example.com.";
+
+ } else {
+ // Unknown address, return an empty pointer.
+ lease.reset();
+
+ }
+
+ return (lease);
+}
+
+template <typename T>
+void GenericLeaseMgrTest::checkLeasesDifferent(const std::vector<T>& leases) const {
+
+ // Check they were created
+ for (int i = 0; i < leases.size(); ++i) {
+ ASSERT_TRUE(leases[i]);
+ }
+
+ // Check they are different
+ for (int i = 0; i < (leases.size() - 1); ++i) {
+ for (int j = (i + 1); j < leases.size(); ++j) {
+ stringstream s;
+ s << "Comparing leases " << i << " & " << j << " for equality";
+ SCOPED_TRACE(s.str());
+ EXPECT_TRUE(*leases[i] != *leases[j]);
+ }
+ }
+}
+
+vector<Lease4Ptr>
+GenericLeaseMgrTest::createLeases4() {
+
+ // Create leases for each address
+ vector<Lease4Ptr> leases;
+ for (int i = 0; i < straddress4_.size(); ++i) {
+ leases.push_back(initializeLease4(straddress4_[i]));
+ }
+ EXPECT_EQ(8, leases.size());
+
+ // Check all were created and that they are different.
+ checkLeasesDifferent(leases);
+
+ return (leases);
+}
+
+vector<Lease6Ptr>
+GenericLeaseMgrTest::createLeases6() {
+
+ // Create leases for each address
+ vector<Lease6Ptr> leases;
+ for (int i = 0; i < straddress6_.size(); ++i) {
+ leases.push_back(initializeLease6(straddress6_[i]));
+ }
+ EXPECT_EQ(8, leases.size());
+
+ // Check all were created and that they are different.
+ checkLeasesDifferent(leases);
+
+ return (leases);
+}
+
+void
+GenericLeaseMgrTest::testGetLease4ClientId() {
+ // Let's initialize a specific lease ...
+ Lease4Ptr lease = initializeLease4(straddress4_[1]);
+ EXPECT_TRUE(lmptr_->addLease(lease));
+ Lease4Collection returned = lmptr_->getLease4(*lease->client_id_);
+
+ ASSERT_EQ(1, returned.size());
+ // We should retrieve our lease...
+ detailCompareLease(lease, *returned.begin());
+ lease = initializeLease4(straddress4_[2]);
+ returned = lmptr_->getLease4(*lease->client_id_);
+
+ ASSERT_EQ(0, returned.size());
+}
+
+void
+GenericLeaseMgrTest::testGetLease4NullClientId() {
+ // Let's initialize a specific lease ... But this time
+ // We keep its client id for further lookup and
+ // We clearly 'reset' it ...
+ Lease4Ptr leaseA = initializeLease4(straddress4_[4]);
+ ClientIdPtr client_id = leaseA->client_id_;
+ leaseA->client_id_ = ClientIdPtr();
+ ASSERT_TRUE(lmptr_->addLease(leaseA));
+
+ Lease4Collection returned = lmptr_->getLease4(*client_id);
+ // Shouldn't have our previous lease ...
+ ASSERT_TRUE(returned.empty());
+
+ // Add another lease with the non-NULL client id, and make sure that the
+ // lookup will not break due to existence of both leases with non-NULL and
+ // NULL client ids.
+ Lease4Ptr leaseB = initializeLease4(straddress4_[0]);
+ // Shouldn't throw any null pointer exception
+ ASSERT_TRUE(lmptr_->addLease(leaseB));
+ // Try to get the lease.
+ returned = lmptr_->getLease4(*client_id);
+ ASSERT_TRUE(returned.empty());
+
+ // Let's make it more interesting and add another lease with NULL client id.
+ Lease4Ptr leaseC = initializeLease4(straddress4_[5]);
+ leaseC->client_id_.reset();
+ ASSERT_TRUE(lmptr_->addLease(leaseC));
+ returned = lmptr_->getLease4(*client_id);
+ ASSERT_TRUE(returned.empty());
+
+ // But getting the lease with non-NULL client id should be successful.
+ returned = lmptr_->getLease4(*leaseB->client_id_);
+ ASSERT_EQ(1, returned.size());
+}
+
+void
+GenericLeaseMgrTest::testLease4NullClientId() {
+ // Get the leases to be used for the test.
+ vector<Lease4Ptr> leases = createLeases4();
+
+ // Let's clear client-id pointers
+ leases[1]->client_id_ = ClientIdPtr();
+ leases[2]->client_id_ = ClientIdPtr();
+ leases[3]->client_id_ = ClientIdPtr();
+
+ // Start the tests. Add three leases to the database, read them back and
+ // check they are what we think they are.
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ EXPECT_TRUE(lmptr_->addLease(leases[2]));
+ EXPECT_TRUE(lmptr_->addLease(leases[3]));
+ lmptr_->commit();
+
+ // Reopen the database to ensure that they actually got stored.
+ reopen();
+
+ Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ l_returned = lmptr_->getLease4(ioaddress4_[2]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+
+ l_returned = lmptr_->getLease4(ioaddress4_[3]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[3], l_returned);
+
+ // Check that we can't add a second lease with the same address
+ EXPECT_FALSE(lmptr_->addLease(leases[1]));
+
+ // Check that we can get the lease by HWAddr
+ HWAddr tmp(leases[2]->hwaddr_, HTYPE_ETHER);
+ Lease4Collection returned = lmptr_->getLease4(tmp);
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[2], *returned.begin());
+
+ l_returned = lmptr_->getLease4(tmp, leases[2]->subnet_id_);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+
+ // Check that we can update the lease
+ // Modify some fields in lease 1 (not the address) and update it.
+ ++leases[1]->subnet_id_;
+ leases[1]->valid_lft_ *= 2;
+ lmptr_->updateLease4(leases[1]);
+
+ // ... and check that the lease is indeed updated
+ l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Delete a lease, check that it's gone, and that we can't delete it
+ // a second time.
+ EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
+ l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ EXPECT_FALSE(l_returned);
+ EXPECT_FALSE(lmptr_->deleteLease(ioaddress4_[1]));
+
+ // Check that the second address is still there.
+ l_returned = lmptr_->getLease4(ioaddress4_[2]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+}
+
+void
+GenericLeaseMgrTest::testGetLease4HWAddr1() {
+ // Let's initialize two different leases 4 and just add the first ...
+ Lease4Ptr leaseA = initializeLease4(straddress4_[5]);
+ HWAddr hwaddrA(leaseA->hwaddr_, HTYPE_ETHER);
+ HWAddr hwaddrB(vector<uint8_t>(6, 0x80), HTYPE_ETHER);
+
+ EXPECT_TRUE(lmptr_->addLease(leaseA));
+
+ // we should not have a lease, with this MAC Addr
+ Lease4Collection returned = lmptr_->getLease4(hwaddrB);
+ ASSERT_EQ(0, returned.size());
+
+ // But with this one
+ returned = lmptr_->getLease4(hwaddrA);
+ ASSERT_EQ(1, returned.size());
+}
+
+void
+GenericLeaseMgrTest::testGetLease4HWAddr2() {
+ // Get the leases to be used for the test and add to the database
+ vector<Lease4Ptr> leases = createLeases4();
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Get the leases matching the hardware address of lease 1
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ HWAddr tmp(leases[1]->hwaddr_, HTYPE_ETHER);
+ Lease4Collection returned = lmptr_->getLease4(tmp);
+
+ // Should be three leases, matching leases[1], [3] and [5].
+ ASSERT_EQ(3, returned.size());
+
+ // Easiest way to check is to look at the addresses.
+ vector<string> addresses;
+ for (Lease4Collection::const_iterator i = returned.begin();
+ i != returned.end(); ++i) {
+ addresses.push_back((*i)->addr_.toText());
+ }
+ sort(addresses.begin(), addresses.end());
+ EXPECT_EQ(straddress4_[1], addresses[0]);
+ EXPECT_EQ(straddress4_[3], addresses[1]);
+ EXPECT_EQ(straddress4_[5], addresses[2]);
+
+ // Repeat test with just one expected match
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ returned = lmptr_->getLease4(HWAddr(leases[2]->hwaddr_, HTYPE_ETHER));
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[2], *returned.begin());
+
+ // Check that an empty vector is valid
+ EXPECT_TRUE(leases[7]->hwaddr_.empty());
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ returned = lmptr_->getLease4(HWAddr(leases[7]->hwaddr_, HTYPE_ETHER));
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[7], *returned.begin());
+
+ // Try to get something with invalid hardware address
+ vector<uint8_t> invalid(6, 0);
+ returned = lmptr_->getLease4(invalid);
+ EXPECT_EQ(0, returned.size());
+}
+
+void
+GenericLeaseMgrTest::testGetLease4ClientIdHWAddrSubnetId() {
+ Lease4Ptr leaseA = initializeLease4(straddress4_[4]);
+ Lease4Ptr leaseB = initializeLease4(straddress4_[5]);
+ Lease4Ptr leaseC = initializeLease4(straddress4_[6]);
+ // Set NULL client id for one of the leases. This is to make sure that such
+ // a lease may coexist with other leases with non NULL client id.
+ leaseC->client_id_.reset();
+
+ HWAddr hwaddrA(leaseA->hwaddr_, HTYPE_ETHER);
+ HWAddr hwaddrB(leaseB->hwaddr_, HTYPE_ETHER);
+ HWAddr hwaddrC(leaseC->hwaddr_, HTYPE_ETHER);
+ EXPECT_TRUE(lmptr_->addLease(leaseA));
+ EXPECT_TRUE(lmptr_->addLease(leaseB));
+ EXPECT_TRUE(lmptr_->addLease(leaseC));
+ // First case we should retrieve our lease
+ Lease4Ptr lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrA, leaseA->subnet_id_);
+ detailCompareLease(lease, leaseA);
+ // Retrieve the other lease.
+ lease = lmptr_->getLease4(*leaseB->client_id_, hwaddrB, leaseB->subnet_id_);
+ detailCompareLease(lease, leaseB);
+ // The last lease has NULL client id so we will use a different getLease4 function
+ // which doesn't require client id (just a hwaddr and subnet id).
+ lease = lmptr_->getLease4(hwaddrC, leaseC->subnet_id_);
+ detailCompareLease(lease, leaseC);
+
+ // An attempt to retrieve the lease with non matching lease parameters should
+ // result in NULL pointer being returned.
+ lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrB, leaseA->subnet_id_);
+ EXPECT_FALSE(lease);
+ lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrA, leaseB->subnet_id_);
+ EXPECT_FALSE(lease);
+}
+
+void
+GenericLeaseMgrTest::testAddGetDelete6(bool check_t1_t2) {
+ IOAddress addr("2001:db8:1::456");
+
+ uint8_t llt[] = {0, 1, 2, 3, 4, 5, 6, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
+ DuidPtr duid(new DUID(llt, sizeof(llt)));
+
+ uint32_t iaid = 7; // just a number
+
+ SubnetID subnet_id = 8; // just another number
+
+ Lease6Ptr lease(new Lease6(Lease::TYPE_NA, addr, duid, iaid, 100, 200, 50,
+ 80, subnet_id));
+
+ EXPECT_TRUE(lmptr_->addLease(lease));
+
+ // should not be allowed to add a second lease with the same address
+ EXPECT_FALSE(lmptr_->addLease(lease));
+
+ Lease6Ptr x = lmptr_->getLease6(Lease::TYPE_NA,
+ IOAddress("2001:db8:1::234"));
+ EXPECT_EQ(Lease6Ptr(), x);
+
+ x = lmptr_->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::456"));
+ ASSERT_TRUE(x);
+
+ EXPECT_EQ(x->addr_, addr);
+ EXPECT_TRUE(*x->duid_ == *duid);
+ EXPECT_EQ(x->iaid_, iaid);
+ EXPECT_EQ(x->subnet_id_, subnet_id);
+
+ // These are not important from lease management perspective, but
+ // let's check them anyway.
+ EXPECT_EQ(Lease::TYPE_NA, x->type_);
+ EXPECT_EQ(100, x->preferred_lft_);
+ EXPECT_EQ(200, x->valid_lft_);
+ if (check_t1_t2) {
+ // Backend supports T1,T2 storage: check the values
+ EXPECT_EQ(50, x->t1_);
+ EXPECT_EQ(80, x->t2_);
+ } else {
+ // Backend does not support storing, check that it returns 0s.
+ EXPECT_EQ(0, x->t1_);
+ EXPECT_EQ(0, x->t2_);
+ }
+
+ // Test getLease6(duid, iaid, subnet_id) - positive case
+ Lease6Ptr y = lmptr_->getLease6(Lease::TYPE_NA, *duid, iaid, subnet_id);
+ ASSERT_TRUE(y);
+ EXPECT_TRUE(*y->duid_ == *duid);
+ EXPECT_EQ(y->iaid_, iaid);
+ EXPECT_EQ(y->addr_, addr);
+
+ // Test getLease6(duid, iaid, subnet_id) - wrong iaid
+ uint32_t invalid_iaid = 9; // no such iaid
+ y = lmptr_->getLease6(Lease::TYPE_NA, *duid, invalid_iaid, subnet_id);
+ EXPECT_FALSE(y);
+
+ uint32_t invalid_subnet_id = 999;
+ y = lmptr_->getLease6(Lease::TYPE_NA, *duid, iaid, invalid_subnet_id);
+ EXPECT_FALSE(y);
+
+ // truncated duid
+ DuidPtr invalid_duid(new DUID(llt, sizeof(llt) - 1));
+ y = lmptr_->getLease6(Lease::TYPE_NA, *invalid_duid, iaid, subnet_id);
+ EXPECT_FALSE(y);
+
+ // should return false - there's no such address
+ EXPECT_FALSE(lmptr_->deleteLease(IOAddress("2001:db8:1::789")));
+
+ // this one should succeed
+ EXPECT_TRUE(lmptr_->deleteLease(IOAddress("2001:db8:1::456")));
+
+ // after the lease is deleted, it should really be gone
+ x = lmptr_->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::456"));
+ EXPECT_EQ(Lease6Ptr(), x);
+}
+
+void
+GenericLeaseMgrTest::testBasicLease4() {
+ // Get the leases to be used for the test.
+ vector<Lease4Ptr> leases = createLeases4();
+
+ // Start the tests. Add three leases to the database, read them back and
+ // check they are what we think they are.
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ EXPECT_TRUE(lmptr_->addLease(leases[2]));
+ EXPECT_TRUE(lmptr_->addLease(leases[3]));
+ lmptr_->commit();
+
+ // Reopen the database to ensure that they actually got stored.
+ reopen();
+
+ Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ l_returned = lmptr_->getLease4(ioaddress4_[2]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+
+ l_returned = lmptr_->getLease4(ioaddress4_[3]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[3], l_returned);
+
+ // Check that we can't add a second lease with the same address
+ EXPECT_FALSE(lmptr_->addLease(leases[1]));
+
+ // Delete a lease, check that it's gone, and that we can't delete it
+ // a second time.
+ EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
+ l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ EXPECT_FALSE(l_returned);
+ EXPECT_FALSE(lmptr_->deleteLease(ioaddress4_[1]));
+
+ // Check that the second address is still there.
+ l_returned = lmptr_->getLease4(ioaddress4_[2]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+}
+
+
+void
+GenericLeaseMgrTest::testBasicLease6() {
+ // Get the leases to be used for the test.
+ vector<Lease6Ptr> leases = createLeases6();
+
+ // Start the tests. Add three leases to the database, read them back and
+ // check they are what we think they are.
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ EXPECT_TRUE(lmptr_->addLease(leases[2]));
+ EXPECT_TRUE(lmptr_->addLease(leases[3]));
+ lmptr_->commit();
+
+ // Reopen the database to ensure that they actually got stored.
+ reopen();
+
+ Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ l_returned = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+
+ l_returned = lmptr_->getLease6(leasetype6_[3], ioaddress6_[3]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[3], l_returned);
+
+ // Check that we can't add a second lease with the same address
+ EXPECT_FALSE(lmptr_->addLease(leases[1]));
+
+ // Delete a lease, check that it's gone, and that we can't delete it
+ // a second time.
+ EXPECT_TRUE(lmptr_->deleteLease(ioaddress6_[1]));
+ l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
+ EXPECT_FALSE(l_returned);
+ EXPECT_FALSE(lmptr_->deleteLease(ioaddress6_[1]));
+
+ // Check that the second address is still there.
+ l_returned = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[2], l_returned);
+}
+
+void
+GenericLeaseMgrTest::testLease4InvalidHostname() {
+ // Get the leases to be used for the test.
+ vector<Lease4Ptr> leases = createLeases4();
+
+ // Create a dummy hostname, consisting of 255 characters.
+ leases[1]->hostname_.assign(255, 'a');
+ ASSERT_TRUE(lmptr_->addLease(leases[1]));
+
+ // The new lease must be in the database.
+ Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ detailCompareLease(leases[1], l_returned);
+
+ // Let's delete the lease, so as we can try to add it again with
+ // invalid hostname.
+ EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
+
+ // Create a hostname with 256 characters. It should not be accepted.
+ leases[1]->hostname_.assign(256, 'a');
+ EXPECT_THROW(lmptr_->addLease(leases[1]), DbOperationError);
+}
+
+/// @brief Verify that too long hostname for Lease6 is not accepted.
+void
+GenericLeaseMgrTest::testLease6InvalidHostname() {
+ // Get the leases to be used for the test.
+ vector<Lease6Ptr> leases = createLeases6();
+
+ // Create a dummy hostname, consisting of 255 characters.
+ leases[1]->hostname_.assign(255, 'a');
+ ASSERT_TRUE(lmptr_->addLease(leases[1]));
+
+ // The new lease must be in the database.
+ Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
+ detailCompareLease(leases[1], l_returned);
+
+ // Let's delete the lease, so as we can try to add it again with
+ // invalid hostname.
+ EXPECT_TRUE(lmptr_->deleteLease(ioaddress6_[1]));
+
+ // Create a hostname with 256 characters. It should not be accepted.
+ leases[1]->hostname_.assign(256, 'a');
+ EXPECT_THROW(lmptr_->addLease(leases[1]), DbOperationError);
+}
+
+void
+GenericLeaseMgrTest::testGetLease4HWAddrSize() {
+ // Create leases, although we need only one.
+ vector<Lease4Ptr> leases = createLeases4();
+
+ // Now add leases with increasing hardware address size.
+ for (uint8_t i = 0; i <= HWAddr::MAX_HWADDR_LEN; ++i) {
+ leases[1]->hwaddr_.resize(i, i);
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ Lease4Collection returned =
+ lmptr_->getLease4(HWAddr(leases[1]->hwaddr_, HTYPE_ETHER));
+
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[1], *returned.begin());
+ (void) lmptr_->deleteLease(leases[1]->addr_);
+ }
+
+ // Database should not let us add one that is too big
+ // (The 42 is a random value put in each byte of the address.)
+ /// @todo: 2589 will make this test impossible
+ leases[1]->hwaddr_.resize(HWAddr::MAX_HWADDR_LEN + 100, 42);
+ EXPECT_THROW(lmptr_->addLease(leases[1]), isc::dhcp::DbOperationError);
+}
+
+void
+GenericLeaseMgrTest::testGetLease4HWAddrSubnetId() {
+ // Get the leases to be used for the test and add to the database
+ vector<Lease4Ptr> leases = createLeases4();
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Get the leases matching the hardware address of lease 1 and
+ // subnet ID of lease 1. Result should be a single lease - lease 1.
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ Lease4Ptr returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
+ HTYPE_ETHER), leases[1]->subnet_id_);
+
+ ASSERT_TRUE(returned);
+ detailCompareLease(leases[1], returned);
+
+ // Try for a match to the hardware address of lease 1 and the wrong
+ // subnet ID.
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_, HTYPE_ETHER),
+ leases[1]->subnet_id_ + 1);
+ EXPECT_FALSE(returned);
+
+ // Try for a match to the subnet ID of lease 1 (and lease 4) but
+ // the wrong hardware address.
+ vector<uint8_t> invalid_hwaddr(15, 0x77);
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ returned = lmptr_->getLease4(HWAddr(invalid_hwaddr, HTYPE_ETHER),
+ leases[1]->subnet_id_);
+ EXPECT_FALSE(returned);
+
+ // Try for a match to an unknown hardware address and an unknown
+ // subnet ID.
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ returned = lmptr_->getLease4(HWAddr(invalid_hwaddr, HTYPE_ETHER),
+ leases[1]->subnet_id_ + 1);
+ EXPECT_FALSE(returned);
+
+ // Add a second lease with the same values as the first and check that
+ // an attempt to access the database by these parameters throws a
+ // "multiple records" exception. (We expect there to be only one record
+ // with that combination, so getting them via getLeaseX() (as opposed
+ // to getLeaseXCollection() should throw an exception.)
+ EXPECT_TRUE(lmptr_->deleteLease(leases[2]->addr_));
+ leases[1]->addr_ = leases[2]->addr_;
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ EXPECT_THROW(returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
+ HTYPE_ETHER),
+ leases[1]->subnet_id_),
+ isc::dhcp::MultipleRecords);
+
+
+}
+
+void
+GenericLeaseMgrTest::testGetLease4HWAddrSubnetIdSize() {
+ // Create leases, although we need only one.
+ vector<Lease4Ptr> leases = createLeases4();
+
+ // Now add leases with increasing hardware address size and check
+ // that they can be retrieved.
+ for (uint8_t i = 0; i <= HWAddr::MAX_HWADDR_LEN; ++i) {
+ leases[1]->hwaddr_.resize(i, i);
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ /// @todo: Simply use HWAddr directly once 2589 is implemented
+ Lease4Ptr returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
+ HTYPE_ETHER),
+ leases[1]->subnet_id_);
+ ASSERT_TRUE(returned);
+ detailCompareLease(leases[1], returned);
+ (void) lmptr_->deleteLease(leases[1]->addr_);
+ }
+
+ // Database should not let us add one that is too big
+ // (The 42 is a random value put in each byte of the address.)
+ leases[1]->hwaddr_.resize(HWAddr::MAX_HWADDR_LEN + 100, 42);
+ EXPECT_THROW(lmptr_->addLease(leases[1]), isc::dhcp::DbOperationError);
+}
+
+void
+GenericLeaseMgrTest::testGetLease4ClientId2() {
+ // Get the leases to be used for the test and add to the database
+ vector<Lease4Ptr> leases = createLeases4();
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Get the leases matching the Client ID address of lease 1
+ Lease4Collection returned = lmptr_->getLease4(*leases[1]->client_id_);
+
+ // Should be four leases, matching leases[1], [4], [5] and [6].
+ ASSERT_EQ(4, returned.size());
+
+ // Easiest way to check is to look at the addresses.
+ vector<string> addresses;
+ for (Lease4Collection::const_iterator i = returned.begin();
+ i != returned.end(); ++i) {
+ addresses.push_back((*i)->addr_.toText());
+ }
+ sort(addresses.begin(), addresses.end());
+ EXPECT_EQ(straddress4_[1], addresses[0]);
+ EXPECT_EQ(straddress4_[4], addresses[1]);
+ EXPECT_EQ(straddress4_[5], addresses[2]);
+ EXPECT_EQ(straddress4_[6], addresses[3]);
+
+ // Repeat test with just one expected match
+ returned = lmptr_->getLease4(*leases[3]->client_id_);
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[3], *returned.begin());
+
+ // Check that client-id is NULL
+ EXPECT_FALSE(leases[7]->client_id_);
+ HWAddr tmp(leases[7]->hwaddr_, HTYPE_ETHER);
+ returned = lmptr_->getLease4(tmp);
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[7], *returned.begin());
+
+ // Try to get something with invalid client ID
+ const uint8_t invalid_data[] = {0, 0, 0};
+ ClientId invalid(invalid_data, sizeof(invalid_data));
+ returned = lmptr_->getLease4(invalid);
+ EXPECT_EQ(0, returned.size());
+}
+
+void
+GenericLeaseMgrTest::testGetLease4ClientIdSize() {
+ // Create leases, although we need only one.
+ vector<Lease4Ptr> leases = createLeases4();
+
+ // Now add leases with increasing Client ID size can be retrieved.
+ // For speed, go from 0 to 128 is steps of 16.
+ // Intermediate client_id_max is to overcome problem if
+ // ClientId::MAX_CLIENT_ID_LEN is used in an EXPECT_EQ.
+ int client_id_max = ClientId::MAX_CLIENT_ID_LEN;
+ EXPECT_EQ(128, client_id_max);
+
+ int client_id_min = ClientId::MIN_CLIENT_ID_LEN;
+ EXPECT_EQ(2, client_id_min); // See RFC2132, section 9.14
+
+ for (uint8_t i = client_id_min; i <= client_id_max; i += 16) {
+ vector<uint8_t> clientid_vec(i, i);
+ leases[1]->client_id_.reset(new ClientId(clientid_vec));
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ Lease4Collection returned = lmptr_->getLease4(*leases[1]->client_id_);
+ ASSERT_TRUE(returned.size() == 1);
+ detailCompareLease(leases[1], *returned.begin());
+ (void) lmptr_->deleteLease(leases[1]->addr_);
+ }
+
+ // Don't bother to check client IDs longer than the maximum -
+ // these cannot be constructed, and that limitation is tested
+ // in the DUID/Client ID unit tests.
+}
+
+void
+GenericLeaseMgrTest::testGetLease4ClientIdSubnetId() {
+ // Get the leases to be used for the test and add to the database
+ vector<Lease4Ptr> leases = createLeases4();
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Get the leases matching the client ID of lease 1 and
+ // subnet ID of lease 1. Result should be a single lease - lease 1.
+ Lease4Ptr returned = lmptr_->getLease4(*leases[1]->client_id_,
+ leases[1]->subnet_id_);
+ ASSERT_TRUE(returned);
+ detailCompareLease(leases[1], returned);
+
+ // Try for a match to the client ID of lease 1 and the wrong
+ // subnet ID.
+ returned = lmptr_->getLease4(*leases[1]->client_id_,
+ leases[1]->subnet_id_ + 1);
+ EXPECT_FALSE(returned);
+
+ // Try for a match to the subnet ID of lease 1 (and lease 4) but
+ // the wrong client ID
+ const uint8_t invalid_data[] = {0, 0, 0};
+ ClientId invalid(invalid_data, sizeof(invalid_data));
+ returned = lmptr_->getLease4(invalid, leases[1]->subnet_id_);
+ EXPECT_FALSE(returned);
+
+ // Try for a match to an unknown hardware address and an unknown
+ // subnet ID.
+ returned = lmptr_->getLease4(invalid, leases[1]->subnet_id_ + 1);
+ EXPECT_FALSE(returned);
+}
+
+void
+GenericLeaseMgrTest::testGetLeases6DuidIaid() {
+ // Get the leases to be used for the test.
+ vector<Lease6Ptr> leases = createLeases6();
+ ASSERT_LE(6, leases.size()); // Expect to access leases 0 through 5
+
+ // Add them to the database
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Get the leases matching the DUID and IAID of lease[1].
+ Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
+ *leases[1]->duid_,
+ leases[1]->iaid_);
+
+ // Should be two leases, matching leases[1] and [4].
+ ASSERT_EQ(2, returned.size());
+
+ // Easiest way to check is to look at the addresses.
+ vector<string> addresses;
+ for (Lease6Collection::const_iterator i = returned.begin();
+ i != returned.end(); ++i) {
+ addresses.push_back((*i)->addr_.toText());
+ }
+ sort(addresses.begin(), addresses.end());
+ EXPECT_EQ(straddress6_[1], addresses[0]);
+ EXPECT_EQ(straddress6_[4], addresses[1]);
+
+ // Check that nothing is returned when either the IAID or DUID match
+ // nothing.
+ returned = lmptr_->getLeases6(leasetype6_[1], *leases[1]->duid_,
+ leases[1]->iaid_ + 1);
+ EXPECT_EQ(0, returned.size());
+
+ // Alter the leases[1] DUID to match nothing in the database.
+ vector<uint8_t> duid_vector = leases[1]->duid_->getDuid();
+ ++duid_vector[0];
+ DUID new_duid(duid_vector);
+ returned = lmptr_->getLeases6(leasetype6_[1], new_duid, leases[1]->iaid_);
+ EXPECT_EQ(0, returned.size());
+}
+
+void
+GenericLeaseMgrTest::testGetLeases6DuidSize() {
+ // Create leases, although we need only one.
+ vector<Lease6Ptr> leases = createLeases6();
+
+ // Now add leases with increasing DUID size can be retrieved.
+ // For speed, go from 0 to 128 is steps of 16.
+ int duid_max = DUID::MAX_DUID_LEN;
+ EXPECT_EQ(128, duid_max);
+
+ int duid_min = DUID::MIN_DUID_LEN;
+ EXPECT_EQ(1, duid_min);
+
+ for (uint8_t i = duid_min; i <= duid_max; i += 16) {
+ vector<uint8_t> duid_vec(i, i);
+ leases[1]->duid_.reset(new DUID(duid_vec));
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
+ *leases[1]->duid_,
+ leases[1]->iaid_);
+ ASSERT_EQ(1, returned.size());
+ detailCompareLease(leases[1], *returned.begin());
+ (void) lmptr_->deleteLease(leases[1]->addr_);
+ }
+
+ // Don't bother to check DUIDs longer than the maximum - these cannot be
+ // constructed, and that limitation is tested in the DUID/Client ID unit
+ // tests.
+
+}
+
+void
+GenericLeaseMgrTest::testLease6LeaseTypeCheck() {
+ Lease6Ptr empty_lease(new Lease6());
+
+ DuidPtr duid(new DUID(vector<uint8_t>(8, 0x77)));
+
+ // Initialize unused fields.
+ empty_lease->t1_ = 0; // Not saved
+ empty_lease->t2_ = 0; // Not saved
+ empty_lease->fixed_ = false; // Unused
+ empty_lease->comments_ = std::string(""); // Unused
+ empty_lease->iaid_ = 142;
+ empty_lease->duid_ = DuidPtr(new DUID(*duid));
+ empty_lease->subnet_id_ = 23;
+ empty_lease->preferred_lft_ = 100;
+ empty_lease->valid_lft_ = 100;
+ empty_lease->cltt_ = 100;
+ empty_lease->fqdn_fwd_ = true;
+ empty_lease->fqdn_rev_ = true;
+ empty_lease->hostname_ = "myhost.example.com.";
+ empty_lease->prefixlen_ = 4;
+
+ // Make Two leases per lease type, all with the same DUID, IAID but
+ // alternate the subnet_ids.
+ vector<Lease6Ptr> leases;
+ for (int i = 0; i < 6; ++i) {
+ Lease6Ptr lease(new Lease6(*empty_lease));
+ lease->type_ = leasetype6_[i / 2];
+ lease->addr_ = IOAddress(straddress6_[i]);
+ lease->subnet_id_ += (i % 2);
+ leases.push_back(lease);
+ EXPECT_TRUE(lmptr_->addLease(lease));
+ }
+
+ // Verify getting a single lease by type and address.
+ for (int i = 0; i < 6; ++i) {
+ // Look for exact match for each lease type.
+ Lease6Ptr returned = lmptr_->getLease6(leasetype6_[i / 2],
+ leases[i]->addr_);
+ // We should match one per lease type.
+ ASSERT_TRUE(returned);
+ EXPECT_TRUE(*returned == *leases[i]);
+
+ // Same address but wrong lease type, should not match.
+ returned = lmptr_->getLease6(leasetype6_[i / 2 + 1], leases[i]->addr_);
+ ASSERT_FALSE(returned);
+ }
+
+ // Verify getting a collection of leases by type, DUID, and IAID.
+ // Iterate over the lease types, asking for leases based on
+ // lease type, DUID, and IAID.
+ for (int i = 0; i < 3; ++i) {
+ Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i],
+ *duid, 142);
+ // We should match two per lease type.
+ ASSERT_EQ(2, returned.size());
+
+ // Collection order returned is not guaranteed.
+ // Easiest way to check is to look at the addresses.
+ vector<string> addresses;
+ for (Lease6Collection::const_iterator it = returned.begin();
+ it != returned.end(); ++it) {
+ addresses.push_back((*it)->addr_.toText());
+ }
+ sort(addresses.begin(), addresses.end());
+
+ // Now verify that the lease addresses match.
+ EXPECT_EQ(addresses[0], leases[(i * 2)]->addr_.toText());
+ EXPECT_EQ(addresses[1], leases[(i * 2 + 1)]->addr_.toText());
+ }
+
+ // Verify getting a collection of leases by type, DUID, IAID, and subnet id.
+ // Iterate over the lease types, asking for leases based on
+ // lease type, DUID, IAID, and subnet_id.
+ for (int i = 0; i < 3; ++i) {
+ Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i],
+ *duid, 142, 23);
+ // We should match one per lease type.
+ ASSERT_EQ(1, returned.size());
+ EXPECT_TRUE(*(returned[0]) == *leases[i * 2]);
+ }
+
+ // Verify getting a single lease by type, duid, iad, and subnet id.
+ for (int i = 0; i < 6; ++i) {
+ Lease6Ptr returned = lmptr_->getLease6(leasetype6_[i / 2],
+ *duid, 142, (23 + (i % 2)));
+ // We should match one per lease type.
+ ASSERT_TRUE(returned);
+ EXPECT_TRUE(*returned == *leases[i]);
+ }
+}
+
+void
+GenericLeaseMgrTest::testGetLease6DuidIaidSubnetId() {
+ // Get the leases to be used for the test and add them to the database.
+ vector<Lease6Ptr> leases = createLeases6();
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Get the leases matching the DUID and IAID of lease[1].
+ Lease6Ptr returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
+ leases[1]->iaid_,
+ leases[1]->subnet_id_);
+ ASSERT_TRUE(returned);
+ EXPECT_TRUE(*returned == *leases[1]);
+
+ // Modify each of the three parameters (DUID, IAID, Subnet ID) and
+ // check that nothing is returned.
+ returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
+ leases[1]->iaid_ + 1, leases[1]->subnet_id_);
+ EXPECT_FALSE(returned);
+
+ returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
+ leases[1]->iaid_, leases[1]->subnet_id_ + 1);
+ EXPECT_FALSE(returned);
+
+ // Alter the leases[1] DUID to match nothing in the database.
+ vector<uint8_t> duid_vector = leases[1]->duid_->getDuid();
+ ++duid_vector[0];
+ DUID new_duid(duid_vector);
+ returned = lmptr_->getLease6(leasetype6_[1], new_duid, leases[1]->iaid_,
+ leases[1]->subnet_id_);
+ EXPECT_FALSE(returned);
+}
+
+/// @brief Checks that getLease6() works with different DUID sizes
+void
+GenericLeaseMgrTest::testGetLease6DuidIaidSubnetIdSize() {
+
+ // Create leases, although we need only one.
+ vector<Lease6Ptr> leases = createLeases6();
+
+ // Now add leases with increasing DUID size can be retrieved.
+ // For speed, go from 0 to 128 is steps of 16.
+ int duid_max = DUID::MAX_DUID_LEN;
+ EXPECT_EQ(128, duid_max);
+
+ int duid_min = DUID::MIN_DUID_LEN;
+ EXPECT_EQ(1, duid_min);
+
+ for (uint8_t i = duid_min; i <= duid_max; i += 16) {
+ vector<uint8_t> duid_vec(i, i);
+ leases[1]->duid_.reset(new DUID(duid_vec));
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ Lease6Ptr returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
+ leases[1]->iaid_,
+ leases[1]->subnet_id_);
+ ASSERT_TRUE(returned);
+ detailCompareLease(leases[1], returned);
+ (void) lmptr_->deleteLease(leases[1]->addr_);
+ }
+
+ // Don't bother to check DUIDs longer than the maximum - these cannot be
+ // constructed, and that limitation is tested in the DUID/Client ID unit
+ // tests.
+}
+
+void
+GenericLeaseMgrTest::testUpdateLease4() {
+ // Get the leases to be used for the test and add them to the database.
+ vector<Lease4Ptr> leases = createLeases4();
+ for (int i = 0; i < leases.size(); ++i) {
+ EXPECT_TRUE(lmptr_->addLease(leases[i]));
+ }
+
+ // Modify some fields in lease 1 (not the address) and update it.
+ ++leases[1]->subnet_id_;
+ leases[1]->valid_lft_ *= 2;
+ leases[1]->hostname_ = "modified.hostname.";
+ leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_;
+ leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;;
+ lmptr_->updateLease4(leases[1]);
+
+ // ... and check what is returned is what is expected.
+ Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Alter the lease again and check.
+ ++leases[1]->subnet_id_;
+ leases[1]->cltt_ += 6;
+ lmptr_->updateLease4(leases[1]);
+
+ // Explicitly clear the returned pointer before getting new data to ensure
+ // that the new data is returned.
+ l_returned.reset();
+ l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Check we can do an update without changing data.
+ lmptr_->updateLease4(leases[1]);
+ l_returned.reset();
+ l_returned = lmptr_->getLease4(ioaddress4_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Try to update the lease with the too long hostname.
+ leases[1]->hostname_.assign(256, 'a');
+ EXPECT_THROW(lmptr_->updateLease4(leases[1]), isc::dhcp::DbOperationError);
+
+ // Try updating a lease not in the database.
+ lmptr_->deleteLease(ioaddress4_[2]);
+ EXPECT_THROW(lmptr_->updateLease4(leases[2]), isc::dhcp::NoSuchLease);
+}
+
+void
+GenericLeaseMgrTest::testUpdateLease6() {
+ // Get the leases to be used for the test.
+ vector<Lease6Ptr> leases = createLeases6();
+ ASSERT_LE(3, leases.size()); // Expect to access leases 0 through 2
+
+ // Add a lease to the database and check that the lease is there.
+ EXPECT_TRUE(lmptr_->addLease(leases[1]));
+ lmptr_->commit();
+
+ Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Modify some fields in lease 1 (not the address) and update it.
+ ++leases[1]->iaid_;
+ leases[1]->type_ = Lease::TYPE_PD;
+ leases[1]->valid_lft_ *= 2;
+ leases[1]->hostname_ = "modified.hostname.v6.";
+ leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_;
+ leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;;
+ lmptr_->updateLease6(leases[1]);
+ lmptr_->commit();
+
+ // ... and check what is returned is what is expected.
+ l_returned.reset();
+ l_returned = lmptr_->getLease6(Lease::TYPE_PD, ioaddress6_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Alter the lease again and check.
+ ++leases[1]->iaid_;
+ leases[1]->type_ = Lease::TYPE_TA;
+ leases[1]->cltt_ += 6;
+ leases[1]->prefixlen_ = 93;
+ lmptr_->updateLease6(leases[1]);
+
+ l_returned.reset();
+ l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Check we can do an update without changing data.
+ lmptr_->updateLease6(leases[1]);
+ l_returned.reset();
+ l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]);
+ ASSERT_TRUE(l_returned);
+ detailCompareLease(leases[1], l_returned);
+
+ // Try to update the lease with the too long hostname.
+ leases[1]->hostname_.assign(256, 'a');
+ EXPECT_THROW(lmptr_->updateLease6(leases[1]), isc::dhcp::DbOperationError);
+
+ // Try updating a lease not in the database.
+ EXPECT_THROW(lmptr_->updateLease6(leases[2]), isc::dhcp::NoSuchLease);
+}
+
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc
diff --git a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h
new file mode 100644
index 0000000..03ccbe2
--- /dev/null
+++ b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h
@@ -0,0 +1,249 @@
+// Copyright (C) 2014 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef GENERIC_LEASE_MGR_UNITTEST_H
+#define GENERIC_LEASE_MGR_UNITTEST_H
+
+#include <dhcpsrv/lease_mgr.h>
+#include <gtest/gtest.h>
+#include <vector>
+
+namespace isc {
+namespace dhcp {
+namespace test {
+
+/// @brief Test Fixture class with utility functions for LeaseMgr backends
+///
+/// It contains utility functions, like dummy lease creation.
+/// All concrete LeaseMgr test classes should be derived from it.
+class GenericLeaseMgrTest : public ::testing::Test {
+public:
+
+ /// @brief Default constructor.
+ GenericLeaseMgrTest();
+
+ /// @brief Virtual destructor.
+ virtual ~GenericLeaseMgrTest();
+
+ /// @brief Reopen the database
+ ///
+ /// Closes the database and re-opens it. It must be implemented
+ /// in derived classes.
+ virtual void reopen() = 0;
+
+ /// @brief Initialize Lease4 Fields
+ ///
+ /// Returns a pointer to a Lease4 structure. Different values are put into
+ /// the lease according to the address passed.
+ ///
+ /// This is just a convenience function for the test methods.
+ ///
+ /// @param address Address to use for the initialization
+ ///
+ /// @return Lease4Ptr. This will not point to anything if the
+ /// initialization failed (e.g. unknown address).
+ Lease4Ptr initializeLease4(std::string address);
+
+ /// @brief Initialize Lease6 Fields
+ ///
+ /// Returns a pointer to a Lease6 structure. Different values are put into
+ /// the lease according to the address passed.
+ ///
+ /// This is just a convenience function for the test methods.
+ ///
+ /// @param address Address to use for the initialization
+ ///
+ /// @return Lease6Ptr. This will not point to anything if the initialization
+ /// failed (e.g. unknown address).
+ Lease6Ptr initializeLease6(std::string address);
+
+ /// @brief Check Leases present and different
+ ///
+ /// Checks a vector of lease pointers and ensures that all the leases
+ /// they point to are present and different. If not, a GTest assertion
+ /// will fail.
+ ///
+ /// @param leases Vector of pointers to leases
+ /// @tparam Type of the leases held in the vector: @c Lease4 or
+ /// @c Lease6.
+ template <typename T>
+ void checkLeasesDifferent(const std::vector<T>& leases) const;
+
+ /// @brief Creates leases for the test
+ ///
+ /// Creates all leases for the test and checks that they are different.
+ ///
+ /// @return vector<Lease4Ptr> Vector of pointers to leases
+ std::vector<Lease4Ptr> createLeases4();
+
+ /// @brief Creates leases for the test
+ ///
+ /// Creates all leases for the test and checks that they are different.
+ ///
+ /// @return vector<Lease6Ptr> Vector of pointers to leases
+ std::vector<Lease6Ptr> createLeases6();
+
+ /// @brief checks that addLease, getLease4(addr) and deleteLease() works
+ void testBasicLease4();
+
+ /// @brief Test lease retrieval using client id.
+ void testGetLease4ClientId();
+
+ /// @brief Test lease retrieval when leases with NULL client id are present.
+ void testGetLease4NullClientId();
+
+ /// @brief Test lease retrieval using HW address.
+ void testGetLease4HWAddr1();
+
+ /// @brief Check GetLease4 methods - access by Hardware Address
+ ///
+ /// Adds leases to the database and checks that they can be accessed using
+ /// HWAddr information.
+ void testGetLease4HWAddr2();
+
+ /// @brief Test lease retrieval using client id, HW address and subnet id.
+ void testGetLease4ClientIdHWAddrSubnetId();
+
+ // @brief Get lease4 by hardware address (2)
+ //
+ // Check that the system can cope with getting a hardware address of
+ // any size.
+ void testGetLease4HWAddrSize();
+
+ /// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID
+ ///
+ /// Adds leases to the database and checks that they can be accessed via
+ /// a combination of hardware address and subnet ID
+ void testGetLease4HWAddrSubnetId();
+
+ /// @brief Get lease4 by hardware address and subnet ID (2)
+ ///
+ /// Check that the system can cope with getting a hardware address of
+ /// any size.
+ void testGetLease4HWAddrSubnetIdSize();
+
+ /// @brief Check GetLease4 methods - access by Client ID
+ ///
+ /// Adds leases to the database and checks that they can be accessed via
+ /// the Client ID.
+ void testGetLease4ClientId2();
+
+ /// @brief Get Lease4 by client ID (2)
+ ///
+ /// Check that the system can cope with a client ID of any size.
+ void testGetLease4ClientIdSize();
+
+ /// @brief Check GetLease4 methods - access by Client ID & Subnet ID
+ ///
+ /// Adds leases to the database and checks that they can be accessed via
+ /// a combination of client and subnet IDs.
+ void testGetLease4ClientIdSubnetId();
+
+ /// @brief Basic Lease4 Checks
+ ///
+ /// Checks that the addLease, getLease4(by address), getLease4(hwaddr,subnet_id),
+ /// updateLease4() and deleteLease (IPv4 address) can handle NULL client-id.
+ /// (client-id is optional and may not be present)
+ ///
+ /// @todo: check if it does overlap with @ref testGetLease4NullClientId()
+ void testLease4NullClientId();
+
+ /// @brief Basic Lease6 Checks
+ ///
+ /// Checks that the addLease, getLease6 (by address) and deleteLease (with an
+ /// IPv6 address) works.
+ void testBasicLease6();
+
+ /// @brief Test that IPv6 lease can be added, retrieved and deleted.
+ ///
+ /// This method checks basic IPv6 lease operations. There's check_t1_t2
+ /// parameter that controls whether the backend supports storing T1, T2
+ /// parameters. memfile supports it, while MySQL doesn't. If T1,T2
+ /// storage is not supported, the expected values are 0.
+ ///
+ /// @param check_t1_t2 controls whether T1,T2 timers should be checked
+ void testAddGetDelete6(bool check_t1_t2);
+
+ /// @brief Check GetLease6 methods - access by DUID/IAID
+ ///
+ /// Adds leases to the database and checks that they can be accessed via
+ /// a combination of DUID and IAID.
+ void testGetLeases6DuidIaid();
+
+ /// @brief Check that the system can cope with a DUID of allowed size.
+ void testGetLeases6DuidSize();
+
+ /// @brief Check that getLease6 methods discriminate by lease type.
+ ///
+ /// Adds six leases, two per lease type all with the same duid and iad but
+ /// with alternating subnet_ids.
+ /// It then verifies that all of getLeases6() method variants correctly
+ /// discriminate between the leases based on lease type alone.
+ void testLease6LeaseTypeCheck();
+
+ /// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID
+ ///
+ /// Adds leases to the database and checks that they can be accessed via
+ /// a combination of DIUID and IAID.
+ void testGetLease6DuidIaidSubnetId();
+
+ /// @brief Checks that getLease6() works with different DUID sizes
+ void testGetLease6DuidIaidSubnetIdSize();
+
+ /// @brief Verify that too long hostname for Lease4 is not accepted.
+ ///
+ /// Checks that the it is not possible to create a lease when the hostname
+ /// length exceeds 255 characters.
+ void testLease4InvalidHostname();
+
+ /// @brief Verify that too long hostname for Lease6 is not accepted.
+ ///
+ /// Checks that the it is not possible to create a lease when the hostname
+ /// length exceeds 255 characters.
+ void testLease6InvalidHostname();
+
+ /// @brief Lease4 update test
+ ///
+ /// Checks that the code is able to update an IPv4 lease in the database.
+ void testUpdateLease4();
+
+ /// @brief Lease6 update test
+ ///
+ /// Checks that the code is able to update an IPv6 lease in the database.
+ void testUpdateLease6();
+
+ /// @brief String forms of IPv4 addresses
+ std::vector<std::string> straddress4_;
+
+ /// @brief IOAddress forms of IPv4 addresses
+ std::vector<isc::asiolink::IOAddress> ioaddress4_;
+
+ /// @brief String forms of IPv6 addresses
+ std::vector<std::string> straddress6_;
+
+ /// @brief Types of IPv6 Leases
+ std::vector<Lease::Type> leasetype6_;
+
+ /// @brief IOAddress forms of IPv6 addresses
+ std::vector<isc::asiolink::IOAddress> ioaddress6_;
+
+ /// @brief Pointer to the lease manager
+ LeaseMgr* lmptr_;
+};
+
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc
+
+#endif
diff --git a/src/lib/dhcpsrv/tests/lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/lease_mgr_unittest.cc
index 7e7fee2..0037bc9 100644
--- a/src/lib/dhcpsrv/tests/lease_mgr_unittest.cc
+++ b/src/lib/dhcpsrv/tests/lease_mgr_unittest.cc
@@ -18,6 +18,7 @@
#include <dhcpsrv/lease_mgr.h>
#include <dhcpsrv/memfile_lease_mgr.h>
#include <dhcpsrv/tests/test_utils.h>
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
#include <gtest/gtest.h>
diff --git a/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc
index 2650c7f..1b2001e 100644
--- a/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc
+++ b/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc
@@ -19,6 +19,7 @@
#include <dhcpsrv/lease_mgr.h>
#include <dhcpsrv/memfile_lease_mgr.h>
#include <dhcpsrv/tests/test_utils.h>
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
#include <gtest/gtest.h>
#include <iostream>
@@ -75,7 +76,9 @@ TEST_F(MemfileLeaseMgrTest, getTypeAndName) {
// Checks that adding/getting/deleting a Lease6 object works.
TEST_F(MemfileLeaseMgrTest, addGetDelete6) {
- testAddGetDelete6(true);
+ testAddGetDelete6(true); // true - check T1,T2 values
+ // memfile is able to preserve those values, but some other
+ // backends can't do that.
}
/// @brief Basic Lease4 Checks
@@ -146,7 +149,7 @@ TEST_F(MemfileLeaseMgrTest, getLease4ClientId2) {
testGetLease4ClientId2();
}
-// @brief Get Lease4 by client ID (2)
+// @brief Get Lease4 by client ID
//
// Check that the system can cope with a client ID of any size.
TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSize) {
@@ -165,11 +168,16 @@ TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSubnetId) {
///
/// Adds leases to the database and checks that they can be accessed via
/// a combination of DUID and IAID.
+/// @todo: test disabled, because Memfile_LeaseMgr::getLeases6(Lease::Type,
+/// const DUID& duid, uint32_t iaid) const is not implemented yet.
TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidIaid) {
testGetLeases6DuidIaid();
}
// Check that the system can cope with a DUID of allowed size.
+
+/// @todo: test disabled, because Memfile_LeaseMgr::getLeases6(Lease::Type,
+/// const DUID& duid, uint32_t iaid) const is not implemented yet.
TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidSize) {
testGetLeases6DuidSize();
}
@@ -180,6 +188,8 @@ TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidSize) {
/// with alternating subnet_ids.
/// It then verifies that all of getLeases6() method variants correctly
/// discriminate between the leases based on lease type alone.
+/// @todo: Disabled, because type parameter in Memfile_LeaseMgr::getLease6
+/// (Lease::Type, const isc::asiolink::IOAddress& addr) const is not used.
TEST_F(MemfileLeaseMgrTest, DISABLED_lease6LeaseTypeCheck) {
testLease6LeaseTypeCheck();
}
@@ -192,6 +202,8 @@ TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetId) {
testGetLease6DuidIaidSubnetId();
}
+/// Checks that getLease6(type, duid, iaid, subnet-id) works with different
+/// DUID sizes
TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetIdSize) {
testGetLease6DuidIaidSubnetIdSize();
}
@@ -199,6 +211,9 @@ TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetIdSize) {
/// @brief Lease4 update tests
///
/// Checks that we are able to update a lease in the database.
+/// @todo: Disabled, because memfile does not throw when lease is updated.
+/// We should reconsider if lease{4,6} structures should have a limit
+/// implemented in them.
TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease4) {
testUpdateLease4();
}
@@ -206,6 +221,9 @@ TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease4) {
/// @brief Lease6 update tests
///
/// Checks that we are able to update a lease in the database.
+/// @todo: Disabled, because memfile does not throw when lease is updated.
+/// We should reconsider if lease{4,6} structures should have a limit
+/// implemented in them.
TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease6) {
testUpdateLease6();
}
diff --git a/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc
index c7d0b9a..7f1e972 100644
--- a/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc
+++ b/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc
@@ -18,9 +18,9 @@
#include <dhcpsrv/lease_mgr_factory.h>
#include <dhcpsrv/mysql_lease_mgr.h>
#include <dhcpsrv/tests/test_utils.h>
+#include <dhcpsrv/tests/generic_lease_mgr_unittest.h>
#include <exceptions/exceptions.h>
-
#include <gtest/gtest.h>
#include <algorithm>
diff --git a/src/lib/dhcpsrv/tests/test_utils.cc b/src/lib/dhcpsrv/tests/test_utils.cc
index 66d6c49..b9bd0cc 100644
--- a/src/lib/dhcpsrv/tests/test_utils.cc
+++ b/src/lib/dhcpsrv/tests/test_utils.cc
@@ -24,24 +24,6 @@ namespace isc {
namespace dhcp {
namespace test {
-// IPv4 and IPv6 addresses used in the tests
-const char* ADDRESS4[] = {
- "192.0.2.0", "192.0.2.1", "192.0.2.2", "192.0.2.3",
- "192.0.2.4", "192.0.2.5", "192.0.2.6", "192.0.2.7",
- NULL
-};
-const char* ADDRESS6[] = {
- "2001:db8::0", "2001:db8::1", "2001:db8::2", "2001:db8::3",
- "2001:db8::4", "2001:db8::5", "2001:db8::6", "2001:db8::7",
- NULL
-};
-
-// Lease types that correspond to ADDRESS6 leases
-static const Lease::Type LEASETYPE6[] = {
- Lease::TYPE_NA, Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA,
- Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA, Lease::TYPE_TA
-};
-
void
detailCompareLease(const Lease4Ptr& first, const Lease4Ptr& second) {
// Compare address strings. Comparison of address objects is not used, as
@@ -98,1325 +80,6 @@ detailCompareLease(const Lease6Ptr& first, const Lease6Ptr& second) {
EXPECT_EQ(first->hostname_, second->hostname_);
}
-GenericLeaseMgrTest::GenericLeaseMgrTest()
- : lmptr_(NULL) {
- // Initialize address strings and IOAddresses
- for (int i = 0; ADDRESS4[i] != NULL; ++i) {
- string addr(ADDRESS4[i]);
- straddress4_.push_back(addr);
- IOAddress ioaddr(addr);
- ioaddress4_.push_back(ioaddr);
- }
-
- for (int i = 0; ADDRESS6[i] != NULL; ++i) {
- string addr(ADDRESS6[i]);
- straddress6_.push_back(addr);
- IOAddress ioaddr(addr);
- ioaddress6_.push_back(ioaddr);
-
- /// Let's create different lease types. We use LEASETYPE6 values as
- /// a template
- leasetype6_.push_back(LEASETYPE6[i]);
- }
-}
-
-GenericLeaseMgrTest::~GenericLeaseMgrTest() {
- // Does nothing. The derived classes are expected to clean up, i.e.
- // remove the lmptr_ pointer.
-}
-
-Lease4Ptr
-GenericLeaseMgrTest::initializeLease4(std::string address) {
- Lease4Ptr lease(new Lease4());
-
- // Set the address of the lease
- lease->addr_ = IOAddress(address);
-
- // Initialize unused fields.
- lease->ext_ = 0; // Not saved
- lease->t1_ = 0; // Not saved
- lease->t2_ = 0; // Not saved
- lease->fixed_ = false; // Unused
- lease->comments_ = std::string(""); // Unused
-
- // Set other parameters. For historical reasons, address 0 is not used.
- if (address == straddress4_[0]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x08);
- lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 0x42)));
- lease->valid_lft_ = 8677;
- lease->cltt_ = 168256;
- lease->subnet_id_ = 23;
- lease->fqdn_rev_ = true;
- lease->fqdn_fwd_ = false;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress4_[1]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x19);
- lease->client_id_ = ClientIdPtr(
- new ClientId(vector<uint8_t>(8, 0x53)));
- lease->valid_lft_ = 3677;
- lease->cltt_ = 123456;
- lease->subnet_id_ = 73;
- lease->fqdn_rev_ = true;
- lease->fqdn_fwd_ = true;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress4_[2]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x2a);
- lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 0x64)));
- lease->valid_lft_ = 5412;
- lease->cltt_ = 234567;
- lease->subnet_id_ = 73; // Same as lease 1
- lease->fqdn_rev_ = false;
- lease->fqdn_fwd_ = false;
- lease->hostname_ = "";
-
- } else if (address == straddress4_[3]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x19); // Same as lease 1
- lease->client_id_ = ClientIdPtr(
- new ClientId(vector<uint8_t>(8, 0x75)));
-
- // The times used in the next tests are deliberately restricted - we
- // should be able to cope with valid lifetimes up to 0xffffffff.
- // However, this will lead to overflows.
- // @TODO: test overflow conditions when code has been fixed
- lease->valid_lft_ = 7000;
- lease->cltt_ = 234567;
- lease->subnet_id_ = 37;
- lease->fqdn_rev_ = true;
- lease->fqdn_fwd_ = true;
- lease->hostname_ = "otherhost.example.com.";
-
- } else if (address == straddress4_[4]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x4c);
- // Same ClientId as straddr4_[1]
- lease->client_id_ = ClientIdPtr(
- new ClientId(vector<uint8_t>(8, 0x53))); // Same as lease 1
- lease->valid_lft_ = 7736;
- lease->cltt_ = 222456;
- lease->subnet_id_ = 85;
- lease->fqdn_rev_ = true;
- lease->fqdn_fwd_ = true;
- lease->hostname_ = "otherhost.example.com.";
-
- } else if (address == straddress4_[5]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x19); // Same as lease 1
- // Same ClientId and IAID as straddress4_1
- lease->client_id_ = ClientIdPtr(
- new ClientId(vector<uint8_t>(8, 0x53))); // Same as lease 1
- lease->valid_lft_ = 7832;
- lease->cltt_ = 227476;
- lease->subnet_id_ = 175;
- lease->fqdn_rev_ = false;
- lease->fqdn_fwd_ = false;
- lease->hostname_ = "otherhost.example.com.";
- } else if (address == straddress4_[6]) {
- lease->hwaddr_ = vector<uint8_t>(6, 0x6e);
- // Same ClientId as straddress4_1
- lease->client_id_ = ClientIdPtr(
- new ClientId(vector<uint8_t>(8, 0x53))); // Same as lease 1
- lease->valid_lft_ = 1832;
- lease->cltt_ = 627476;
- lease->subnet_id_ = 112;
- lease->fqdn_rev_ = false;
- lease->fqdn_fwd_ = true;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress4_[7]) {
- lease->hwaddr_ = vector<uint8_t>(); // Empty
- lease->client_id_ = ClientIdPtr(); // Empty
- lease->valid_lft_ = 7975;
- lease->cltt_ = 213876;
- lease->subnet_id_ = 19;
- lease->fqdn_rev_ = true;
- lease->fqdn_fwd_ = true;
- lease->hostname_ = "myhost.example.com.";
-
- } else {
- // Unknown address, return an empty pointer.
- lease.reset();
-
- }
-
- return (lease);
-}
-
-Lease6Ptr
-GenericLeaseMgrTest::initializeLease6(std::string address) {
- Lease6Ptr lease(new Lease6());
-
- // Set the address of the lease
- lease->addr_ = IOAddress(address);
-
- // Initialize unused fields.
- lease->t1_ = 0; // Not saved
- lease->t2_ = 0; // Not saved
- lease->fixed_ = false; // Unused
- lease->comments_ = std::string(""); // Unused
-
- // Set other parameters. For historical reasons, address 0 is not used.
- if (address == straddress6_[0]) {
- lease->type_ = leasetype6_[0];
- lease->prefixlen_ = 4;
- lease->iaid_ = 142;
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x77)));
- lease->preferred_lft_ = 900;
- lease->valid_lft_ = 8677;
- lease->cltt_ = 168256;
- lease->subnet_id_ = 23;
- lease->fqdn_fwd_ = true;
- lease->fqdn_rev_ = true;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress6_[1]) {
- lease->type_ = leasetype6_[1];
- lease->prefixlen_ = 0;
- lease->iaid_ = 42;
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
- lease->preferred_lft_ = 3600;
- lease->valid_lft_ = 3677;
- lease->cltt_ = 123456;
- lease->subnet_id_ = 73;
- lease->fqdn_fwd_ = false;
- lease->fqdn_rev_ = true;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress6_[2]) {
- lease->type_ = leasetype6_[2];
- lease->prefixlen_ = 7;
- lease->iaid_ = 89;
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x3a)));
- lease->preferred_lft_ = 1800;
- lease->valid_lft_ = 5412;
- lease->cltt_ = 234567;
- lease->subnet_id_ = 73; // Same as lease 1
- lease->fqdn_fwd_ = false;
- lease->fqdn_rev_ = false;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress6_[3]) {
- lease->type_ = leasetype6_[3];
- lease->prefixlen_ = 28;
- lease->iaid_ = 0xfffffffe;
- vector<uint8_t> duid;
- for (uint8_t i = 31; i < 126; ++i) {
- duid.push_back(i);
- }
- lease->duid_ = DuidPtr(new DUID(duid));
-
- // The times used in the next tests are deliberately restricted - we
- // should be able to cope with valid lifetimes up to 0xffffffff.
- // However, this will lead to overflows.
- // @TODO: test overflow conditions when code has been fixed
- lease->preferred_lft_ = 7200;
- lease->valid_lft_ = 7000;
- lease->cltt_ = 234567;
- lease->subnet_id_ = 37;
- lease->fqdn_fwd_ = true;
- lease->fqdn_rev_ = false;
- lease->hostname_ = "myhost.example.com.";
-
- } else if (address == straddress6_[4]) {
- // Same DUID and IAID as straddress6_1
- lease->type_ = leasetype6_[4];
- lease->prefixlen_ = 15;
- lease->iaid_ = 42;
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
- lease->preferred_lft_ = 4800;
- lease->valid_lft_ = 7736;
- lease->cltt_ = 222456;
- lease->subnet_id_ = 671;
- lease->fqdn_fwd_ = true;
- lease->fqdn_rev_ = true;
- lease->hostname_ = "otherhost.example.com.";
-
- } else if (address == straddress6_[5]) {
- // Same DUID and IAID as straddress6_1
- lease->type_ = leasetype6_[5];
- lease->prefixlen_ = 24;
- lease->iaid_ = 42; // Same as lease 4
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
- // Same as lease 4
- lease->preferred_lft_ = 5400;
- lease->valid_lft_ = 7832;
- lease->cltt_ = 227476;
- lease->subnet_id_ = 175;
- lease->fqdn_fwd_ = false;
- lease->fqdn_rev_ = true;
- lease->hostname_ = "hostname.example.com.";
-
- } else if (address == straddress6_[6]) {
- // Same DUID as straddress6_1
- lease->type_ = leasetype6_[6];
- lease->prefixlen_ = 24;
- lease->iaid_ = 93;
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0x42)));
- // Same as lease 4
- lease->preferred_lft_ = 5400;
- lease->valid_lft_ = 1832;
- lease->cltt_ = 627476;
- lease->subnet_id_ = 112;
- lease->fqdn_fwd_ = false;
- lease->fqdn_rev_ = true;
- lease->hostname_ = "hostname.example.com.";
-
- } else if (address == straddress6_[7]) {
- // Same IAID as straddress6_1
- lease->type_ = leasetype6_[7];
- lease->prefixlen_ = 24;
- lease->iaid_ = 42;
- lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, 0xe5)));
- lease->preferred_lft_ = 5600;
- lease->valid_lft_ = 7975;
- lease->cltt_ = 213876;
- lease->subnet_id_ = 19;
- lease->fqdn_fwd_ = false;
- lease->fqdn_rev_ = true;
- lease->hostname_ = "hostname.example.com.";
-
- } else {
- // Unknown address, return an empty pointer.
- lease.reset();
-
- }
-
- return (lease);
-}
-
-template <typename T>
-void GenericLeaseMgrTest::checkLeasesDifferent(const std::vector<T>& leases) const {
-
- // Check they were created
- for (int i = 0; i < leases.size(); ++i) {
- ASSERT_TRUE(leases[i]);
- }
-
- // Check they are different
- for (int i = 0; i < (leases.size() - 1); ++i) {
- for (int j = (i + 1); j < leases.size(); ++j) {
- stringstream s;
- s << "Comparing leases " << i << " & " << j << " for equality";
- SCOPED_TRACE(s.str());
- EXPECT_TRUE(*leases[i] != *leases[j]);
- }
- }
-}
-
-vector<Lease4Ptr>
-GenericLeaseMgrTest::createLeases4() {
-
- // Create leases for each address
- vector<Lease4Ptr> leases;
- for (int i = 0; i < straddress4_.size(); ++i) {
- leases.push_back(initializeLease4(straddress4_[i]));
- }
- EXPECT_EQ(8, leases.size());
-
- // Check all were created and that they are different.
- checkLeasesDifferent(leases);
-
- return (leases);
-}
-
-vector<Lease6Ptr>
-GenericLeaseMgrTest::createLeases6() {
-
- // Create leases for each address
- vector<Lease6Ptr> leases;
- for (int i = 0; i < straddress6_.size(); ++i) {
- leases.push_back(initializeLease6(straddress6_[i]));
- }
- EXPECT_EQ(8, leases.size());
-
- // Check all were created and that they are different.
- checkLeasesDifferent(leases);
-
- return (leases);
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientId() {
- // Let's initialize a specific lease ...
- Lease4Ptr lease = initializeLease4(straddress4_[1]);
- EXPECT_TRUE(lmptr_->addLease(lease));
- Lease4Collection returned = lmptr_->getLease4(*lease->client_id_);
-
- ASSERT_EQ(1, returned.size());
- // We should retrieve our lease...
- detailCompareLease(lease, *returned.begin());
- lease = initializeLease4(straddress4_[2]);
- returned = lmptr_->getLease4(*lease->client_id_);
-
- ASSERT_EQ(0, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4NullClientId() {
- // Let's initialize a specific lease ... But this time
- // We keep its client id for further lookup and
- // We clearly 'reset' it ...
- Lease4Ptr leaseA = initializeLease4(straddress4_[4]);
- ClientIdPtr client_id = leaseA->client_id_;
- leaseA->client_id_ = ClientIdPtr();
- ASSERT_TRUE(lmptr_->addLease(leaseA));
-
- Lease4Collection returned = lmptr_->getLease4(*client_id);
- // Shouldn't have our previous lease ...
- ASSERT_TRUE(returned.empty());
-
- // Add another lease with the non-NULL client id, and make sure that the
- // lookup will not break due to existence of both leases with non-NULL and
- // NULL client ids.
- Lease4Ptr leaseB = initializeLease4(straddress4_[0]);
- // Shouldn't throw any null pointer exception
- ASSERT_TRUE(lmptr_->addLease(leaseB));
- // Try to get the lease.
- returned = lmptr_->getLease4(*client_id);
- ASSERT_TRUE(returned.empty());
-
- // Let's make it more interesting and add another lease with NULL client id.
- Lease4Ptr leaseC = initializeLease4(straddress4_[5]);
- leaseC->client_id_.reset();
- ASSERT_TRUE(lmptr_->addLease(leaseC));
- returned = lmptr_->getLease4(*client_id);
- ASSERT_TRUE(returned.empty());
-
- // But getting the lease with non-NULL client id should be successful.
- returned = lmptr_->getLease4(*leaseB->client_id_);
- ASSERT_EQ(1, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testLease4NullClientId() {
- // Get the leases to be used for the test.
- vector<Lease4Ptr> leases = createLeases4();
-
- // Let's clear client-id pointers
- leases[1]->client_id_ = ClientIdPtr();
- leases[2]->client_id_ = ClientIdPtr();
- leases[3]->client_id_ = ClientIdPtr();
-
- // Start the tests. Add three leases to the database, read them back and
- // check they are what we think they are.
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- EXPECT_TRUE(lmptr_->addLease(leases[2]));
- EXPECT_TRUE(lmptr_->addLease(leases[3]));
- lmptr_->commit();
-
- // Reopen the database to ensure that they actually got stored.
- reopen();
-
- Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- l_returned = lmptr_->getLease4(ioaddress4_[2]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-
- l_returned = lmptr_->getLease4(ioaddress4_[3]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[3], l_returned);
-
- // Check that we can't add a second lease with the same address
- EXPECT_FALSE(lmptr_->addLease(leases[1]));
-
- // Check that we can get the lease by HWAddr
- HWAddr tmp(leases[2]->hwaddr_, HTYPE_ETHER);
- Lease4Collection returned = lmptr_->getLease4(tmp);
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[2], *returned.begin());
-
- l_returned = lmptr_->getLease4(tmp, leases[2]->subnet_id_);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-
- // Check that we can update the lease
- // Modify some fields in lease 1 (not the address) and update it.
- ++leases[1]->subnet_id_;
- leases[1]->valid_lft_ *= 2;
- lmptr_->updateLease4(leases[1]);
-
- // ... and check that the lease is indeed updated
- l_returned = lmptr_->getLease4(ioaddress4_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Delete a lease, check that it's gone, and that we can't delete it
- // a second time.
- EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
- l_returned = lmptr_->getLease4(ioaddress4_[1]);
- EXPECT_FALSE(l_returned);
- EXPECT_FALSE(lmptr_->deleteLease(ioaddress4_[1]));
-
- // Check that the second address is still there.
- l_returned = lmptr_->getLease4(ioaddress4_[2]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-}
-
-void
-GenericLeaseMgrTest::testGetLease4HWAddr1() {
- // Let's initialize two different leases 4 and just add the first ...
- Lease4Ptr leaseA = initializeLease4(straddress4_[5]);
- HWAddr hwaddrA(leaseA->hwaddr_, HTYPE_ETHER);
- HWAddr hwaddrB(vector<uint8_t>(6, 0x80), HTYPE_ETHER);
-
- EXPECT_TRUE(lmptr_->addLease(leaseA));
-
- // we should not have a lease, with this MAC Addr
- Lease4Collection returned = lmptr_->getLease4(hwaddrB);
- ASSERT_EQ(0, returned.size());
-
- // But with this one
- returned = lmptr_->getLease4(hwaddrA);
- ASSERT_EQ(1, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4HWAddr2() {
- // Get the leases to be used for the test and add to the database
- vector<Lease4Ptr> leases = createLeases4();
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Get the leases matching the hardware address of lease 1
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- HWAddr tmp(leases[1]->hwaddr_, HTYPE_ETHER);
- Lease4Collection returned = lmptr_->getLease4(tmp);
-
- // Should be three leases, matching leases[1], [3] and [5].
- ASSERT_EQ(3, returned.size());
-
- // Easiest way to check is to look at the addresses.
- vector<string> addresses;
- for (Lease4Collection::const_iterator i = returned.begin();
- i != returned.end(); ++i) {
- addresses.push_back((*i)->addr_.toText());
- }
- sort(addresses.begin(), addresses.end());
- EXPECT_EQ(straddress4_[1], addresses[0]);
- EXPECT_EQ(straddress4_[3], addresses[1]);
- EXPECT_EQ(straddress4_[5], addresses[2]);
-
- // Repeat test with just one expected match
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- returned = lmptr_->getLease4(HWAddr(leases[2]->hwaddr_, HTYPE_ETHER));
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[2], *returned.begin());
-
- // Check that an empty vector is valid
- EXPECT_TRUE(leases[7]->hwaddr_.empty());
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- returned = lmptr_->getLease4(HWAddr(leases[7]->hwaddr_, HTYPE_ETHER));
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[7], *returned.begin());
-
- // Try to get something with invalid hardware address
- vector<uint8_t> invalid(6, 0);
- returned = lmptr_->getLease4(invalid);
- EXPECT_EQ(0, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientIdHWAddrSubnetId() {
- Lease4Ptr leaseA = initializeLease4(straddress4_[4]);
- Lease4Ptr leaseB = initializeLease4(straddress4_[5]);
- Lease4Ptr leaseC = initializeLease4(straddress4_[6]);
- // Set NULL client id for one of the leases. This is to make sure that such
- // a lease may coexist with other leases with non NULL client id.
- leaseC->client_id_.reset();
-
- HWAddr hwaddrA(leaseA->hwaddr_, HTYPE_ETHER);
- HWAddr hwaddrB(leaseB->hwaddr_, HTYPE_ETHER);
- HWAddr hwaddrC(leaseC->hwaddr_, HTYPE_ETHER);
- EXPECT_TRUE(lmptr_->addLease(leaseA));
- EXPECT_TRUE(lmptr_->addLease(leaseB));
- EXPECT_TRUE(lmptr_->addLease(leaseC));
- // First case we should retrieve our lease
- Lease4Ptr lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrA, leaseA->subnet_id_);
- detailCompareLease(lease, leaseA);
- // Retrieve the other lease.
- lease = lmptr_->getLease4(*leaseB->client_id_, hwaddrB, leaseB->subnet_id_);
- detailCompareLease(lease, leaseB);
- // The last lease has NULL client id so we will use a different getLease4 function
- // which doesn't require client id (just a hwaddr and subnet id).
- lease = lmptr_->getLease4(hwaddrC, leaseC->subnet_id_);
- detailCompareLease(lease, leaseC);
-
- // An attempt to retrieve the lease with non matching lease parameters should
- // result in NULL pointer being returned.
- lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrB, leaseA->subnet_id_);
- EXPECT_FALSE(lease);
- lease = lmptr_->getLease4(*leaseA->client_id_, hwaddrA, leaseB->subnet_id_);
- EXPECT_FALSE(lease);
-}
-
-void
-GenericLeaseMgrTest::testAddGetDelete6(bool check_t1_t2) {
- IOAddress addr("2001:db8:1::456");
-
- uint8_t llt[] = {0, 1, 2, 3, 4, 5, 6, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
- DuidPtr duid(new DUID(llt, sizeof(llt)));
-
- uint32_t iaid = 7; // just a number
-
- SubnetID subnet_id = 8; // just another number
-
- Lease6Ptr lease(new Lease6(Lease::TYPE_NA, addr, duid, iaid, 100, 200, 50,
- 80, subnet_id));
-
- EXPECT_TRUE(lmptr_->addLease(lease));
-
- // should not be allowed to add a second lease with the same address
- EXPECT_FALSE(lmptr_->addLease(lease));
-
- Lease6Ptr x = lmptr_->getLease6(Lease::TYPE_NA,
- IOAddress("2001:db8:1::234"));
- EXPECT_EQ(Lease6Ptr(), x);
-
- x = lmptr_->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::456"));
- ASSERT_TRUE(x);
-
- EXPECT_EQ(x->addr_, addr);
- EXPECT_TRUE(*x->duid_ == *duid);
- EXPECT_EQ(x->iaid_, iaid);
- EXPECT_EQ(x->subnet_id_, subnet_id);
-
- // These are not important from lease management perspective, but
- // let's check them anyway.
- EXPECT_EQ(Lease::TYPE_NA, x->type_);
- EXPECT_EQ(100, x->preferred_lft_);
- EXPECT_EQ(200, x->valid_lft_);
- if (check_t1_t2) {
- // Backend supports T1,T2 storage: check the values
- EXPECT_EQ(50, x->t1_);
- EXPECT_EQ(80, x->t2_);
- } else {
- // Backend does not support storing, check that it returns 0s.
- EXPECT_EQ(0, x->t1_);
- EXPECT_EQ(0, x->t2_);
- }
-
- // Test getLease6(duid, iaid, subnet_id) - positive case
- Lease6Ptr y = lmptr_->getLease6(Lease::TYPE_NA, *duid, iaid, subnet_id);
- ASSERT_TRUE(y);
- EXPECT_TRUE(*y->duid_ == *duid);
- EXPECT_EQ(y->iaid_, iaid);
- EXPECT_EQ(y->addr_, addr);
-
- // Test getLease6(duid, iaid, subnet_id) - wrong iaid
- uint32_t invalid_iaid = 9; // no such iaid
- y = lmptr_->getLease6(Lease::TYPE_NA, *duid, invalid_iaid, subnet_id);
- EXPECT_FALSE(y);
-
- uint32_t invalid_subnet_id = 999;
- y = lmptr_->getLease6(Lease::TYPE_NA, *duid, iaid, invalid_subnet_id);
- EXPECT_FALSE(y);
-
- // truncated duid
- DuidPtr invalid_duid(new DUID(llt, sizeof(llt) - 1));
- y = lmptr_->getLease6(Lease::TYPE_NA, *invalid_duid, iaid, subnet_id);
- EXPECT_FALSE(y);
-
- // should return false - there's no such address
- EXPECT_FALSE(lmptr_->deleteLease(IOAddress("2001:db8:1::789")));
-
- // this one should succeed
- EXPECT_TRUE(lmptr_->deleteLease(IOAddress("2001:db8:1::456")));
-
- // after the lease is deleted, it should really be gone
- x = lmptr_->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::456"));
- EXPECT_EQ(Lease6Ptr(), x);
-}
-
-void
-GenericLeaseMgrTest::testBasicLease4() {
- // Get the leases to be used for the test.
- vector<Lease4Ptr> leases = createLeases4();
-
- // Start the tests. Add three leases to the database, read them back and
- // check they are what we think they are.
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- EXPECT_TRUE(lmptr_->addLease(leases[2]));
- EXPECT_TRUE(lmptr_->addLease(leases[3]));
- lmptr_->commit();
-
- // Reopen the database to ensure that they actually got stored.
- reopen();
-
- Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- l_returned = lmptr_->getLease4(ioaddress4_[2]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-
- l_returned = lmptr_->getLease4(ioaddress4_[3]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[3], l_returned);
-
- // Check that we can't add a second lease with the same address
- EXPECT_FALSE(lmptr_->addLease(leases[1]));
-
- // Delete a lease, check that it's gone, and that we can't delete it
- // a second time.
- EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
- l_returned = lmptr_->getLease4(ioaddress4_[1]);
- EXPECT_FALSE(l_returned);
- EXPECT_FALSE(lmptr_->deleteLease(ioaddress4_[1]));
-
- // Check that the second address is still there.
- l_returned = lmptr_->getLease4(ioaddress4_[2]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-}
-
-
-void
-GenericLeaseMgrTest::testBasicLease6() {
- // Get the leases to be used for the test.
- vector<Lease6Ptr> leases = createLeases6();
-
- // Start the tests. Add three leases to the database, read them back and
- // check they are what we think they are.
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- EXPECT_TRUE(lmptr_->addLease(leases[2]));
- EXPECT_TRUE(lmptr_->addLease(leases[3]));
- lmptr_->commit();
-
- // Reopen the database to ensure that they actually got stored.
- reopen();
-
- Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- l_returned = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-
- l_returned = lmptr_->getLease6(leasetype6_[3], ioaddress6_[3]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[3], l_returned);
-
- // Check that we can't add a second lease with the same address
- EXPECT_FALSE(lmptr_->addLease(leases[1]));
-
- // Delete a lease, check that it's gone, and that we can't delete it
- // a second time.
- EXPECT_TRUE(lmptr_->deleteLease(ioaddress6_[1]));
- l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
- EXPECT_FALSE(l_returned);
- EXPECT_FALSE(lmptr_->deleteLease(ioaddress6_[1]));
-
- // Check that the second address is still there.
- l_returned = lmptr_->getLease6(leasetype6_[2], ioaddress6_[2]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[2], l_returned);
-}
-
-void
-GenericLeaseMgrTest::testLease4InvalidHostname() {
- // Get the leases to be used for the test.
- vector<Lease4Ptr> leases = createLeases4();
-
- // Create a dummy hostname, consisting of 255 characters.
- leases[1]->hostname_.assign(255, 'a');
- ASSERT_TRUE(lmptr_->addLease(leases[1]));
-
- // The new lease must be in the database.
- Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
- detailCompareLease(leases[1], l_returned);
-
- // Let's delete the lease, so as we can try to add it again with
- // invalid hostname.
- EXPECT_TRUE(lmptr_->deleteLease(ioaddress4_[1]));
-
- // Create a hostname with 256 characters. It should not be accepted.
- leases[1]->hostname_.assign(256, 'a');
- EXPECT_THROW(lmptr_->addLease(leases[1]), DbOperationError);
-}
-
-/// @brief Verify that too long hostname for Lease6 is not accepted.
-void
-GenericLeaseMgrTest::testLease6InvalidHostname() {
- // Get the leases to be used for the test.
- vector<Lease6Ptr> leases = createLeases6();
-
- // Create a dummy hostname, consisting of 255 characters.
- leases[1]->hostname_.assign(255, 'a');
- ASSERT_TRUE(lmptr_->addLease(leases[1]));
-
- // The new lease must be in the database.
- Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
- detailCompareLease(leases[1], l_returned);
-
- // Let's delete the lease, so as we can try to add it again with
- // invalid hostname.
- EXPECT_TRUE(lmptr_->deleteLease(ioaddress6_[1]));
-
- // Create a hostname with 256 characters. It should not be accepted.
- leases[1]->hostname_.assign(256, 'a');
- EXPECT_THROW(lmptr_->addLease(leases[1]), DbOperationError);
-}
-
-void
-GenericLeaseMgrTest::testGetLease4HWAddrSize() {
- // Create leases, although we need only one.
- vector<Lease4Ptr> leases = createLeases4();
-
- // Now add leases with increasing hardware address size.
- for (uint8_t i = 0; i <= HWAddr::MAX_HWADDR_LEN; ++i) {
- leases[1]->hwaddr_.resize(i, i);
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- Lease4Collection returned =
- lmptr_->getLease4(HWAddr(leases[1]->hwaddr_, HTYPE_ETHER));
-
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[1], *returned.begin());
- (void) lmptr_->deleteLease(leases[1]->addr_);
- }
-
- // Database should not let us add one that is too big
- // (The 42 is a random value put in each byte of the address.)
- /// @todo: 2589 will make this test impossible
- leases[1]->hwaddr_.resize(HWAddr::MAX_HWADDR_LEN + 100, 42);
- EXPECT_THROW(lmptr_->addLease(leases[1]), isc::dhcp::DbOperationError);
-}
-
-void
-GenericLeaseMgrTest::testGetLease4HWAddrSubnetId() {
- // Get the leases to be used for the test and add to the database
- vector<Lease4Ptr> leases = createLeases4();
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Get the leases matching the hardware address of lease 1 and
- // subnet ID of lease 1. Result should be a single lease - lease 1.
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- Lease4Ptr returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
- HTYPE_ETHER), leases[1]->subnet_id_);
-
- ASSERT_TRUE(returned);
- detailCompareLease(leases[1], returned);
-
- // Try for a match to the hardware address of lease 1 and the wrong
- // subnet ID.
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_, HTYPE_ETHER),
- leases[1]->subnet_id_ + 1);
- EXPECT_FALSE(returned);
-
- // Try for a match to the subnet ID of lease 1 (and lease 4) but
- // the wrong hardware address.
- vector<uint8_t> invalid_hwaddr(15, 0x77);
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- returned = lmptr_->getLease4(HWAddr(invalid_hwaddr, HTYPE_ETHER),
- leases[1]->subnet_id_);
- EXPECT_FALSE(returned);
-
- // Try for a match to an unknown hardware address and an unknown
- // subnet ID.
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- returned = lmptr_->getLease4(HWAddr(invalid_hwaddr, HTYPE_ETHER),
- leases[1]->subnet_id_ + 1);
- EXPECT_FALSE(returned);
-
- // Add a second lease with the same values as the first and check that
- // an attempt to access the database by these parameters throws a
- // "multiple records" exception. (We expect there to be only one record
- // with that combination, so getting them via getLeaseX() (as opposed
- // to getLeaseXCollection() should throw an exception.)
- EXPECT_TRUE(lmptr_->deleteLease(leases[2]->addr_));
- leases[1]->addr_ = leases[2]->addr_;
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- EXPECT_THROW(returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
- HTYPE_ETHER),
- leases[1]->subnet_id_),
- isc::dhcp::MultipleRecords);
-
-
-}
-
-void
-GenericLeaseMgrTest::testGetLease4HWAddrSubnetIdSize() {
- // Create leases, although we need only one.
- vector<Lease4Ptr> leases = createLeases4();
-
- // Now add leases with increasing hardware address size and check
- // that they can be retrieved.
- for (uint8_t i = 0; i <= HWAddr::MAX_HWADDR_LEN; ++i) {
- leases[1]->hwaddr_.resize(i, i);
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- /// @todo: Simply use HWAddr directly once 2589 is implemented
- Lease4Ptr returned = lmptr_->getLease4(HWAddr(leases[1]->hwaddr_,
- HTYPE_ETHER),
- leases[1]->subnet_id_);
- ASSERT_TRUE(returned);
- detailCompareLease(leases[1], returned);
- (void) lmptr_->deleteLease(leases[1]->addr_);
- }
-
- // Database should not let us add one that is too big
- // (The 42 is a random value put in each byte of the address.)
- leases[1]->hwaddr_.resize(HWAddr::MAX_HWADDR_LEN + 100, 42);
- EXPECT_THROW(lmptr_->addLease(leases[1]), isc::dhcp::DbOperationError);
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientId2() {
- // Get the leases to be used for the test and add to the database
- vector<Lease4Ptr> leases = createLeases4();
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Get the leases matching the Client ID address of lease 1
- Lease4Collection returned = lmptr_->getLease4(*leases[1]->client_id_);
-
- // Should be four leases, matching leases[1], [4], [5] and [6].
- ASSERT_EQ(4, returned.size());
-
- // Easiest way to check is to look at the addresses.
- vector<string> addresses;
- for (Lease4Collection::const_iterator i = returned.begin();
- i != returned.end(); ++i) {
- addresses.push_back((*i)->addr_.toText());
- }
- sort(addresses.begin(), addresses.end());
- EXPECT_EQ(straddress4_[1], addresses[0]);
- EXPECT_EQ(straddress4_[4], addresses[1]);
- EXPECT_EQ(straddress4_[5], addresses[2]);
- EXPECT_EQ(straddress4_[6], addresses[3]);
-
- // Repeat test with just one expected match
- returned = lmptr_->getLease4(*leases[3]->client_id_);
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[3], *returned.begin());
-
- // Check that client-id is NULL
- EXPECT_FALSE(leases[7]->client_id_);
- HWAddr tmp(leases[7]->hwaddr_, HTYPE_ETHER);
- returned = lmptr_->getLease4(tmp);
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[7], *returned.begin());
-
- // Try to get something with invalid client ID
- const uint8_t invalid_data[] = {0, 0, 0};
- ClientId invalid(invalid_data, sizeof(invalid_data));
- returned = lmptr_->getLease4(invalid);
- EXPECT_EQ(0, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientIdSize() {
- // Create leases, although we need only one.
- vector<Lease4Ptr> leases = createLeases4();
-
- // Now add leases with increasing Client ID size can be retrieved.
- // For speed, go from 0 to 128 is steps of 16.
- // Intermediate client_id_max is to overcome problem if
- // ClientId::MAX_CLIENT_ID_LEN is used in an EXPECT_EQ.
- int client_id_max = ClientId::MAX_CLIENT_ID_LEN;
- EXPECT_EQ(128, client_id_max);
-
- int client_id_min = ClientId::MIN_CLIENT_ID_LEN;
- EXPECT_EQ(2, client_id_min); // See RFC2132, section 9.14
-
- for (uint8_t i = client_id_min; i <= client_id_max; i += 16) {
- vector<uint8_t> clientid_vec(i, i);
- leases[1]->client_id_.reset(new ClientId(clientid_vec));
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- Lease4Collection returned = lmptr_->getLease4(*leases[1]->client_id_);
- ASSERT_TRUE(returned.size() == 1);
- detailCompareLease(leases[1], *returned.begin());
- (void) lmptr_->deleteLease(leases[1]->addr_);
- }
-
- // Don't bother to check client IDs longer than the maximum -
- // these cannot be constructed, and that limitation is tested
- // in the DUID/Client ID unit tests.
-}
-
-void
-GenericLeaseMgrTest::testGetLease4ClientIdSubnetId() {
- // Get the leases to be used for the test and add to the database
- vector<Lease4Ptr> leases = createLeases4();
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Get the leases matching the client ID of lease 1 and
- // subnet ID of lease 1. Result should be a single lease - lease 1.
- Lease4Ptr returned = lmptr_->getLease4(*leases[1]->client_id_,
- leases[1]->subnet_id_);
- ASSERT_TRUE(returned);
- detailCompareLease(leases[1], returned);
-
- // Try for a match to the client ID of lease 1 and the wrong
- // subnet ID.
- returned = lmptr_->getLease4(*leases[1]->client_id_,
- leases[1]->subnet_id_ + 1);
- EXPECT_FALSE(returned);
-
- // Try for a match to the subnet ID of lease 1 (and lease 4) but
- // the wrong client ID
- const uint8_t invalid_data[] = {0, 0, 0};
- ClientId invalid(invalid_data, sizeof(invalid_data));
- returned = lmptr_->getLease4(invalid, leases[1]->subnet_id_);
- EXPECT_FALSE(returned);
-
- // Try for a match to an unknown hardware address and an unknown
- // subnet ID.
- returned = lmptr_->getLease4(invalid, leases[1]->subnet_id_ + 1);
- EXPECT_FALSE(returned);
-}
-
-void
-GenericLeaseMgrTest::testGetLeases6DuidIaid() {
- // Get the leases to be used for the test.
- vector<Lease6Ptr> leases = createLeases6();
- ASSERT_LE(6, leases.size()); // Expect to access leases 0 through 5
-
- // Add them to the database
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Get the leases matching the DUID and IAID of lease[1].
- Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
- *leases[1]->duid_,
- leases[1]->iaid_);
-
- // Should be two leases, matching leases[1] and [4].
- ASSERT_EQ(2, returned.size());
-
- // Easiest way to check is to look at the addresses.
- vector<string> addresses;
- for (Lease6Collection::const_iterator i = returned.begin();
- i != returned.end(); ++i) {
- addresses.push_back((*i)->addr_.toText());
- }
- sort(addresses.begin(), addresses.end());
- EXPECT_EQ(straddress6_[1], addresses[0]);
- EXPECT_EQ(straddress6_[4], addresses[1]);
-
- // Check that nothing is returned when either the IAID or DUID match
- // nothing.
- returned = lmptr_->getLeases6(leasetype6_[1], *leases[1]->duid_,
- leases[1]->iaid_ + 1);
- EXPECT_EQ(0, returned.size());
-
- // Alter the leases[1] DUID to match nothing in the database.
- vector<uint8_t> duid_vector = leases[1]->duid_->getDuid();
- ++duid_vector[0];
- DUID new_duid(duid_vector);
- returned = lmptr_->getLeases6(leasetype6_[1], new_duid, leases[1]->iaid_);
- EXPECT_EQ(0, returned.size());
-}
-
-void
-GenericLeaseMgrTest::testGetLeases6DuidSize() {
- // Create leases, although we need only one.
- vector<Lease6Ptr> leases = createLeases6();
-
- // Now add leases with increasing DUID size can be retrieved.
- // For speed, go from 0 to 128 is steps of 16.
- int duid_max = DUID::MAX_DUID_LEN;
- EXPECT_EQ(128, duid_max);
-
- int duid_min = DUID::MIN_DUID_LEN;
- EXPECT_EQ(1, duid_min);
-
- for (uint8_t i = duid_min; i <= duid_max; i += 16) {
- vector<uint8_t> duid_vec(i, i);
- leases[1]->duid_.reset(new DUID(duid_vec));
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- Lease6Collection returned = lmptr_->getLeases6(leasetype6_[1],
- *leases[1]->duid_,
- leases[1]->iaid_);
- ASSERT_EQ(1, returned.size());
- detailCompareLease(leases[1], *returned.begin());
- (void) lmptr_->deleteLease(leases[1]->addr_);
- }
-
- // Don't bother to check DUIDs longer than the maximum - these cannot be
- // constructed, and that limitation is tested in the DUID/Client ID unit
- // tests.
-
-}
-
-void
-GenericLeaseMgrTest::testLease6LeaseTypeCheck() {
- Lease6Ptr empty_lease(new Lease6());
-
- DuidPtr duid(new DUID(vector<uint8_t>(8, 0x77)));
-
- // Initialize unused fields.
- empty_lease->t1_ = 0; // Not saved
- empty_lease->t2_ = 0; // Not saved
- empty_lease->fixed_ = false; // Unused
- empty_lease->comments_ = std::string(""); // Unused
- empty_lease->iaid_ = 142;
- empty_lease->duid_ = DuidPtr(new DUID(*duid));
- empty_lease->subnet_id_ = 23;
- empty_lease->preferred_lft_ = 100;
- empty_lease->valid_lft_ = 100;
- empty_lease->cltt_ = 100;
- empty_lease->fqdn_fwd_ = true;
- empty_lease->fqdn_rev_ = true;
- empty_lease->hostname_ = "myhost.example.com.";
- empty_lease->prefixlen_ = 4;
-
- // Make Two leases per lease type, all with the same DUID, IAID but
- // alternate the subnet_ids.
- vector<Lease6Ptr> leases;
- for (int i = 0; i < 6; ++i) {
- Lease6Ptr lease(new Lease6(*empty_lease));
- lease->type_ = leasetype6_[i / 2];
- lease->addr_ = IOAddress(straddress6_[i]);
- lease->subnet_id_ += (i % 2);
- leases.push_back(lease);
- EXPECT_TRUE(lmptr_->addLease(lease));
- }
-
- // Verify getting a single lease by type and address.
- for (int i = 0; i < 6; ++i) {
- // Look for exact match for each lease type.
- Lease6Ptr returned = lmptr_->getLease6(leasetype6_[i / 2],
- leases[i]->addr_);
- // We should match one per lease type.
- ASSERT_TRUE(returned);
- EXPECT_TRUE(*returned == *leases[i]);
-
- // Same address but wrong lease type, should not match.
- returned = lmptr_->getLease6(leasetype6_[i / 2 + 1], leases[i]->addr_);
- ASSERT_FALSE(returned);
- }
-
- // Verify getting a collection of leases by type, DUID, and IAID.
- // Iterate over the lease types, asking for leases based on
- // lease type, DUID, and IAID.
- for (int i = 0; i < 3; ++i) {
- Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i],
- *duid, 142);
- // We should match two per lease type.
- ASSERT_EQ(2, returned.size());
-
- // Collection order returned is not guaranteed.
- // Easiest way to check is to look at the addresses.
- vector<string> addresses;
- for (Lease6Collection::const_iterator it = returned.begin();
- it != returned.end(); ++it) {
- addresses.push_back((*it)->addr_.toText());
- }
- sort(addresses.begin(), addresses.end());
-
- // Now verify that the lease addresses match.
- EXPECT_EQ(addresses[0], leases[(i * 2)]->addr_.toText());
- EXPECT_EQ(addresses[1], leases[(i * 2 + 1)]->addr_.toText());
- }
-
- // Verify getting a collection of leases by type, DUID, IAID, and subnet id.
- // Iterate over the lease types, asking for leases based on
- // lease type, DUID, IAID, and subnet_id.
- for (int i = 0; i < 3; ++i) {
- Lease6Collection returned = lmptr_->getLeases6(leasetype6_[i],
- *duid, 142, 23);
- // We should match one per lease type.
- ASSERT_EQ(1, returned.size());
- EXPECT_TRUE(*(returned[0]) == *leases[i * 2]);
- }
-
- // Verify getting a single lease by type, duid, iad, and subnet id.
- for (int i = 0; i < 6; ++i) {
- Lease6Ptr returned = lmptr_->getLease6(leasetype6_[i / 2],
- *duid, 142, (23 + (i % 2)));
- // We should match one per lease type.
- ASSERT_TRUE(returned);
- EXPECT_TRUE(*returned == *leases[i]);
- }
-}
-
-void
-GenericLeaseMgrTest::testGetLease6DuidIaidSubnetId() {
- // Get the leases to be used for the test and add them to the database.
- vector<Lease6Ptr> leases = createLeases6();
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Get the leases matching the DUID and IAID of lease[1].
- Lease6Ptr returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
- leases[1]->iaid_,
- leases[1]->subnet_id_);
- ASSERT_TRUE(returned);
- EXPECT_TRUE(*returned == *leases[1]);
-
- // Modify each of the three parameters (DUID, IAID, Subnet ID) and
- // check that nothing is returned.
- returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
- leases[1]->iaid_ + 1, leases[1]->subnet_id_);
- EXPECT_FALSE(returned);
-
- returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
- leases[1]->iaid_, leases[1]->subnet_id_ + 1);
- EXPECT_FALSE(returned);
-
- // Alter the leases[1] DUID to match nothing in the database.
- vector<uint8_t> duid_vector = leases[1]->duid_->getDuid();
- ++duid_vector[0];
- DUID new_duid(duid_vector);
- returned = lmptr_->getLease6(leasetype6_[1], new_duid, leases[1]->iaid_,
- leases[1]->subnet_id_);
- EXPECT_FALSE(returned);
-}
-
-/// @brief Checks that getLease6() works with different DUID sizes
-void
-GenericLeaseMgrTest::testGetLease6DuidIaidSubnetIdSize() {
-
- // Create leases, although we need only one.
- vector<Lease6Ptr> leases = createLeases6();
-
- // Now add leases with increasing DUID size can be retrieved.
- // For speed, go from 0 to 128 is steps of 16.
- int duid_max = DUID::MAX_DUID_LEN;
- EXPECT_EQ(128, duid_max);
-
- int duid_min = DUID::MIN_DUID_LEN;
- EXPECT_EQ(1, duid_min);
-
- for (uint8_t i = duid_min; i <= duid_max; i += 16) {
- vector<uint8_t> duid_vec(i, i);
- leases[1]->duid_.reset(new DUID(duid_vec));
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- Lease6Ptr returned = lmptr_->getLease6(leasetype6_[1], *leases[1]->duid_,
- leases[1]->iaid_,
- leases[1]->subnet_id_);
- ASSERT_TRUE(returned);
- detailCompareLease(leases[1], returned);
- (void) lmptr_->deleteLease(leases[1]->addr_);
- }
-
- // Don't bother to check DUIDs longer than the maximum - these cannot be
- // constructed, and that limitation is tested in the DUID/Client ID unit
- // tests.
-}
-
-void
-GenericLeaseMgrTest::testUpdateLease4() {
- // Get the leases to be used for the test and add them to the database.
- vector<Lease4Ptr> leases = createLeases4();
- for (int i = 0; i < leases.size(); ++i) {
- EXPECT_TRUE(lmptr_->addLease(leases[i]));
- }
-
- // Modify some fields in lease 1 (not the address) and update it.
- ++leases[1]->subnet_id_;
- leases[1]->valid_lft_ *= 2;
- leases[1]->hostname_ = "modified.hostname.";
- leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_;
- leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;;
- lmptr_->updateLease4(leases[1]);
-
- // ... and check what is returned is what is expected.
- Lease4Ptr l_returned = lmptr_->getLease4(ioaddress4_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Alter the lease again and check.
- ++leases[1]->subnet_id_;
- leases[1]->cltt_ += 6;
- lmptr_->updateLease4(leases[1]);
-
- // Explicitly clear the returned pointer before getting new data to ensure
- // that the new data is returned.
- l_returned.reset();
- l_returned = lmptr_->getLease4(ioaddress4_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Check we can do an update without changing data.
- lmptr_->updateLease4(leases[1]);
- l_returned.reset();
- l_returned = lmptr_->getLease4(ioaddress4_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Try to update the lease with the too long hostname.
- leases[1]->hostname_.assign(256, 'a');
- EXPECT_THROW(lmptr_->updateLease4(leases[1]), isc::dhcp::DbOperationError);
-
- // Try updating a lease not in the database.
- lmptr_->deleteLease(ioaddress4_[2]);
- EXPECT_THROW(lmptr_->updateLease4(leases[2]), isc::dhcp::NoSuchLease);
-}
-
-void
-GenericLeaseMgrTest::testUpdateLease6() {
- // Get the leases to be used for the test.
- vector<Lease6Ptr> leases = createLeases6();
- ASSERT_LE(3, leases.size()); // Expect to access leases 0 through 2
-
- // Add a lease to the database and check that the lease is there.
- EXPECT_TRUE(lmptr_->addLease(leases[1]));
- lmptr_->commit();
-
- Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Modify some fields in lease 1 (not the address) and update it.
- ++leases[1]->iaid_;
- leases[1]->type_ = Lease::TYPE_PD;
- leases[1]->valid_lft_ *= 2;
- leases[1]->hostname_ = "modified.hostname.v6.";
- leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_;
- leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;;
- lmptr_->updateLease6(leases[1]);
- lmptr_->commit();
-
- // ... and check what is returned is what is expected.
- l_returned.reset();
- l_returned = lmptr_->getLease6(Lease::TYPE_PD, ioaddress6_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Alter the lease again and check.
- ++leases[1]->iaid_;
- leases[1]->type_ = Lease::TYPE_TA;
- leases[1]->cltt_ += 6;
- leases[1]->prefixlen_ = 93;
- lmptr_->updateLease6(leases[1]);
-
- l_returned.reset();
- l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Check we can do an update without changing data.
- lmptr_->updateLease6(leases[1]);
- l_returned.reset();
- l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]);
- ASSERT_TRUE(l_returned);
- detailCompareLease(leases[1], l_returned);
-
- // Try to update the lease with the too long hostname.
- leases[1]->hostname_.assign(256, 'a');
- EXPECT_THROW(lmptr_->updateLease6(leases[1]), isc::dhcp::DbOperationError);
-
- // Try updating a lease not in the database.
- EXPECT_THROW(lmptr_->updateLease6(leases[2]), isc::dhcp::NoSuchLease);
-}
-
-
-};
-};
-};
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc
diff --git a/src/lib/dhcpsrv/tests/test_utils.h b/src/lib/dhcpsrv/tests/test_utils.h
index 26576d9..a9d4ab2 100644
--- a/src/lib/dhcpsrv/tests/test_utils.h
+++ b/src/lib/dhcpsrv/tests/test_utils.h
@@ -43,218 +43,8 @@ detailCompareLease(const Lease6Ptr& first, const Lease6Ptr& second);
void
detailCompareLease(const Lease4Ptr& first, const Lease4Ptr& second);
-/// @brief Test Fixture class with utility functions for LeaseMgr backends
-///
-/// It contains utility functions, like dummy lease creation.
-/// All concrete LeaseMgr test classes should be derived from it.
-class GenericLeaseMgrTest : public ::testing::Test {
-public:
-
- /// @brief Default constructor.
- GenericLeaseMgrTest();
-
- /// @brief Virtual destructor.
- virtual ~GenericLeaseMgrTest();
-
- /// @brief Reopen the database
- ///
- /// Closes the database and re-opens it. It must be implemented
- /// in derived classes.
- virtual void reopen() = 0;
-
- /// @brief Initialize Lease4 Fields
- ///
- /// Returns a pointer to a Lease4 structure. Different values are put into
- /// the lease according to the address passed.
- ///
- /// This is just a convenience function for the test methods.
- ///
- /// @param address Address to use for the initialization
- ///
- /// @return Lease4Ptr. This will not point to anything if the
- /// initialization failed (e.g. unknown address).
- Lease4Ptr initializeLease4(std::string address);
-
- /// @brief Initialize Lease6 Fields
- ///
- /// Returns a pointer to a Lease6 structure. Different values are put into
- /// the lease according to the address passed.
- ///
- /// This is just a convenience function for the test methods.
- ///
- /// @param address Address to use for the initialization
- ///
- /// @return Lease6Ptr. This will not point to anything if the initialization
- /// failed (e.g. unknown address).
- Lease6Ptr initializeLease6(std::string address);
-
- /// @brief Check Leases present and different
- ///
- /// Checks a vector of lease pointers and ensures that all the leases
- /// they point to are present and different. If not, a GTest assertion
- /// will fail.
- ///
- /// @param leases Vector of pointers to leases
- /// @tparam Type of the leases held in the vector: @c Lease4 or
- /// @c Lease6.
- template <typename T>
- void checkLeasesDifferent(const std::vector<T>& leases) const;
-
- /// @brief Creates leases for the test
- ///
- /// Creates all leases for the test and checks that they are different.
- ///
- /// @return vector<Lease4Ptr> Vector of pointers to leases
- std::vector<Lease4Ptr> createLeases4();
-
- /// @brief Creates leases for the test
- ///
- /// Creates all leases for the test and checks that they are different.
- ///
- /// @return vector<Lease6Ptr> Vector of pointers to leases
- std::vector<Lease6Ptr> createLeases6();
-
- /// @brief checks that addLease, getLease4(addr) and deleteLease() works
- void testBasicLease4();
-
- /// @brief Test lease retrieval using client id.
- void testGetLease4ClientId();
-
- /// @brief Test lease retrieval when leases with NULL client id are present.
- void testGetLease4NullClientId();
-
- /// @brief Test lease retrieval using HW address.
- void testGetLease4HWAddr1();
-
- /// @brief Check GetLease4 methods - access by Hardware Address
- ///
- /// Adds leases to the database and checks that they can be accessed using
- /// HWAddr information.
- void testGetLease4HWAddr2();
-
- /// @brief Test lease retrieval using client id, HW address and subnet id.
- void testGetLease4ClientIdHWAddrSubnetId();
-
- // @brief Get lease4 by hardware address (2)
- //
- // Check that the system can cope with getting a hardware address of
- // any size.
- void testGetLease4HWAddrSize();
-
- /// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID
- ///
- /// Adds leases to the database and checks that they can be accessed via
- /// a combination of hardware address and subnet ID
- void testGetLease4HWAddrSubnetId();
-
- /// @brief Get lease4 by hardware address and subnet ID (2)
- ///
- /// Check that the system can cope with getting a hardware address of
- /// any size.
- void testGetLease4HWAddrSubnetIdSize();
-
- /// @brief Check GetLease4 methods - access by Client ID
- ///
- /// Adds leases to the database and checks that they can be accessed via
- /// the Client ID.
- void testGetLease4ClientId2();
-
- /// @brief Get Lease4 by client ID (2)
- ///
- /// Check that the system can cope with a client ID of any size.
- void testGetLease4ClientIdSize();
-
- /// @brief Check GetLease4 methods - access by Client ID & Subnet ID
- ///
- /// Adds leases to the database and checks that they can be accessed via
- /// a combination of client and subnet IDs.
- void testGetLease4ClientIdSubnetId();
-
- /// @brief Basic Lease4 Checks
- ///
- /// Checks that the addLease, getLease4(by address), getLease4(hwaddr,subnet_id),
- /// updateLease4() and deleteLease (IPv4 address) can handle NULL client-id.
- /// (client-id is optional and may not be present)
- ///
- /// @todo: check if it does overlap with @ref testGetLease4NullClientId()
- void testLease4NullClientId();
-
- /// @brief Basic Lease6 Checks
- ///
- /// Checks that the addLease, getLease6 (by address) and deleteLease (with an
- /// IPv6 address) works.
- void testBasicLease6();
-
- /// @brief Test that IPv6 lease can be added, retrieved and deleted.
- ///
- /// This method checks basic IPv6 lease operations. There's check_t1_t2
- /// parameter that controls whether the backend supports storing T1, T2
- /// parameters. memfile supports it, while MySQL doesn't. If T1,T2
- /// storage is not supported, the expected values are 0.
- ///
- /// @param check_t1_t2 controls whether T1,T2 timers should be checked
- void testAddGetDelete6(bool check_t1_t2);
-
- /// @brief Check GetLease6 methods - access by DUID/IAID
- ///
- /// Adds leases to the database and checks that they can be accessed via
- /// a combination of DUID and IAID.
- void testGetLeases6DuidIaid();
-
- /// @brief Check that the system can cope with a DUID of allowed size.
- void testGetLeases6DuidSize();
-
- /// @brief Check that getLease6 methods discriminate by lease type.
- ///
- /// Adds six leases, two per lease type all with the same duid and iad but
- /// with alternating subnet_ids.
- /// It then verifies that all of getLeases6() method variants correctly
- /// discriminate between the leases based on lease type alone.
- void testLease6LeaseTypeCheck();
-
- /// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID
- ///
- /// Adds leases to the database and checks that they can be accessed via
- /// a combination of DIUID and IAID.
- void testGetLease6DuidIaidSubnetId();
-
- /// @brief Checks that getLease6() works with different DUID sizes
- void testGetLease6DuidIaidSubnetIdSize();
-
- /// @brief Verify that too long hostname for Lease4 is not accepted.
- ///
- /// Checks that the it is not possible to create a lease when the hostname
- /// length exceeds 255 characters.
- void testLease4InvalidHostname();
-
- /// @brief Verify that too long hostname for Lease6 is not accepted.
- ///
- /// Checks that the it is not possible to create a lease when the hostname
- /// length exceeds 255 characters.
- void testLease6InvalidHostname();
-
- /// @brief Lease4 update test
- ///
- /// Checks that the code is able to update an IPv4 lease in the database.
- void testUpdateLease4();
-
- /// @brief Lease6 update test
- ///
- /// Checks that the code is able to update an IPv6 lease in the database.
- void testUpdateLease6();
-
- // Member variables
- std::vector<std::string> straddress4_; ///< String forms of IPv4 addresses
- std::vector<isc::asiolink::IOAddress> ioaddress4_; ///< IOAddress forms of IPv4 addresses
- std::vector<std::string> straddress6_; ///< String forms of IPv6 addresses
- std::vector<Lease::Type> leasetype6_; ///< Lease types
- std::vector<isc::asiolink::IOAddress> ioaddress6_; ///< IOAddress forms of IPv6 addresses
-
- LeaseMgr* lmptr_; ///< Pointer to the lease manager
-};
-
-};
-};
-};
+}; // namespace test
+}; // namespace dhcp
+}; // namespace isc
#endif
More information about the bind10-changes
mailing list