Add a PersistentStore to FeatureEngagementTracker

components/feature_engagement_tracker/internal/model_impl_unittest.cc

Index: components/feature_engagement_tracker/internal/model_impl_unittest.cc
diff --git a/components/feature_engagement_tracker/internal/model_impl_unittest.cc b/components/feature_engagement_tracker/internal/model_impl_unittest.cc
index fff5e72e187614051b30eaa5b538750a30dae67e..b94d2a46618fb62a93de96b9e3ba5796ec5ec479 100644
--- a/components/feature_engagement_tracker/internal/model_impl_unittest.cc
+++ b/components/feature_engagement_tracker/internal/model_impl_unittest.cc
@@ -18,6 +18,7 @@
 #include "components/feature_engagement_tracker/internal/in_memory_store.h"
 #include "components/feature_engagement_tracker/internal/never_storage_validator.h"
 #include "components/feature_engagement_tracker/internal/proto/event.pb.h"
+#include "components/feature_engagement_tracker/internal/test/event_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace feature_engagement_tracker {
@@ -37,42 +38,6 @@ void RegisterFeatureConfig(EditableConfiguration* configuration,
   configuration->SetConfiguration(&feature, config);
 }
 
-void SetEventCountForDay(Event* event, uint32_t day, uint32_t count) {
-  Event_Count* event_count = event->add_events();
-  event_count->set_day(day);
-  event_count->set_count(count);
-}
-
-// Verifies that the given |event| contains a |day| with the correct |count|,
-// and that the day only exists a single time.
-void VerifyEventCount(const Event* event, uint32_t day, uint32_t count) {
-  bool found_day = false;
-  for (int i = 0; i < event->events_size(); ++i) {
-    Event_Count event_count = event->events(i);
-    if (event_count.day() == day) {
-      EXPECT_FALSE(found_day);
-      found_day = true;
-      EXPECT_EQ(count, event_count.count());
-    }
-  }
-  EXPECT_TRUE(found_day);
-}
-
-// Verifies that the event |a| and |b| contain the exact same data.
-void VerifyEqual(const Event* a, const Event* b) {
-  if (!a || !b) {
-    // If one of the events are nullptr, both should be nullptr.
-    ASSERT_EQ(a, b);
-    return;
-  }
-
-  EXPECT_EQ(a->name(), b->name());
-  EXPECT_EQ(a->events_size(), b->events_size());
-  for (int i = 0; i < a->events_size(); ++i) {
-    VerifyEventCount(b, a->events(i).day(), a->events(i).count());
-  }
-}
-
 // A test-only implementation of InMemoryStore that tracks calls to
 // WriteEvent(...).
 class TestInMemoryStore : public InMemoryStore {
@@ -108,21 +73,21 @@ std::unique_ptr<TestInMemoryStore> CreatePrefilledStore() {
 
   Event foo;
   foo.set_name("foo");
-  SetEventCountForDay(&foo, 1, 1);
+  test::SetEventCountForDay(&foo, 1, 1);
   events->push_back(foo);
 
   Event bar;
   bar.set_name("bar");
-  SetEventCountForDay(&bar, 1, 3);
-  SetEventCountForDay(&bar, 2, 3);
-  SetEventCountForDay(&bar, 5, 5);
+  test::SetEventCountForDay(&bar, 1, 3);
+  test::SetEventCountForDay(&bar, 2, 3);
+  test::SetEventCountForDay(&bar, 5, 5);
   events->push_back(bar);
 
   Event qux;
   qux.set_name("qux");
-  SetEventCountForDay(&qux, 1, 5);
-  SetEventCountForDay(&qux, 2, 1);
-  SetEventCountForDay(&qux, 3, 2);
+  test::SetEventCountForDay(&qux, 1, 5);
+  test::SetEventCountForDay(&qux, 2, 1);
+  test::SetEventCountForDay(&qux, 3, 2);
   events->push_back(qux);
 
   return base::MakeUnique<TestInMemoryStore>(std::move(events), true);
@@ -195,21 +160,21 @@ TEST_F(ModelImplTest, InitializeShouldLoadEntries) {
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ("foo", foo_event->name());
   EXPECT_EQ(1, foo_event->events_size());
-  VerifyEventCount(foo_event, 1u, 1u);
+  test::VerifyEventCount(foo_event, 1u, 1u);
 
   const Event* bar_event = model_->GetEvent("bar");
   EXPECT_EQ("bar", bar_event->name());
   EXPECT_EQ(3, bar_event->events_size());
-  VerifyEventCount(bar_event, 1u, 3u);
-  VerifyEventCount(bar_event, 2u, 3u);
-  VerifyEventCount(bar_event, 5u, 5u);
+  test::VerifyEventCount(bar_event, 1u, 3u);
+  test::VerifyEventCount(bar_event, 2u, 3u);
+  test::VerifyEventCount(bar_event, 5u, 5u);
 
   const Event* qux_event = model_->GetEvent("qux");
   EXPECT_EQ("qux", qux_event->name());
   EXPECT_EQ(3, qux_event->events_size());
-  VerifyEventCount(qux_event, 1u, 5u);
-  VerifyEventCount(qux_event, 2u, 1u);
-  VerifyEventCount(qux_event, 3u, 2u);
+  test::VerifyEventCount(qux_event, 1u, 5u);
+  test::VerifyEventCount(qux_event, 2u, 1u);
+  test::VerifyEventCount(qux_event, 3u, 2u);
 }
 
 TEST_F(ModelImplTest, RetrievingNewEventsShouldYieldNullptr) {
@@ -220,7 +185,7 @@ TEST_F(ModelImplTest, RetrievingNewEventsShouldYieldNullptr) {
 
   const Event* no_event = model_->GetEvent("no");
   EXPECT_EQ(nullptr, no_event);
-  VerifyEqual(nullptr, store_->GetLastWrittenEvent());
+  test::VerifyEventsEqual(nullptr, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingNonExistingEvent) {
@@ -234,8 +199,8 @@ TEST_F(ModelImplTest, IncrementingNonExistingEvent) {
   const Event* event1 = model_->GetEvent("nonexisting");
   EXPECT_EQ("nonexisting", event1->name());
   EXPECT_EQ(1, event1->events_size());
-  VerifyEventCount(event1, 1u, 1u);
-  VerifyEqual(event1, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(event1, 1u, 1u);
+  test::VerifyEventsEqual(event1, store_->GetLastWrittenEvent());
 
   // Incrementing the event after it has been initialized to 1, it should now
   // have a count of 2 for the given day.
@@ -243,8 +208,8 @@ TEST_F(ModelImplTest, IncrementingNonExistingEvent) {
   const Event* event2 = model_->GetEvent("nonexisting");
   Event_Count event2_count = event2->events(0);
   EXPECT_EQ(1, event2->events_size());
-  VerifyEventCount(event2, 1u, 2u);
-  VerifyEqual(event2, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(event2, 1u, 2u);
+  test::VerifyEventsEqual(event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingNonExistingEventMultipleDays) {
@@ -259,10 +224,10 @@ TEST_F(ModelImplTest, IncrementingNonExistingEventMultipleDays) {
   model_->IncrementEvent("nonexisting", 3u);
   const Event* event = model_->GetEvent("nonexisting");
   EXPECT_EQ(3, event->events_size());
-  VerifyEventCount(event, 1u, 1u);
-  VerifyEventCount(event, 2u, 2u);
-  VerifyEventCount(event, 3u, 1u);
-  VerifyEqual(event, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(event, 1u, 1u);
+  test::VerifyEventCount(event, 2u, 2u);
+  test::VerifyEventCount(event, 3u, 1u);
+  test::VerifyEventsEqual(event, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingSingleDayExistingEvent) {
@@ -275,14 +240,14 @@ TEST_F(ModelImplTest, IncrementingSingleDayExistingEvent) {
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ("foo", foo_event->name());
   EXPECT_EQ(1, foo_event->events_size());
-  VerifyEventCount(foo_event, 1u, 1u);
+  test::VerifyEventCount(foo_event, 1u, 1u);
 
   // Incrementing |foo| should change count to 2.
   model_->IncrementEvent("foo", 1u);
   const Event* foo_event2 = model_->GetEvent("foo");
   EXPECT_EQ(1, foo_event2->events_size());
-  VerifyEventCount(foo_event2, 1u, 2u);
-  VerifyEqual(foo_event2, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(foo_event2, 1u, 2u);
+  test::VerifyEventsEqual(foo_event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingSingleDayExistingEventTwice) {
@@ -297,8 +262,8 @@ TEST_F(ModelImplTest, IncrementingSingleDayExistingEventTwice) {
   model_->IncrementEvent("foo", 1u);
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ(1, foo_event->events_size());
-  VerifyEventCount(foo_event, 1u, 3u);
-  VerifyEqual(foo_event, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(foo_event, 1u, 3u);
+  test::VerifyEventsEqual(foo_event, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingExistingMultiDayEvent) {
@@ -310,11 +275,11 @@ TEST_F(ModelImplTest, IncrementingExistingMultiDayEvent) {
   // |bar| is inserted into the store with a count of 3 at day 2. Incrementing
   // that day should lead to a count of 4.
   const Event* bar_event = model_->GetEvent("bar");
-  VerifyEventCount(bar_event, 2u, 3u);
+  test::VerifyEventCount(bar_event, 2u, 3u);
   model_->IncrementEvent("bar", 2u);
   const Event* bar_event2 = model_->GetEvent("bar");
-  VerifyEventCount(bar_event2, 2u, 4u);
-  VerifyEqual(bar_event2, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(bar_event2, 2u, 4u);
+  test::VerifyEventsEqual(bar_event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingExistingMultiDayEventNewDay) {
@@ -327,12 +292,12 @@ TEST_F(ModelImplTest, IncrementingExistingMultiDayEventNewDay) {
   // the day.
   model_->IncrementEvent("bar", 10u);
   const Event* bar_event = model_->GetEvent("bar");
-  VerifyEventCount(bar_event, 10u, 1u);
-  VerifyEqual(bar_event, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(bar_event, 10u, 1u);
+  test::VerifyEventsEqual(bar_event, store_->GetLastWrittenEvent());
   model_->IncrementEvent("bar", 10u);
   const Event* bar_event2 = model_->GetEvent("bar");
-  VerifyEventCount(bar_event2, 10u, 2u);
-  VerifyEqual(bar_event2, store_->GetLastWrittenEvent());
+  test::VerifyEventCount(bar_event2, 10u, 2u);
+  test::VerifyEventsEqual(bar_event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, ShowState) {