src/sync/sessions/model_type_registry_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/deferred_sequenced_task_runner.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/thread_task_runner_handle.h"
  10 #include "sync/engine/model_type_sync_proxy_impl.h"
  11 #include "sync/internal_api/public/base/model_type.h"
  12 #include "sync/sessions/model_type_registry.h"
  13 #include "sync/test/engine/fake_model_worker.h"
  14 #include "sync/test/engine/mock_nudge_handler.h"
  15 #include "sync/test/engine/test_directory_setter_upper.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace syncer {
  19
  20 class ModelTypeRegistryTest : public ::testing::Test {
  21  public:
  22   ModelTypeRegistryTest();
  23   virtual void SetUp() override;
  24   virtual void TearDown() override;
  25
  26   ModelTypeRegistry* registry();
  27
  28   static DataTypeState MakeInitialDataTypeState(ModelType type) {
  29     DataTypeState state;
  30     state.progress_marker.set_data_type_id(
  31         GetSpecificsFieldNumberFromModelType(type));
  32     state.next_client_id = 0;
  33     return state;
  34   }
  35
  36  private:
  37   syncable::Directory* directory();
  38
  39   base::MessageLoop message_loop_;
  40
  41   TestDirectorySetterUpper dir_maker_;
  42   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
  43   scoped_ptr<ModelTypeRegistry> registry_;
  44   MockNudgeHandler mock_nudge_handler_;
  45 };
  46
  47 ModelTypeRegistryTest::ModelTypeRegistryTest() {}
  48
  49 void ModelTypeRegistryTest::SetUp() {
  50   dir_maker_.SetUp();
  51   scoped_refptr<ModelSafeWorker> passive_worker(
  52       new FakeModelWorker(GROUP_PASSIVE));
  53   scoped_refptr<ModelSafeWorker> ui_worker(
  54       new FakeModelWorker(GROUP_UI));
  55   scoped_refptr<ModelSafeWorker> db_worker(
  56       new FakeModelWorker(GROUP_DB));
  57   workers_.push_back(passive_worker);
  58   workers_.push_back(ui_worker);
  59   workers_.push_back(db_worker);
  60
  61   registry_.reset(
  62       new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
  63 }
  64
  65 void ModelTypeRegistryTest::TearDown() {
  66   registry_.reset();
  67   workers_.clear();
  68   dir_maker_.TearDown();
  69 }
  70
  71 ModelTypeRegistry* ModelTypeRegistryTest::registry() {
  72   return registry_.get();
  73 }
  74
  75 syncable::Directory* ModelTypeRegistryTest::directory() {
  76   return dir_maker_.directory();
  77 }
  78
  79 // Create some directory update handlers and commit contributors.
  80 //
  81 // We don't get to inspect any of the state we're modifying.  This test is
  82 // useful only for detecting crashes or memory leaks.
  83 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_Once) {
  84   ModelSafeRoutingInfo routing_info;
  85   routing_info.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
  86   routing_info.insert(std::make_pair(BOOKMARKS, GROUP_UI));
  87   routing_info.insert(std::make_pair(AUTOFILL, GROUP_DB));
  88
  89   registry()->SetEnabledDirectoryTypes(routing_info);
  90 }
  91
  92 // Try two different routing info settings.
  93 //
  94 // We don't get to inspect any of the state we're modifying.  This test is
  95 // useful only for detecting crashes or memory leaks.
  96 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_Repeatedly) {
  97   ModelSafeRoutingInfo routing_info1;
  98   routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
  99   routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_PASSIVE));
 100   routing_info1.insert(std::make_pair(AUTOFILL, GROUP_PASSIVE));
 101
 102   registry()->SetEnabledDirectoryTypes(routing_info1);
 103
 104   ModelSafeRoutingInfo routing_info2;
 105   routing_info2.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
 106   routing_info2.insert(std::make_pair(BOOKMARKS, GROUP_UI));
 107   routing_info2.insert(std::make_pair(AUTOFILL, GROUP_DB));
 108
 109   registry()->SetEnabledDirectoryTypes(routing_info2);
 110 }
 111
 112 // Test removing all types from the list.
 113 //
 114 // We don't get to inspect any of the state we're modifying.  This test is
 115 // useful only for detecting crashes or memory leaks.
 116 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_Clear) {
 117   ModelSafeRoutingInfo routing_info1;
 118   routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
 119   routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI));
 120   routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB));
 121
 122   registry()->SetEnabledDirectoryTypes(routing_info1);
 123
 124   ModelSafeRoutingInfo routing_info2;
 125   registry()->SetEnabledDirectoryTypes(routing_info2);
 126 }
 127
 128 // Test disabling then re-enabling some directory types.
 129 //
 130 // We don't get to inspect any of the state we're modifying.  This test is
 131 // useful only for detecting crashes or memory leaks.
 132 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_OffAndOn) {
 133   ModelSafeRoutingInfo routing_info1;
 134   routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
 135   routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI));
 136   routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB));
 137
 138   registry()->SetEnabledDirectoryTypes(routing_info1);
 139
 140   ModelSafeRoutingInfo routing_info2;
 141   registry()->SetEnabledDirectoryTypes(routing_info2);
 142
 143   registry()->SetEnabledDirectoryTypes(routing_info1);
 144 }
 145
 146 TEST_F(ModelTypeRegistryTest, NonBlockingTypes) {
 147   ModelTypeSyncProxyImpl themes_sync_proxy(syncer::THEMES);
 148   ModelTypeSyncProxyImpl sessions_sync_proxy(syncer::SESSIONS);
 149   scoped_refptr<base::DeferredSequencedTaskRunner> task_runner =
 150       new base::DeferredSequencedTaskRunner(
 151           base::ThreadTaskRunnerHandle::Get());
 152
 153   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 154
 155   registry()->ConnectSyncTypeToWorker(syncer::THEMES,
 156                                       MakeInitialDataTypeState(THEMES),
 157                                       UpdateResponseDataList(),
 158                                       task_runner,
 159                                       themes_sync_proxy.AsWeakPtrForUI());
 160   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
 161       ModelTypeSet(syncer::THEMES)));
 162
 163   registry()->ConnectSyncTypeToWorker(syncer::SESSIONS,
 164                                       MakeInitialDataTypeState(SESSIONS),
 165                                       UpdateResponseDataList(),
 166                                       task_runner,
 167                                       sessions_sync_proxy.AsWeakPtrForUI());
 168   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
 169       ModelTypeSet(syncer::THEMES, syncer::SESSIONS)));
 170
 171   registry()->DisconnectSyncWorker(syncer::THEMES);
 172   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
 173       ModelTypeSet(syncer::SESSIONS)));
 174
 175   // Allow ModelTypeRegistry destruction to delete the
 176   // Sessions' ModelTypeSyncWorker.
 177 }
 178
 179 TEST_F(ModelTypeRegistryTest, NonBlockingTypesWithDirectoryTypes) {
 180   ModelTypeSyncProxyImpl themes_sync_proxy(syncer::THEMES);
 181   ModelTypeSyncProxyImpl sessions_sync_proxy(syncer::SESSIONS);
 182   scoped_refptr<base::DeferredSequencedTaskRunner> task_runner =
 183       new base::DeferredSequencedTaskRunner(
 184           base::ThreadTaskRunnerHandle::Get());
 185
 186   ModelSafeRoutingInfo routing_info1;
 187   routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
 188   routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI));
 189   routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB));
 190
 191   ModelTypeSet current_types;
 192   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 193
 194   // Add the themes non-blocking type.
 195   registry()->ConnectSyncTypeToWorker(syncer::THEMES,
 196                                       MakeInitialDataTypeState(THEMES),
 197                                       UpdateResponseDataList(),
 198                                       task_runner,
 199                                       themes_sync_proxy.AsWeakPtrForUI());
 200   current_types.Put(syncer::THEMES);
 201   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 202
 203   // Add some directory types.
 204   registry()->SetEnabledDirectoryTypes(routing_info1);
 205   current_types.PutAll(GetRoutingInfoTypes(routing_info1));
 206   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 207
 208   // Add sessions non-blocking type.
 209   registry()->ConnectSyncTypeToWorker(syncer::SESSIONS,
 210                                       MakeInitialDataTypeState(SESSIONS),
 211                                       UpdateResponseDataList(),
 212                                       task_runner,
 213                                       sessions_sync_proxy.AsWeakPtrForUI());
 214   current_types.Put(syncer::SESSIONS);
 215   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 216
 217   // Remove themes non-blocking type.
 218   registry()->DisconnectSyncWorker(syncer::THEMES);
 219   current_types.Remove(syncer::THEMES);
 220   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 221
 222   // Clear all directory types.
 223   ModelSafeRoutingInfo routing_info2;
 224   registry()->SetEnabledDirectoryTypes(routing_info2);
 225   current_types.RemoveAll(GetRoutingInfoTypes(routing_info1));
 226   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 227 }
 228
 229 TEST_F(ModelTypeRegistryTest, DeletionOrdering) {
 230   scoped_ptr<ModelTypeSyncProxyImpl> themes_sync_proxy(
 231       new ModelTypeSyncProxyImpl(syncer::THEMES));
 232   scoped_ptr<ModelTypeSyncProxyImpl> sessions_sync_proxy(
 233       new ModelTypeSyncProxyImpl(syncer::SESSIONS));
 234   scoped_refptr<base::DeferredSequencedTaskRunner> task_runner =
 235       new base::DeferredSequencedTaskRunner(
 236           base::ThreadTaskRunnerHandle::Get());
 237
 238   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 239
 240   registry()->ConnectSyncTypeToWorker(syncer::THEMES,
 241                                       MakeInitialDataTypeState(THEMES),
 242                                       UpdateResponseDataList(),
 243                                       task_runner,
 244                                       themes_sync_proxy->AsWeakPtrForUI());
 245   registry()->ConnectSyncTypeToWorker(syncer::SESSIONS,
 246                                       MakeInitialDataTypeState(SESSIONS),
 247                                       UpdateResponseDataList(),
 248                                       task_runner,
 249                                       sessions_sync_proxy->AsWeakPtrForUI());
 250   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
 251       ModelTypeSet(syncer::THEMES, syncer::SESSIONS)));
 252
 253   // Tear down themes processing, starting with the worker.
 254   registry()->DisconnectSyncWorker(syncer::THEMES);
 255   themes_sync_proxy.reset();
 256
 257   // Tear down sessions processing, starting with the type sync proxy.
 258   sessions_sync_proxy.reset();
 259   registry()->DisconnectSyncWorker(syncer::SESSIONS);
 260
 261   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 262 }
 263
 264 }  // namespace syncer