[#2883] added unittests for pool stats

diff --git a/src/lib/dhcpsrv/cfg_subnets6.cc b/src/lib/dhcpsrv/cfg_subnets6.cc
index 97b94eef30ab5d0b7fd69bd51d4871fde7d096a3..f353a62adc91bc6709cfd2a61d37ccb3c6e511a7 100644 (file)
--- a/src/lib/dhcpsrv/cfg_subnets6.cc
+++ b/src/lib/dhcpsrv/cfg_subnets6.cc
@@ -545,12 +545,12 @@ CfgSubnets6::updateStatistics() {
                                                                              "total-pds")),
                                pool->getCapacity());
 
-            const std::string& name_nas =
+            const std::string& name_pds =
                 StatsMgr::generateName("subnet", subnet_id,
                                        StatsMgr::generateName("pd-pool", pool->getID(),
                                        "cumulative-assigned-pds"));
-            if (!stats_mgr.getObservation(name_nas)) {
-                stats_mgr.setValue(name_nas, static_cast<int64_t>(0));
+            if (!stats_mgr.getObservation(name_pds)) {
+                stats_mgr.setValue(name_pds, static_cast<int64_t>(0));
             }
         }
     }

diff --git a/src/lib/dhcpsrv/subnet.cc b/src/lib/dhcpsrv/subnet.cc
index 1f7f75105ede1f50e84e5ca829d3044de6e7a533..247ae1b9986f6d6c73686bb701692b32a6f5cb22 100644 (file)
--- a/src/lib/dhcpsrv/subnet.cc
+++ b/src/lib/dhcpsrv/subnet.cc
@@ -522,12 +522,6 @@ Subnet::addPool(const PoolPtr& pool) {
     // Sort pools by first address.
     std::sort(pools_writable.begin(), pools_writable.end(),
               comparePoolFirstAddress);
-
-    uint64_t index = 0;
-    for (const auto& pool : pools_writable) {
-        pool->setID(index);
-        index++;
-    }
 }
 
 void

diff --git a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
index 37756b9672602142ec0cdf8b358a6774552466c2..700960731550ad0df4f72bda8036e01972f8ef1b 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
@@ -366,9 +366,9 @@ TEST_F(AllocEngine4Test, fakeAlloc4) {
 
     // Assigned addresses should still be zero.
     EXPECT_TRUE(testStatistics("assigned-addresses", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-addresses", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-addresses"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-addresses",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-addresses", glbl_cumulative));
 }
 
 // This test checks if the allocation with a hint that is valid (in range,
@@ -1860,9 +1860,9 @@ TEST_F(AllocEngine4Test, discoverReuseDeclinedLease4Stats) {
 
     // Check that the stats declined stats were not modified
     EXPECT_TRUE(testStatistics("assigned-addresses", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-addresses", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-addresses"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-addresses",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-addresses", glbl_cumulative));
     EXPECT_TRUE(testStatistics("declined-addresses", 0));
     EXPECT_TRUE(testStatistics("reclaimed-declined-addresses", 0));
     EXPECT_TRUE(testStatistics("declined-addresses", 0, subnet_->getID()));
@@ -3139,9 +3139,9 @@ TEST_F(AllocEngine4Test, fakeAlloc4Stat) {
     ObservationPtr stat = StatsMgr::instance().getObservation(name);
     ASSERT_TRUE(stat);
     EXPECT_EQ(100, stat->getInteger().first);
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-addresses", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-addresses"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-addresses",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-addresses", glbl_cumulative));
 }
 
 // This test checks that the allocated-addresses statistic is decreased when

diff --git a/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
index 6c0dfa0dfed1eaa0f6e71f4c260f7119dc6f7d2b..918ca7fd159242f87cce7c0183192dd5b4846e7c 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine6_unittest.cc
@@ -173,9 +173,9 @@ TEST_F(AllocEngine6Test, fakeAlloc6) {
 
     // We should not have bumped the assigned counter.
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // This test checks if the fake PD allocation (for SOLICIT) can succeed
@@ -193,9 +193,9 @@ TEST_F(AllocEngine6Test, pdFakeAlloc6) {
 
     // We should not have bumped the assigned counter
     EXPECT_TRUE(testStatistics("assigned-pds", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-pds", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-pds"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-pds",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-pds", glbl_cumulative));
 }
 
 // This test checks if the allocation with a hint that is valid (in range,
@@ -446,9 +446,9 @@ TEST_F(AllocEngine6Test, solicitReuseExpiredLease6) {
 
     // Verify the none of relevant stats were altered.
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
     EXPECT_TRUE(testStatistics("reclaimed-leases", 0));
     EXPECT_TRUE(testStatistics("reclaimed-leases", 0, subnet_->getID()));
 }
@@ -777,8 +777,8 @@ TEST_F(AllocEngine6Test, requestReuseExpiredLease6) {
     glbl_cumulative += 1;
     EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
     EXPECT_TRUE(testStatistics("assigned-nas", -1, other_subnetid));
-    EXPECT_EQ(other_cumulative,
-              getStatistics("cumulative-assigned-nas", other_subnetid));
+    EXPECT_FALSE(testStatistics("cumulative-assigned-nas",
+                                other_cumulative, other_subnetid, false));
     EXPECT_TRUE(testStatistics("reclaimed-leases", 1));
     EXPECT_TRUE(testStatistics("reclaimed-leases", 0, subnet_->getID()));
     EXPECT_TRUE(testStatistics("reclaimed-leases", 1, other_subnetid));
@@ -1182,9 +1182,9 @@ TEST_F(AllocEngine6Test, reservedAddressInPoolSolicitValidHint) {
 
     // Assigned count should not have been incremented.
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (in-pool case)
@@ -1262,9 +1262,9 @@ TEST_F(AllocEngine6Test, reservedAddressInPoolSolicitMatchingHint) {
 
     // Assigned count should not have been incremented.
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (in-pool case)
@@ -1339,9 +1339,9 @@ TEST_F(AllocEngine6Test, reservedAddressOutOfPoolSolicitNoHint) {
 
     // Assigned count should not have been incremented.
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (out-of-pool case)
@@ -1375,9 +1375,9 @@ TEST_F(AllocEngine6Test, reservedAddressOutOfPoolRequestNoHint) {
 
     // We should not have bumped the address counter
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (in-pool case)
@@ -1414,9 +1414,9 @@ TEST_F(AllocEngine6Test, reservedAddressOutOfPoolSolicitValidHint) {
 
     // We should not have bumped the address counter
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (out-of-pool case)
@@ -1453,9 +1453,9 @@ TEST_F(AllocEngine6Test, reservedAddressOutOfPoolRequestValidHint) {
 
     // We should not have bumped the address counter
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (out-of-pool case)
@@ -1492,9 +1492,9 @@ TEST_F(AllocEngine6Test, reservedAddressOutOfPoolSolicitMatchingHint) {
 
     // We should not have bumped the address counter
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // Checks that a client gets the address reserved (out-of-pool case)
@@ -1531,9 +1531,9 @@ TEST_F(AllocEngine6Test, reservedAddressOutOfPoolRequestMatchingHint) {
 
     // We should not have bumped the address counter
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
 }
 
 // In the following situation:
@@ -2570,9 +2570,9 @@ TEST_F(AllocEngine6Test, solicitReuseDeclinedLease6Stats) {
 
     // Check that the stats were not modified
     EXPECT_TRUE(testStatistics("assigned-nas", 0, subnet_->getID()));
-    EXPECT_EQ(cumulative,
-              getStatistics("cumulative-assigned-nas", subnet_->getID()));
-    EXPECT_EQ(glbl_cumulative, getStatistics("cumulative-assigned-nas"));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas",
+                               cumulative, subnet_->getID()));
+    EXPECT_TRUE(testStatistics("cumulative-assigned-nas", glbl_cumulative));
     EXPECT_TRUE(testStatistics("declined-addresses", 0));
     EXPECT_TRUE(testStatistics("reclaimed-declined-addresses", 0));
     EXPECT_TRUE(testStatistics("declined-addresses", 0, subnet_->getID()));

diff --git a/src/lib/dhcpsrv/tests/alloc_engine_expiration_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine_expiration_unittest.cc
index 138d7e138f251f46376240f268106234a190cc62..6e913473cd75237b2594a2e513eac805b1cfafab 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine_expiration_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine_expiration_unittest.cc
@@ -1084,15 +1084,15 @@ public:
         // Addresses (DHCPDECLINE support) (v4) or Duplicate Addresses (DECLINE
         // support) sections in the User's Guide or a comment in
         // Dhcpv4Srv::declineLease or Dhcpv6Srv::declineLease.
-        testStatistics("subnet[1]." + stat_name, 1000 - subnet1_cnt);
-        testStatistics("subnet[2]." + stat_name, 2000 - subnet2_cnt);
+        testStatistics(stat_name, 1000 - subnet1_cnt, 1);
+        testStatistics(stat_name, 2000 - subnet2_cnt, 2);
 
-        testStatistics("subnet[1].declined-addresses", 100 - subnet1_cnt);
-        testStatistics("subnet[2].declined-addresses", 200 - subnet2_cnt);
+        testStatistics("declined-addresses", 100 - subnet1_cnt, 1);
+        testStatistics("declined-addresses", 200 - subnet2_cnt, 2);
 
         // subnet[X].reclaimed-declined-addresses should go up in each subnet
-        testStatistics("subnet[1].reclaimed-declined-addresses", 10000 + subnet1_cnt);
-        testStatistics("subnet[2].reclaimed-declined-addresses", 20000 + subnet1_cnt);
+        testStatistics("reclaimed-declined-addresses", 10000 + subnet1_cnt, 1);
+        testStatistics("reclaimed-declined-addresses", 20000 + subnet1_cnt, 2);
     }
 
     /// @brief Collection of leases created at construction time.
@@ -1382,13 +1382,13 @@ ExpirationAllocEngine6Test::testReclaimExpiredLeasesStats() {
         EXPECT_TRUE(testStatistics("reclaimed-leases", i));
         // Make sure that the number of reclaimed leases is also distributed
         // across two subnets.
-        EXPECT_TRUE(testStatistics("subnet[1].reclaimed-leases", i / 2));
-        EXPECT_TRUE(testStatistics("subnet[2].reclaimed-leases", i / 2));
+        EXPECT_TRUE(testStatistics("reclaimed-leases", i / 2, 1));
+        EXPECT_TRUE(testStatistics("reclaimed-leases", i / 2, 2));
         // Number of assigned leases should decrease as we reclaim them.
-        EXPECT_TRUE(testStatistics("subnet[1].assigned-nas",
-                                   (TEST_LEASES_NUM - i) / 2));
-        EXPECT_TRUE(testStatistics("subnet[2].assigned-pds",
-                                   (TEST_LEASES_NUM - i) / 2));
+        EXPECT_TRUE(testStatistics("assigned-nas",
+                                   (TEST_LEASES_NUM - i) / 2, 1));
+        EXPECT_TRUE(testStatistics("assigned-pds",
+                                   (TEST_LEASES_NUM - i) / 2, 2));
     }
 }
 
@@ -2037,13 +2037,13 @@ ExpirationAllocEngine4Test::testReclaimExpiredLeasesStats() {
         EXPECT_TRUE(testStatistics("reclaimed-leases", i));
         // Make sure that the number of reclaimed leases is also distributed
         // across two subnets.
-        EXPECT_TRUE(testStatistics("subnet[1].reclaimed-leases", i / 2));
-        EXPECT_TRUE(testStatistics("subnet[2].reclaimed-leases", i / 2));
+        EXPECT_TRUE(testStatistics("reclaimed-leases", i / 2, 1));
+        EXPECT_TRUE(testStatistics("reclaimed-leases", i / 2, 2));
         // Number of assigned leases should decrease as we reclaim them.
-        EXPECT_TRUE(testStatistics("subnet[1].assigned-addresses",
-                                   (TEST_LEASES_NUM - i) / 2));
-        EXPECT_TRUE(testStatistics("subnet[2].assigned-addresses",
-                                   (TEST_LEASES_NUM - i) / 2));
+        EXPECT_TRUE(testStatistics("assigned-addresses",
+                                   (TEST_LEASES_NUM - i) / 2, 1));
+        EXPECT_TRUE(testStatistics("assigned-addresses",
+                                   (TEST_LEASES_NUM - i) / 2, 2));
     }
 }
 

diff --git a/src/lib/dhcpsrv/tests/alloc_engine_utils.cc b/src/lib/dhcpsrv/tests/alloc_engine_utils.cc
index e334d1e242f7a1af167c51c2c95ed1bdc03107a1..46f4d8069ce4d59a34103a8115cef8c1bb765fb6 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine_utils.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine_utils.cc
@@ -41,7 +41,7 @@ namespace dhcp {
 namespace test {
 
 bool testStatistics(const std::string& stat_name, const int64_t exp_value,
-                    const SubnetID subnet_id) {
+                    const SubnetID subnet_id, bool fail_missing) {
     try {
         std::string name = (subnet_id == SUBNET_ID_UNUSED ? stat_name :
                             StatsMgr::generateName("subnet", subnet_id, stat_name));
@@ -56,10 +56,38 @@ bool testStatistics(const std::string& stat_name, const int64_t exp_value,
             }
             return (observation->getInteger().first == exp_value);
         } else {
-            ADD_FAILURE() << "Expected statistic " << name
-                          << " not found.";
+            if (fail_missing) {
+                ADD_FAILURE() << "Expected statistic " << name
+                              << " not found.";
+            } else {
+                if (exp_value) {
+                    ADD_FAILURE() << "Checking non existent statistic and expected value is not 0. Broken test?";
+                }
+            }
+        }
+        if (subnet_id != SUBNET_ID_UNUSED) {
+            name = StatsMgr::generateName("subnet", subnet_id, StatsMgr::generateName("pool", 0, stat_name));
+            observation = StatsMgr::instance().getObservation(name);
+            if (observation) {
+                if (observation->getInteger().first != exp_value) {
+                    ADD_FAILURE()
+                        << "value of the observed statistics '"
+                        << name << "' ("
+                        << observation->getInteger().first << ") "
+                        << "doesn't match expected value (" << exp_value << ")";
+                }
+                return (observation->getInteger().first == exp_value);
+            } else {
+                if (fail_missing) {
+                    ADD_FAILURE() << "Expected statistic " << name
+                                  << " not found.";
+                } else {
+                    if (exp_value) {
+                        ADD_FAILURE() << "Checking non existent statistic and expected value is not 0. Broken test?";
+                    }
+                }
+            }
         }
-
     } catch (...) {
         ;
     }

diff --git a/src/lib/dhcpsrv/tests/alloc_engine_utils.h b/src/lib/dhcpsrv/tests/alloc_engine_utils.h
index 2d327299b1d32aa952fc0d97370e39a7e054242f..9ad9238e0d30a2427e23c08881e65c3d132e81da 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine_utils.h
+++ b/src/lib/dhcpsrv/tests/alloc_engine_utils.h
@@ -41,12 +41,15 @@ namespace test {
 /// @param stat_name Statistic name.
 /// @param exp_value Expected value.
 /// @param subnet_id subnet_id of the desired subnet, if not zero
+/// @param fail_missing flag which indicate if test should fail if the statistic
+/// does not exist, or simply ignore it.
 ///
 /// @return true if the statistic manager holds a particular value,
 /// false otherwise.
 bool testStatistics(const std::string& stat_name,
                     const int64_t exp_value,
-                    const SubnetID subnet_id = SUBNET_ID_UNUSED);
+                    const SubnetID subnet_id = SUBNET_ID_UNUSED,
+                    bool fail_missing = true);
 
 /// @brief Get a value held by statistic manager.
 ///

diff --git a/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc b/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc
index b07adba5d191550ce1f680479441bb713a48b615..104420261df4038d27c710e5fccde4ddaeb1f566 100644 (file)
--- a/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc
+++ b/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc
@@ -1837,6 +1837,9 @@ TEST(CfgSubnets4Test, updateStatistics) {
     // Create subnet.
     Subnet4Ptr subnet(new Subnet4(IOAddress("192.0.2.0"), 26, 1, 2, 3, 100));
 
+    Pool4Ptr pool(new Pool4(IOAddress("192.0.2.0"), 26));
+    subnet->addPool(pool);
+
     // Add subnet.
     cfg->add(subnet);
 
@@ -1861,31 +1864,61 @@ TEST(CfgSubnets4Test, updateStatistics) {
                                "total-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_FALSE(observation);
+
     cfg->updateStatistics();
 
     observation = StatsMgr::instance().getObservation(
@@ -1912,7 +1945,13 @@ TEST(CfgSubnets4Test, updateStatistics) {
         StatsMgr::generateName("subnet", subnet_id,
                                "total-addresses"));
     ASSERT_TRUE(observation);
-    ASSERT_EQ(0, observation->getInteger().first);
+    ASSERT_EQ(64, observation->getInteger().first);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(64, observation->getInteger().first);
 
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
@@ -1920,29 +1959,59 @@ TEST(CfgSubnets4Test, updateStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-addresses"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
 }
 
 // This test verifies that remove statistics works as expected.
@@ -1957,6 +2026,9 @@ TEST(CfgSubnets4Test, removeStatistics) {
     // Create subnet.
     Subnet4Ptr subnet(new Subnet4(IOAddress("192.0.2.0"), 26, 1, 2, 3, 100));
 
+    Pool4Ptr pool(new Pool4(IOAddress("192.0.2.0"), 26));
+    subnet->addPool(pool);
+
     // Add subnet.
     cfg.add(subnet);
 
@@ -1971,6 +2043,17 @@ TEST(CfgSubnets4Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-addresses"),
@@ -1982,6 +2065,17 @@ TEST(CfgSubnets4Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-addresses"),
@@ -1993,6 +2087,17 @@ TEST(CfgSubnets4Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"),
@@ -2004,6 +2109,17 @@ TEST(CfgSubnets4Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"),
@@ -2015,6 +2131,17 @@ TEST(CfgSubnets4Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"),
@@ -2026,6 +2153,17 @@ TEST(CfgSubnets4Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     // remove all statistics
     cfg.removeStatistics();
 
@@ -2034,30 +2172,60 @@ TEST(CfgSubnets4Test, removeStatistics) {
                                "total-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"));
     ASSERT_FALSE(observation);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_FALSE(observation);
 }
 
 // This test verifies that in range host reservation works as expected.

diff --git a/src/lib/dhcpsrv/tests/cfg_subnets6_unittest.cc b/src/lib/dhcpsrv/tests/cfg_subnets6_unittest.cc
index e5a5f511a0fe62ea313d36ea066627dc7f3093c8..309eb505f923384f1fa1580bccf40e15fef0c5eb 100644 (file)
--- a/src/lib/dhcpsrv/tests/cfg_subnets6_unittest.cc
+++ b/src/lib/dhcpsrv/tests/cfg_subnets6_unittest.cc
@@ -1618,6 +1618,12 @@ TEST(CfgSubnets6Test, updateStatistics) {
     // Create subnet.
     Subnet6Ptr subnet(new Subnet6(IOAddress("2001:db8:1::"), 48, 1, 2, 3, 4, 100));
 
+    Pool6Ptr pool(new Pool6(Lease::TYPE_NA, IOAddress("2001:db8:1::"), IOAddress("2001:db8:1::FF")));
+    subnet->addPool(pool);
+
+    pool.reset(new Pool6(Lease::TYPE_PD, IOAddress("3001:1:2::"), 96, 112));
+    subnet->addPool(pool);
+
     // Add subnet.
     cfg->add(subnet);
 
@@ -1646,46 +1652,96 @@ TEST(CfgSubnets6Test, updateStatistics) {
                                "total-nas"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-nas")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "total-pds"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "total-pds")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-nas"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-nas")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-pds"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "assigned-pds")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-nas"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-nas")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-pds"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "cumulative-assigned-pds")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_FALSE(observation);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "reclaimed-leases")));
+    ASSERT_FALSE(observation);
+
     cfg->updateStatistics();
 
     observation = StatsMgr::instance().getObservation(
@@ -1717,13 +1773,25 @@ TEST(CfgSubnets6Test, updateStatistics) {
         StatsMgr::generateName("subnet", subnet_id,
                                "total-nas"));
     ASSERT_TRUE(observation);
-    ASSERT_EQ(0, observation->getBigInteger().first);
+    ASSERT_EQ(256, observation->getBigInteger().first);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-nas")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(256, observation->getBigInteger().first);
 
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "total-pds"));
     ASSERT_TRUE(observation);
-    ASSERT_EQ(0, observation->getBigInteger().first);
+    ASSERT_EQ(65536, observation->getBigInteger().first);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "total-pds")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(65536, observation->getBigInteger().first);
 
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
@@ -1731,41 +1799,89 @@ TEST(CfgSubnets6Test, updateStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-nas")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-pds"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "assigned-pds")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-nas"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-nas")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-pds"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "cumulative-assigned-pds")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"));
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "reclaimed-leases")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
 }
 
 // This test verifies that remove statistics works as expected.
@@ -1780,6 +1896,12 @@ TEST(CfgSubnets6Test, removeStatistics) {
     // Create subnet.
     Subnet6Ptr subnet(new Subnet6(IOAddress("2001:db8:1::"), 48, 1, 2, 3, 4, 100));
 
+    Pool6Ptr pool(new Pool6(Lease::TYPE_NA, IOAddress("2001:db8:1::"), IOAddress("2001:db8:1::FF")));
+    subnet->addPool(pool);
+
+    pool.reset(new Pool6(Lease::TYPE_PD, IOAddress("3001:1:2::"), 96, 112));
+    subnet->addPool(pool);
+
     // Add subnet.
     cfg.add(subnet);
 
@@ -1794,6 +1916,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getBigInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-nas")),
+        int128_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-nas")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getBigInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "total-pds"),
@@ -1805,6 +1938,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getBigInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "total-pds")),
+        int128_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "total-pds")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getBigInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-nas"),
@@ -1816,6 +1960,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-nas")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-nas")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-pds"),
@@ -1827,6 +1982,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "assigned-pds")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "assigned-pds")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-nas"),
@@ -1838,6 +2004,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-nas")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-nas")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-pds"),
@@ -1849,6 +2026,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "cumulative-assigned-pds")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "cumulative-assigned-pds")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"),
@@ -1860,6 +2048,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"),
@@ -1871,6 +2070,17 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     StatsMgr::instance().setValue(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"),
@@ -1882,6 +2092,28 @@ TEST(CfgSubnets6Test, removeStatistics) {
     ASSERT_TRUE(observation);
     ASSERT_EQ(0, observation->getInteger().first);
 
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
+    StatsMgr::instance().setValue(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "reclaimed-leases")),
+        int64_t(0));
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "reclaimed-leases")));
+    ASSERT_TRUE(observation);
+    ASSERT_EQ(0, observation->getInteger().first);
+
     // remove all statistics
     cfg.removeStatistics();
 
@@ -1890,45 +2122,95 @@ TEST(CfgSubnets6Test, removeStatistics) {
                                "total-nas"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "total-nas")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "total-pds"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "total-pds")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-nas"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "assigned-nas")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "assigned-pds"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "assigned-pds")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-nas"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "cumulative-assigned-nas")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "cumulative-assigned-pds"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "cumulative-assigned-pds")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-declined-addresses"));
     ASSERT_FALSE(observation);
 
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-declined-addresses")));
+    ASSERT_FALSE(observation);
+
     observation = StatsMgr::instance().getObservation(
         StatsMgr::generateName("subnet", subnet_id,
                                "reclaimed-leases"));
     ASSERT_FALSE(observation);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pool", 0, "reclaimed-leases")));
+    ASSERT_FALSE(observation);
+
+    observation = StatsMgr::instance().getObservation(
+        StatsMgr::generateName("subnet", subnet_id,
+                               StatsMgr::generateName("pd-pool", 0, "reclaimed-leases")));
+    ASSERT_FALSE(observation);
 }
 
 // This test verifies that in range host reservation works as expected.

diff --git a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc
index c42ab8092b3df4539c7cd37afcae6f5e606ceff0..a452accd8540bbfced26ea63f4ceaf9e365369f4 100644 (file)
--- a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc
+++ b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.cc
@@ -808,7 +808,6 @@ GenericLeaseMgrTest::testBasicLease4() {
     detailCompareLease(leases[3], l_returned);
 }
 
-
 void
 GenericLeaseMgrTest::testBasicLease6() {
     // Get the leases to be used for the test.
@@ -2878,15 +2877,42 @@ GenericLeaseMgrTest::checkLeaseStats(const StatValMapList& expectedStats) {
     for (int subnet_idx = 0; subnet_idx < expectedStats.size(); ++subnet_idx) {
         BOOST_FOREACH(StatValPair expectedStat, expectedStats[subnet_idx]) {
             // Verify the per subnet value.
-            checkStat(stats::StatsMgr::generateName("subnet", subnet_idx+1,
+            checkStat(stats::StatsMgr::generateName("subnet", subnet_idx + 1,
                                                     expectedStat.first),
-                      expectedStat.second);
+                      expectedStat.second.value_);
+
+            if (expectedStat.second.check_pool_) {
+                if (expectedStat.first.find("pd") != string::npos) {
+                    checkStat(stats::StatsMgr::generateName("subnet", subnet_idx + 1,
+                                                            stats::StatsMgr::generateName("pd-pool", 0,
+                                                                                          expectedStat.first)),
+                              expectedStat.second.value_);
+                } else {
+                    checkStat(stats::StatsMgr::generateName("subnet", subnet_idx + 1,
+                                                            stats::StatsMgr::generateName("pool", 0,
+                                                                                          expectedStat.first)),
+                              expectedStat.second.value_);
+                }
+            } else {
+                string name;
+                if (expectedStat.first.find("pd") != string::npos) {
+                    name = stats::StatsMgr::generateName("subnet", subnet_idx + 1,
+                                                         stats::StatsMgr::generateName("pd-pool", 0,
+                                                         expectedStat.first));
+                } else {
+                    name = stats::StatsMgr::generateName("subnet", subnet_idx + 1,
+                                                         stats::StatsMgr::generateName("pool", 0,
+                                                         expectedStat.first));
+                }
+                ObservationPtr const obs(stats::StatsMgr::instance().getObservation(name));
+                ASSERT_FALSE(obs) << "stat " << name << " should not be present";
+            }
 
             // Add the value to globals as needed.
             if (expectedStat.first == "declined-addresses") {
-                declined_addresses += expectedStat.second;
+                declined_addresses += expectedStat.second.value_;
             } else if (expectedStat.first == "reclaimed-declined-addresses") {
-                reclaimed_declined_addresses += expectedStat.second;
+                reclaimed_declined_addresses += expectedStat.second.value_;
             }
         }
     }
@@ -2990,7 +3016,6 @@ GenericLeaseMgrTest::testRecountLeaseStats4() {
     subnet->addPool(pool);
     cfg->add(subnet);
 
-
     ASSERT_NO_THROW(CfgMgr::instance().commit());
 
     // Create the expected stats list.  At this point, the only stat
@@ -2999,6 +3024,7 @@ GenericLeaseMgrTest::testRecountLeaseStats4() {
     for (int i = 0; i < num_subnets; ++i) {
         expectedStats[i]["total-addresses"] = 256;
         expectedStats[i]["assigned-addresses"] = 0;
+        expectedStats[i]["cumulative-assigned-addresses"] = 0;
         expectedStats[i]["declined-addresses"] = 0;
         expectedStats[i]["reclaimed-declined-addresses"] = 0;
         expectedStats[i]["reclaimed-leases"] = 0;
@@ -3101,22 +3127,26 @@ GenericLeaseMgrTest::testRecountLeaseStats6() {
     cfg->add(subnet);
 
     ASSERT_NO_THROW(CfgMgr::instance().commit());
-
-
     // Create the expected stats list.  At this point, the only stat
     // that should be non-zero is total-nas/total-pds.
     for (int i = 0; i < num_subnets; ++i) {
         expectedStats[i]["assigned-nas"] = 0;
+        expectedStats[i]["cumulative-assigned-nas"] = 0;
         expectedStats[i]["declined-addresses"] = 0;
         expectedStats[i]["reclaimed-declined-addresses"] = 0;
-        expectedStats[i]["assigned-pds"] = 0;
         expectedStats[i]["reclaimed-leases"] = 0;
+        expectedStats[i]["assigned-pds"] = 0;
+        expectedStats[i]["cumulative-assigned-pds"] = 0;
     }
 
+    // Stats should not be present because the subnet has no PD pool.
+    expectedStats[subnet_id - 1]["total-pds"].check_pool_ = false;
+    expectedStats[subnet_id - 1]["assigned-pds"].check_pool_ = false;
+    expectedStats[subnet_id - 1]["cumulative-assigned-pds"].check_pool_ = false;
+
     // Make sure stats are as expected.
     ASSERT_NO_FATAL_FAILURE(checkLeaseStats(expectedStats));
 
-
     // Recount stats.  We should have the same results.
     ASSERT_NO_THROW(lmptr_->recountLeaseStats6());
 
@@ -3744,7 +3774,6 @@ GenericLeaseMgrTest::testLeaseStatsQuery6() {
         checkQueryAgainstRowSet(query, expected_rows);
     }
 
-
     // Now let's insert some leases into subnet 1.
     // Three assigned NAs.
     // Two declined NAs.

diff --git a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h
index b0d64eb56a597c40a91bb4ce4631fa9c67606ff2..50e4424729cb59c67ca28e13a25f4a407baa8819 100644 (file)
--- a/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h
+++ b/src/lib/dhcpsrv/tests/generic_lease_mgr_unittest.h
@@ -22,8 +22,18 @@ namespace dhcp {
 namespace test {
 
 /// @brief typedefs to simplify lease statistic testing
-typedef std::map<std::string, int64_t> StatValMap;
-typedef std::pair<std::string, int64_t> StatValPair;
+struct SubnetPoolVal {
+    int64_t value_;
+    bool check_pool_;
+    SubnetPoolVal() : value_(0), check_pool_(true) {
+    };
+    SubnetPoolVal(int64_t value) : value_(value), check_pool_(true) {
+    };
+    SubnetPoolVal(int64_t value, bool check) : value_(value), check_pool_(check) {
+    };
+};
+typedef std::map<std::string, SubnetPoolVal> StatValMap;
+typedef std::pair<std::string, SubnetPoolVal> StatValPair;
 typedef std::vector<StatValMap> StatValMapList;
 typedef std::set<LeaseStatsRow> RowSet;