[5452] Added a new unit test against regression

diff --git a/src/lib/dhcpsrv/tests/host_unittest.cc b/src/lib/dhcpsrv/tests/host_unittest.cc
index fad37178ec10c87901557a0e8b7023a91d5e7c63..df9501da3e153f97b7788a028ce562e6ee7c225a 100644 (file)
--- a/src/lib/dhcpsrv/tests/host_unittest.cc
+++ b/src/lib/dhcpsrv/tests/host_unittest.cc
@@ -190,7 +190,7 @@ TEST_F(HostTest, getIdentifier) {
 // This test verifies that it is possible to create a Host object
 // using hardware address in the textual format.
 TEST_F(HostTest, createFromHWAddrString) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("01:02:03:04:05:06", "hw-address",
                                         SubnetID(1), SubnetID(2),
                                         IOAddress("192.0.2.3"),
@@ -229,7 +229,7 @@ TEST_F(HostTest, createFromHWAddrString) {
 // This test verifies that it is possible to create Host object using
 // a DUID in the textual format.
 TEST_F(HostTest, createFromDUIDString) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("a1:b2:c3:d4:e5:06", "duid",
                                         SubnetID(10), SubnetID(20),
                                         IOAddress("192.0.2.5"),
@@ -263,7 +263,7 @@ TEST_F(HostTest, createFromDUIDString) {
 // This test verifies that it is possible to create Host object using
 // hardware address in the binary format.
 TEST_F(HostTest, createFromHWAddrBinary) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Prepare the hardware address in binary format.
     const uint8_t hwaddr_data[] = {
         0xaa, 0xab, 0xca, 0xda, 0xbb, 0xee
@@ -299,7 +299,7 @@ TEST_F(HostTest, createFromHWAddrBinary) {
 // This test verifies that it is possible to create a Host object using
 // DUID in the binary format.
 TEST_F(HostTest, createFromDuidBinary) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Prepare DUID binary.
     const uint8_t duid_data[] = {
         1, 2, 3, 4, 5, 6
@@ -327,7 +327,7 @@ TEST_F(HostTest, createFromDuidBinary) {
 // This test verifies that it is possible create Host instance using all
 // supported identifiers in a binary format.
 TEST_F(HostTest, createFromIdentifierBinary) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Iterate over all supported identifier types.
     for (unsigned int i = 0; i < identifierTypeUpperBound(); ++i) {
         const Host::IdentifierType type = static_cast<Host::IdentifierType>(i);
@@ -356,7 +356,7 @@ TEST_F(HostTest, createFromIdentifierBinary) {
 // This test verifies that it is possible to create Host instance using
 // all supported identifiers in hexadecimal format.
 TEST_F(HostTest, createFromIdentifierHex) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Iterate over all supported identifiers.
     for (unsigned int i = 0; i < identifierTypeUpperBound(); ++i) {
         const Host::IdentifierType type = static_cast<Host::IdentifierType>(i);
@@ -401,7 +401,7 @@ TEST_F(HostTest, createFromIdentifierHex) {
 // This test verifies that it is possible to create Host instance using
 // identifiers specified as text in quotes.
 TEST_F(HostTest, createFromIdentifierString) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // It is not allowed to specify HW address or DUID as a string in quotes.
     for (unsigned int i = 2; i < identifierTypeUpperBound(); ++i) {
         const Host::IdentifierType type = static_cast<Host::IdentifierType>(i);
@@ -446,7 +446,7 @@ TEST_F(HostTest, createFromIdentifierString) {
 // using setIdentifier method with an identifier specified in
 // hexadecimal format.
 TEST_F(HostTest, setIdentifierHex) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Iterate over all supported identifiers.
     for (unsigned int i = 0; i < identifierTypeUpperBound(); ++i) {
 
@@ -532,7 +532,7 @@ TEST_F(HostTest, setIdentifierHex) {
 // using setIdentifier method with an identifier specified in binary
 // format.
 TEST_F(HostTest, setIdentifierBinary) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Iterate over all supported identifier types.
     for (unsigned int i = 0; i < identifierTypeUpperBound(); ++i) {
 
@@ -588,7 +588,7 @@ TEST_F(HostTest, setIdentifierBinary) {
 // This test verifies that the IPv6 reservations of a different type can
 // be added for the host.
 TEST_F(HostTest, addReservations) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("01:02:03:04:05:06", "hw-address",
                                         SubnetID(1), SubnetID(2),
                                         IOAddress("192.0.2.3"))));
@@ -646,7 +646,7 @@ TEST_F(HostTest, addReservations) {
 // This test checks that various modifiers may be used to replace the current
 // values of the Host class.
 TEST_F(HostTest, setValues) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("01:02:03:04:05:06", "hw-address",
                                         SubnetID(1), SubnetID(2),
                                         IOAddress("192.0.2.3"),
@@ -697,7 +697,7 @@ TEST_F(HostTest, setValues) {
 
 // Test that Host constructors initialize client classes from string.
 TEST_F(HostTest, clientClassesFromConstructor) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     // Prepare the hardware address in binary format.
     const uint8_t hwaddr_data[] = {
         0xaa, 0xab, 0xca, 0xda, 0xbb, 0xee
@@ -738,7 +738,7 @@ TEST_F(HostTest, clientClassesFromConstructor) {
 
 // Test that new client classes can be added for the Host.
 TEST_F(HostTest, addClientClasses) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("01:02:03:04:05:06", "hw-address",
                                         SubnetID(1), SubnetID(2),
                                         IOAddress("192.0.2.3"))));
@@ -925,7 +925,7 @@ TEST_F(HostTest, getIdentifierName) {
 // This test checks that Host object is correctly described in the
 // textual format using the toText method.
 TEST_F(HostTest, toText) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("01:02:03:04:05:06", "hw-address",
                                         SubnetID(1), SubnetID(2),
                                         IOAddress("192.0.2.3"),
@@ -1012,7 +1012,7 @@ TEST_F(HostTest, toText) {
 
 // Test verifies if the host can store HostId properly.
 TEST_F(HostTest, hostId) {
-    boost::scoped_ptr<Host> host;
+    HostPtr host;
     ASSERT_NO_THROW(host.reset(new Host("01:02:03:04:05:06", "hw-address",
                                         SubnetID(1), SubnetID(2),
                                         IOAddress("192.0.2.3"),

diff --git a/src/lib/dhcpsrv/tests/srv_config_unittest.cc b/src/lib/dhcpsrv/tests/srv_config_unittest.cc
index acf7806e597f570d31f6c31ab26c2d3b4017d4cf..1258164015b421a5e39d52fc87934f641753bcf7 100644 (file)
--- a/src/lib/dhcpsrv/tests/srv_config_unittest.cc
+++ b/src/lib/dhcpsrv/tests/srv_config_unittest.cc
@@ -15,6 +15,7 @@
 
 using namespace isc::asiolink;
 using namespace isc::dhcp;
+using namespace isc::data;
 
 // Those are the tests for SrvConfig storage. Right now they are minimal,
 // but the number is expected to grow significantly once we migrate more
@@ -409,10 +410,10 @@ TEST_F(SrvConfigTest, hooksLibraries) {
     EXPECT_EQ(0, libraries.get().size());
 
     // Verify we can update it.
-    isc::data::ConstElementPtr elem0;
+    ConstElementPtr elem0;
     libraries.add("foo", elem0);
     std::string config = "{ \"library\": \"bar\" }";
-    isc::data::ConstElementPtr elem1 = isc::data::Element::fromJSON(config);
+    ConstElementPtr elem1 = Element::fromJSON(config);
     libraries.add("bar", elem1);
     EXPECT_EQ(2, libraries.get().size());
     EXPECT_EQ(2, conf.getHooksConfig().get().size());
@@ -487,4 +488,261 @@ TEST_F(SrvConfigTest, unparse) {
         (header4 + defaults + defaults4 + params + trailer, conf);
 }    
 
+// Verifies that the toElement method does not miss host reservations
+TEST_F(SrvConfigTest, unparseHR) {
+    // DHCPv4 version
+    SrvConfig conf4(32);
+
+    // Add a plain subnet
+    Triplet<uint32_t> def_triplet;
+    SubnetID p_id(1);
+    Subnet4Ptr psubnet4(new Subnet4(IOAddress("192.0.1.0"), 24,
+                                    def_triplet, def_triplet, 4000, p_id));
+    conf4.getCfgSubnets4()->add(psubnet4);
+
+    // Add a shared network
+    SharedNetwork4Ptr network4(new SharedNetwork4("frog"));
+    conf4.getCfgSharedNetworks4()->add(network4);
+
+    // Add a shared subnet
+    SubnetID s_id(100);
+    Subnet4Ptr ssubnet4(new Subnet4(IOAddress("192.0.2.0"), 24,
+                                    def_triplet, def_triplet, 4000, s_id));
+    network4->add(ssubnet4);
+
+    // Add a host reservation to the plain subnet
+    HostPtr phost4(new Host("00:01:02:03:04:05", "hw-address",
+                            p_id, SubnetID(0), IOAddress("192.0.1.1")));
+    conf4.getCfgHosts()->add(phost4);
+
+    // Add a host reservation to the shared subnet
+    HostPtr shost4(new Host("00:05:04:03:02:01", "hw-address",
+                            s_id, SubnetID(0), IOAddress("192.0.2.1")));
+    conf4.getCfgHosts()->add(shost4);
+
+    // Unparse the config
+    ConstElementPtr unparsed4 = conf4.toElement();
+    ASSERT_TRUE(unparsed4);
+    ASSERT_EQ(Element::map, unparsed4->getType());
+
+    // Get Dhcp4 entry
+    ConstElementPtr dhcp4;
+    ASSERT_NO_THROW(dhcp4 = unparsed4->get("Dhcp4"));
+    ASSERT_TRUE(dhcp4);
+    ASSERT_EQ(Element::map, dhcp4->getType());
+
+    // Get plain subnets
+    ConstElementPtr check;
+    ASSERT_NO_THROW(check = dhcp4->get("subnet4"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the plain subnet
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Its ID is 1
+    ConstElementPtr sub;
+    ASSERT_NO_THROW(sub = check->get("id"));
+    ASSERT_TRUE(sub);
+    ASSERT_EQ(Element::integer, sub->getType());
+    EXPECT_EQ(p_id, sub->intValue());
+
+    // Get its host reservations
+    ASSERT_NO_THROW(check = check->get("reservations"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the plain host reservation
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Check the reserved address
+    ASSERT_NO_THROW(check = check->get("ip-address"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::string, check->getType());
+    EXPECT_EQ("192.0.1.1", check->stringValue());
+
+    // Get shared networks
+    ASSERT_NO_THROW(check = dhcp4->get("shared-networks"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the shared network
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Its name is "frog"
+    ASSERT_NO_THROW(sub = check->get("name"));
+    ASSERT_TRUE(sub);
+    ASSERT_EQ(Element::string, sub->getType());
+    EXPECT_EQ("frog", sub->stringValue());
+
+    // Get shared subnets
+    ASSERT_NO_THROW(check = check->get("subnet4"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the shared subnet
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Its ID is 100
+    ASSERT_NO_THROW(sub = check->get("id"));
+    ASSERT_TRUE(sub);
+    ASSERT_EQ(Element::integer, sub->getType());
+    EXPECT_EQ(s_id, sub->intValue());
+
+    // Get its host reservations
+    ASSERT_NO_THROW(check = check->get("reservations"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the shared host reservation
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Check the reserved address
+    ASSERT_NO_THROW(check = check->get("ip-address"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::string, check->getType());
+    EXPECT_EQ("192.0.2.1", check->stringValue());
+
+    // DHCPv6 version
+    CfgMgr::instance().setFamily(AF_INET6);
+    SrvConfig conf6(32);
+
+    // Add a plain subnet
+    Subnet6Ptr psubnet6(new Subnet6(IOAddress("2001:db8:1::"), 64,
+                                    1000, 2000, 3000, 4000, p_id));
+    conf6.getCfgSubnets6()->add(psubnet6);
+
+    // Add a shared network
+    SharedNetwork6Ptr network6(new SharedNetwork6("frog"));
+    conf6.getCfgSharedNetworks6()->add(network6);
+
+    // Add a shared subnet
+    Subnet6Ptr ssubnet6(new Subnet6(IOAddress("2001:db8:2::"), 64,
+                                    1000, 2000, 3000, 4000, s_id));
+    network6->add(ssubnet6);
+
+    // Add a host reservation to the plain subnet
+    HostPtr phost6(new Host("a1:b2:c3:d4:e5:f6", "duid", SubnetID(0),
+                            p_id, IOAddress::IPV4_ZERO_ADDRESS(),
+                            "foo.example.org"));
+    conf6.getCfgHosts()->add(phost6);
+
+    // Add a host reservation to the shared subnet
+    HostPtr shost6(new Host("f6:e5:d4:c3:b2:a1", "duid", SubnetID(0),
+                            s_id, IOAddress::IPV4_ZERO_ADDRESS(),
+                            "bar.example.org"));
+    conf6.getCfgHosts()->add(shost6);
+
+    // Unparse the config
+    ConstElementPtr unparsed6 = conf6.toElement();
+    ASSERT_TRUE(unparsed6);
+    ASSERT_EQ(Element::map, unparsed6->getType());
+
+    // Get Dhcp6 entry
+    ConstElementPtr dhcp6;
+    ASSERT_NO_THROW(dhcp6 = unparsed6->get("Dhcp6"));
+    ASSERT_TRUE(dhcp6);
+    ASSERT_EQ(Element::map, dhcp6->getType());
+
+    // Get plain subnets
+    ASSERT_NO_THROW(check = dhcp6->get("subnet6"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the plain subnet
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Its ID is 1
+    ASSERT_NO_THROW(sub = check->get("id"));
+    ASSERT_TRUE(sub);
+    ASSERT_EQ(Element::integer, sub->getType());
+    EXPECT_EQ(p_id, sub->intValue());
+
+    // Get its host reservations
+    ASSERT_NO_THROW(check = check->get("reservations"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the plain host reservation
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Check the host name
+    ASSERT_NO_THROW(check = check->get("hostname"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::string, check->getType());
+    EXPECT_EQ("foo.example.org", check->stringValue());
+
+    // Get shared networks
+    ASSERT_NO_THROW(check = dhcp6->get("shared-networks"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the shared network
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Its name is "frog"
+    ASSERT_NO_THROW(sub = check->get("name"));
+    ASSERT_TRUE(sub);
+    ASSERT_EQ(Element::string, sub->getType());
+    EXPECT_EQ("frog", sub->stringValue());
+
+    // Get shared subnets
+    ASSERT_NO_THROW(check = check->get("subnet6"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the shared subnet
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Its ID is 100
+    ASSERT_NO_THROW(sub = check->get("id"));
+    ASSERT_TRUE(sub);
+    ASSERT_EQ(Element::integer, sub->getType());
+    EXPECT_EQ(s_id, sub->intValue());
+
+    // Get its host reservations
+    ASSERT_NO_THROW(check = check->get("reservations"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::list, check->getType());
+    EXPECT_EQ(1, check->size());
+
+    // Get the shared host reservation
+    ASSERT_NO_THROW(check = check->get(0));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::map, check->getType());
+
+    // Check the host name
+    ASSERT_NO_THROW(check = check->get("hostname"));
+    ASSERT_TRUE(check);
+    ASSERT_EQ(Element::string, check->getType());
+    EXPECT_EQ("bar.example.org", check->stringValue());
+}
+
 } // end of anonymous namespace