[Sync] Split UserEventService into interface and impl, add fake impl, add unit tests.

chrome/browser/ui/webui/sync_internals_message_handler_unittest.cc

 // Copyright 2015 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 "chrome/browser/ui/webui/sync_internals_message_handler.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/user_event_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/browser_sync/browser_sync_switches.h"
 #include "components/sync/driver/about_sync_util.h"
 #include "components/sync/driver/fake_sync_service.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync/js/js_test_util.h"
+#include "components/sync/user_events/fake_user_event_service.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_web_ui.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
+using syncer::FakeUserEventService;
 using syncer::SyncService;
 using syncer::SyncServiceObserver;
 using syncer::TypeDebugInfoObserver;
 
 namespace {
 
 class TestableSyncInternalsMessageHandler : public SyncInternalsMessageHandler {
  public:
   TestableSyncInternalsMessageHandler(
       content::WebUI* web_ui,
@@ skipping 51 matching lines @@
   syncer::MockJsController js_controller_;
   base::Callback<void(std::unique_ptr<base::ListValue>)>
       get_all_nodes_callback_;
 };
 
 static std::unique_ptr<KeyedService> BuildTestSyncService(
     content::BrowserContext* context) {
   return base::MakeUnique<TestSyncService>();
 }
 
+static std::unique_ptr<KeyedService> BuildFakeUserEventService(
+    content::BrowserContext* context) {
+  return base::MakeUnique<FakeUserEventService>();
+}
+
 class SyncInternalsMessageHandlerTest : public ::testing::Test {
  protected:
   SyncInternalsMessageHandlerTest() {
     site_instance_ = content::SiteInstance::Create(&profile_);
     web_contents_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(&profile_, site_instance_.get())));
     web_ui_.set_web_contents(web_contents_.get());
     test_sync_service_ = static_cast<TestSyncService*>(
         ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, &BuildTestSyncService));
+    fake_user_event_service_ = static_cast<FakeUserEventService*>(
+        browser_sync::UserEventServiceFactory::GetInstance()
+            ->SetTestingFactoryAndUse(&profile_, &BuildFakeUserEventService));
     handler_.reset(new TestableSyncInternalsMessageHandler(
         &web_ui_,
         base::BindRepeating(
             &SyncInternalsMessageHandlerTest::ConstructAboutInformation,
             base::Unretained(this))));
   }
 
   std::unique_ptr<DictionaryValue> ConstructAboutInformation(
       SyncService* service,
       version_info::Channel channel) {
@@ skipping 31 matching lines @@
   }
 
   void ValidateEmptyAboutInfoCall() {
     EXPECT_TRUE(web_ui_.call_data().empty());
   }
 
   TestingProfile* profile() { return &profile_; }
 
   TestSyncService* test_sync_service() { return test_sync_service_; }
 
+  FakeUserEventService* fake_user_event_service() {
+    return fake_user_event_service_;
+  }
+
   TestableSyncInternalsMessageHandler* handler() { return handler_.get(); }
 
   int CallCountWithName(const std::string& function_name) {
     int count = 0;
     for (const auto& call_data : web_ui_.call_data()) {
       if (call_data->function_name() == function_name) {
         count++;
       }
     }
     return count;
   }
 
   int about_sync_data_delegate_call_count() const {
     return about_sync_data_delegate_call_count_;
   }
 
   const SyncService* last_delegate_sync_service() const {
     return last_delegate_sync_service_;
   }
 
   void ResetHandler() { handler_.reset(); }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   scoped_refptr<content::SiteInstance> site_instance_;
   std::unique_ptr<content::WebContents> web_contents_;
   content::TestWebUI web_ui_;
   TestSyncService* test_sync_service_;
+  FakeUserEventService* fake_user_event_service_;
   std::unique_ptr<TestableSyncInternalsMessageHandler> handler_;
   int about_sync_data_delegate_call_count_ = 0;
   SyncService* last_delegate_sync_service_ = nullptr;
 };
 
 TEST_F(SyncInternalsMessageHandlerTest, AddRemoveObservers) {
   ListValue empty_list;
 
   EXPECT_EQ(0, test_sync_service()->add_observer_count());
   handler()->HandleRegisterForEvents(&empty_list);
@@ skipping 108 matching lines @@
   ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(profile(),
                                                               nullptr);
 
   handler()->AllowJavascriptForTesting();
   handler()->OnStateChanged(nullptr);
   EXPECT_EQ(1, about_sync_data_delegate_call_count());
   EXPECT_EQ(nullptr, last_delegate_sync_service());
   ValidateAboutInfoCall();
 }
 
+TEST_F(SyncInternalsMessageHandlerTest, WriteUserEvent) {
+  ListValue args;
+  args.AppendString("1000000000000000000");
+  args.AppendString("-1");
+  handler()->HandleWriteUserEvent(&args);
+
+  ASSERT_EQ(1u, fake_user_event_service()->GetRecordedUserEvents().size());
+  const sync_pb::UserEventSpecifics& event =
+      *fake_user_event_service()->GetRecordedUserEvents().begin();
+  EXPECT_EQ(1000000000000000000, event.event_time_usec());
+  EXPECT_EQ(-1, event.navigation_id());
+}
+
+TEST_F(SyncInternalsMessageHandlerTest, WriteUserEventBadParse) {
+  ListValue args;
+  args.AppendString("123abc");
+  args.AppendString("");
+  handler()->HandleWriteUserEvent(&args);
+
+  ASSERT_EQ(1u, fake_user_event_service()->GetRecordedUserEvents().size());
+  const sync_pb::UserEventSpecifics& event =
+      *fake_user_event_service()->GetRecordedUserEvents().begin();
+  EXPECT_EQ(0, event.event_time_usec());
+  EXPECT_EQ(0, event.navigation_id());
+}
+
 }  // namespace