Reporting: Implement garbage collector.

net/reporting/reporting_garbage_collector_unittest.cc

Index: net/reporting/reporting_garbage_collector_unittest.cc
diff --git a/net/reporting/reporting_garbage_collector_unittest.cc b/net/reporting/reporting_garbage_collector_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e95593f01bd2aae79a470e73562effabb1c22701
--- /dev/null
+++ b/net/reporting/reporting_garbage_collector_unittest.cc
@@ -0,0 +1,106 @@
+// 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_garbage_collector.h"
+
+#include <string>
+
+#include "base/memory/ptr_util.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "base/time/time.h"
+#include "net/reporting/reporting_cache.h"
+#include "net/reporting/reporting_report.h"
+#include "net/reporting/reporting_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+namespace {
+
+const GURL kUrl("https://origin/path");
+const std::string kGroup("group");
+const std::string kType("default");
+
+class ReportingGarbageCollectorTest : public ::testing::Test {
+ protected:
+  ReportingGarbageCollectorTest() {
+    policy_.report_max_age = base::TimeDelta::FromMinutes(15);
+    policy_.report_max_attempts = 5;
+    policy_.report_persist_across_network_changes = false;
+  }
+
+  void CollectGarbage(bool network_changed) {
+    ReportingGarbageCollector::CollectGarbage(
+        &cache_, policy_, clock_.NowTicks(), network_changed);
+  }
+
+  size_t report_count() {
+    std::vector<const ReportingReport*> reports;
+    cache_.GetReports(&reports);
+    return reports.size();
+  }
+
+  base::SimpleTestTickClock clock_;
+  ReportingCache cache_;
+  ReportingGarbageCollector::Policy policy_;
+};
+
+TEST_F(ReportingGarbageCollectorTest, Report) {
+  cache_.AddReport(kUrl, kGroup, kType,
+                   base::MakeUnique<base::DictionaryValue>(), clock_.NowTicks(),
+                   0);
+
+  CollectGarbage(/* network_changed= */ false);
+  EXPECT_EQ(1u, report_count());
+}
+
+TEST_F(ReportingGarbageCollectorTest, ExpiredReport) {
+  cache_.AddReport(kUrl, kGroup, kType,
+                   base::MakeUnique<base::DictionaryValue>(), clock_.NowTicks(),
+                   0);
+
+  clock_.Advance(2 * policy_.report_max_age);
+
+  CollectGarbage(/* network_changed= */ false);
+  EXPECT_EQ(0u, report_count());
+}
+
+TEST_F(ReportingGarbageCollectorTest, FailedReport) {
+  cache_.AddReport(kUrl, kGroup, kType,
+                   base::MakeUnique<base::DictionaryValue>(), clock_.NowTicks(),
+                   0);
+
+  std::vector<const ReportingReport*> reports;
+  cache_.GetReports(&reports);
+  for (int i = 0; i < policy_.report_max_attempts; i++) {
+    cache_.IncrementReportsAttempts(reports);
+  }
+
+  CollectGarbage(/* network_changed= */ false);
+  EXPECT_EQ(0u, report_count());
+}
+
+TEST_F(ReportingGarbageCollectorTest, NetworkChangePersist) {
+  policy_.report_persist_across_network_changes = true;
+
+  cache_.AddReport(kUrl, kGroup, kType,
+                   base::MakeUnique<base::DictionaryValue>(), clock_.NowTicks(),
+                   0);
+
+  CollectGarbage(/* network_changed= */ true);
+  EXPECT_EQ(1u, report_count());
+}
+
+TEST_F(ReportingGarbageCollectorTest, NetworkChangeClear) {
+  policy_.report_persist_across_network_changes = false;
+
+  cache_.AddReport(kUrl, kGroup, kType,
+                   base::MakeUnique<base::DictionaryValue>(), clock_.NowTicks(),
+                   0);
+
+  CollectGarbage(/* network_changed= */ true);
+  EXPECT_EQ(0u, report_count());
+}
+
+}  // namespace
+}  // namespace net