OLD | NEW |
| (Empty) |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include <memory> | |
6 #include <utility> | |
7 | |
8 #include "base/files/file_util.h" | |
9 #include "base/strings/utf_string_conversions.h" | |
10 #include "base/threading/thread_task_runner_handle.h" | |
11 #include "build/build_config.h" | |
12 #include "components/browser_sync/browser/profile_sync_service.h" | |
13 #include "components/browser_sync/browser/profile_sync_test_util.h" | |
14 #include "components/prefs/pref_service.h" | |
15 #include "components/signin/core/browser/account_tracker_service.h" | |
16 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h" | |
17 #include "components/signin/core/browser/profile_oauth2_token_service.h" | |
18 #include "components/signin/core/browser/signin_manager.h" | |
19 #include "components/signin/core/common/signin_pref_names.h" | |
20 #include "components/sync/driver/data_type_manager.h" | |
21 #include "components/sync/driver/data_type_manager_mock.h" | |
22 #include "components/sync/driver/fake_data_type_controller.h" | |
23 #include "components/sync/driver/glue/sync_backend_host_mock.h" | |
24 #include "components/sync/driver/pref_names.h" | |
25 #include "components/sync/driver/sync_api_component_factory_mock.h" | |
26 #include "components/sync/driver/sync_prefs.h" | |
27 #include "components/sync/driver/sync_service_observer.h" | |
28 #include "components/syncable_prefs/pref_service_syncable.h" | |
29 #include "google_apis/gaia/gaia_auth_consumer.h" | |
30 #include "google_apis/gaia/gaia_constants.h" | |
31 #include "google_apis/gaia/oauth2_token_service.h" | |
32 #include "net/url_request/url_request_test_util.h" | |
33 #include "testing/gmock/include/gmock/gmock.h" | |
34 #include "testing/gtest/include/gtest/gtest.h" | |
35 | |
36 using browser_sync::SyncBackendHostMock; | |
37 using sync_driver::DataTypeManager; | |
38 using sync_driver::DataTypeManagerMock; | |
39 using testing::_; | |
40 using testing::AnyNumber; | |
41 using testing::DoAll; | |
42 using testing::Mock; | |
43 using testing::Return; | |
44 | |
45 namespace { | |
46 | |
47 const char kGaiaId[] = "12345"; | |
48 const char kEmail[] = "test_user@gmail.com"; | |
49 const char kDummyPassword[] = ""; | |
50 | |
51 class SyncServiceObserverMock : public sync_driver::SyncServiceObserver { | |
52 public: | |
53 SyncServiceObserverMock(); | |
54 virtual ~SyncServiceObserverMock(); | |
55 | |
56 MOCK_METHOD0(OnStateChanged, void()); | |
57 }; | |
58 | |
59 SyncServiceObserverMock::SyncServiceObserverMock() {} | |
60 | |
61 SyncServiceObserverMock::~SyncServiceObserverMock() {} | |
62 | |
63 } // namespace | |
64 | |
65 ACTION_P(InvokeOnConfigureStart, sync_service) { | |
66 sync_service->OnConfigureStart(); | |
67 } | |
68 | |
69 ACTION_P3(InvokeOnConfigureDone, sync_service, error_callback, result) { | |
70 DataTypeManager::ConfigureResult configure_result = | |
71 static_cast<DataTypeManager::ConfigureResult>(result); | |
72 if (result.status == sync_driver::DataTypeManager::ABORTED) | |
73 error_callback.Run(&configure_result); | |
74 sync_service->OnConfigureDone(configure_result); | |
75 } | |
76 | |
77 class ProfileSyncServiceStartupTest : public testing::Test { | |
78 public: | |
79 ProfileSyncServiceStartupTest() { | |
80 profile_sync_service_bundle_.auth_service() | |
81 ->set_auto_post_fetch_response_on_message_loop(true); | |
82 } | |
83 | |
84 ~ProfileSyncServiceStartupTest() override { | |
85 sync_service_->RemoveObserver(&observer_); | |
86 sync_service_->Shutdown(); | |
87 } | |
88 | |
89 void CreateSyncService( | |
90 ProfileSyncService::StartBehavior start_behavior) { | |
91 component_factory_ = profile_sync_service_bundle_.component_factory(); | |
92 browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder( | |
93 &profile_sync_service_bundle_); | |
94 ProfileSyncService::InitParams init_params = | |
95 profile_sync_service_bundle_.CreateBasicInitParams(start_behavior, | |
96 builder.Build()); | |
97 | |
98 sync_service_.reset(new ProfileSyncService(std::move(init_params))); | |
99 sync_service_->RegisterDataTypeController( | |
100 base::MakeUnique<sync_driver::FakeDataTypeController>( | |
101 syncer::BOOKMARKS)); | |
102 sync_service_->AddObserver(&observer_); | |
103 } | |
104 | |
105 void IssueTestTokens(const std::string& account_id) { | |
106 profile_sync_service_bundle_.auth_service()->UpdateCredentials( | |
107 account_id, "oauth2_login_token"); | |
108 } | |
109 | |
110 void SetError(DataTypeManager::ConfigureResult* result) { | |
111 sync_driver::DataTypeStatusTable::TypeErrorMap errors; | |
112 errors[syncer::BOOKMARKS] = | |
113 syncer::SyncError(FROM_HERE, | |
114 syncer::SyncError::UNRECOVERABLE_ERROR, | |
115 "Error", | |
116 syncer::BOOKMARKS); | |
117 result->data_type_status_table.UpdateFailedDataTypes(errors); | |
118 } | |
119 | |
120 protected: | |
121 std::string SimulateTestUserSignin(ProfileSyncService* sync_service) { | |
122 std::string account_id = | |
123 profile_sync_service_bundle_.account_tracker()->SeedAccountInfo(kGaiaId, | |
124 kEmail); | |
125 pref_service()->SetString(prefs::kGoogleServicesAccountId, account_id); | |
126 #if !defined(OS_CHROMEOS) | |
127 profile_sync_service_bundle_.signin_manager()->SignIn(kGaiaId, kEmail, | |
128 kDummyPassword); | |
129 #else | |
130 profile_sync_service_bundle_.signin_manager()->SetAuthenticatedAccountInfo( | |
131 kGaiaId, kEmail); | |
132 if (sync_service) | |
133 sync_service->GoogleSigninSucceeded(account_id, kEmail, kDummyPassword); | |
134 #endif | |
135 return account_id; | |
136 } | |
137 | |
138 DataTypeManagerMock* SetUpDataTypeManager() { | |
139 DataTypeManagerMock* data_type_manager = new DataTypeManagerMock(); | |
140 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
141 .WillOnce(Return(data_type_manager)); | |
142 return data_type_manager; | |
143 } | |
144 | |
145 browser_sync::SyncBackendHostMock* SetUpSyncBackendHost() { | |
146 browser_sync::SyncBackendHostMock* sync_backend_host = | |
147 new browser_sync::SyncBackendHostMock(); | |
148 EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)) | |
149 .WillOnce(Return(sync_backend_host)); | |
150 return sync_backend_host; | |
151 } | |
152 | |
153 PrefService* pref_service() { | |
154 return profile_sync_service_bundle_.pref_service(); | |
155 } | |
156 | |
157 base::MessageLoop message_loop_; | |
158 browser_sync::ProfileSyncServiceBundle profile_sync_service_bundle_; | |
159 std::unique_ptr<ProfileSyncService> sync_service_; | |
160 SyncServiceObserverMock observer_; | |
161 sync_driver::DataTypeStatusTable data_type_status_table_; | |
162 SyncApiComponentFactoryMock* component_factory_ = nullptr; | |
163 }; | |
164 | |
165 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest { | |
166 public: | |
167 ProfileSyncServiceStartupCrosTest() { | |
168 CreateSyncService(ProfileSyncService::AUTO_START); | |
169 SimulateTestUserSignin(nullptr); | |
170 EXPECT_TRUE( | |
171 profile_sync_service_bundle_.signin_manager()->IsAuthenticated()); | |
172 } | |
173 }; | |
174 | |
175 TEST_F(ProfileSyncServiceStartupTest, StartFirstTime) { | |
176 // We've never completed startup. | |
177 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
178 CreateSyncService(ProfileSyncService::MANUAL_START); | |
179 SetUpSyncBackendHost(); | |
180 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
181 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); | |
182 | |
183 // Should not actually start, rather just clean things up and wait | |
184 // to be enabled. | |
185 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
186 sync_service_->Initialize(); | |
187 | |
188 // Preferences should be back to defaults. | |
189 EXPECT_EQ(0, | |
190 pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); | |
191 EXPECT_FALSE( | |
192 pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete)); | |
193 Mock::VerifyAndClearExpectations(data_type_manager); | |
194 | |
195 // Then start things up. | |
196 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(1); | |
197 EXPECT_CALL(*data_type_manager, state()). | |
198 WillOnce(Return(DataTypeManager::CONFIGURED)). | |
199 WillOnce(Return(DataTypeManager::CONFIGURED)); | |
200 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
201 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
202 | |
203 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
204 | |
205 // Simulate successful signin as test_user. | |
206 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
207 // Create some tokens in the token service. | |
208 IssueTestTokens(account_id); | |
209 | |
210 // Simulate the UI telling sync it has finished setting up. | |
211 sync_blocker.reset(); | |
212 sync_service_->SetFirstSetupComplete(); | |
213 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
214 } | |
215 | |
216 // TODO(pavely): Reenable test once android is switched to oauth2. | |
217 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) { | |
218 // We've never completed startup. | |
219 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
220 CreateSyncService(ProfileSyncService::MANUAL_START); | |
221 | |
222 // Should not actually start, rather just clean things up and wait | |
223 // to be enabled. | |
224 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
225 .Times(0); | |
226 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
227 sync_service_->Initialize(); | |
228 | |
229 // Preferences should be back to defaults. | |
230 EXPECT_EQ(0, | |
231 pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); | |
232 EXPECT_FALSE( | |
233 pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete)); | |
234 | |
235 // Then start things up. | |
236 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
237 | |
238 // Simulate successful signin as test_user. | |
239 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
240 | |
241 profile_sync_service_bundle_.auth_service()->LoadCredentials(account_id); | |
242 | |
243 sync_blocker.reset(); | |
244 // ProfileSyncService should try to start by requesting access token. | |
245 // This request should fail as login token was not issued. | |
246 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
247 EXPECT_EQ(GoogleServiceAuthError::USER_NOT_SIGNED_UP, | |
248 sync_service_->GetAuthError().state()); | |
249 } | |
250 | |
251 // TODO(pavely): Reenable test once android is switched to oauth2. | |
252 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartInvalidCredentials) { | |
253 CreateSyncService(ProfileSyncService::MANUAL_START); | |
254 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
255 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); | |
256 | |
257 // Tell the backend to stall while downloading control types (simulating an | |
258 // auth error). | |
259 mock_sbh->set_fail_initial_download(true); | |
260 | |
261 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
262 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); | |
263 | |
264 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
265 sync_service_->Initialize(); | |
266 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
267 Mock::VerifyAndClearExpectations(data_type_manager); | |
268 | |
269 // Update the credentials, unstalling the backend. | |
270 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
271 EXPECT_CALL(*data_type_manager, state()). | |
272 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
273 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
274 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
275 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
276 | |
277 // Simulate successful signin. | |
278 SimulateTestUserSignin(sync_service_.get()); | |
279 | |
280 sync_blocker.reset(); | |
281 | |
282 // Verify we successfully finish startup and configuration. | |
283 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
284 } | |
285 | |
286 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) { | |
287 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
288 .Times(0); | |
289 EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)).Times(0); | |
290 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
291 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
292 | |
293 sync_service_->Initialize(); | |
294 // Sync should not start because there are no tokens yet. | |
295 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
296 sync_service_->SetFirstSetupComplete(); | |
297 | |
298 // Sync should not start because there are still no tokens. | |
299 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
300 } | |
301 | |
302 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) { | |
303 SetUpSyncBackendHost(); | |
304 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
305 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
306 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
307 EXPECT_CALL(*data_type_manager, state()). | |
308 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
309 EXPECT_CALL(*data_type_manager, Stop()); | |
310 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
311 | |
312 IssueTestTokens( | |
313 profile_sync_service_bundle_.account_tracker()->PickAccountIdForAccount( | |
314 "12345", kEmail)); | |
315 sync_service_->Initialize(); | |
316 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
317 } | |
318 | |
319 TEST_F(ProfileSyncServiceStartupTest, StartNormal) { | |
320 // Pre load the tokens | |
321 CreateSyncService(ProfileSyncService::MANUAL_START); | |
322 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
323 sync_service_->SetFirstSetupComplete(); | |
324 SetUpSyncBackendHost(); | |
325 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
326 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
327 EXPECT_CALL(*data_type_manager, state()). | |
328 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
329 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
330 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
331 | |
332 IssueTestTokens(account_id); | |
333 | |
334 sync_service_->Initialize(); | |
335 } | |
336 | |
337 // Test that we can recover from a case where a bug in the code resulted in | |
338 // OnUserChoseDatatypes not being properly called and datatype preferences | |
339 // therefore being left unset. | |
340 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) { | |
341 // Clear the datatype preference fields (simulating bug 154940). | |
342 pref_service()->ClearPref(sync_driver::prefs::kSyncKeepEverythingSynced); | |
343 syncer::ModelTypeSet user_types = syncer::UserTypes(); | |
344 for (syncer::ModelTypeSet::Iterator iter = user_types.First(); | |
345 iter.Good(); iter.Inc()) { | |
346 pref_service()->ClearPref( | |
347 sync_driver::SyncPrefs::GetPrefNameForDataType(iter.Get())); | |
348 } | |
349 | |
350 // Pre load the tokens | |
351 CreateSyncService(ProfileSyncService::MANUAL_START); | |
352 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
353 sync_service_->SetFirstSetupComplete(); | |
354 SetUpSyncBackendHost(); | |
355 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
356 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
357 EXPECT_CALL(*data_type_manager, state()). | |
358 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
359 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
360 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
361 | |
362 IssueTestTokens(account_id); | |
363 sync_service_->Initialize(); | |
364 | |
365 EXPECT_TRUE(pref_service()->GetBoolean( | |
366 sync_driver::prefs::kSyncKeepEverythingSynced)); | |
367 } | |
368 | |
369 // Verify that the recovery of datatype preferences doesn't overwrite a valid | |
370 // case where only bookmarks are enabled. | |
371 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) { | |
372 // Explicitly set Keep Everything Synced to false and have only bookmarks | |
373 // enabled. | |
374 pref_service()->SetBoolean(sync_driver::prefs::kSyncKeepEverythingSynced, | |
375 false); | |
376 | |
377 // Pre load the tokens | |
378 CreateSyncService(ProfileSyncService::MANUAL_START); | |
379 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
380 sync_service_->SetFirstSetupComplete(); | |
381 SetUpSyncBackendHost(); | |
382 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
383 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
384 EXPECT_CALL(*data_type_manager, state()). | |
385 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
386 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
387 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
388 IssueTestTokens(account_id); | |
389 sync_service_->Initialize(); | |
390 | |
391 EXPECT_FALSE(pref_service()->GetBoolean( | |
392 sync_driver::prefs::kSyncKeepEverythingSynced)); | |
393 } | |
394 | |
395 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) { | |
396 // Service should not be started by Initialize() since it's managed. | |
397 pref_service()->SetString(prefs::kGoogleServicesAccountId, kEmail); | |
398 CreateSyncService(ProfileSyncService::MANUAL_START); | |
399 | |
400 // Disable sync through policy. | |
401 pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true); | |
402 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
403 .Times(0); | |
404 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
405 | |
406 sync_service_->Initialize(); | |
407 } | |
408 | |
409 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) { | |
410 CreateSyncService(ProfileSyncService::MANUAL_START); | |
411 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
412 sync_service_->SetFirstSetupComplete(); | |
413 SetUpSyncBackendHost(); | |
414 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
415 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
416 EXPECT_CALL(*data_type_manager, state()) | |
417 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
418 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
419 IssueTestTokens(account_id); | |
420 sync_service_->Initialize(); | |
421 EXPECT_TRUE(sync_service_->IsBackendInitialized()); | |
422 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
423 | |
424 // The service should stop when switching to managed mode. | |
425 Mock::VerifyAndClearExpectations(data_type_manager); | |
426 EXPECT_CALL(*data_type_manager, state()). | |
427 WillOnce(Return(DataTypeManager::CONFIGURED)); | |
428 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
429 pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true); | |
430 EXPECT_FALSE(sync_service_->IsBackendInitialized()); | |
431 // Note that PSS no longer references |data_type_manager| after stopping. | |
432 | |
433 // When switching back to unmanaged, the state should change but sync should | |
434 // not start automatically because IsFirstSetupComplete() will be false. | |
435 // A new DataTypeManager should not be created. | |
436 Mock::VerifyAndClearExpectations(data_type_manager); | |
437 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
438 .Times(0); | |
439 pref_service()->ClearPref(sync_driver::prefs::kSyncManaged); | |
440 EXPECT_FALSE(sync_service_->IsBackendInitialized()); | |
441 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
442 } | |
443 | |
444 TEST_F(ProfileSyncServiceStartupTest, StartFailure) { | |
445 CreateSyncService(ProfileSyncService::MANUAL_START); | |
446 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
447 sync_service_->SetFirstSetupComplete(); | |
448 SetUpSyncBackendHost(); | |
449 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
450 DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED; | |
451 DataTypeManager::ConfigureResult result( | |
452 status, | |
453 syncer::ModelTypeSet()); | |
454 EXPECT_CALL(*data_type_manager, Configure(_, _)) | |
455 .WillRepeatedly( | |
456 DoAll(InvokeOnConfigureStart(sync_service_.get()), | |
457 InvokeOnConfigureDone( | |
458 sync_service_.get(), | |
459 base::Bind(&ProfileSyncServiceStartupTest::SetError, | |
460 base::Unretained(this)), | |
461 result))); | |
462 EXPECT_CALL(*data_type_manager, state()). | |
463 WillOnce(Return(DataTypeManager::STOPPED)); | |
464 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
465 IssueTestTokens(account_id); | |
466 sync_service_->Initialize(); | |
467 EXPECT_TRUE(sync_service_->HasUnrecoverableError()); | |
468 } | |
469 | |
470 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) { | |
471 // Pre load the tokens | |
472 CreateSyncService(ProfileSyncService::MANUAL_START); | |
473 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
474 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); | |
475 mock_sbh->set_fail_initial_download(true); | |
476 | |
477 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
478 | |
479 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
480 sync_service_->Initialize(); | |
481 | |
482 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
483 IssueTestTokens(account_id); | |
484 sync_blocker.reset(); | |
485 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
486 } | |
OLD | NEW |