From: Tomek Mrugalski Date: Mon, 10 Mar 2014 19:23:39 +0000 (+0100) Subject: [3359] Changes after review: X-Git-Tag: kea-eng-20140313~17^2 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=516b7c2ffbd3a0c50eb21edd7210e67846882257;p=thirdparty%2Fkea.git [3359] Changes after review: - GenericLeaseMgrTest class moved to a separate file - @todo added for disabled tests in memfile (with explanations) - Added several comments --- diff --git a/src/lib/dhcpsrv/tests/Makefile.am b/src/lib/dhcpsrv/tests/Makefile.am index 037db46055..c55ed85540 100644 --- a/src/lib/dhcpsrv/tests/Makefile.am +++ b/src/lib/dhcpsrv/tests/Makefile.am @@ -59,6 +59,7 @@ libdhcpsrv_unittests_SOURCES += dbaccess_parser_unittest.cc libdhcpsrv_unittests_SOURCES += lease_unittest.cc libdhcpsrv_unittests_SOURCES += lease_mgr_factory_unittest.cc libdhcpsrv_unittests_SOURCES += lease_mgr_unittest.cc +libdhcpsrv_unittests_SOURCES += generic_lease_mgr_unittest.cc libdhcpsrv_unittests_SOURCES += memfile_lease_mgr_unittest.cc libdhcpsrv_unittests_SOURCES += dhcp_parsers_unittest.cc if HAVE_MYSQL diff --git a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc new file mode 100644 index 0000000000..1d24cf8086 --- /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 +#include +#include +#include +#include + +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(6, 0x08); + lease->client_id_ = ClientIdPtr(new ClientId(vector(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(6, 0x19); + lease->client_id_ = ClientIdPtr( + new ClientId(vector(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(6, 0x2a); + lease->client_id_ = ClientIdPtr(new ClientId(vector(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(6, 0x19); // Same as lease 1 + lease->client_id_ = ClientIdPtr( + new ClientId(vector(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(6, 0x4c); + // Same ClientId as straddr4_[1] + lease->client_id_ = ClientIdPtr( + new ClientId(vector(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(6, 0x19); // Same as lease 1 + // Same ClientId and IAID as straddress4_1 + lease->client_id_ = ClientIdPtr( + new ClientId(vector(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(6, 0x6e); + // Same ClientId as straddress4_1 + lease->client_id_ = ClientIdPtr( + new ClientId(vector(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(); // 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(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(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(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 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(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(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(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(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 +void GenericLeaseMgrTest::checkLeasesDifferent(const std::vector& 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 +GenericLeaseMgrTest::createLeases4() { + + // Create leases for each address + vector 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 +GenericLeaseMgrTest::createLeases6() { + + // Create leases for each address + vector 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 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(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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(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 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 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 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 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 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 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 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 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 0000000000..03ccbe2991 --- /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 +#include +#include + +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 + void checkLeasesDifferent(const std::vector& leases) const; + + /// @brief Creates leases for the test + /// + /// Creates all leases for the test and checks that they are different. + /// + /// @return vector Vector of pointers to leases + std::vector createLeases4(); + + /// @brief Creates leases for the test + /// + /// Creates all leases for the test and checks that they are different. + /// + /// @return vector Vector of pointers to leases + std::vector 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 straddress4_; + + /// @brief IOAddress forms of IPv4 addresses + std::vector ioaddress4_; + + /// @brief String forms of IPv6 addresses + std::vector straddress6_; + + /// @brief Types of IPv6 Leases + std::vector leasetype6_; + + /// @brief IOAddress forms of IPv6 addresses + std::vector 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 7e7fee296f..0037bc9052 100644 --- a/src/lib/dhcpsrv/tests/lease_mgr_unittest.cc +++ b/src/lib/dhcpsrv/tests/lease_mgr_unittest.cc @@ -18,6 +18,7 @@ #include #include #include +#include #include diff --git a/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/memfile_lease_mgr_unittest.cc index 2650c7fc6e..1b2001ec46 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 #include #include +#include #include #include @@ -75,7 +76,9 @@ TEST_F(MemfileLeaseMgrTest, getTypeAndName) { // Checks that adding/getting/deleting a Lease6 object works. TEST_F(MemfileLeaseMgrTest, addGetDelete6) { - testAddGetDelete6(true); + testAddGetDelete6(true); // true - check T1,T2 values + // memfile is able to preserve those values, but some other + // backends can't do that. } /// @brief Basic Lease4 Checks @@ -146,7 +149,7 @@ TEST_F(MemfileLeaseMgrTest, getLease4ClientId2) { testGetLease4ClientId2(); } -// @brief Get Lease4 by client ID (2) +// @brief Get Lease4 by client ID // // Check that the system can cope with a client ID of any size. TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSize) { @@ -165,11 +168,16 @@ TEST_F(MemfileLeaseMgrTest, getLease4ClientIdSubnetId) { /// /// Adds leases to the database and checks that they can be accessed via /// a combination of DUID and IAID. +/// @todo: test disabled, because Memfile_LeaseMgr::getLeases6(Lease::Type, +/// const DUID& duid, uint32_t iaid) const is not implemented yet. TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidIaid) { testGetLeases6DuidIaid(); } // Check that the system can cope with a DUID of allowed size. + +/// @todo: test disabled, because Memfile_LeaseMgr::getLeases6(Lease::Type, +/// const DUID& duid, uint32_t iaid) const is not implemented yet. TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidSize) { testGetLeases6DuidSize(); } @@ -180,6 +188,8 @@ TEST_F(MemfileLeaseMgrTest, DISABLED_getLeases6DuidSize) { /// with alternating subnet_ids. /// It then verifies that all of getLeases6() method variants correctly /// discriminate between the leases based on lease type alone. +/// @todo: Disabled, because type parameter in Memfile_LeaseMgr::getLease6 +/// (Lease::Type, const isc::asiolink::IOAddress& addr) const is not used. TEST_F(MemfileLeaseMgrTest, DISABLED_lease6LeaseTypeCheck) { testLease6LeaseTypeCheck(); } @@ -192,6 +202,8 @@ TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetId) { testGetLease6DuidIaidSubnetId(); } +/// Checks that getLease6(type, duid, iaid, subnet-id) works with different +/// DUID sizes TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetIdSize) { testGetLease6DuidIaidSubnetIdSize(); } @@ -199,6 +211,9 @@ TEST_F(MemfileLeaseMgrTest, getLease6DuidIaidSubnetIdSize) { /// @brief Lease4 update tests /// /// Checks that we are able to update a lease in the database. +/// @todo: Disabled, because memfile does not throw when lease is updated. +/// We should reconsider if lease{4,6} structures should have a limit +/// implemented in them. TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease4) { testUpdateLease4(); } @@ -206,6 +221,9 @@ TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease4) { /// @brief Lease6 update tests /// /// Checks that we are able to update a lease in the database. +/// @todo: Disabled, because memfile does not throw when lease is updated. +/// We should reconsider if lease{4,6} structures should have a limit +/// implemented in them. TEST_F(MemfileLeaseMgrTest, DISABLED_updateLease6) { testUpdateLease6(); } diff --git a/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/mysql_lease_mgr_unittest.cc index c7d0b9a2dd..7f1e9729fe 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 #include #include +#include #include - #include #include diff --git a/src/lib/dhcpsrv/tests/test_utils.cc b/src/lib/dhcpsrv/tests/test_utils.cc index 66d6c499ea..b9bd0cce21 100644 --- a/src/lib/dhcpsrv/tests/test_utils.cc +++ b/src/lib/dhcpsrv/tests/test_utils.cc @@ -24,24 +24,6 @@ namespace isc { namespace dhcp { namespace test { -// IPv4 and IPv6 addresses used in the tests -const char* ADDRESS4[] = { - "192.0.2.0", "192.0.2.1", "192.0.2.2", "192.0.2.3", - "192.0.2.4", "192.0.2.5", "192.0.2.6", "192.0.2.7", - NULL -}; -const char* ADDRESS6[] = { - "2001:db8::0", "2001:db8::1", "2001:db8::2", "2001:db8::3", - "2001:db8::4", "2001:db8::5", "2001:db8::6", "2001:db8::7", - NULL -}; - -// Lease types that correspond to ADDRESS6 leases -static const Lease::Type LEASETYPE6[] = { - Lease::TYPE_NA, Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA, - Lease::TYPE_TA, Lease::TYPE_PD, Lease::TYPE_NA, Lease::TYPE_TA -}; - void detailCompareLease(const Lease4Ptr& first, const Lease4Ptr& second) { // Compare address strings. Comparison of address objects is not used, as @@ -98,1325 +80,6 @@ detailCompareLease(const Lease6Ptr& first, const Lease6Ptr& second) { EXPECT_EQ(first->hostname_, second->hostname_); } -GenericLeaseMgrTest::GenericLeaseMgrTest() - : lmptr_(NULL) { - // Initialize address strings and IOAddresses - for (int i = 0; ADDRESS4[i] != NULL; ++i) { - string addr(ADDRESS4[i]); - straddress4_.push_back(addr); - IOAddress ioaddr(addr); - ioaddress4_.push_back(ioaddr); - } - - for (int i = 0; ADDRESS6[i] != NULL; ++i) { - string addr(ADDRESS6[i]); - straddress6_.push_back(addr); - IOAddress ioaddr(addr); - ioaddress6_.push_back(ioaddr); - - /// Let's create different lease types. We use LEASETYPE6 values as - /// a template - leasetype6_.push_back(LEASETYPE6[i]); - } -} - -GenericLeaseMgrTest::~GenericLeaseMgrTest() { - // Does nothing. The derived classes are expected to clean up, i.e. - // remove the lmptr_ pointer. -} - -Lease4Ptr -GenericLeaseMgrTest::initializeLease4(std::string address) { - Lease4Ptr lease(new Lease4()); - - // Set the address of the lease - lease->addr_ = IOAddress(address); - - // Initialize unused fields. - lease->ext_ = 0; // Not saved - lease->t1_ = 0; // Not saved - lease->t2_ = 0; // Not saved - lease->fixed_ = false; // Unused - lease->comments_ = std::string(""); // Unused - - // Set other parameters. For historical reasons, address 0 is not used. - if (address == straddress4_[0]) { - lease->hwaddr_ = vector(6, 0x08); - lease->client_id_ = ClientIdPtr(new ClientId(vector(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(6, 0x19); - lease->client_id_ = ClientIdPtr( - new ClientId(vector(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(6, 0x2a); - lease->client_id_ = ClientIdPtr(new ClientId(vector(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(6, 0x19); // Same as lease 1 - lease->client_id_ = ClientIdPtr( - new ClientId(vector(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(6, 0x4c); - // Same ClientId as straddr4_[1] - lease->client_id_ = ClientIdPtr( - new ClientId(vector(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(6, 0x19); // Same as lease 1 - // Same ClientId and IAID as straddress4_1 - lease->client_id_ = ClientIdPtr( - new ClientId(vector(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(6, 0x6e); - // Same ClientId as straddress4_1 - lease->client_id_ = ClientIdPtr( - new ClientId(vector(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(); // 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(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(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(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 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(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(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(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(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 -void GenericLeaseMgrTest::checkLeasesDifferent(const std::vector& 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 -GenericLeaseMgrTest::createLeases4() { - - // Create leases for each address - vector 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 -GenericLeaseMgrTest::createLeases6() { - - // Create leases for each address - vector 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 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(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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(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 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 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 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 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 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 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 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 leases = createLeases6(); - ASSERT_LE(3, leases.size()); // Expect to access leases 0 through 2 - - // Add a lease to the database and check that the lease is there. - EXPECT_TRUE(lmptr_->addLease(leases[1])); - lmptr_->commit(); - - Lease6Ptr l_returned = lmptr_->getLease6(leasetype6_[1], ioaddress6_[1]); - ASSERT_TRUE(l_returned); - detailCompareLease(leases[1], l_returned); - - // Modify some fields in lease 1 (not the address) and update it. - ++leases[1]->iaid_; - leases[1]->type_ = Lease::TYPE_PD; - leases[1]->valid_lft_ *= 2; - leases[1]->hostname_ = "modified.hostname.v6."; - leases[1]->fqdn_fwd_ = !leases[1]->fqdn_fwd_; - leases[1]->fqdn_rev_ = !leases[1]->fqdn_rev_;; - lmptr_->updateLease6(leases[1]); - lmptr_->commit(); - - // ... and check what is returned is what is expected. - l_returned.reset(); - l_returned = lmptr_->getLease6(Lease::TYPE_PD, ioaddress6_[1]); - ASSERT_TRUE(l_returned); - detailCompareLease(leases[1], l_returned); - - // Alter the lease again and check. - ++leases[1]->iaid_; - leases[1]->type_ = Lease::TYPE_TA; - leases[1]->cltt_ += 6; - leases[1]->prefixlen_ = 93; - lmptr_->updateLease6(leases[1]); - - l_returned.reset(); - l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]); - ASSERT_TRUE(l_returned); - detailCompareLease(leases[1], l_returned); - - // Check we can do an update without changing data. - lmptr_->updateLease6(leases[1]); - l_returned.reset(); - l_returned = lmptr_->getLease6(Lease::TYPE_TA, ioaddress6_[1]); - ASSERT_TRUE(l_returned); - detailCompareLease(leases[1], l_returned); - - // Try to update the lease with the too long hostname. - leases[1]->hostname_.assign(256, 'a'); - EXPECT_THROW(lmptr_->updateLease6(leases[1]), isc::dhcp::DbOperationError); - - // Try updating a lease not in the database. - EXPECT_THROW(lmptr_->updateLease6(leases[2]), isc::dhcp::NoSuchLease); -} - - -}; -}; -}; +}; // namespace test +}; // namespace dhcp +}; // namespace isc diff --git a/src/lib/dhcpsrv/tests/test_utils.h b/src/lib/dhcpsrv/tests/test_utils.h index 26576d92ed..a9d4ab26dc 100644 --- a/src/lib/dhcpsrv/tests/test_utils.h +++ b/src/lib/dhcpsrv/tests/test_utils.h @@ -43,218 +43,8 @@ detailCompareLease(const Lease6Ptr& first, const Lease6Ptr& second); void detailCompareLease(const Lease4Ptr& first, const Lease4Ptr& second); -/// @brief Test Fixture class with utility functions for LeaseMgr backends -/// -/// It contains utility functions, like dummy lease creation. -/// All concrete LeaseMgr test classes should be derived from it. -class GenericLeaseMgrTest : public ::testing::Test { -public: - - /// @brief Default constructor. - GenericLeaseMgrTest(); - - /// @brief Virtual destructor. - virtual ~GenericLeaseMgrTest(); - - /// @brief Reopen the database - /// - /// Closes the database and re-opens it. It must be implemented - /// in derived classes. - virtual void reopen() = 0; - - /// @brief Initialize Lease4 Fields - /// - /// Returns a pointer to a Lease4 structure. Different values are put into - /// the lease according to the address passed. - /// - /// This is just a convenience function for the test methods. - /// - /// @param address Address to use for the initialization - /// - /// @return Lease4Ptr. This will not point to anything if the - /// initialization failed (e.g. unknown address). - Lease4Ptr initializeLease4(std::string address); - - /// @brief Initialize Lease6 Fields - /// - /// Returns a pointer to a Lease6 structure. Different values are put into - /// the lease according to the address passed. - /// - /// This is just a convenience function for the test methods. - /// - /// @param address Address to use for the initialization - /// - /// @return Lease6Ptr. This will not point to anything if the initialization - /// failed (e.g. unknown address). - Lease6Ptr initializeLease6(std::string address); - - /// @brief Check Leases present and different - /// - /// Checks a vector of lease pointers and ensures that all the leases - /// they point to are present and different. If not, a GTest assertion - /// will fail. - /// - /// @param leases Vector of pointers to leases - /// @tparam Type of the leases held in the vector: @c Lease4 or - /// @c Lease6. - template - void checkLeasesDifferent(const std::vector& leases) const; - - /// @brief Creates leases for the test - /// - /// Creates all leases for the test and checks that they are different. - /// - /// @return vector Vector of pointers to leases - std::vector createLeases4(); - - /// @brief Creates leases for the test - /// - /// Creates all leases for the test and checks that they are different. - /// - /// @return vector Vector of pointers to leases - std::vector createLeases6(); - - /// @brief checks that addLease, getLease4(addr) and deleteLease() works - void testBasicLease4(); - - /// @brief Test lease retrieval using client id. - void testGetLease4ClientId(); - - /// @brief Test lease retrieval when leases with NULL client id are present. - void testGetLease4NullClientId(); - - /// @brief Test lease retrieval using HW address. - void testGetLease4HWAddr1(); - - /// @brief Check GetLease4 methods - access by Hardware Address - /// - /// Adds leases to the database and checks that they can be accessed using - /// HWAddr information. - void testGetLease4HWAddr2(); - - /// @brief Test lease retrieval using client id, HW address and subnet id. - void testGetLease4ClientIdHWAddrSubnetId(); - - // @brief Get lease4 by hardware address (2) - // - // Check that the system can cope with getting a hardware address of - // any size. - void testGetLease4HWAddrSize(); - - /// @brief Check GetLease4 methods - access by Hardware Address & Subnet ID - /// - /// Adds leases to the database and checks that they can be accessed via - /// a combination of hardware address and subnet ID - void testGetLease4HWAddrSubnetId(); - - /// @brief Get lease4 by hardware address and subnet ID (2) - /// - /// Check that the system can cope with getting a hardware address of - /// any size. - void testGetLease4HWAddrSubnetIdSize(); - - /// @brief Check GetLease4 methods - access by Client ID - /// - /// Adds leases to the database and checks that they can be accessed via - /// the Client ID. - void testGetLease4ClientId2(); - - /// @brief Get Lease4 by client ID (2) - /// - /// Check that the system can cope with a client ID of any size. - void testGetLease4ClientIdSize(); - - /// @brief Check GetLease4 methods - access by Client ID & Subnet ID - /// - /// Adds leases to the database and checks that they can be accessed via - /// a combination of client and subnet IDs. - void testGetLease4ClientIdSubnetId(); - - /// @brief Basic Lease4 Checks - /// - /// Checks that the addLease, getLease4(by address), getLease4(hwaddr,subnet_id), - /// updateLease4() and deleteLease (IPv4 address) can handle NULL client-id. - /// (client-id is optional and may not be present) - /// - /// @todo: check if it does overlap with @ref testGetLease4NullClientId() - void testLease4NullClientId(); - - /// @brief Basic Lease6 Checks - /// - /// Checks that the addLease, getLease6 (by address) and deleteLease (with an - /// IPv6 address) works. - void testBasicLease6(); - - /// @brief Test that IPv6 lease can be added, retrieved and deleted. - /// - /// This method checks basic IPv6 lease operations. There's check_t1_t2 - /// parameter that controls whether the backend supports storing T1, T2 - /// parameters. memfile supports it, while MySQL doesn't. If T1,T2 - /// storage is not supported, the expected values are 0. - /// - /// @param check_t1_t2 controls whether T1,T2 timers should be checked - void testAddGetDelete6(bool check_t1_t2); - - /// @brief Check GetLease6 methods - access by DUID/IAID - /// - /// Adds leases to the database and checks that they can be accessed via - /// a combination of DUID and IAID. - void testGetLeases6DuidIaid(); - - /// @brief Check that the system can cope with a DUID of allowed size. - void testGetLeases6DuidSize(); - - /// @brief Check that getLease6 methods discriminate by lease type. - /// - /// Adds six leases, two per lease type all with the same duid and iad but - /// with alternating subnet_ids. - /// It then verifies that all of getLeases6() method variants correctly - /// discriminate between the leases based on lease type alone. - void testLease6LeaseTypeCheck(); - - /// @brief Check GetLease6 methods - access by DUID/IAID/SubnetID - /// - /// Adds leases to the database and checks that they can be accessed via - /// a combination of DIUID and IAID. - void testGetLease6DuidIaidSubnetId(); - - /// @brief Checks that getLease6() works with different DUID sizes - void testGetLease6DuidIaidSubnetIdSize(); - - /// @brief Verify that too long hostname for Lease4 is not accepted. - /// - /// Checks that the it is not possible to create a lease when the hostname - /// length exceeds 255 characters. - void testLease4InvalidHostname(); - - /// @brief Verify that too long hostname for Lease6 is not accepted. - /// - /// Checks that the it is not possible to create a lease when the hostname - /// length exceeds 255 characters. - void testLease6InvalidHostname(); - - /// @brief Lease4 update test - /// - /// Checks that the code is able to update an IPv4 lease in the database. - void testUpdateLease4(); - - /// @brief Lease6 update test - /// - /// Checks that the code is able to update an IPv6 lease in the database. - void testUpdateLease6(); - - // Member variables - std::vector straddress4_; ///< String forms of IPv4 addresses - std::vector ioaddress4_; ///< IOAddress forms of IPv4 addresses - std::vector straddress6_; ///< String forms of IPv6 addresses - std::vector leasetype6_; ///< Lease types - std::vector ioaddress6_; ///< IOAddress forms of IPv6 addresses - - LeaseMgr* lmptr_; ///< Pointer to the lease manager -}; - -}; -}; -}; +}; // namespace test +}; // namespace dhcp +}; // namespace isc #endif