Support IPH NotifyEvent calls before Initialize

components/feature_engagement_tracker/internal/model_impl_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 "components/feature_engagement_tracker/internal/model_impl.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "components/feature_engagement_tracker/internal/editable_configuration.h"
 #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 {
 
 namespace {
@@ skipping 97 matching lines @@
   test::SetEventCountForDay(&qux, 2, 1);
   test::SetEventCountForDay(&qux, 3, 2);
   events->push_back(qux);
 
   return base::MakeUnique<TestInMemoryStore>(std::move(events), true);
 }
 
 class ModelImplTest : public ::testing::Test {
  public:
   ModelImplTest()
-      : got_initialize_callback_(false), initialize_callback_result_(false) {}
+      : task_runner_(new base::TestSimpleTaskRunner),
+        handle_(task_runner_),
+        got_initialize_callback_(false),
+        initialize_callback_result_(false) {}
 
   void SetUp() override {
     std::unique_ptr<TestInMemoryStore> store = CreateStore();
     store_ = store.get();
 
     auto storage_validator = base::MakeUnique<TestStorageValidator>();
     storage_validator_ = storage_validator.get();
 
     model_.reset(new ModelImpl(std::move(store), std::move(storage_validator)));
 
     // By default store all events for a very long time.
     storage_validator_->SetMaxKeepAge("foo", 10000u);
     storage_validator_->SetMaxKeepAge("bar", 10000u);
     storage_validator_->SetMaxKeepAge("qux", 10000u);
   }
 
   virtual std::unique_ptr<TestInMemoryStore> CreateStore() {
     return CreatePrefilledStore();
   }
 
   void OnModelInitializationFinished(bool success) {
     got_initialize_callback_ = true;
     initialize_callback_result_ = success;
   }
 
  protected:
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::ThreadTaskRunnerHandle handle_;
+
   std::unique_ptr<ModelImpl> model_;
   TestInMemoryStore* store_;
   TestStorageValidator* storage_validator_;
   bool got_initialize_callback_;
   bool initialize_callback_result_;
-
- private:
-  base::MessageLoop message_loop_;
 };
 
 class LoadFailingModelImplTest : public ModelImplTest {
  public:
   LoadFailingModelImplTest() : ModelImplTest() {}
 
   std::unique_ptr<TestInMemoryStore> CreateStore() override {
     return base::MakeUnique<TestInMemoryStore>(
         base::MakeUnique<std::vector<Event>>(), false);
   }
 };
 
 }  // namespace
 
+TEST_F(ModelImplTest, InitializeShouldBeReadyImmediatelyAfterCallback) {
+  model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
+                                base::Unretained(this)),
+                     1000u);
+
+  // Only run pending tasks on the queue.  Do not run any subsequently queued
+  // tasks that result from running the current pending tasks.
+  task_runner_->RunPendingTasks();
+
+  EXPECT_TRUE(got_initialize_callback_);
+  EXPECT_TRUE(model_->IsReady());
+}
+
 TEST_F(ModelImplTest, InitializeShouldLoadEntries) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
   EXPECT_TRUE(got_initialize_callback_);
   EXPECT_TRUE(initialize_callback_result_);
 
   // Verify that all the data matches what was put into the store in
   // CreateStore().
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ("foo", foo_event->name());
   EXPECT_EQ(1, foo_event->events_size());
   test::VerifyEventCount(foo_event, 1u, 1u);
@@ skipping 19 matching lines @@
 
   // Back to day 2, i.e. 2 events.
   storage_validator_->SetMaxKeepAge("bar", 4u);
 
   // Back to day epoch, i.e. all events.
   storage_validator_->SetMaxKeepAge("qux", 10u);
 
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      5u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
   EXPECT_TRUE(got_initialize_callback_);
   EXPECT_TRUE(initialize_callback_result_);
 
   // Verify that all the data matches what was put into the store in
   // CreateStore(), minus the events that should no longer exist.
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ(nullptr, foo_event);
   EXPECT_EQ("foo", store_->GetLastDeletedEvent());
 
@@ skipping 14 matching lines @@
 
   // In total, only two operations should have happened, the update of "bar",
   // and the delete of "foo".
   EXPECT_EQ(2u, store_->GetStoreOperationCount());
 }
 
 TEST_F(ModelImplTest, RetrievingNewEventsShouldYieldNullptr) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   const Event* no_event = model_->GetEvent("no");
   EXPECT_EQ(nullptr, no_event);
   test::VerifyEventsEqual(nullptr, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingNonExistingEvent) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   // Incrementing the event should work even if it does not exist.
   model_->IncrementEvent("nonexisting", 1u);
   const Event* event1 = model_->GetEvent("nonexisting");
   ASSERT_NE(nullptr, event1);
   EXPECT_EQ("nonexisting", event1->name());
   EXPECT_EQ(1, event1->events_size());
   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.
   model_->IncrementEvent("nonexisting", 1u);
   const Event* event2 = model_->GetEvent("nonexisting");
   ASSERT_NE(nullptr, event2);
   Event_Count event2_count = event2->events(0);
   EXPECT_EQ(1, event2->events_size());
   test::VerifyEventCount(event2, 1u, 2u);
   test::VerifyEventsEqual(event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingNonExistingEventMultipleDays) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   model_->IncrementEvent("nonexisting", 1u);
   model_->IncrementEvent("nonexisting", 2u);
   model_->IncrementEvent("nonexisting", 2u);
   model_->IncrementEvent("nonexisting", 3u);
   const Event* event = model_->GetEvent("nonexisting");
   ASSERT_NE(nullptr, event);
   EXPECT_EQ(3, event->events_size());
   test::VerifyEventCount(event, 1u, 1u);
   test::VerifyEventCount(event, 2u, 2u);
   test::VerifyEventCount(event, 3u, 1u);
   test::VerifyEventsEqual(event, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingNonExistingEventWithoutStoring) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   storage_validator_->SetShouldStore(false);
 
   // Incrementing the event should not be written or stored in-memory.
   model_->IncrementEvent("nonexisting", 1u);
   const Event* event1 = model_->GetEvent("nonexisting");
   EXPECT_EQ(nullptr, event1);
   test::VerifyEventsEqual(nullptr, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingExistingEventWithoutStoring) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   // Write one event before turning off storage.
   model_->IncrementEvent("nonexisting", 1u);
   const Event* first_event = model_->GetEvent("nonexisting");
   ASSERT_NE(nullptr, first_event);
   test::VerifyEventsEqual(first_event, store_->GetLastWrittenEvent());
 
   storage_validator_->SetShouldStore(false);
 
   // Incrementing the event should no longer be written or stored in-memory.
   model_->IncrementEvent("nonexisting", 1u);
   const Event* second_event = model_->GetEvent("nonexisting");
   EXPECT_EQ(first_event, second_event);
   test::VerifyEventsEqual(first_event, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingSingleDayExistingEvent) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   // |foo| is inserted into the store with a count of 1 at day 1.
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ("foo", foo_event->name());
   EXPECT_EQ(1, foo_event->events_size());
   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());
   test::VerifyEventCount(foo_event2, 1u, 2u);
   test::VerifyEventsEqual(foo_event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingSingleDayExistingEventTwice) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   // |foo| is inserted into the store with a count of 1 at day 1, so
   // incrementing twice should lead to 3.
   model_->IncrementEvent("foo", 1u);
   model_->IncrementEvent("foo", 1u);
   const Event* foo_event = model_->GetEvent("foo");
   EXPECT_EQ(1, foo_event->events_size());
   test::VerifyEventCount(foo_event, 1u, 3u);
   test::VerifyEventsEqual(foo_event, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingExistingMultiDayEvent) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   // |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");
   test::VerifyEventCount(bar_event, 2u, 3u);
   model_->IncrementEvent("bar", 2u);
   const Event* bar_event2 = model_->GetEvent("bar");
   test::VerifyEventCount(bar_event2, 2u, 4u);
   test::VerifyEventsEqual(bar_event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(ModelImplTest, IncrementingExistingMultiDayEventNewDay) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_TRUE(model_->IsReady());
 
   // |bar| does not contain entries for day 10, so incrementing should create
   // the day.
   model_->IncrementEvent("bar", 10u);
   const Event* bar_event = model_->GetEvent("bar");
   test::VerifyEventCount(bar_event, 10u, 1u);
   test::VerifyEventsEqual(bar_event, store_->GetLastWrittenEvent());
   model_->IncrementEvent("bar", 10u);
   const Event* bar_event2 = model_->GetEvent("bar");
   test::VerifyEventCount(bar_event2, 10u, 2u);
   test::VerifyEventsEqual(bar_event2, store_->GetLastWrittenEvent());
 }
 
 TEST_F(LoadFailingModelImplTest, FailedInitializeInformsCaller) {
   model_->Initialize(base::Bind(&ModelImplTest::OnModelInitializationFinished,
                                 base::Unretained(this)),
                      1000u);
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
   EXPECT_FALSE(model_->IsReady());
   EXPECT_TRUE(got_initialize_callback_);
   EXPECT_FALSE(initialize_callback_result_);
 }
 
 }  // namespace feature_engagement_tracker