BIND 10 master, updated. e670f65bbe881e7df6fbf3eab10da05ef48554c5 [master] ChangeLog for #3359 updated.
BIND 10 source code commits
bind10-changes at lists.isc.org
Tue Mar 11 11:17:52 UTC 2014
The branch, master has been updated
via e670f65bbe881e7df6fbf3eab10da05ef48554c5 (commit)
via 3d6c11630ada9d0681a813cf026f6bb16aabb9fa (commit)
via 516b7c2ffbd3a0c50eb21edd7210e67846882257 (commit)
via 32900a49231b47f2535519272e1618886fdc845c (commit)
via 032ae89cd0ca9d04703555611aece3d3b791565f (commit)
via acbc792b359ff90ed791e9ea45c30c39240a0c7b (commit)
via 8e7af49f4f4b72187ec0861c95bd80e8900fcedf (commit)
via ae241216b7a9764e00835ffbde13011102db3983 (commit)
via 44267f77cf3490f3a79014acf39be61027a372f4 (commit)
via c62714b4a8458c4cc777d32fe11b4aab61b91fad (commit)
from 305e3c4cd191f091c4e961b0ecd17cf21b836a43 (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 e670f65bbe881e7df6fbf3eab10da05ef48554c5
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Tue Mar 11 12:17:32 2014 +0100
[master] ChangeLog for #3359 updated.
commit 3d6c11630ada9d0681a813cf026f6bb16aabb9fa
Merge: 305e3c4 516b7c2
Author: Tomek Mrugalski <tomasz at isc.org>
Date: Tue Mar 11 11:45:04 2014 +0100
[master] Merge branch 'trac3359' (shared unit-tests for all DHCP backends)
-----------------------------------------------------------------------
Summary of changes:
ChangeLog | 5 +
src/lib/dhcpsrv/tests/Makefile.am | 1 +
...r_unittest.cc => generic_lease_mgr_unittest.cc} | 1101 ++++++++++++--------
src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h | 249 +++++
src/lib/dhcpsrv/tests/lease_mgr_unittest.cc | 9 +
.../dhcpsrv/tests/memfile_lease_mgr_unittest.cc | 223 ++--
src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc | 783 +-------------
src/lib/dhcpsrv/tests/test_utils.cc | 506 +--------
src/lib/dhcpsrv/tests/test_utils.h | 93 +-
9 files changed, 1101 insertions(+), 1869 deletions(-)
copy src/lib/dhcpsrv/tests/{mysql_lease_mgr_unittest.cc => generic_lease_mgr_unittest.cc} (60%)
create mode 100644 src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h
-----------------------------------------------------------------------
diff --git a/ChangeLog b/ChangeLog
index 84076ae..09c273d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,10 @@
bind10-1.2.0beta1 released on March 6, 2014
+767. [func] tomek
+ Unit-tests for all database backends are now shared. This improves
+ test coverage for memfile and any future backends that may appear.
+ (Trac #3359, git 3d6c11630ada9d0681a813cf026f6bb16aabb9fa)
+
766. [func] muks
--disable-dns and --disable-dhcp configure arguments have been
added to conditionally disable the DNS or DHCP components
diff --git a/src/lib/dhcpsrv/tests/Makefile.am b/src/lib/dhcpsrv/tests/Makefile.am
index 2e38dfc..9e13592 100644
--- a/src/lib/dhcpsrv/tests/Makefile.am
+++ b/src/lib/dhcpsrv/tests/Makefile.am
@@ -61,6 +61,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 f8a4aed..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>
@@ -247,6 +248,14 @@ class LeaseMgrTest : public GenericLeaseMgrTest {
public:
LeaseMgrTest() {
}
+
+ /// @brief Reopen the database
+ ///
+ /// No-op implementation. We need to provide concrete implementation,
+ /// as this is a pure virtual method in GenericLeaseMgrTest.
+ virtual void reopen() {
+ }
+
};
namespace {
diff --git a/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc
index 6570750..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>
@@ -34,13 +35,25 @@ namespace {
// empty class for now, but may be extended once Addr6 becomes bigger
class MemfileLeaseMgrTest : public GenericLeaseMgrTest {
public:
+
+ /// @brief memfile lease mgr test constructor
+ ///
+ /// Creates memfile and stores it in lmptr_ pointer
MemfileLeaseMgrTest() {
const LeaseMgr::ParameterMap pmap;
lmptr_ = new Memfile_LeaseMgr(pmap);
}
+ virtual void reopen() {
+ /// @todo: write lease to disk, flush, read file from disk
+ }
+
+ /// @brief destructor
+ ///
+ /// destroys lease manager backend.
virtual ~MemfileLeaseMgrTest() {
delete lmptr_;
+ lmptr_ = 0;
}
};
@@ -57,113 +70,169 @@ TEST_F(MemfileLeaseMgrTest, constructor) {
// Checks if the getType() and getName() methods both return "memfile".
TEST_F(MemfileLeaseMgrTest, getTypeAndName) {
- const LeaseMgr::ParameterMap pmap; // Empty parameter map
- boost::scoped_ptr<Memfile_LeaseMgr> lease_mgr(new Memfile_LeaseMgr(pmap));
-
- EXPECT_EQ(std::string("memfile"), lease_mgr->getType());
- EXPECT_EQ(std::string("memory"), lease_mgr->getName());
+ EXPECT_EQ(std::string("memfile"), lmptr_->getType());
+ EXPECT_EQ(std::string("memory"), lmptr_->getName());
}
// Checks that adding/getting/deleting a Lease6 object works.
TEST_F(MemfileLeaseMgrTest, addGetDelete6) {
- const LeaseMgr::ParameterMap pmap; // Empty parameter map
- boost::scoped_ptr<LeaseMgr> lease_mgr(new Memfile_LeaseMgr(pmap));
-
- IOAddress addr("2001:db8:1::456");
+ testAddGetDelete6(true); // true - check T1,T2 values
+ // memfile is able to preserve those values, but some other
+ // backends can't do that.
+}
- uint8_t llt[] = {0, 1, 2, 3, 4, 5, 6, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
- DuidPtr duid(new DUID(llt, sizeof(llt)));
+/// @brief Basic Lease4 Checks
+///
+/// Checks that the addLease, getLease4 (by address) and deleteLease (with an
+/// IPv4 address) works.
+TEST_F(MemfileLeaseMgrTest, basicLease4) {
+ testBasicLease4();
+}
- uint32_t iaid = 7; // just a number
+/// @todo Write more memfile tests
- SubnetID subnet_id = 8; // just another number
+// Simple test about lease4 retrieval through client id method
+TEST_F(MemfileLeaseMgrTest, getLease4ClientId) {
+ testGetLease4ClientId();
+}
- Lease6Ptr lease(new Lease6(Lease::TYPE_NA, addr,
- duid, iaid, 100, 200, 50, 80,
- subnet_id));
+// Checks that lease4 retrieval client id is null is working
+TEST_F(MemfileLeaseMgrTest, getLease4NullClientId) {
+ testGetLease4NullClientId();
+}
- EXPECT_TRUE(lease_mgr->addLease(lease));
+// Checks lease4 retrieval through HWAddr
+TEST_F(MemfileLeaseMgrTest, getLease4HWAddr1) {
+ testGetLease4HWAddr1();
+}
- // should not be allowed to add a second lease with the same address
- EXPECT_FALSE(lease_mgr->addLease(lease));
+/// @brief Check GetLease4 methods - access by Hardware Address
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// a combination of DUID and IAID.
+TEST_F(MemfileLeaseMgrTest, getLease4HWAddr2) {
+ testGetLease4HWAddr2();
+}
- Lease6Ptr x = lease_mgr->getLease6(Lease::TYPE_NA,
- IOAddress("2001:db8:1::234"));
- EXPECT_EQ(Lease6Ptr(), x);
+// Checks lease4 retrieval with clientId, HWAddr and subnet_id
+TEST_F(MemfileLeaseMgrTest, getLease4ClientIdHWAddrSubnetId) {
+ testGetLease4ClientIdHWAddrSubnetId();
+}
- x = lease_mgr->getLease6(Lease::TYPE_NA,
- IOAddress("2001:db8:1::456"));
- ASSERT_TRUE(x);
+/// @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)
+TEST_F(MemfileLeaseMgrTest, DISABLED_lease4NullClientId) {
- EXPECT_EQ(x->addr_, addr);
- EXPECT_TRUE(*x->duid_ == *duid);
- EXPECT_EQ(x->iaid_, iaid);
- EXPECT_EQ(x->subnet_id_, subnet_id);
+ /// @todo Test is disabled, because memfile does not support disk storage, so
+ /// all leases are lost after reopen()
+ testLease4NullClientId();
+}
- // These are not important from lease management perspective, but
- // let's check them anyway.
- EXPECT_EQ(x->type_, Lease::TYPE_NA);
- EXPECT_EQ(x->preferred_lft_, 100);
- EXPECT_EQ(x->valid_lft_, 200);
- EXPECT_EQ(x->t1_, 50);
- EXPECT_EQ(x->t2_, 80);
+/// @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
+TEST_F(MemfileLeaseMgrTest, DISABLED_getLease4HwaddrSubnetId) {
- // Test getLease6(duid, iaid, subnet_id) - positive case
- Lease6Ptr y = lease_mgr->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);
+ /// @todo: fails on memfile. It's probably a memfile bug.
+ testGetLease4HWAddrSubnetId();
+}
- // Test getLease6(duid, iaid, subnet_id) - wrong iaid
- uint32_t invalid_iaid = 9; // no such iaid
- y = lease_mgr->getLease6(Lease::TYPE_NA, *duid, invalid_iaid,
- subnet_id);
- EXPECT_FALSE(y);
+/// @brief Check GetLease4 methods - access by Client ID
+///
+/// Adds leases to the database and checks that they can be accessed via
+/// the Client ID.
+TEST_F(MemfileLeaseMgrTest, getLease4ClientId2) {
+ testGetLease4ClientId2();
+}
- uint32_t invalid_subnet_id = 999;
- y = lease_mgr->getLease6(Lease::TYPE_NA, *duid, iaid,
- invalid_subnet_id);
- EXPECT_FALSE(y);
+// @brief Get Lease4 by client ID
+//
+// Check that the system can cope with a client ID of any size.
+TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSize) {
+ testGetLease4ClientIdSize();
+}
- // truncated duid
- DuidPtr invalid_duid(new DUID(llt, sizeof(llt) - 1));
- y = lease_mgr->getLease6(Lease::TYPE_NA, *invalid_duid, iaid,
- subnet_id);
- EXPECT_FALSE(y);
+/// @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.
+TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSubnetId) {
+ testGetLease4ClientIdSubnetId();
+}
- // should return false - there's no such address
- EXPECT_FALSE(lease_mgr->deleteLease(IOAddress("2001:db8:1::789")));
+/// @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.
+/// @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();
+}
- // this one should succeed
- EXPECT_TRUE(lease_mgr->deleteLease(IOAddress("2001:db8:1::456")));
+// Check that the system can cope with a DUID of allowed size.
- // after the lease is deleted, it should really be gone
- x = lease_mgr->getLease6(Lease::TYPE_NA, IOAddress("2001:db8:1::456"));
- EXPECT_EQ(Lease6Ptr(), x);
+/// @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();
}
-/// @todo Write more memfile tests
+/// @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.
+/// @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();
+}
-// Simple test about lease4 retrieval through client id method
-TEST_F(MemfileLeaseMgrTest, getLease4ClientId) {
- testGetLease4ClientId();
+/// @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.
+TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetId) {
+ testGetLease6DuidIaidSubnetId();
}
-// Checks that lease4 retrieval client id is null is working
-TEST_F(MemfileLeaseMgrTest, getLease4NullClientId) {
- testGetLease4NullClientId();
+/// Checks that getLease6(type, duid, iaid, subnet-id) works with different
+/// DUID sizes
+TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetIdSize) {
+ testGetLease6DuidIaidSubnetIdSize();
}
-// Checks lease4 retrieval through HWAddr
-TEST_F(MemfileLeaseMgrTest, getLease4HWAddr) {
- testGetLease4HWAddr();
+/// @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();
}
-// Checks lease4 retrieval with clientId, HWAddr and subnet_id
-TEST_F(MemfileLeaseMgrTest, getLease4ClientIdHWAddrSubnetId) {
- testGetLease4ClientIdHWAddrSubnetId();
+/// @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();
}
+// The following tests are not applicable for memfile. When adding
+// new tests to the list here, make sure to provide brief explanation
+// why they are not applicable:
+//
+// testGetLease4HWAddrSubnetIdSize() - memfile just keeps Lease structure
+// and does not do any checks of HWAddr content
+
}; // end of anonymous namespace
diff --git a/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc
index 578ef3c..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>
@@ -323,122 +323,21 @@ TEST_F(MySqlLeaseMgrTest, checkVersion) {
/// Checks that the addLease, getLease4 (by address) and deleteLease (with an
/// IPv4 address) works.
TEST_F(MySqlLeaseMgrTest, basicLease4) {
- // 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);
+ testBasicLease4();
+}
+
+TEST_F(MySqlLeaseMgrTest, testAddGetDelete6) {
+ testAddGetDelete6(false);
}
+
/// @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)
TEST_F(MySqlLeaseMgrTest, lease4NullClientId) {
- // 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);
-
+ testLease4NullClientId();
}
/// @brief Verify that too long hostname for Lease4 is not accepted.
@@ -446,24 +345,7 @@ TEST_F(MySqlLeaseMgrTest, lease4NullClientId) {
/// Checks that the it is not possible to create a lease when the hostname
/// length exceeds 255 characters.
TEST_F(MySqlLeaseMgrTest, lease4InvalidHostname) {
- // 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);
+ testLease4InvalidHostname();
}
/// @brief Basic Lease6 Checks
@@ -471,45 +353,7 @@ TEST_F(MySqlLeaseMgrTest, lease4InvalidHostname) {
/// Checks that the addLease, getLease6 (by address) and deleteLease (with an
/// IPv6 address) works.
TEST_F(MySqlLeaseMgrTest, basicLease6) {
- // 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);
+ testBasicLease6();
}
/// @brief Verify that too long hostname for Lease6 is not accepted.
@@ -517,102 +361,25 @@ TEST_F(MySqlLeaseMgrTest, basicLease6) {
/// Checks that the it is not possible to create a lease when the hostname
/// length exceeds 255 characters.
TEST_F(MySqlLeaseMgrTest, lease6InvalidHostname) {
- // 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);
+ testLease6InvalidHostname();
}
/// @brief Check GetLease4 methods - access by Hardware Address
-///
-/// Adds leases to the database and checks that they can be accessed via
-/// a combination of DIUID and IAID.
-TEST_F(MySqlLeaseMgrTest, getLease4Hwaddr) {
- // 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());
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddr1) {
+ testGetLease4HWAddr1();
+}
- // 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());
+/// @brief Check GetLease4 methods - access by Hardware Address
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddr2) {
+ testGetLease4HWAddr2();
}
// @brief Get lease4 by hardware address (2)
//
// Check that the system can cope with getting a hardware address of
// any size.
-TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSize) {
-
- // 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);
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddrSize) {
+ testGetLease4HWAddrSize();
}
/// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID
@@ -620,167 +387,35 @@ TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSize) {
/// Adds leases to the database and checks that they can be accessed via
/// a combination of hardware address and subnet ID
TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSubnetId) {
- // 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);
-
+ 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.
-TEST_F(MySqlLeaseMgrTest, getLease4HwaddrSubnetIdSize) {
-
- // 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_);
- }
+TEST_F(MySqlLeaseMgrTest, getLease4HWAddrSubnetIdSize) {
+ testGetLease4HWAddrSubnetIdSize();
+}
- // 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);
+// This test was derived from memfile.
+TEST_F(MySqlLeaseMgrTest, getLease4ClientId) {
+ testGetLease4ClientId();
}
/// @brief Check GetLease4 methods - access by Client ID
///
/// Adds leases to the database and checks that they can be accessed via
/// the Client ID.
-TEST_F(MySqlLeaseMgrTest, getLease4ClientId) {
- // 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());
+TEST_F(MySqlLeaseMgrTest, getLease4ClientId2) {
+ testGetLease4ClientId2();
}
// @brief Get Lease4 by client ID (2)
//
// Check that the system can cope with a client ID of any size.
TEST_F(MySqlLeaseMgrTest, getLease4ClientIdSize) {
-
- // 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.
+ testGetLease4ClientIdSize();
}
/// @brief Check GetLease4 methods - access by Client ID & Subnet ID
@@ -788,115 +423,20 @@ TEST_F(MySqlLeaseMgrTest, getLease4ClientIdSize) {
/// Adds leases to the database and checks that they can be accessed via
/// a combination of client and subnet IDs.
TEST_F(MySqlLeaseMgrTest, getLease4ClientIdSubnetId) {
- // 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);
+ testGetLease4ClientIdSubnetId();
}
/// @brief Check GetLease6 methods - access by DUID/IAID
///
/// Adds leases to the database and checks that they can be accessed via
-/// a combination of DIUID and IAID.
+/// a combination of DUID and IAID.
TEST_F(MySqlLeaseMgrTest, getLeases6DuidIaid) {
- // 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());
+ testGetLeases6DuidIaid();
}
-// @brief Get Lease4 by DUID and IAID (2)
-//
-// Check that the system can cope with a DUID of any size.
-TEST_F(MySqlLeaseMgrTest, getLeases6DuidIaidSize) {
-
- // 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.
+// Check that the system can cope with a DUID of allowed size.
+TEST_F(MySqlLeaseMgrTest, getLeases6DuidSize) {
+ testGetLeases6DuidSize();
}
/// @brief Check that getLease6 methods discriminate by lease type.
@@ -906,95 +446,7 @@ TEST_F(MySqlLeaseMgrTest, getLeases6DuidIaidSize) {
/// It then verifies that all of getLeases6() method variants correctly
/// discriminate between the leases based on lease type alone.
TEST_F(MySqlLeaseMgrTest, lease6LeaseTypeCheck) {
-
- 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]);
- }
+ testLease6LeaseTypeCheck();
}
/// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID
@@ -1002,180 +454,25 @@ TEST_F(MySqlLeaseMgrTest, lease6LeaseTypeCheck) {
/// Adds leases to the database and checks that they can be accessed via
/// a combination of DIUID and IAID.
TEST_F(MySqlLeaseMgrTest, getLease6DuidIaidSubnetId) {
- // 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);
+ testGetLease6DuidIaidSubnetId();
}
-
-// @brief Get Lease4 by DUID, IAID & subnet ID (2)
-//
-// Check that the system can cope with a DUID of any size.
TEST_F(MySqlLeaseMgrTest, getLease6DuidIaidSubnetIdSize) {
-
- // 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.
+ testGetLease6DuidIaidSubnetIdSize();
}
/// @brief Lease4 update tests
///
/// Checks that we are able to update a lease in the database.
TEST_F(MySqlLeaseMgrTest, updateLease4) {
- // 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);
+ testUpdateLease4();
}
/// @brief Lease6 update tests
///
/// Checks that we are able to update a lease in the database.
TEST_F(MySqlLeaseMgrTest, updateLease6) {
- // 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);
+ testUpdateLease6();
}
}; // Of anonymous namespace
diff --git a/src/lib/dhcpsrv/tests/test_utils.cc b/src/lib/dhcpsrv/tests/test_utils.cc
index 44d60ea..b9bd0cc 100644
--- a/src/lib/dhcpsrv/tests/test_utils.cc
+++ b/src/lib/dhcpsrv/tests/test_utils.cc
@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2013 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-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
@@ -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,486 +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.
-}
-
-/// @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
-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);
-}
-
-/// @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
-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);
-}
-
-/// @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
-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]);
- }
- }
-}
-
-/// @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
-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);
-}
-
-/// @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
-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::testGetLease4HWAddr() {
- // 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::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);
-}
-
-
-};
-};
-};
+}; // 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 6a86724..a9d4ab2 100644
--- a/src/lib/dhcpsrv/tests/test_utils.h
+++ b/src/lib/dhcpsrv/tests/test_utils.h
@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2013 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-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
@@ -43,93 +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 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
- 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 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 testGetLease4HWAddr();
-
- /// @brief Test lease retrieval using client id, HW address and subnet id.
- void testGetLease4ClientIdHWAddrSubnetId();
-
- // 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