OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/sync/driver/backend_migrator.h" | 5 #include "components/sync/driver/backend_migrator.h" |
6 | 6 |
7 #include "base/message_loop/message_loop.h" | 7 #include "base/message_loop/message_loop.h" |
8 #include "base/run_loop.h" | 8 #include "base/run_loop.h" |
9 #include "base/tracked_objects.h" | 9 #include "base/tracked_objects.h" |
10 #include "components/sync/base/model_type_test_util.h" | 10 #include "components/sync/base/model_type_test_util.h" |
11 #include "components/sync/core/test/test_user_share.h" | 11 #include "components/sync/core/test/test_user_share.h" |
12 #include "components/sync/core/write_transaction.h" | 12 #include "components/sync/core/write_transaction.h" |
13 #include "components/sync/driver/data_type_manager_mock.h" | 13 #include "components/sync/driver/data_type_manager_mock.h" |
14 #include "components/sync/driver/fake_sync_service.h" | 14 #include "components/sync/driver/fake_sync_service.h" |
15 #include "components/sync/protocol/sync.pb.h" | 15 #include "components/sync/protocol/sync.pb.h" |
16 #include "components/sync/syncable/directory.h" // TODO(tim): Remove. Bug 13113
0. | 16 #include "components/sync/syncable/directory.h" // TODO(tim): Remove. Bug 13113
0. |
17 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "testing/gmock/include/gmock/gmock.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
19 | 19 |
20 using ::testing::_; | 20 using ::testing::_; |
21 using ::testing::Eq; | 21 using ::testing::Eq; |
22 using ::testing::Mock; | 22 using ::testing::Mock; |
23 using ::testing::NiceMock; | 23 using ::testing::NiceMock; |
24 using ::testing::Return; | 24 using ::testing::Return; |
25 using sync_driver::DataTypeManager; | |
26 using sync_driver::DataTypeManagerMock; | |
27 | 25 |
28 namespace browser_sync { | 26 namespace syncer { |
29 | |
30 using syncer::SyncCycleSnapshot; | |
31 | 27 |
32 class SyncBackendMigratorTest : public testing::Test { | 28 class SyncBackendMigratorTest : public testing::Test { |
33 public: | 29 public: |
34 SyncBackendMigratorTest() {} | 30 SyncBackendMigratorTest() {} |
35 virtual ~SyncBackendMigratorTest() {} | 31 virtual ~SyncBackendMigratorTest() {} |
36 | 32 |
37 virtual void SetUp() { | 33 virtual void SetUp() { |
38 test_user_share_.SetUp(); | 34 test_user_share_.SetUp(); |
39 Mock::VerifyAndClear(manager()); | 35 Mock::VerifyAndClear(manager()); |
40 preferred_types_.Put(syncer::BOOKMARKS); | 36 preferred_types_.Put(BOOKMARKS); |
41 preferred_types_.Put(syncer::PREFERENCES); | 37 preferred_types_.Put(PREFERENCES); |
42 preferred_types_.Put(syncer::AUTOFILL); | 38 preferred_types_.Put(AUTOFILL); |
43 | 39 |
44 migrator_.reset(new BackendMigrator("Profile0", | 40 migrator_.reset(new BackendMigrator("Profile0", |
45 test_user_share_.user_share(), | 41 test_user_share_.user_share(), |
46 service(), manager(), base::Closure())); | 42 service(), manager(), base::Closure())); |
47 SetUnsyncedTypes(syncer::ModelTypeSet()); | 43 SetUnsyncedTypes(ModelTypeSet()); |
48 } | 44 } |
49 | 45 |
50 virtual void TearDown() { | 46 virtual void TearDown() { |
51 migrator_.reset(); | 47 migrator_.reset(); |
52 test_user_share_.TearDown(); | 48 test_user_share_.TearDown(); |
53 } | 49 } |
54 | 50 |
55 // Marks all types in |unsynced_types| as unsynced and all other | 51 // Marks all types in |unsynced_types| as unsynced and all other |
56 // types as synced. | 52 // types as synced. |
57 void SetUnsyncedTypes(syncer::ModelTypeSet unsynced_types) { | 53 void SetUnsyncedTypes(ModelTypeSet unsynced_types) { |
58 syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share()); | 54 WriteTransaction trans(FROM_HERE, test_user_share_.user_share()); |
59 for (int i = syncer::FIRST_REAL_MODEL_TYPE; i < syncer::MODEL_TYPE_COUNT; | 55 for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) { |
60 ++i) { | 56 ModelType type = ModelTypeFromInt(i); |
61 syncer::ModelType type = syncer::ModelTypeFromInt(i); | |
62 sync_pb::DataTypeProgressMarker progress_marker; | 57 sync_pb::DataTypeProgressMarker progress_marker; |
63 if (!unsynced_types.Has(type)) { | 58 if (!unsynced_types.Has(type)) { |
64 progress_marker.set_token("dummy"); | 59 progress_marker.set_token("dummy"); |
65 } | 60 } |
66 trans.GetDirectory()->SetDownloadProgress(type, progress_marker); | 61 trans.GetDirectory()->SetDownloadProgress(type, progress_marker); |
67 } | 62 } |
68 } | 63 } |
69 | 64 |
70 void SendConfigureDone(DataTypeManager::ConfigureStatus status, | 65 void SendConfigureDone(DataTypeManager::ConfigureStatus status, |
71 syncer::ModelTypeSet requested_types) { | 66 ModelTypeSet requested_types) { |
72 if (status == DataTypeManager::OK) { | 67 if (status == DataTypeManager::OK) { |
73 DataTypeManager::ConfigureResult result(status, requested_types); | 68 DataTypeManager::ConfigureResult result(status, requested_types); |
74 migrator_->OnConfigureDone(result); | 69 migrator_->OnConfigureDone(result); |
75 } else { | 70 } else { |
76 DataTypeManager::ConfigureResult result(status, requested_types); | 71 DataTypeManager::ConfigureResult result(status, requested_types); |
77 migrator_->OnConfigureDone(result); | 72 migrator_->OnConfigureDone(result); |
78 } | 73 } |
79 base::RunLoop run_loop; | 74 base::RunLoop run_loop; |
80 run_loop.RunUntilIdle(); | 75 run_loop.RunUntilIdle(); |
81 } | 76 } |
82 | 77 |
83 sync_driver::SyncService* service() { return &service_; } | 78 SyncService* service() { return &service_; } |
84 DataTypeManagerMock* manager() { return &manager_; } | 79 DataTypeManagerMock* manager() { return &manager_; } |
85 syncer::ModelTypeSet preferred_types() { return preferred_types_; } | 80 ModelTypeSet preferred_types() { return preferred_types_; } |
86 BackendMigrator* migrator() { return migrator_.get(); } | 81 BackendMigrator* migrator() { return migrator_.get(); } |
87 void RemovePreferredType(syncer::ModelType type) { | 82 void RemovePreferredType(ModelType type) { preferred_types_.Remove(type); } |
88 preferred_types_.Remove(type); | |
89 } | |
90 | 83 |
91 private: | 84 private: |
92 base::MessageLoop message_loop_; | 85 base::MessageLoop message_loop_; |
93 syncer::ModelTypeSet preferred_types_; | 86 ModelTypeSet preferred_types_; |
94 sync_driver::FakeSyncService service_; | 87 FakeSyncService service_; |
95 NiceMock<DataTypeManagerMock> manager_; | 88 NiceMock<DataTypeManagerMock> manager_; |
96 syncer::TestUserShare test_user_share_; | 89 TestUserShare test_user_share_; |
97 std::unique_ptr<BackendMigrator> migrator_; | 90 std::unique_ptr<BackendMigrator> migrator_; |
98 }; | 91 }; |
99 | 92 |
100 class MockMigrationObserver : public MigrationObserver { | 93 class MockMigrationObserver : public MigrationObserver { |
101 public: | 94 public: |
102 virtual ~MockMigrationObserver() {} | 95 virtual ~MockMigrationObserver() {} |
103 | 96 |
104 MOCK_METHOD0(OnMigrationStateChange, void()); | 97 MOCK_METHOD0(OnMigrationStateChange, void()); |
105 }; | 98 }; |
106 | 99 |
107 // Test that in the normal case a migration does transition through each state | 100 // Test that in the normal case a migration does transition through each state |
108 // and wind up back in IDLE. | 101 // and wind up back in IDLE. |
109 TEST_F(SyncBackendMigratorTest, Sanity) { | 102 TEST_F(SyncBackendMigratorTest, Sanity) { |
110 MockMigrationObserver migration_observer; | 103 MockMigrationObserver migration_observer; |
111 migrator()->AddMigrationObserver(&migration_observer); | 104 migrator()->AddMigrationObserver(&migration_observer); |
112 EXPECT_CALL(migration_observer, OnMigrationStateChange()).Times(4); | 105 EXPECT_CALL(migration_observer, OnMigrationStateChange()).Times(4); |
113 | 106 |
114 syncer::ModelTypeSet to_migrate, difference; | 107 ModelTypeSet to_migrate, difference; |
115 to_migrate.Put(syncer::PREFERENCES); | 108 to_migrate.Put(PREFERENCES); |
116 difference.Put(syncer::AUTOFILL); | 109 difference.Put(AUTOFILL); |
117 difference.Put(syncer::BOOKMARKS); | 110 difference.Put(BOOKMARKS); |
118 | 111 |
119 EXPECT_CALL(*manager(), state()) | 112 EXPECT_CALL(*manager(), state()) |
120 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 113 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
121 EXPECT_CALL(*manager(), | 114 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)) |
122 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)) | |
123 .Times(1); | 115 .Times(1); |
124 EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION)) | 116 EXPECT_CALL(*manager(), Configure(_, CONFIGURE_REASON_MIGRATION)).Times(1); |
125 .Times(1); | |
126 | 117 |
127 migrator()->MigrateTypes(to_migrate); | 118 migrator()->MigrateTypes(to_migrate); |
128 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 119 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
129 | 120 |
130 SetUnsyncedTypes(to_migrate); | 121 SetUnsyncedTypes(to_migrate); |
131 SendConfigureDone(DataTypeManager::OK, difference); | 122 SendConfigureDone(DataTypeManager::OK, difference); |
132 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); | 123 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); |
133 | 124 |
134 SetUnsyncedTypes(syncer::ModelTypeSet()); | 125 SetUnsyncedTypes(ModelTypeSet()); |
135 SendConfigureDone(DataTypeManager::OK, preferred_types()); | 126 SendConfigureDone(DataTypeManager::OK, preferred_types()); |
136 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); | 127 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); |
137 | 128 |
138 migrator()->RemoveMigrationObserver(&migration_observer); | 129 migrator()->RemoveMigrationObserver(&migration_observer); |
139 } | 130 } |
140 | 131 |
141 // Test that in the normal case with Nigori a migration transitions through | 132 // Test that in the normal case with Nigori a migration transitions through |
142 // each state and wind up back in IDLE. | 133 // each state and wind up back in IDLE. |
143 TEST_F(SyncBackendMigratorTest, MigrateNigori) { | 134 TEST_F(SyncBackendMigratorTest, MigrateNigori) { |
144 syncer::ModelTypeSet to_migrate, difference; | 135 ModelTypeSet to_migrate, difference; |
145 to_migrate.Put(syncer::NIGORI); | 136 to_migrate.Put(NIGORI); |
146 difference.Put(syncer::AUTOFILL); | 137 difference.Put(AUTOFILL); |
147 difference.Put(syncer::BOOKMARKS); | 138 difference.Put(BOOKMARKS); |
148 | 139 |
149 EXPECT_CALL(*manager(), state()) | 140 EXPECT_CALL(*manager(), state()) |
150 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 141 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
151 | 142 |
152 EXPECT_CALL(*manager(), | 143 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)); |
153 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)); | |
154 | 144 |
155 migrator()->MigrateTypes(to_migrate); | 145 migrator()->MigrateTypes(to_migrate); |
156 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 146 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
157 | 147 |
158 SetUnsyncedTypes(to_migrate); | 148 SetUnsyncedTypes(to_migrate); |
159 SendConfigureDone(DataTypeManager::OK, difference); | 149 SendConfigureDone(DataTypeManager::OK, difference); |
160 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); | 150 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); |
161 | 151 |
162 SetUnsyncedTypes(syncer::ModelTypeSet()); | 152 SetUnsyncedTypes(ModelTypeSet()); |
163 SendConfigureDone(DataTypeManager::OK, preferred_types()); | 153 SendConfigureDone(DataTypeManager::OK, preferred_types()); |
164 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); | 154 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); |
165 } | 155 } |
166 | 156 |
167 // Test that the migrator waits for the data type manager to be idle before | 157 // Test that the migrator waits for the data type manager to be idle before |
168 // starting a migration. | 158 // starting a migration. |
169 TEST_F(SyncBackendMigratorTest, WaitToStart) { | 159 TEST_F(SyncBackendMigratorTest, WaitToStart) { |
170 syncer::ModelTypeSet to_migrate; | 160 ModelTypeSet to_migrate; |
171 to_migrate.Put(syncer::PREFERENCES); | 161 to_migrate.Put(PREFERENCES); |
172 | 162 |
173 EXPECT_CALL(*manager(), state()) | 163 EXPECT_CALL(*manager(), state()) |
174 .WillOnce(Return(DataTypeManager::CONFIGURING)); | 164 .WillOnce(Return(DataTypeManager::CONFIGURING)); |
175 EXPECT_CALL(*manager(), Configure(_, _)).Times(0); | 165 EXPECT_CALL(*manager(), Configure(_, _)).Times(0); |
176 migrator()->MigrateTypes(to_migrate); | 166 migrator()->MigrateTypes(to_migrate); |
177 EXPECT_EQ(BackendMigrator::WAITING_TO_START, migrator()->state()); | 167 EXPECT_EQ(BackendMigrator::WAITING_TO_START, migrator()->state()); |
178 | 168 |
179 Mock::VerifyAndClearExpectations(manager()); | 169 Mock::VerifyAndClearExpectations(manager()); |
180 EXPECT_CALL(*manager(), state()) | 170 EXPECT_CALL(*manager(), state()) |
181 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 171 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
182 EXPECT_CALL(*manager(), | 172 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)); |
183 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)); | 173 SetUnsyncedTypes(ModelTypeSet()); |
184 SetUnsyncedTypes(syncer::ModelTypeSet()); | 174 SendConfigureDone(DataTypeManager::OK, ModelTypeSet()); |
185 SendConfigureDone(DataTypeManager::OK, syncer::ModelTypeSet()); | |
186 | 175 |
187 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 176 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
188 } | 177 } |
189 | 178 |
190 // Test that the migrator can cope with a migration request while a migration | 179 // Test that the migrator can cope with a migration request while a migration |
191 // is in progress. | 180 // is in progress. |
192 TEST_F(SyncBackendMigratorTest, RestartMigration) { | 181 TEST_F(SyncBackendMigratorTest, RestartMigration) { |
193 syncer::ModelTypeSet to_migrate1, to_migrate2, to_migrate_union, bookmarks; | 182 ModelTypeSet to_migrate1, to_migrate2, to_migrate_union, bookmarks; |
194 to_migrate1.Put(syncer::PREFERENCES); | 183 to_migrate1.Put(PREFERENCES); |
195 to_migrate2.Put(syncer::AUTOFILL); | 184 to_migrate2.Put(AUTOFILL); |
196 to_migrate_union.Put(syncer::PREFERENCES); | 185 to_migrate_union.Put(PREFERENCES); |
197 to_migrate_union.Put(syncer::AUTOFILL); | 186 to_migrate_union.Put(AUTOFILL); |
198 bookmarks.Put(syncer::BOOKMARKS); | 187 bookmarks.Put(BOOKMARKS); |
199 | 188 |
200 EXPECT_CALL(*manager(), state()) | 189 EXPECT_CALL(*manager(), state()) |
201 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 190 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
202 EXPECT_CALL(*manager(), | 191 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)) |
203 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)) | |
204 .Times(2); | 192 .Times(2); |
205 migrator()->MigrateTypes(to_migrate1); | 193 migrator()->MigrateTypes(to_migrate1); |
206 | 194 |
207 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 195 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
208 migrator()->MigrateTypes(to_migrate2); | 196 migrator()->MigrateTypes(to_migrate2); |
209 | 197 |
210 const syncer::ModelTypeSet difference1 = | 198 const ModelTypeSet difference1 = Difference(preferred_types(), to_migrate1); |
211 Difference(preferred_types(), to_migrate1); | |
212 | 199 |
213 Mock::VerifyAndClearExpectations(manager()); | 200 Mock::VerifyAndClearExpectations(manager()); |
214 EXPECT_CALL(*manager(), | 201 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)) |
215 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)) | |
216 .Times(1); | 202 .Times(1); |
217 EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION)) | 203 EXPECT_CALL(*manager(), Configure(_, CONFIGURE_REASON_MIGRATION)).Times(1); |
218 .Times(1); | |
219 SetUnsyncedTypes(to_migrate1); | 204 SetUnsyncedTypes(to_migrate1); |
220 SendConfigureDone(DataTypeManager::OK, difference1); | 205 SendConfigureDone(DataTypeManager::OK, difference1); |
221 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 206 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
222 | 207 |
223 SetUnsyncedTypes(to_migrate_union); | 208 SetUnsyncedTypes(to_migrate_union); |
224 SendConfigureDone(DataTypeManager::OK, bookmarks); | 209 SendConfigureDone(DataTypeManager::OK, bookmarks); |
225 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); | 210 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); |
226 } | 211 } |
227 | 212 |
228 // Test that an external invocation of Configure(...) during a migration results | 213 // Test that an external invocation of Configure(...) during a migration results |
229 // in a migration reattempt. | 214 // in a migration reattempt. |
230 TEST_F(SyncBackendMigratorTest, InterruptedWhileDisablingTypes) { | 215 TEST_F(SyncBackendMigratorTest, InterruptedWhileDisablingTypes) { |
231 syncer::ModelTypeSet to_migrate; | 216 ModelTypeSet to_migrate; |
232 syncer::ModelTypeSet difference; | 217 ModelTypeSet difference; |
233 to_migrate.Put(syncer::PREFERENCES); | 218 to_migrate.Put(PREFERENCES); |
234 difference.Put(syncer::AUTOFILL); | 219 difference.Put(AUTOFILL); |
235 difference.Put(syncer::BOOKMARKS); | 220 difference.Put(BOOKMARKS); |
236 | 221 |
237 EXPECT_CALL(*manager(), state()) | 222 EXPECT_CALL(*manager(), state()) |
238 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 223 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
239 EXPECT_CALL(*manager(), | 224 EXPECT_CALL(*manager(), PurgeForMigration(HasModelTypes(to_migrate), |
240 PurgeForMigration(HasModelTypes(to_migrate), | 225 CONFIGURE_REASON_MIGRATION)); |
241 syncer::CONFIGURE_REASON_MIGRATION)); | |
242 migrator()->MigrateTypes(to_migrate); | 226 migrator()->MigrateTypes(to_migrate); |
243 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 227 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
244 | 228 |
245 Mock::VerifyAndClearExpectations(manager()); | 229 Mock::VerifyAndClearExpectations(manager()); |
246 EXPECT_CALL(*manager(), | 230 EXPECT_CALL(*manager(), PurgeForMigration(HasModelTypes(to_migrate), |
247 PurgeForMigration(HasModelTypes(to_migrate), | 231 CONFIGURE_REASON_MIGRATION)); |
248 syncer::CONFIGURE_REASON_MIGRATION)); | 232 SetUnsyncedTypes(ModelTypeSet()); |
249 SetUnsyncedTypes(syncer::ModelTypeSet()); | |
250 SendConfigureDone(DataTypeManager::OK, preferred_types()); | 233 SendConfigureDone(DataTypeManager::OK, preferred_types()); |
251 | 234 |
252 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 235 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
253 } | 236 } |
254 | 237 |
255 // Test that spurious OnConfigureDone events don't confuse the | 238 // Test that spurious OnConfigureDone events don't confuse the |
256 // migrator while it's waiting for disabled types to have been purged | 239 // migrator while it's waiting for disabled types to have been purged |
257 // from the sync db. | 240 // from the sync db. |
258 TEST_F(SyncBackendMigratorTest, WaitingForPurge) { | 241 TEST_F(SyncBackendMigratorTest, WaitingForPurge) { |
259 syncer::ModelTypeSet to_migrate, difference; | 242 ModelTypeSet to_migrate, difference; |
260 to_migrate.Put(syncer::PREFERENCES); | 243 to_migrate.Put(PREFERENCES); |
261 to_migrate.Put(syncer::AUTOFILL); | 244 to_migrate.Put(AUTOFILL); |
262 difference.Put(syncer::BOOKMARKS); | 245 difference.Put(BOOKMARKS); |
263 | 246 |
264 EXPECT_CALL(*manager(), state()) | 247 EXPECT_CALL(*manager(), state()) |
265 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 248 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
266 EXPECT_CALL(*manager(), | 249 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)) |
267 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)) | |
268 .Times(1); | 250 .Times(1); |
269 EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION)) | 251 EXPECT_CALL(*manager(), Configure(_, CONFIGURE_REASON_MIGRATION)).Times(1); |
270 .Times(1); | |
271 | 252 |
272 migrator()->MigrateTypes(to_migrate); | 253 migrator()->MigrateTypes(to_migrate); |
273 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 254 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
274 | 255 |
275 SendConfigureDone(DataTypeManager::OK, difference); | 256 SendConfigureDone(DataTypeManager::OK, difference); |
276 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 257 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
277 | 258 |
278 syncer::ModelTypeSet prefs; | 259 ModelTypeSet prefs; |
279 prefs.Put(syncer::PREFERENCES); | 260 prefs.Put(PREFERENCES); |
280 SetUnsyncedTypes(prefs); | 261 SetUnsyncedTypes(prefs); |
281 SendConfigureDone(DataTypeManager::OK, difference); | 262 SendConfigureDone(DataTypeManager::OK, difference); |
282 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); | 263 EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state()); |
283 | 264 |
284 SetUnsyncedTypes(to_migrate); | 265 SetUnsyncedTypes(to_migrate); |
285 SendConfigureDone(DataTypeManager::OK, difference); | 266 SendConfigureDone(DataTypeManager::OK, difference); |
286 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); | 267 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); |
287 } | 268 } |
288 | 269 |
289 TEST_F(SyncBackendMigratorTest, MigratedTypeDisabledByUserDuringMigration) { | 270 TEST_F(SyncBackendMigratorTest, MigratedTypeDisabledByUserDuringMigration) { |
290 syncer::ModelTypeSet to_migrate; | 271 ModelTypeSet to_migrate; |
291 to_migrate.Put(syncer::PREFERENCES); | 272 to_migrate.Put(PREFERENCES); |
292 | 273 |
293 EXPECT_CALL(*manager(), state()) | 274 EXPECT_CALL(*manager(), state()) |
294 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 275 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
295 EXPECT_CALL(*manager(), | 276 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)) |
296 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)) | |
297 .Times(1); | 277 .Times(1); |
298 EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION)) | 278 EXPECT_CALL(*manager(), Configure(_, CONFIGURE_REASON_MIGRATION)).Times(1); |
299 .Times(1); | |
300 migrator()->MigrateTypes(to_migrate); | 279 migrator()->MigrateTypes(to_migrate); |
301 | 280 |
302 RemovePreferredType(syncer::PREFERENCES); | 281 RemovePreferredType(PREFERENCES); |
303 SetUnsyncedTypes(to_migrate); | 282 SetUnsyncedTypes(to_migrate); |
304 SendConfigureDone(DataTypeManager::OK, preferred_types()); | 283 SendConfigureDone(DataTypeManager::OK, preferred_types()); |
305 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); | 284 EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state()); |
306 SetUnsyncedTypes(syncer::ModelTypeSet()); | 285 SetUnsyncedTypes(ModelTypeSet()); |
307 SendConfigureDone(DataTypeManager::OK, preferred_types()); | 286 SendConfigureDone(DataTypeManager::OK, preferred_types()); |
308 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); | 287 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); |
309 } | 288 } |
310 | 289 |
311 TEST_F(SyncBackendMigratorTest, ConfigureFailure) { | 290 TEST_F(SyncBackendMigratorTest, ConfigureFailure) { |
312 syncer::ModelTypeSet to_migrate; | 291 ModelTypeSet to_migrate; |
313 to_migrate.Put(syncer::PREFERENCES); | 292 to_migrate.Put(PREFERENCES); |
314 | 293 |
315 EXPECT_CALL(*manager(), state()) | 294 EXPECT_CALL(*manager(), state()) |
316 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 295 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
317 EXPECT_CALL(*manager(), | 296 EXPECT_CALL(*manager(), PurgeForMigration(_, CONFIGURE_REASON_MIGRATION)) |
318 PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)) | |
319 .Times(1); | 297 .Times(1); |
320 migrator()->MigrateTypes(to_migrate); | 298 migrator()->MigrateTypes(to_migrate); |
321 SetUnsyncedTypes(syncer::ModelTypeSet()); | 299 SetUnsyncedTypes(ModelTypeSet()); |
322 SendConfigureDone(DataTypeManager::ABORTED, syncer::ModelTypeSet()); | 300 SendConfigureDone(DataTypeManager::ABORTED, ModelTypeSet()); |
323 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); | 301 EXPECT_EQ(BackendMigrator::IDLE, migrator()->state()); |
324 } | 302 } |
325 | 303 |
326 }; // namespace browser_sync | 304 }; // namespace browser_sync |
OLD | NEW |