profile_sync_service_startup_unittest.cc revision c407dc5cd9bdc5668497f21b26b09d988ab439de 
1// Copyright (c) 2010 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 "testing/gtest/include/gtest/gtest.h"
6
7#include "base/message_loop.h"
8#include "base/scoped_ptr.h"
9#include "chrome/browser/chrome_thread.h"
10#include "chrome/browser/net/gaia/token_service.h"
11#include "chrome/browser/sync/glue/data_type_manager.h"
12#include "chrome/browser/sync/glue/data_type_manager_mock.h"
13#include "chrome/browser/sync/profile_sync_factory_mock.h"
14#include "chrome/browser/sync/profile_sync_test_util.h"
15#include "chrome/browser/sync/test_profile_sync_service.h"
16#include "chrome/common/net/gaia/gaia_auth_consumer.h"
17#include "chrome/common/notification_type.h"
18#include "chrome/common/pref_names.h"
19#include "chrome/test/testing_profile.h"
20#include "testing/gmock/include/gmock/gmock.h"
21
22using browser_sync::DataTypeManager;
23using browser_sync::DataTypeManagerMock;
24using testing::_;
25using testing::DoAll;
26using testing::InvokeArgument;
27using testing::Mock;
28using testing::Return;
29
30ACTION_P(InvokeCallback, callback_result) {
31  arg0->Run(callback_result);
32  delete arg0;
33}
34
35// TODO(skrul) This test fails on the mac. See http://crbug.com/33443
36#if defined(OS_MACOSX)
37#define SKIP_MACOSX(test) DISABLED_##test
38#else
39#define SKIP_MACOSX(test) test
40#endif
41
42class ProfileSyncServiceStartupTest : public testing::Test {
43 public:
44  ProfileSyncServiceStartupTest()
45      : ui_thread_(ChromeThread::UI, &message_loop_) {}
46
47  virtual ~ProfileSyncServiceStartupTest() {
48    // The PSS has some deletes that are scheduled on the main thread
49    // so we must delete the service and run the message loop.
50    service_.reset();
51    MessageLoop::current()->RunAllPending();
52  }
53
54  virtual void SetUp() {
55    service_.reset(new TestProfileSyncService(&factory_, &profile_,
56                                              false, true, NULL));
57    service_->AddObserver(&observer_);
58    service_->set_num_expected_resumes(0);
59    service_->set_num_expected_pauses(0);
60    service_->set_synchronous_sync_configuration();
61  }
62
63  virtual void TearDown() {
64    service_->RemoveObserver(&observer_);
65  }
66
67 protected:
68  DataTypeManagerMock* SetUpDataTypeManager() {
69    DataTypeManagerMock* data_type_manager = new DataTypeManagerMock();
70    EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).
71        WillOnce(Return(data_type_manager));
72    return data_type_manager;
73  }
74
75  MessageLoop message_loop_;
76  ChromeThread ui_thread_;
77  TestingProfile profile_;
78  ProfileSyncFactoryMock factory_;
79  scoped_ptr<TestProfileSyncService> service_;
80  ProfileSyncServiceObserverMock observer_;
81};
82
83TEST_F(ProfileSyncServiceStartupTest, SKIP_MACOSX(StartFirstTime)) {
84  DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
85  EXPECT_CALL(*data_type_manager, Configure(_)).Times(0);
86
87  // We've never completed startup.
88  profile_.GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
89
90  // Should not actually start, rather just clean things up and wait
91  // to be enabled.
92  EXPECT_CALL(observer_, OnStateChanged()).Times(1);
93  service_->Initialize();
94
95  // Preferences should be back to defaults.
96  EXPECT_EQ(0, profile_.GetPrefs()->GetInt64(prefs::kSyncLastSyncedTime));
97  EXPECT_FALSE(profile_.GetPrefs()->GetBoolean(prefs::kSyncHasSetupCompleted));
98  Mock::VerifyAndClearExpectations(data_type_manager);
99
100  // Then start things up.
101  EXPECT_CALL(*data_type_manager, Configure(_)).Times(1);
102  EXPECT_CALL(*data_type_manager, state()).
103      WillOnce(Return(DataTypeManager::CONFIGURED));
104  EXPECT_CALL(*data_type_manager, Stop()).Times(1);
105  EXPECT_CALL(observer_, OnStateChanged()).Times(4);
106  service_->EnableForUser(NULL);
107  syncable::ModelTypeSet set;
108  set.insert(syncable::BOOKMARKS);
109  service_->OnUserChoseDatatypes(false, set);
110}
111
112TEST_F(ProfileSyncServiceStartupTest, SKIP_MACOSX(StartNormal)) {
113  DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
114  EXPECT_CALL(*data_type_manager, Configure(_)).Times(1);
115  EXPECT_CALL(*data_type_manager, state()).
116      WillOnce(Return(DataTypeManager::CONFIGURED));
117  EXPECT_CALL(*data_type_manager, Stop()).Times(1);
118
119  EXPECT_CALL(observer_, OnStateChanged()).Times(3);
120
121  service_->Initialize();
122}
123
124TEST_F(ProfileSyncServiceStartupTest, SKIP_MACOSX(ManagedStartup)) {
125  // Disable sync through policy.
126  profile_.GetPrefs()->SetBoolean(prefs::kSyncManaged, true);
127
128  EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).Times(0);
129  EXPECT_CALL(observer_, OnStateChanged()).Times(1);
130
131  // Service should not be started by Initialize() since it's managed.
132  service_->Initialize();
133}
134
135TEST_F(ProfileSyncServiceStartupTest, SKIP_MACOSX(SwitchManaged)) {
136  DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
137  EXPECT_CALL(*data_type_manager, Configure(_)).Times(1);
138  EXPECT_CALL(observer_, OnStateChanged()).Times(3);
139
140  service_->Initialize();
141
142  // The service should stop when switching to managed mode.
143  Mock::VerifyAndClearExpectations(data_type_manager);
144  EXPECT_CALL(*data_type_manager, state()).
145      WillOnce(Return(DataTypeManager::CONFIGURED));
146  EXPECT_CALL(*data_type_manager, Stop()).Times(1);
147  EXPECT_CALL(observer_, OnStateChanged()).Times(2);
148  profile_.GetPrefs()->SetBoolean(prefs::kSyncManaged, true);
149
150  // When switching back to unmanaged, the state should change, but the service
151  // should not start up automatically (kSyncSetupCompleted will be false).
152  Mock::VerifyAndClearExpectations(data_type_manager);
153  EXPECT_CALL(factory_, CreateDataTypeManager(_, _)).Times(0);
154  EXPECT_CALL(observer_, OnStateChanged()).Times(1);
155  profile_.GetPrefs()->ClearPref(prefs::kSyncManaged);
156}
157
158TEST_F(ProfileSyncServiceStartupTest, SKIP_MACOSX(StartFailure)) {
159  DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
160  DataTypeManager::ConfigureResult result =
161      DataTypeManager::ASSOCIATION_FAILED;
162  EXPECT_CALL(*data_type_manager, Configure(_)).
163      WillOnce(DoAll(Notify(NotificationType::SYNC_CONFIGURE_START),
164                     NotifyWithResult(NotificationType::SYNC_CONFIGURE_DONE,
165                                      &result)));
166  EXPECT_CALL(*data_type_manager, Stop()).Times(1);
167  EXPECT_CALL(*data_type_manager, state()).
168      WillOnce(Return(DataTypeManager::STOPPED));
169
170  EXPECT_CALL(observer_, OnStateChanged()).Times(3);
171
172  service_->Initialize();
173  EXPECT_TRUE(service_->unrecoverable_error_detected());
174}
175
176class ProfileSyncServiceStartupBootstrapTest
177    : public ProfileSyncServiceStartupTest {
178 public:
179  ProfileSyncServiceStartupBootstrapTest() {}
180  virtual ~ProfileSyncServiceStartupBootstrapTest() {}
181
182  virtual void SetUp() {
183    service_.reset(new TestProfileSyncService(&factory_, &profile_,
184                                              true, true, NULL));
185    service_->AddObserver(&observer_);
186    service_->set_num_expected_resumes(0);
187    service_->set_num_expected_pauses(0);
188    service_->set_synchronous_sync_configuration();
189  }
190};
191
192TEST_F(ProfileSyncServiceStartupBootstrapTest, SKIP_MACOSX(StartFirstTime)) {
193  DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
194  EXPECT_CALL(*data_type_manager, Configure(_)).Times(1);
195  EXPECT_CALL(*data_type_manager, state()).
196      WillOnce(Return(DataTypeManager::CONFIGURED));
197  EXPECT_CALL(*data_type_manager, Stop()).Times(1);
198  EXPECT_CALL(observer_, OnStateChanged()).Times(4);
199
200  profile_.GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
201
202  // Pretend the login screen worked.
203  GaiaAuthConsumer::ClientLoginResult result;
204  result.sid = "sid";
205  result.lsid = "lsid";
206  profile_.GetTokenService()->SetClientLoginResult(result);
207  // Will start sync even though setup hasn't been completed (since
208  // setup is bypassed when bootstrapping is enabled).
209  service_->Initialize();
210}
211