OLD | NEW |
| (Empty) |
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 "sync/sessions/model_type_registry.h" | |
6 | |
7 #include <utility> | |
8 #include <vector> | |
9 | |
10 #include "base/deferred_sequenced_task_runner.h" | |
11 #include "base/memory/ptr_util.h" | |
12 #include "base/message_loop/message_loop.h" | |
13 #include "sync/internal_api/public/activation_context.h" | |
14 #include "sync/internal_api/public/base/model_type.h" | |
15 #include "sync/internal_api/public/test/fake_model_type_processor.h" | |
16 #include "sync/protocol/data_type_state.pb.h" | |
17 #include "sync/syncable/directory.h" | |
18 #include "sync/syncable/model_neutral_mutable_entry.h" | |
19 #include "sync/syncable/syncable_model_neutral_write_transaction.h" | |
20 #include "sync/test/engine/fake_model_worker.h" | |
21 #include "sync/test/engine/mock_nudge_handler.h" | |
22 #include "sync/test/engine/test_directory_setter_upper.h" | |
23 #include "testing/gtest/include/gtest/gtest.h" | |
24 | |
25 namespace syncer { | |
26 | |
27 class ModelTypeRegistryTest : public ::testing::Test { | |
28 public: | |
29 ModelTypeRegistryTest(); | |
30 void SetUp() override; | |
31 void TearDown() override; | |
32 | |
33 ModelTypeRegistry* registry(); | |
34 | |
35 static sync_pb::DataTypeState MakeInitialDataTypeState(ModelType type) { | |
36 sync_pb::DataTypeState state; | |
37 state.mutable_progress_marker()->set_data_type_id( | |
38 GetSpecificsFieldNumberFromModelType(type)); | |
39 return state; | |
40 } | |
41 | |
42 static std::unique_ptr<syncer_v2::ActivationContext> MakeActivationContext( | |
43 const sync_pb::DataTypeState& data_type_state, | |
44 std::unique_ptr<syncer_v2::ModelTypeProcessor> type_processor) { | |
45 std::unique_ptr<syncer_v2::ActivationContext> context = | |
46 base::WrapUnique(new syncer_v2::ActivationContext); | |
47 context->data_type_state = data_type_state; | |
48 context->type_processor = std::move(type_processor); | |
49 return context; | |
50 } | |
51 | |
52 void MarkInitialSyncEndedForDirectoryType(ModelType type) { | |
53 syncable::ModelNeutralWriteTransaction trans(FROM_HERE, syncable::SYNCER, | |
54 directory()); | |
55 syncable::ModelNeutralMutableEntry entry( | |
56 &trans, syncable::CREATE_NEW_TYPE_ROOT, type); | |
57 ASSERT_TRUE(entry.good()); | |
58 entry.PutServerIsDir(true); | |
59 entry.PutUniqueServerTag(ModelTypeToRootTag(type)); | |
60 directory()->MarkInitialSyncEndedForType(&trans, type); | |
61 } | |
62 | |
63 private: | |
64 syncable::Directory* directory(); | |
65 | |
66 base::MessageLoop message_loop_; | |
67 | |
68 TestDirectorySetterUpper dir_maker_; | |
69 std::vector<scoped_refptr<ModelSafeWorker> > workers_; | |
70 std::unique_ptr<ModelTypeRegistry> registry_; | |
71 MockNudgeHandler mock_nudge_handler_; | |
72 }; | |
73 | |
74 ModelTypeRegistryTest::ModelTypeRegistryTest() {} | |
75 | |
76 void ModelTypeRegistryTest::SetUp() { | |
77 dir_maker_.SetUp(); | |
78 scoped_refptr<ModelSafeWorker> passive_worker( | |
79 new FakeModelWorker(GROUP_PASSIVE)); | |
80 scoped_refptr<ModelSafeWorker> ui_worker( | |
81 new FakeModelWorker(GROUP_UI)); | |
82 scoped_refptr<ModelSafeWorker> db_worker( | |
83 new FakeModelWorker(GROUP_DB)); | |
84 workers_.push_back(passive_worker); | |
85 workers_.push_back(ui_worker); | |
86 workers_.push_back(db_worker); | |
87 | |
88 registry_.reset( | |
89 new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_)); | |
90 } | |
91 | |
92 void ModelTypeRegistryTest::TearDown() { | |
93 registry_.reset(); | |
94 workers_.clear(); | |
95 dir_maker_.TearDown(); | |
96 } | |
97 | |
98 ModelTypeRegistry* ModelTypeRegistryTest::registry() { | |
99 return registry_.get(); | |
100 } | |
101 | |
102 syncable::Directory* ModelTypeRegistryTest::directory() { | |
103 return dir_maker_.directory(); | |
104 } | |
105 | |
106 // Create some directory update handlers and commit contributors. | |
107 // | |
108 // We don't get to inspect any of the state we're modifying. This test is | |
109 // useful only for detecting crashes or memory leaks. | |
110 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_Once) { | |
111 ModelSafeRoutingInfo routing_info; | |
112 routing_info.insert(std::make_pair(NIGORI, GROUP_PASSIVE)); | |
113 routing_info.insert(std::make_pair(BOOKMARKS, GROUP_UI)); | |
114 routing_info.insert(std::make_pair(AUTOFILL, GROUP_DB)); | |
115 routing_info.insert(std::make_pair(APPS, GROUP_NON_BLOCKING)); | |
116 | |
117 registry()->SetEnabledDirectoryTypes(routing_info); | |
118 | |
119 UpdateHandlerMap* update_handler_map = registry()->update_handler_map(); | |
120 // Apps is non-blocking type, SetEnabledDirectoryTypes shouldn't instantiate | |
121 // update_handler for it. | |
122 EXPECT_TRUE(update_handler_map->find(APPS) == update_handler_map->end()); | |
123 } | |
124 | |
125 // Try two different routing info settings. | |
126 // | |
127 // We don't get to inspect any of the state we're modifying. This test is | |
128 // useful only for detecting crashes or memory leaks. | |
129 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_Repeatedly) { | |
130 ModelSafeRoutingInfo routing_info1; | |
131 routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE)); | |
132 routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_PASSIVE)); | |
133 routing_info1.insert(std::make_pair(AUTOFILL, GROUP_PASSIVE)); | |
134 routing_info1.insert(std::make_pair(APPS, GROUP_NON_BLOCKING)); | |
135 | |
136 registry()->SetEnabledDirectoryTypes(routing_info1); | |
137 | |
138 ModelSafeRoutingInfo routing_info2; | |
139 routing_info2.insert(std::make_pair(NIGORI, GROUP_PASSIVE)); | |
140 routing_info2.insert(std::make_pair(BOOKMARKS, GROUP_UI)); | |
141 routing_info2.insert(std::make_pair(AUTOFILL, GROUP_DB)); | |
142 routing_info2.insert(std::make_pair(APPS, GROUP_NON_BLOCKING)); | |
143 | |
144 registry()->SetEnabledDirectoryTypes(routing_info2); | |
145 } | |
146 | |
147 // Test removing all types from the list. | |
148 // | |
149 // We don't get to inspect any of the state we're modifying. This test is | |
150 // useful only for detecting crashes or memory leaks. | |
151 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_Clear) { | |
152 ModelSafeRoutingInfo routing_info1; | |
153 routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE)); | |
154 routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI)); | |
155 routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB)); | |
156 routing_info1.insert(std::make_pair(APPS, GROUP_NON_BLOCKING)); | |
157 | |
158 registry()->SetEnabledDirectoryTypes(routing_info1); | |
159 | |
160 ModelSafeRoutingInfo routing_info2; | |
161 registry()->SetEnabledDirectoryTypes(routing_info2); | |
162 } | |
163 | |
164 // Test disabling then re-enabling some directory types. | |
165 // | |
166 // We don't get to inspect any of the state we're modifying. This test is | |
167 // useful only for detecting crashes or memory leaks. | |
168 TEST_F(ModelTypeRegistryTest, SetEnabledDirectoryTypes_OffAndOn) { | |
169 ModelSafeRoutingInfo routing_info1; | |
170 routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE)); | |
171 routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI)); | |
172 routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB)); | |
173 routing_info1.insert(std::make_pair(APPS, GROUP_NON_BLOCKING)); | |
174 | |
175 registry()->SetEnabledDirectoryTypes(routing_info1); | |
176 | |
177 ModelSafeRoutingInfo routing_info2; | |
178 registry()->SetEnabledDirectoryTypes(routing_info2); | |
179 | |
180 registry()->SetEnabledDirectoryTypes(routing_info1); | |
181 } | |
182 | |
183 TEST_F(ModelTypeRegistryTest, NonBlockingTypes) { | |
184 EXPECT_TRUE(registry()->GetEnabledTypes().Empty()); | |
185 | |
186 registry()->ConnectType( | |
187 syncer::THEMES, | |
188 MakeActivationContext( | |
189 MakeInitialDataTypeState(THEMES), | |
190 base::WrapUnique(new syncer_v2::FakeModelTypeProcessor()))); | |
191 EXPECT_EQ(ModelTypeSet(syncer::THEMES), registry()->GetEnabledTypes()); | |
192 | |
193 registry()->ConnectType( | |
194 syncer::SESSIONS, | |
195 MakeActivationContext( | |
196 MakeInitialDataTypeState(SESSIONS), | |
197 base::WrapUnique(new syncer_v2::FakeModelTypeProcessor()))); | |
198 EXPECT_EQ(ModelTypeSet(syncer::THEMES, syncer::SESSIONS), | |
199 registry()->GetEnabledTypes()); | |
200 | |
201 registry()->DisconnectType(syncer::THEMES); | |
202 EXPECT_EQ(ModelTypeSet(syncer::SESSIONS), registry()->GetEnabledTypes()); | |
203 | |
204 // Allow ModelTypeRegistry destruction to delete the | |
205 // Sessions' ModelTypeSyncWorker. | |
206 } | |
207 | |
208 TEST_F(ModelTypeRegistryTest, NonBlockingTypesWithDirectoryTypes) { | |
209 ModelSafeRoutingInfo routing_info1; | |
210 routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE)); | |
211 routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI)); | |
212 routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB)); | |
213 routing_info1.insert(std::make_pair(THEMES, GROUP_NON_BLOCKING)); | |
214 routing_info1.insert(std::make_pair(SESSIONS, GROUP_NON_BLOCKING)); | |
215 | |
216 ModelTypeSet directory_types(NIGORI, BOOKMARKS, AUTOFILL); | |
217 | |
218 ModelTypeSet current_types; | |
219 EXPECT_TRUE(registry()->GetEnabledTypes().Empty()); | |
220 | |
221 // Add the themes non-blocking type. | |
222 registry()->ConnectType( | |
223 syncer::THEMES, | |
224 MakeActivationContext( | |
225 MakeInitialDataTypeState(THEMES), | |
226 base::WrapUnique(new syncer_v2::FakeModelTypeProcessor()))); | |
227 current_types.Put(syncer::THEMES); | |
228 EXPECT_EQ(current_types, registry()->GetEnabledTypes()); | |
229 | |
230 // Add some directory types. | |
231 registry()->SetEnabledDirectoryTypes(routing_info1); | |
232 current_types.PutAll(directory_types); | |
233 EXPECT_EQ(current_types, registry()->GetEnabledTypes()); | |
234 | |
235 // Add sessions non-blocking type. | |
236 registry()->ConnectType( | |
237 syncer::SESSIONS, | |
238 MakeActivationContext( | |
239 MakeInitialDataTypeState(SESSIONS), | |
240 base::WrapUnique(new syncer_v2::FakeModelTypeProcessor()))); | |
241 current_types.Put(syncer::SESSIONS); | |
242 EXPECT_EQ(current_types, registry()->GetEnabledTypes()); | |
243 | |
244 // Remove themes non-blocking type. | |
245 registry()->DisconnectType(syncer::THEMES); | |
246 current_types.Remove(syncer::THEMES); | |
247 EXPECT_EQ(current_types, registry()->GetEnabledTypes()); | |
248 | |
249 // Clear all directory types. | |
250 ModelSafeRoutingInfo routing_info2; | |
251 registry()->SetEnabledDirectoryTypes(routing_info2); | |
252 current_types.RemoveAll(directory_types); | |
253 EXPECT_EQ(current_types, registry()->GetEnabledTypes()); | |
254 } | |
255 | |
256 // Tests correct result returned from GetInitialSyncEndedTypes. | |
257 TEST_F(ModelTypeRegistryTest, GetInitialSyncEndedTypes) { | |
258 ModelSafeRoutingInfo routing_info; | |
259 // Add two directory and two non-blocking types. | |
260 routing_info.insert(std::make_pair(AUTOFILL, GROUP_PASSIVE)); | |
261 routing_info.insert(std::make_pair(BOOKMARKS, GROUP_PASSIVE)); | |
262 routing_info.insert(std::make_pair(THEMES, GROUP_NON_BLOCKING)); | |
263 routing_info.insert(std::make_pair(SESSIONS, GROUP_NON_BLOCKING)); | |
264 registry()->SetEnabledDirectoryTypes(routing_info); | |
265 | |
266 // Only Autofill and Themes types finished initial sync. | |
267 MarkInitialSyncEndedForDirectoryType(AUTOFILL); | |
268 | |
269 sync_pb::DataTypeState data_type_state = MakeInitialDataTypeState(THEMES); | |
270 data_type_state.set_initial_sync_done(true); | |
271 registry()->ConnectType( | |
272 syncer::THEMES, | |
273 MakeActivationContext( | |
274 data_type_state, | |
275 base::WrapUnique(new syncer_v2::FakeModelTypeProcessor()))); | |
276 | |
277 EXPECT_EQ(ModelTypeSet(AUTOFILL, THEMES), | |
278 registry()->GetInitialSyncEndedTypes()); | |
279 } | |
280 | |
281 } // namespace syncer | |
OLD | NEW |