Reporting: Cap number of clients in cache.

net/reporting/reporting_cache_unittest.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/reporting/reporting_cache.h"
 
 #include <string>
 
 #include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/reporting/reporting_client.h"
 #include "net/reporting/reporting_observer.h"
 #include "net/reporting/reporting_report.h"
 #include "net/reporting/reporting_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace net {
 namespace {
 
 class TestReportingObserver : public ReportingObserver {
  public:
   TestReportingObserver() : cache_update_count_(0) {}
 
   void OnCacheUpdated() override { ++cache_update_count_; }
 
   int cache_update_count() const { return cache_update_count_; }
 
  private:
   int cache_update_count_;
 };
 
 class ReportingCacheTest : public ReportingTestBase {
  protected:
   ReportingCacheTest() : ReportingTestBase() {
+    ReportingPolicy policy;
+    policy.max_report_count = 5;
+    policy.max_client_count = 5;
+    UsePolicy(policy);
+
     context()->AddObserver(&observer_);
   }
 
   ~ReportingCacheTest() override { context()->RemoveObserver(&observer_); }
 
   TestReportingObserver* observer() { return &observer_; }
 
   size_t report_count() {
     std::vector<const ReportingReport*> reports;
     cache()->GetReports(&reports);
     return reports.size();
   }
 
+  size_t client_count() {
+    std::vector<const ReportingClient*> clients;
+    cache()->GetClients(&clients);
+    return clients.size();
+  }
+
   const GURL kUrl1_ = GURL("https://origin1/path");
   const url::Origin kOrigin1_ = url::Origin(GURL("https://origin1/"));
   const url::Origin kOrigin2_ = url::Origin(GURL("https://origin2/"));
   const GURL kEndpoint1_ = GURL("https://endpoint1/");
   const GURL kEndpoint2_ = GURL("https://endpoint2/");
   const std::string kGroup1_ = "group1";
   const std::string kGroup2 = "group2";
   const std::string kType_ = "default";
   const base::TimeTicks kNow_ = base::TimeTicks::Now();
   const base::TimeTicks kExpires1_ = kNow_ + base::TimeDelta::FromDays(7);
@@ skipping 338 matching lines @@
   cache()->SetClient(kSuperSuperOrigin, kEndpoint1_,
                      ReportingClient::Subdomains::INCLUDE, kGroup1_,
                      kExpires1_);
 
   std::vector<const ReportingClient*> clients;
   cache()->GetClientsForOriginAndGroup(kOrigin, kGroup1_, &clients);
   ASSERT_EQ(1u, clients.size());
   EXPECT_EQ(kSuperOrigin, clients[0]->origin);
 }
 
-TEST_F(ReportingCacheTest, EvictOldest) {
-  ASSERT_LT(0u, policy().max_report_count);
-  ASSERT_GT(std::numeric_limits<size_t>::max(), policy().max_report_count);
+TEST_F(ReportingCacheTest, EvictOldestReport) {
+  size_t max_report_count = policy().max_report_count;
+
+  ASSERT_LT(0u, max_report_count);
+  ASSERT_GT(std::numeric_limits<size_t>::max(), max_report_count);
 
   base::TimeTicks earliest_queued = tick_clock()->NowTicks();
 
   // Enqueue the maximum number of reports, spaced apart in time.
-  for (size_t i = 0; i < policy().max_report_count; ++i) {
+  for (size_t i = 0; i < max_report_count; ++i) {
     cache()->AddReport(kUrl1_, kGroup1_, kType_,
                        base::MakeUnique<base::DictionaryValue>(),
                        tick_clock()->NowTicks(), 0);
     tick_clock()->Advance(base::TimeDelta::FromMinutes(1));
   }
-  EXPECT_EQ(policy().max_report_count, report_count());
+  EXPECT_EQ(max_report_count, report_count());
 
   // Add one more report to force the cache to evict one.
   cache()->AddReport(kUrl1_, kGroup1_, kType_,
                      base::MakeUnique<base::DictionaryValue>(), kNow_, 0);
 
   // Make sure the cache evicted a report to make room for the new one, and make
   // sure the report evicted was the earliest-queued one.
   std::vector<const ReportingReport*> reports;
   cache()->GetReports(&reports);
-  EXPECT_EQ(policy().max_report_count, reports.size());
+  EXPECT_EQ(max_report_count, reports.size());
   for (const ReportingReport* report : reports)
     EXPECT_NE(earliest_queued, report->queued);
 }
 
 TEST_F(ReportingCacheTest, DontEvictPendingReports) {
-  ASSERT_LT(0u, policy().max_report_count);
-  ASSERT_GT(std::numeric_limits<size_t>::max(), policy().max_report_count);
+  size_t max_report_count = policy().max_report_count;
+
+  ASSERT_LT(0u, max_report_count);
+  ASSERT_GT(std::numeric_limits<size_t>::max(), max_report_count);
 
   // Enqueue the maximum number of reports, spaced apart in time.
-  for (size_t i = 0; i < policy().max_report_count; ++i) {
+  for (size_t i = 0; i < max_report_count; ++i) {
     cache()->AddReport(kUrl1_, kGroup1_, kType_,
                        base::MakeUnique<base::DictionaryValue>(),
                        tick_clock()->NowTicks(), 0);
     tick_clock()->Advance(base::TimeDelta::FromMinutes(1));
   }
-  EXPECT_EQ(policy().max_report_count, report_count());
+  EXPECT_EQ(max_report_count, report_count());
 
   // Mark all of the queued reports pending.
   std::vector<const ReportingReport*> queued_reports;
   cache()->GetReports(&queued_reports);
   cache()->SetReportsPending(queued_reports);
 
   // Add one more report to force the cache to evict one. Since the cache has
   // only pending reports, it will be forced to evict the *new* report!
   cache()->AddReport(kUrl1_, kGroup1_, kType_,
                      base::MakeUnique<base::DictionaryValue>(), kNow_, 0);
 
   // Make sure the cache evicted a report, and make sure the report evicted was
   // the new, non-pending one.
   std::vector<const ReportingReport*> reports;
   cache()->GetReports(&reports);
-  EXPECT_EQ(policy().max_report_count, reports.size());
+  EXPECT_EQ(max_report_count, reports.size());
   for (const ReportingReport* report : reports)
     EXPECT_TRUE(cache()->IsReportPendingForTesting(report));
 }
 
+GURL MakeEndpoint(size_t index) {
+  return GURL(base::StringPrintf("https://endpoint/%zd", index));
+}
+
+TEST_F(ReportingCacheTest, EvictLRUClient) {
+  size_t max_client_count = policy().max_client_count;
+
+  ASSERT_LT(0u, max_client_count);
+  ASSERT_GT(std::numeric_limits<size_t>::max(), max_client_count);
+
+  for (size_t i = 0; i < max_client_count; ++i) {
+    cache()->SetClient(kOrigin1_, MakeEndpoint(i),
+                       ReportingClient::Subdomains::EXCLUDE, kGroup1_,
+                       tomorrow());
+  }
+  EXPECT_EQ(max_client_count, client_count());
+
+  // Use clients in reverse order, so client (max_client_count - 1) is LRU.
+  for (size_t i = 1; i <= max_client_count; ++i) {
+    cache()->MarkClientUsed(kOrigin1_, MakeEndpoint(max_client_count - i));
+    tick_clock()->Advance(base::TimeDelta::FromSeconds(1));
+  }
+
+  // Add one more client, forcing the cache to evict the LRU.
+  cache()->SetClient(kOrigin1_, MakeEndpoint(max_client_count),
+                     ReportingClient::Subdomains::EXCLUDE, kGroup1_,
+                     tomorrow());
+  EXPECT_EQ(max_client_count, client_count());
+  EXPECT_FALSE(FindClientInCache(cache(), kOrigin1_,
+                                 MakeEndpoint(max_client_count - 1)));
+}
+
+TEST_F(ReportingCacheTest, EvictExpiredClient) {
+  size_t max_client_count = policy().max_client_count;
+
+  ASSERT_LT(0u, max_client_count);
+  ASSERT_GT(std::numeric_limits<size_t>::max(), max_client_count);
+
+  for (size_t i = 0; i < max_client_count; ++i) {
+    base::TimeTicks expires =
+        (i == max_client_count - 1) ? yesterday() : tomorrow();
+    cache()->SetClient(kOrigin1_, MakeEndpoint(i),
+                       ReportingClient::Subdomains::EXCLUDE, kGroup1_, expires);
+  }
+  EXPECT_EQ(max_client_count, client_count());
+
+  // Add one more client, forcing the cache to evict the expired one.
+  cache()->SetClient(kOrigin1_, MakeEndpoint(max_client_count),
+                     ReportingClient::Subdomains::EXCLUDE, kGroup1_,
+                     tomorrow());
+  EXPECT_EQ(max_client_count, client_count());
+  EXPECT_FALSE(FindClientInCache(cache(), kOrigin1_,
+                                 MakeEndpoint(max_client_count - 1)));
+}
+
 }  // namespace
 }  // namespace net