| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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 "base/bind.h" | |
| 6 #include "base/message_loop/message_loop.h" | |
| 7 #include "base/prefs/scoped_user_pref_update.h" | |
| 8 #include "base/run_loop.h" | |
| 9 #include "base/strings/utf_string_conversions.h" | |
| 10 #include "base/threading/sequenced_worker_pool.h" | |
| 11 #include "chrome/browser/managed_mode/managed_user_refresh_token_fetcher.h" | |
| 12 #include "chrome/browser/managed_mode/managed_user_registration_utility.h" | |
| 13 #include "chrome/browser/managed_mode/managed_user_shared_settings_service.h" | |
| 14 #include "chrome/browser/managed_mode/managed_user_shared_settings_service_facto
ry.h" | |
| 15 #include "chrome/browser/managed_mode/managed_user_sync_service.h" | |
| 16 #include "chrome/browser/managed_mode/managed_user_sync_service_factory.h" | |
| 17 #include "chrome/common/pref_names.h" | |
| 18 #include "chrome/test/base/testing_pref_service_syncable.h" | |
| 19 #include "chrome/test/base/testing_profile.h" | |
| 20 #include "content/public/browser/browser_thread.h" | |
| 21 #include "google_apis/gaia/google_service_auth_error.h" | |
| 22 #include "sync/api/attachments/attachment_id.h" | |
| 23 #include "sync/api/attachments/attachment_service_proxy_for_test.h" | |
| 24 #include "sync/api/sync_change.h" | |
| 25 #include "sync/api/sync_error_factory_mock.h" | |
| 26 #include "sync/protocol/sync.pb.h" | |
| 27 #include "testing/gtest/include/gtest/gtest.h" | |
| 28 | |
| 29 using sync_pb::ManagedUserSpecifics; | |
| 30 using syncer::SUPERVISED_USERS; | |
| 31 using syncer::SyncChange; | |
| 32 using syncer::SyncChangeList; | |
| 33 using syncer::SyncChangeProcessor; | |
| 34 using syncer::SyncData; | |
| 35 using syncer::SyncDataList; | |
| 36 using syncer::SyncError; | |
| 37 using syncer::SyncErrorFactory; | |
| 38 using syncer::SyncMergeResult; | |
| 39 | |
| 40 namespace { | |
| 41 | |
| 42 const char kSupervisedUserToken[] = "supervisedusertoken"; | |
| 43 | |
| 44 class MockChangeProcessor : public SyncChangeProcessor { | |
| 45 public: | |
| 46 MockChangeProcessor() {} | |
| 47 virtual ~MockChangeProcessor() {} | |
| 48 | |
| 49 // SyncChangeProcessor implementation: | |
| 50 virtual SyncError ProcessSyncChanges( | |
| 51 const tracked_objects::Location& from_here, | |
| 52 const SyncChangeList& change_list) OVERRIDE; | |
| 53 | |
| 54 virtual SyncDataList GetAllSyncData(syncer::ModelType type) const | |
| 55 OVERRIDE { | |
| 56 return SyncDataList(); | |
| 57 } | |
| 58 | |
| 59 const SyncChangeList& changes() const { return change_list_; } | |
| 60 | |
| 61 private: | |
| 62 SyncChangeList change_list_; | |
| 63 }; | |
| 64 | |
| 65 SyncError MockChangeProcessor::ProcessSyncChanges( | |
| 66 const tracked_objects::Location& from_here, | |
| 67 const SyncChangeList& change_list) { | |
| 68 change_list_ = change_list; | |
| 69 return SyncError(); | |
| 70 } | |
| 71 | |
| 72 class MockManagedUserRefreshTokenFetcher | |
| 73 : public ManagedUserRefreshTokenFetcher { | |
| 74 public: | |
| 75 MockManagedUserRefreshTokenFetcher() {} | |
| 76 virtual ~MockManagedUserRefreshTokenFetcher() {} | |
| 77 | |
| 78 // ManagedUserRefreshTokenFetcher implementation: | |
| 79 virtual void Start(const std::string& managed_user_id, | |
| 80 const std::string& device_name, | |
| 81 const TokenCallback& callback) OVERRIDE { | |
| 82 GoogleServiceAuthError error(GoogleServiceAuthError::NONE); | |
| 83 callback.Run(error, kSupervisedUserToken); | |
| 84 } | |
| 85 }; | |
| 86 | |
| 87 } // namespace | |
| 88 | |
| 89 class ManagedUserRegistrationUtilityTest : public ::testing::Test { | |
| 90 public: | |
| 91 ManagedUserRegistrationUtilityTest(); | |
| 92 virtual ~ManagedUserRegistrationUtilityTest(); | |
| 93 | |
| 94 virtual void TearDown() OVERRIDE; | |
| 95 | |
| 96 protected: | |
| 97 scoped_ptr<SyncChangeProcessor> CreateChangeProcessor(); | |
| 98 scoped_ptr<SyncErrorFactory> CreateErrorFactory(); | |
| 99 SyncData CreateRemoteData(const std::string& id, const std::string& name); | |
| 100 | |
| 101 SyncMergeResult StartInitialSync(); | |
| 102 | |
| 103 ManagedUserRegistrationUtility::RegistrationCallback | |
| 104 GetRegistrationCallback(); | |
| 105 | |
| 106 ManagedUserRegistrationUtility* GetRegistrationUtility(); | |
| 107 | |
| 108 void Acknowledge(); | |
| 109 | |
| 110 PrefService* prefs() { return profile_.GetTestingPrefService(); } | |
| 111 ManagedUserSyncService* service() { return service_; } | |
| 112 ManagedUserSharedSettingsService* shared_settings_service() { | |
| 113 return shared_settings_service_; | |
| 114 } | |
| 115 MockChangeProcessor* change_processor() { return change_processor_; } | |
| 116 | |
| 117 bool received_callback() const { return received_callback_; } | |
| 118 const GoogleServiceAuthError& error() const { return error_; } | |
| 119 const std::string& token() const { return token_; } | |
| 120 | |
| 121 private: | |
| 122 void OnManagedUserRegistered(const GoogleServiceAuthError& error, | |
| 123 const std::string& token); | |
| 124 | |
| 125 base::MessageLoop message_loop_; | |
| 126 base::RunLoop run_loop_; | |
| 127 TestingProfile profile_; | |
| 128 ManagedUserSyncService* service_; | |
| 129 ManagedUserSharedSettingsService* shared_settings_service_; | |
| 130 scoped_ptr<ManagedUserRegistrationUtility> registration_utility_; | |
| 131 | |
| 132 // Owned by the ManagedUserSyncService. | |
| 133 MockChangeProcessor* change_processor_; | |
| 134 | |
| 135 // A unique ID for creating "remote" Sync data. | |
| 136 int64 sync_data_id_; | |
| 137 | |
| 138 // Whether OnManagedUserRegistered has been called. | |
| 139 bool received_callback_; | |
| 140 | |
| 141 // Hold the registration result (either an error, or a token). | |
| 142 GoogleServiceAuthError error_; | |
| 143 std::string token_; | |
| 144 | |
| 145 base::WeakPtrFactory<ManagedUserRegistrationUtilityTest> weak_ptr_factory_; | |
| 146 }; | |
| 147 | |
| 148 ManagedUserRegistrationUtilityTest::ManagedUserRegistrationUtilityTest() | |
| 149 : change_processor_(NULL), | |
| 150 sync_data_id_(0), | |
| 151 received_callback_(false), | |
| 152 error_(GoogleServiceAuthError::NUM_STATES), | |
| 153 weak_ptr_factory_(this) { | |
| 154 service_ = ManagedUserSyncServiceFactory::GetForProfile(&profile_); | |
| 155 shared_settings_service_ = | |
| 156 ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(&profile_); | |
| 157 } | |
| 158 | |
| 159 ManagedUserRegistrationUtilityTest::~ManagedUserRegistrationUtilityTest() { | |
| 160 EXPECT_FALSE(weak_ptr_factory_.HasWeakPtrs()); | |
| 161 } | |
| 162 | |
| 163 void ManagedUserRegistrationUtilityTest::TearDown() { | |
| 164 content::BrowserThread::GetBlockingPool()->FlushForTesting(); | |
| 165 base::RunLoop().RunUntilIdle(); | |
| 166 } | |
| 167 | |
| 168 scoped_ptr<SyncChangeProcessor> | |
| 169 ManagedUserRegistrationUtilityTest::CreateChangeProcessor() { | |
| 170 EXPECT_FALSE(change_processor_); | |
| 171 change_processor_ = new MockChangeProcessor(); | |
| 172 return scoped_ptr<SyncChangeProcessor>(change_processor_); | |
| 173 } | |
| 174 | |
| 175 scoped_ptr<SyncErrorFactory> | |
| 176 ManagedUserRegistrationUtilityTest::CreateErrorFactory() { | |
| 177 return scoped_ptr<SyncErrorFactory>(new syncer::SyncErrorFactoryMock()); | |
| 178 } | |
| 179 | |
| 180 SyncMergeResult ManagedUserRegistrationUtilityTest::StartInitialSync() { | |
| 181 SyncDataList initial_sync_data; | |
| 182 SyncMergeResult result = | |
| 183 service()->MergeDataAndStartSyncing(SUPERVISED_USERS, | |
| 184 initial_sync_data, | |
| 185 CreateChangeProcessor(), | |
| 186 CreateErrorFactory()); | |
| 187 EXPECT_FALSE(result.error().IsSet()); | |
| 188 return result; | |
| 189 } | |
| 190 | |
| 191 ManagedUserRegistrationUtility::RegistrationCallback | |
| 192 ManagedUserRegistrationUtilityTest::GetRegistrationCallback() { | |
| 193 return base::Bind( | |
| 194 &ManagedUserRegistrationUtilityTest::OnManagedUserRegistered, | |
| 195 weak_ptr_factory_.GetWeakPtr()); | |
| 196 } | |
| 197 | |
| 198 ManagedUserRegistrationUtility* | |
| 199 ManagedUserRegistrationUtilityTest::GetRegistrationUtility() { | |
| 200 if (registration_utility_.get()) | |
| 201 return registration_utility_.get(); | |
| 202 | |
| 203 scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher( | |
| 204 new MockManagedUserRefreshTokenFetcher); | |
| 205 registration_utility_.reset( | |
| 206 ManagedUserRegistrationUtility::CreateImpl(prefs(), | |
| 207 token_fetcher.Pass(), | |
| 208 service(), | |
| 209 shared_settings_service())); | |
| 210 return registration_utility_.get(); | |
| 211 } | |
| 212 | |
| 213 void ManagedUserRegistrationUtilityTest::Acknowledge() { | |
| 214 SyncChangeList new_changes; | |
| 215 const SyncChangeList& changes = change_processor()->changes(); | |
| 216 for (SyncChangeList::const_iterator it = changes.begin(); it != changes.end(); | |
| 217 ++it) { | |
| 218 EXPECT_EQ(SyncChange::ACTION_ADD, it->change_type()); | |
| 219 ::sync_pb::EntitySpecifics specifics = it->sync_data().GetSpecifics(); | |
| 220 EXPECT_FALSE(specifics.managed_user().acknowledged()); | |
| 221 specifics.mutable_managed_user()->set_acknowledged(true); | |
| 222 new_changes.push_back( | |
| 223 SyncChange(FROM_HERE, | |
| 224 SyncChange::ACTION_UPDATE, | |
| 225 SyncData::CreateRemoteData( | |
| 226 ++sync_data_id_, | |
| 227 specifics, | |
| 228 base::Time(), | |
| 229 syncer::AttachmentIdList(), | |
| 230 syncer::AttachmentServiceProxyForTest::Create()))); | |
| 231 } | |
| 232 service()->ProcessSyncChanges(FROM_HERE, new_changes); | |
| 233 | |
| 234 run_loop_.Run(); | |
| 235 } | |
| 236 | |
| 237 void ManagedUserRegistrationUtilityTest::OnManagedUserRegistered( | |
| 238 const GoogleServiceAuthError& error, | |
| 239 const std::string& token) { | |
| 240 received_callback_ = true; | |
| 241 error_ = error; | |
| 242 token_ = token; | |
| 243 run_loop_.Quit(); | |
| 244 } | |
| 245 | |
| 246 TEST_F(ManagedUserRegistrationUtilityTest, Register) { | |
| 247 StartInitialSync(); | |
| 248 GetRegistrationUtility()->Register( | |
| 249 ManagedUserRegistrationUtility::GenerateNewManagedUserId(), | |
| 250 ManagedUserRegistrationInfo(base::ASCIIToUTF16("Dug"), 0), | |
| 251 GetRegistrationCallback()); | |
| 252 EXPECT_EQ(1u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size()); | |
| 253 Acknowledge(); | |
| 254 | |
| 255 EXPECT_TRUE(received_callback()); | |
| 256 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 257 EXPECT_FALSE(token().empty()); | |
| 258 } | |
| 259 | |
| 260 TEST_F(ManagedUserRegistrationUtilityTest, RegisterBeforeInitialSync) { | |
| 261 GetRegistrationUtility()->Register( | |
| 262 ManagedUserRegistrationUtility::GenerateNewManagedUserId(), | |
| 263 ManagedUserRegistrationInfo(base::ASCIIToUTF16("Nemo"), 5), | |
| 264 GetRegistrationCallback()); | |
| 265 EXPECT_EQ(1u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size()); | |
| 266 StartInitialSync(); | |
| 267 Acknowledge(); | |
| 268 | |
| 269 EXPECT_TRUE(received_callback()); | |
| 270 EXPECT_EQ(GoogleServiceAuthError::NONE, error().state()); | |
| 271 EXPECT_FALSE(token().empty()); | |
| 272 } | |
| 273 | |
| 274 TEST_F(ManagedUserRegistrationUtilityTest, SyncServiceShutdownBeforeRegFinish) { | |
| 275 StartInitialSync(); | |
| 276 GetRegistrationUtility()->Register( | |
| 277 ManagedUserRegistrationUtility::GenerateNewManagedUserId(), | |
| 278 ManagedUserRegistrationInfo(base::ASCIIToUTF16("Remy"), 12), | |
| 279 GetRegistrationCallback()); | |
| 280 EXPECT_EQ(1u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size()); | |
| 281 service()->Shutdown(); | |
| 282 EXPECT_EQ(0u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size()); | |
| 283 EXPECT_TRUE(received_callback()); | |
| 284 EXPECT_EQ(GoogleServiceAuthError::REQUEST_CANCELED, error().state()); | |
| 285 EXPECT_EQ(std::string(), token()); | |
| 286 } | |
| 287 | |
| 288 TEST_F(ManagedUserRegistrationUtilityTest, StopSyncingBeforeRegFinish) { | |
| 289 StartInitialSync(); | |
| 290 GetRegistrationUtility()->Register( | |
| 291 ManagedUserRegistrationUtility::GenerateNewManagedUserId(), | |
| 292 ManagedUserRegistrationInfo(base::ASCIIToUTF16("Mike"), 17), | |
| 293 GetRegistrationCallback()); | |
| 294 EXPECT_EQ(1u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size()); | |
| 295 service()->StopSyncing(SUPERVISED_USERS); | |
| 296 EXPECT_EQ(0u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size()); | |
| 297 EXPECT_TRUE(received_callback()); | |
| 298 EXPECT_EQ(GoogleServiceAuthError::REQUEST_CANCELED, error().state()); | |
| 299 EXPECT_EQ(std::string(), token()); | |
| 300 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 335833003:
Rename "managed (mode|user)" to "supervised user" (part 2) (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src