cloud_external_data_policy_observer_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9
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 "chrome/browser/chromeos/policy/cloud_external_data_policy_observer.h" 6 7#include <utility> 8#include <vector> 9 10#include "base/file_util.h" 11#include "base/files/file_path.h" 12#include "base/json/json_writer.h" 13#include "base/memory/ref_counted.h" 14#include "base/message_loop/message_loop.h" 15#include "base/message_loop/message_loop_proxy.h" 16#include "base/path_service.h" 17#include "base/run_loop.h" 18#include "base/values.h" 19#include "chrome/browser/chrome_notification_types.h" 20#include "chrome/browser/chromeos/login/fake_user_manager.h" 21#include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h" 22#include "chrome/browser/chromeos/policy/device_local_account.h" 23#include "chrome/browser/chromeos/policy/device_local_account_external_data_manager.h" 24#include "chrome/browser/chromeos/policy/device_local_account_policy_provider.h" 25#include "chrome/browser/chromeos/policy/device_local_account_policy_service.h" 26#include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h" 27#include "chrome/browser/chromeos/settings/device_settings_service.h" 28#include "chrome/browser/chromeos/settings/device_settings_test_helper.h" 29#include "chrome/browser/profiles/profile.h" 30#include "chrome/common/chrome_paths.h" 31#include "chrome/test/base/testing_profile.h" 32#include "components/policy/core/common/cloud/cloud_policy_core.h" 33#include "components/policy/core/common/cloud/cloud_policy_store.h" 34#include "components/policy/core/common/cloud/mock_cloud_external_data_manager.h" 35#include "components/policy/core/common/cloud/policy_builder.h" 36#include "components/policy/core/common/external_data_fetcher.h" 37#include "components/policy/core/common/mock_configuration_policy_provider.h" 38#include "components/policy/core/common/policy_map.h" 39#include "components/policy/core/common/policy_service.h" 40#include "components/policy/core/common/policy_service_impl.h" 41#include "components/policy/core/common/policy_types.h" 42#include "content/public/browser/notification_details.h" 43#include "content/public/browser/notification_service.h" 44#include "content/public/browser/notification_source.h" 45#include "net/url_request/test_url_fetcher_factory.h" 46#include "net/url_request/url_fetcher_delegate.h" 47#include "net/url_request/url_request_context_getter.h" 48#include "net/url_request/url_request_status.h" 49#include "policy/policy_constants.h" 50#include "policy/proto/cloud_policy.pb.h" 51#include "testing/gmock/include/gmock/gmock.h" 52#include "testing/gtest/include/gtest/gtest.h" 53#include "url/gurl.h" 54 55namespace em = enterprise_management; 56 57using ::testing::Mock; 58using ::testing::Return; 59using ::testing::SaveArg; 60using ::testing::_; 61 62namespace policy { 63 64namespace { 65 66const char kDeviceLocalAccount[] = "device_local_account@localhost"; 67 68const char kRegularUserID[] = "user@example.com"; 69 70const char kAvatar1URL[] = "http://localhost/avatar1.jpg"; 71const char kAvatar2URL[] = "http://localhost/avatar2.jpg"; 72 73void ConstructAvatarPolicy(const std::string& file_name, 74 const std::string& url, 75 std::string* policy_data, 76 std::string* policy) { 77 base::FilePath test_data_dir; 78 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir)); 79 ASSERT_TRUE(base::ReadFileToString( 80 test_data_dir.Append("chromeos").Append(file_name), 81 policy_data)); 82 base::JSONWriter::Write( 83 test::ConstructExternalDataReference(url, *policy_data).get(), 84 policy); 85} 86 87} // namespace 88 89class CloudExternalDataPolicyObserverTest 90 : public chromeos::DeviceSettingsTestBase, 91 public CloudExternalDataPolicyObserver::Delegate { 92 public: 93 typedef std::pair<std::string, std::string> FetchedCall; 94 95 CloudExternalDataPolicyObserverTest(); 96 virtual ~CloudExternalDataPolicyObserverTest(); 97 98 // chromeos::DeviceSettingsTestBase: 99 virtual void SetUp() OVERRIDE; 100 virtual void TearDown() OVERRIDE; 101 102 // CloudExternalDataPolicyObserver::Delegate: 103 virtual void OnExternalDataSet(const std::string& policy, 104 const std::string& user_id) OVERRIDE; 105 virtual void OnExternalDataCleared(const std::string& policy, 106 const std::string& user_id) OVERRIDE; 107 virtual void OnExternalDataFetched(const std::string& policy, 108 const std::string& user_id, 109 scoped_ptr<std::string> data) OVERRIDE; 110 111 void CreateObserver(); 112 113 void ClearObservations(); 114 115 void SetDeviceLocalAccountAvatarPolicy(const std::string& account_id, 116 const std::string& value); 117 118 void AddDeviceLocalAccount(const std::string& account_id); 119 void RemoveDeviceLocalAccount(const std::string& account_id); 120 121 DeviceLocalAccountPolicyBroker* GetBrokerForDeviceLocalAccountUser(); 122 123 void RefreshDeviceLocalAccountPolicy(DeviceLocalAccountPolicyBroker* broker); 124 125 void LogInAsDeviceLocalAccount(const std::string& user_id); 126 127 void SetRegularUserAvatarPolicy(const std::string& value); 128 129 void LogInAsRegularUser(); 130 131 const std::string device_local_account_user_id_; 132 133 std::string avatar_policy_1_data_; 134 std::string avatar_policy_2_data_; 135 std::string avatar_policy_1_; 136 std::string avatar_policy_2_; 137 138 chromeos::CrosSettings cros_settings_; 139 chromeos::FakeUserManager user_manager_; 140 scoped_ptr<DeviceLocalAccountPolicyService> 141 device_local_account_policy_service_; 142 net::TestURLFetcherFactory url_fetcher_factory_; 143 144 scoped_ptr<DeviceLocalAccountPolicyProvider> 145 device_local_account_policy_provider_; 146 147 MockCloudExternalDataManager external_data_manager_; 148 MockConfigurationPolicyProvider user_policy_provider_; 149 150 scoped_ptr<TestingProfile> profile_; 151 152 scoped_ptr<CloudExternalDataPolicyObserver> observer_; 153 154 std::vector<std::string> set_calls_; 155 std::vector<std::string> cleared_calls_; 156 std::vector<FetchedCall> fetched_calls_; 157 158 ExternalDataFetcher::FetchCallback fetch_callback_; 159 160 private: 161 DISALLOW_COPY_AND_ASSIGN(CloudExternalDataPolicyObserverTest); 162}; 163 164CloudExternalDataPolicyObserverTest::CloudExternalDataPolicyObserverTest() 165 : device_local_account_user_id_(GenerateDeviceLocalAccountUserId( 166 kDeviceLocalAccount, 167 DeviceLocalAccount::TYPE_PUBLIC_SESSION)), 168 cros_settings_(&device_settings_service_) { 169} 170 171CloudExternalDataPolicyObserverTest::~CloudExternalDataPolicyObserverTest() { 172} 173 174void CloudExternalDataPolicyObserverTest::SetUp() { 175 chromeos::DeviceSettingsTestBase::SetUp(); 176 device_local_account_policy_service_.reset( 177 new DeviceLocalAccountPolicyService(&device_settings_test_helper_, 178 &device_settings_service_, 179 &cros_settings_, 180 loop_.message_loop_proxy(), 181 loop_.message_loop_proxy(), 182 loop_.message_loop_proxy(), 183 loop_.message_loop_proxy(), 184 NULL)); 185 url_fetcher_factory_.set_remove_fetcher_on_delete(true); 186 187 EXPECT_CALL(user_policy_provider_, IsInitializationComplete(_)) 188 .WillRepeatedly(Return(true)); 189 user_policy_provider_.Init(); 190 191 ConstructAvatarPolicy("avatar1.jpg", 192 kAvatar1URL, 193 &avatar_policy_1_data_, 194 &avatar_policy_1_); 195 ConstructAvatarPolicy("avatar2.jpg", 196 kAvatar2URL, 197 &avatar_policy_2_data_, 198 &avatar_policy_2_); 199} 200 201void CloudExternalDataPolicyObserverTest::TearDown() { 202 observer_.reset(); 203 user_policy_provider_.Shutdown(); 204 profile_.reset(); 205 if (device_local_account_policy_provider_) { 206 device_local_account_policy_provider_->Shutdown(); 207 device_local_account_policy_provider_.reset(); 208 } 209 device_local_account_policy_service_->Shutdown(); 210 device_local_account_policy_service_.reset(); 211 chromeos::DeviceSettingsTestBase::TearDown(); 212} 213 214 215void CloudExternalDataPolicyObserverTest::OnExternalDataSet( 216 const std::string& policy, 217 const std::string& user_id) { 218 EXPECT_EQ(key::kUserAvatarImage, policy); 219 set_calls_.push_back(user_id); 220} 221 222void CloudExternalDataPolicyObserverTest::OnExternalDataCleared( 223 const std::string& policy, 224 const std::string& user_id) { 225 EXPECT_EQ(key::kUserAvatarImage, policy); 226 cleared_calls_.push_back(user_id); 227} 228 229void CloudExternalDataPolicyObserverTest::OnExternalDataFetched( 230 const std::string& policy, 231 const std::string& user_id, 232 scoped_ptr<std::string> data) { 233 EXPECT_EQ(key::kUserAvatarImage, policy); 234 fetched_calls_.push_back(make_pair(user_id, std::string())); 235 fetched_calls_.back().second.swap(*data); 236} 237 238void CloudExternalDataPolicyObserverTest::CreateObserver() { 239 observer_.reset(new CloudExternalDataPolicyObserver( 240 &cros_settings_, 241 &user_manager_, 242 device_local_account_policy_service_.get(), 243 key::kUserAvatarImage, 244 this)); 245 observer_->Init(); 246} 247 248void CloudExternalDataPolicyObserverTest::ClearObservations() { 249 set_calls_.clear(); 250 cleared_calls_.clear(); 251 fetched_calls_.clear(); 252} 253 254void CloudExternalDataPolicyObserverTest::SetDeviceLocalAccountAvatarPolicy( 255 const std::string& account_id, 256 const std::string& value) { 257 UserPolicyBuilder builder; 258 builder.policy_data().set_policy_type( 259 dm_protocol::kChromePublicAccountPolicyType); 260 builder.policy_data().set_settings_entity_id(account_id); 261 builder.policy_data().set_username(account_id); 262 if (!value.empty()) 263 builder.payload().mutable_useravatarimage()->set_value(value); 264 builder.Build(); 265 device_settings_test_helper_.set_device_local_account_policy_blob( 266 account_id, 267 builder.GetBlob()); 268} 269 270void CloudExternalDataPolicyObserverTest::AddDeviceLocalAccount( 271 const std::string& account_id) { 272 em::DeviceLocalAccountInfoProto* account = 273 device_policy_.payload().mutable_device_local_accounts()->add_account(); 274 account->set_account_id(account_id); 275 account->set_type( 276 em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION); 277 device_policy_.Build(); 278 device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); 279 ReloadDeviceSettings(); 280} 281 282void CloudExternalDataPolicyObserverTest::RemoveDeviceLocalAccount( 283 const std::string& account_id) { 284 em::DeviceLocalAccountsProto* accounts = 285 device_policy_.payload().mutable_device_local_accounts(); 286 std::vector<std::string> account_ids; 287 for (int i = 0; i < accounts->account_size(); ++i) { 288 if (accounts->account(i).account_id() != account_id) 289 account_ids.push_back(accounts->account(i).account_id()); 290 } 291 accounts->clear_account(); 292 for (std::vector<std::string>::const_iterator it = account_ids.begin(); 293 it != account_ids.end(); ++it) { 294 em::DeviceLocalAccountInfoProto* account = accounts->add_account(); 295 account->set_account_id(*it); 296 account->set_type( 297 em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION); 298 } 299 device_policy_.Build(); 300 device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); 301 ReloadDeviceSettings(); 302} 303 304DeviceLocalAccountPolicyBroker* 305 CloudExternalDataPolicyObserverTest::GetBrokerForDeviceLocalAccountUser() { 306 return device_local_account_policy_service_->GetBrokerForUser( 307 device_local_account_user_id_); 308} 309 310void CloudExternalDataPolicyObserverTest::RefreshDeviceLocalAccountPolicy( 311 DeviceLocalAccountPolicyBroker* broker) { 312 broker->core()->store()->Load(); 313 device_settings_test_helper_.Flush(); 314} 315 316void CloudExternalDataPolicyObserverTest::LogInAsDeviceLocalAccount( 317 const std::string& user_id) { 318 device_local_account_policy_provider_.reset( 319 new DeviceLocalAccountPolicyProvider( 320 user_id, 321 device_local_account_policy_service_.get(), 322 scoped_ptr<PolicyMap>())); 323 324 PolicyServiceImpl::Providers providers; 325 providers.push_back(device_local_account_policy_provider_.get()); 326 TestingProfile::Builder builder; 327 builder.SetPolicyService( 328 scoped_ptr<PolicyService>(new PolicyServiceImpl(providers))); 329 330 profile_ = builder.Build(); 331 profile_->set_profile_name(user_id); 332 333 user_manager_.AddUser(user_id); 334 content::NotificationService::current()->Notify( 335 chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED, 336 content::NotificationService::AllSources(), 337 content::Details<Profile>(profile_.get())); 338} 339 340void CloudExternalDataPolicyObserverTest::SetRegularUserAvatarPolicy( 341 const std::string& value) { 342 PolicyMap policy_map; 343 if (!value.empty()) { 344 policy_map.Set( 345 key::kUserAvatarImage, 346 POLICY_LEVEL_MANDATORY, 347 POLICY_SCOPE_USER, 348 new base::StringValue(value), 349 external_data_manager_.CreateExternalDataFetcher( 350 key::kUserAvatarImage).release()); 351 } 352 user_policy_provider_.UpdateChromePolicy(policy_map); 353} 354 355void CloudExternalDataPolicyObserverTest::LogInAsRegularUser() { 356 PolicyServiceImpl::Providers providers; 357 providers.push_back(&user_policy_provider_); 358 TestingProfile::Builder builder; 359 builder.SetPolicyService( 360 scoped_ptr<PolicyService>(new PolicyServiceImpl(providers))); 361 362 profile_ = builder.Build(); 363 profile_->set_profile_name(kRegularUserID); 364 365 user_manager_.AddUser(kRegularUserID); 366 content::NotificationService::current()->Notify( 367 chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED, 368 content::NotificationService::AllSources(), 369 content::Details<Profile>(profile_.get())); 370} 371 372// Verifies that when an external data reference is set for a device-local 373// account, a corresponding notification is emitted and a fetch is started. 374// Further verifies that when the fetch succeeds, a notification containing the 375// external data is emitted. 376TEST_F(CloudExternalDataPolicyObserverTest, 377 ExistingDeviceLocalAccountFetchSuccess) { 378 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 379 AddDeviceLocalAccount(kDeviceLocalAccount); 380 381 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 382 ASSERT_TRUE(broker); 383 broker->external_data_manager()->Connect(NULL); 384 base::RunLoop().RunUntilIdle(); 385 386 CreateObserver(); 387 388 EXPECT_TRUE(cleared_calls_.empty()); 389 EXPECT_TRUE(fetched_calls_.empty()); 390 ASSERT_EQ(1u, set_calls_.size()); 391 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 392 ClearObservations(); 393 394 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 395 ASSERT_TRUE(fetcher); 396 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 397 398 fetcher->SetResponseString(avatar_policy_1_data_); 399 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 400 net::OK)); 401 fetcher->set_response_code(200); 402 fetcher->delegate()->OnURLFetchComplete(fetcher); 403 base::RunLoop().RunUntilIdle(); 404 405 EXPECT_TRUE(set_calls_.empty()); 406 EXPECT_TRUE(cleared_calls_.empty()); 407 ASSERT_EQ(1u, fetched_calls_.size()); 408 EXPECT_EQ(device_local_account_user_id_, fetched_calls_.front().first); 409 EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second); 410 ClearObservations(); 411 412 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1)); 413} 414 415// Verifies that when an external data reference is set for a device-local 416// account, a corresponding notification is emitted and a fetch is started. 417// Further verifies that when the fetch fails, no notification is emitted. 418TEST_F(CloudExternalDataPolicyObserverTest, 419 ExistingDeviceLocalAccountFetchFailure) { 420 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 421 AddDeviceLocalAccount(kDeviceLocalAccount); 422 423 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 424 ASSERT_TRUE(broker); 425 broker->external_data_manager()->Connect(NULL); 426 base::RunLoop().RunUntilIdle(); 427 428 CreateObserver(); 429 430 EXPECT_TRUE(cleared_calls_.empty()); 431 EXPECT_TRUE(fetched_calls_.empty()); 432 ASSERT_EQ(1u, set_calls_.size()); 433 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 434 ClearObservations(); 435 436 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 437 ASSERT_TRUE(fetcher); 438 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 439 440 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 441 net::OK)); 442 fetcher->set_response_code(400); 443 fetcher->delegate()->OnURLFetchComplete(fetcher); 444 base::RunLoop().RunUntilIdle(); 445 446 EXPECT_TRUE(set_calls_.empty()); 447 EXPECT_TRUE(cleared_calls_.empty()); 448 EXPECT_TRUE(fetched_calls_.empty()); 449 ClearObservations(); 450 451 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1)); 452} 453 454// Verifies that when the external data reference for a device-local account is 455// initially not set, no notifications are emitted. Further verifies that when 456// the external data reference is then cleared (which is a no-op), again, no 457// notifications are emitted. 458TEST_F(CloudExternalDataPolicyObserverTest, 459 ExistingDeviceLocalAccountClearUnset) { 460 AddDeviceLocalAccount(kDeviceLocalAccount); 461 462 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 463 ASSERT_TRUE(broker); 464 broker->external_data_manager()->Connect(NULL); 465 base::RunLoop().RunUntilIdle(); 466 467 CreateObserver(); 468 469 EXPECT_TRUE(set_calls_.empty()); 470 EXPECT_TRUE(cleared_calls_.empty()); 471 EXPECT_TRUE(fetched_calls_.empty()); 472 ClearObservations(); 473 474 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0)); 475 476 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, ""); 477 RefreshDeviceLocalAccountPolicy(broker); 478 479 EXPECT_TRUE(set_calls_.empty()); 480 EXPECT_TRUE(cleared_calls_.empty()); 481 EXPECT_TRUE(fetched_calls_.empty()); 482 ClearObservations(); 483 484 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0)); 485} 486 487// Verifies that when the external data reference for a device-local account is 488// initially set, a corresponding notification is emitted and a fetch is 489// started. Further verifies that when the external data reference is then 490// cleared, a corresponding notification is emitted and the fetch is canceled. 491TEST_F(CloudExternalDataPolicyObserverTest, 492 ExistingDeviceLocalAccountClearSet) { 493 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 494 AddDeviceLocalAccount(kDeviceLocalAccount); 495 496 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 497 ASSERT_TRUE(broker); 498 broker->external_data_manager()->Connect(NULL); 499 base::RunLoop().RunUntilIdle(); 500 501 CreateObserver(); 502 503 EXPECT_TRUE(cleared_calls_.empty()); 504 EXPECT_TRUE(fetched_calls_.empty()); 505 ASSERT_EQ(1u, set_calls_.size()); 506 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 507 ClearObservations(); 508 509 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 510 ASSERT_TRUE(fetcher); 511 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 512 513 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, ""); 514 RefreshDeviceLocalAccountPolicy(broker); 515 516 EXPECT_TRUE(set_calls_.empty()); 517 EXPECT_TRUE(fetched_calls_.empty()); 518 ASSERT_EQ(1u, cleared_calls_.size()); 519 EXPECT_EQ(device_local_account_user_id_, cleared_calls_.front()); 520 ClearObservations(); 521 522 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0)); 523} 524 525// Verifies that when the external data reference for a device-local account is 526// initially not set, no notifications are emitted. Further verifies that when 527// the external data reference is then set, a corresponding notification is 528// emitted and a fetch is started. Also verifies that when the fetch eventually 529// succeeds, a notification containing the external data is emitted. 530TEST_F(CloudExternalDataPolicyObserverTest, 531 ExistingDeviceLocalAccountSetUnset) { 532 AddDeviceLocalAccount(kDeviceLocalAccount); 533 534 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 535 ASSERT_TRUE(broker); 536 broker->external_data_manager()->Connect(NULL); 537 base::RunLoop().RunUntilIdle(); 538 539 CreateObserver(); 540 541 EXPECT_TRUE(set_calls_.empty()); 542 EXPECT_TRUE(cleared_calls_.empty()); 543 EXPECT_TRUE(fetched_calls_.empty()); 544 ClearObservations(); 545 546 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 547 RefreshDeviceLocalAccountPolicy(broker); 548 549 EXPECT_TRUE(cleared_calls_.empty()); 550 EXPECT_TRUE(fetched_calls_.empty()); 551 ASSERT_EQ(1u, set_calls_.size()); 552 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 553 ClearObservations(); 554 555 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 556 ASSERT_TRUE(fetcher); 557 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 558 559 fetcher->SetResponseString(avatar_policy_1_data_); 560 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 561 net::OK)); 562 fetcher->set_response_code(200); 563 fetcher->delegate()->OnURLFetchComplete(fetcher); 564 base::RunLoop().RunUntilIdle(); 565 566 EXPECT_TRUE(set_calls_.empty()); 567 EXPECT_TRUE(cleared_calls_.empty()); 568 ASSERT_EQ(1u, fetched_calls_.size()); 569 EXPECT_EQ(device_local_account_user_id_, fetched_calls_.front().first); 570 EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second); 571 ClearObservations(); 572 573 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1)); 574} 575 576// Verifies that when the external data reference for a device-local account is 577// initially set, a corresponding notification is emitted and a fetch is 578// started. Further verifies that when the external data reference is then 579// updated, a corresponding notification is emitted and the fetch is restarted. 580// Also verifies that when the fetch eventually succeeds, a notification 581// containing the external data is emitted. 582TEST_F(CloudExternalDataPolicyObserverTest, ExistingDeviceLocalAccountSetSet) { 583 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 584 AddDeviceLocalAccount(kDeviceLocalAccount); 585 586 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 587 ASSERT_TRUE(broker); 588 broker->external_data_manager()->Connect(NULL); 589 base::RunLoop().RunUntilIdle(); 590 591 CreateObserver(); 592 593 EXPECT_TRUE(cleared_calls_.empty()); 594 EXPECT_TRUE(fetched_calls_.empty()); 595 ASSERT_EQ(1u, set_calls_.size()); 596 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 597 ClearObservations(); 598 599 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 600 ASSERT_TRUE(fetcher); 601 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 602 603 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_2_); 604 RefreshDeviceLocalAccountPolicy(broker); 605 606 EXPECT_TRUE(cleared_calls_.empty()); 607 EXPECT_TRUE(fetched_calls_.empty()); 608 ASSERT_EQ(1u, set_calls_.size()); 609 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 610 ClearObservations(); 611 612 fetcher = url_fetcher_factory_.GetFetcherByID(1); 613 ASSERT_TRUE(fetcher); 614 EXPECT_EQ(GURL(kAvatar2URL), fetcher->GetOriginalURL()); 615 616 fetcher->SetResponseString(avatar_policy_2_data_); 617 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 618 net::OK)); 619 fetcher->set_response_code(200); 620 fetcher->delegate()->OnURLFetchComplete(fetcher); 621 base::RunLoop().RunUntilIdle(); 622 623 EXPECT_TRUE(set_calls_.empty()); 624 EXPECT_TRUE(cleared_calls_.empty()); 625 ASSERT_EQ(1u, fetched_calls_.size()); 626 EXPECT_EQ(device_local_account_user_id_, fetched_calls_.front().first); 627 EXPECT_EQ(avatar_policy_2_data_, fetched_calls_.front().second); 628 ClearObservations(); 629 630 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(2)); 631} 632 633// Verifies that when the external data reference for a device-local account is 634// initially not set, no notifications are emitted during login into the 635// account. Further verifies that when the external data reference is then set, 636// a corresponding notification is emitted only once and a fetch is started. 637// Also verifies that when the fetch eventually succeeds, a notification 638// containing the external data is emitted, again, only once. 639TEST_F(CloudExternalDataPolicyObserverTest, 640 ExistingDeviceLocalAccountSetAfterLogin) { 641 AddDeviceLocalAccount(kDeviceLocalAccount); 642 643 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 644 ASSERT_TRUE(broker); 645 broker->external_data_manager()->Connect(NULL); 646 base::RunLoop().RunUntilIdle(); 647 648 CreateObserver(); 649 650 LogInAsDeviceLocalAccount(kDeviceLocalAccount); 651 652 EXPECT_TRUE(set_calls_.empty()); 653 EXPECT_TRUE(cleared_calls_.empty()); 654 EXPECT_TRUE(fetched_calls_.empty()); 655 ClearObservations(); 656 657 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 658 RefreshDeviceLocalAccountPolicy(broker); 659 660 EXPECT_TRUE(cleared_calls_.empty()); 661 EXPECT_TRUE(fetched_calls_.empty()); 662 ASSERT_EQ(1u, set_calls_.size()); 663 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 664 ClearObservations(); 665 666 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 667 ASSERT_TRUE(fetcher); 668 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 669 670 fetcher->SetResponseString(avatar_policy_1_data_); 671 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 672 net::OK)); 673 fetcher->set_response_code(200); 674 fetcher->delegate()->OnURLFetchComplete(fetcher); 675 base::RunLoop().RunUntilIdle(); 676 677 EXPECT_TRUE(set_calls_.empty()); 678 EXPECT_TRUE(cleared_calls_.empty()); 679 ASSERT_EQ(1u, fetched_calls_.size()); 680 EXPECT_EQ(device_local_account_user_id_, fetched_calls_.front().first); 681 EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second); 682 ClearObservations(); 683 684 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1)); 685} 686 687// Verifies that when the external data reference for a device-local account is 688// initially not set, no notifications are emitted. Further verifies that when 689// the device-local account is then removed, again, no notifications are sent. 690TEST_F(CloudExternalDataPolicyObserverTest, 691 ExistingDeviceLocalAccountRemoveAccountUnset) { 692 AddDeviceLocalAccount(kDeviceLocalAccount); 693 694 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 695 ASSERT_TRUE(broker); 696 broker->external_data_manager()->Connect(NULL); 697 base::RunLoop().RunUntilIdle(); 698 699 CreateObserver(); 700 701 EXPECT_TRUE(set_calls_.empty()); 702 EXPECT_TRUE(cleared_calls_.empty()); 703 EXPECT_TRUE(fetched_calls_.empty()); 704 ClearObservations(); 705 706 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0)); 707 708 RemoveDeviceLocalAccount(kDeviceLocalAccount); 709 710 EXPECT_TRUE(set_calls_.empty()); 711 EXPECT_TRUE(cleared_calls_.empty()); 712 EXPECT_TRUE(fetched_calls_.empty()); 713 ClearObservations(); 714 715 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0)); 716} 717 718// Verifies that when the external data reference for a device-local account is 719// initially set, a corresponding notification is emitted and a fetch is 720// started. Further verifies that when the device-local account is then removed, 721// a notification indicating that the external data reference has been cleared 722// is emitted and the fetch is canceled. 723TEST_F(CloudExternalDataPolicyObserverTest, 724 ExistingDeviceLocalAccountRemoveAccountSet) { 725 SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_); 726 AddDeviceLocalAccount(kDeviceLocalAccount); 727 728 DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser(); 729 ASSERT_TRUE(broker); 730 broker->external_data_manager()->Connect(NULL); 731 base::RunLoop().RunUntilIdle(); 732 733 CreateObserver(); 734 735 EXPECT_TRUE(cleared_calls_.empty()); 736 EXPECT_TRUE(fetched_calls_.empty()); 737 ASSERT_EQ(1u, set_calls_.size()); 738 EXPECT_EQ(device_local_account_user_id_, set_calls_.front()); 739 ClearObservations(); 740 741 net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0); 742 ASSERT_TRUE(fetcher); 743 EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL()); 744 745 RemoveDeviceLocalAccount(kDeviceLocalAccount); 746 747 EXPECT_TRUE(set_calls_.empty()); 748 EXPECT_TRUE(fetched_calls_.empty()); 749 ASSERT_EQ(1u, cleared_calls_.size()); 750 EXPECT_EQ(device_local_account_user_id_, cleared_calls_.front()); 751 ClearObservations(); 752 753 EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0)); 754} 755 756// Verifies that when an external data reference is set for a regular user and 757// the user logs in, a corresponding notification is emitted and a fetch is 758// started. Further verifies that when the fetch succeeds, a notification 759// containing the external data is emitted. 760TEST_F(CloudExternalDataPolicyObserverTest, RegularUserFetchSuccess) { 761 SetRegularUserAvatarPolicy(avatar_policy_1_); 762 763 CreateObserver(); 764 765 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)) 766 .Times(1) 767 .WillOnce(SaveArg<1>(&fetch_callback_)); 768 769 LogInAsRegularUser(); 770 771 EXPECT_TRUE(cleared_calls_.empty()); 772 EXPECT_TRUE(fetched_calls_.empty()); 773 ASSERT_EQ(1u, set_calls_.size()); 774 EXPECT_EQ(kRegularUserID, set_calls_.front()); 775 ClearObservations(); 776 777 Mock::VerifyAndClear(&external_data_manager_); 778 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 779 780 fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_1_data_))); 781 782 EXPECT_TRUE(set_calls_.empty()); 783 EXPECT_TRUE(cleared_calls_.empty()); 784 ASSERT_EQ(1u, fetched_calls_.size()); 785 EXPECT_EQ(kRegularUserID, fetched_calls_.front().first); 786 EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second); 787 ClearObservations(); 788} 789 790// Verifies that when the external data reference for a regular user is not set 791// while the user is logging in, no notifications are emitted. Further verifies 792// that when the external data reference is then cleared (which is a no-op), 793// again, no notifications are emitted. 794TEST_F(CloudExternalDataPolicyObserverTest, RegularUserClearUnset) { 795 CreateObserver(); 796 797 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 798 799 LogInAsRegularUser(); 800 801 EXPECT_TRUE(set_calls_.empty()); 802 EXPECT_TRUE(cleared_calls_.empty()); 803 EXPECT_TRUE(fetched_calls_.empty()); 804 ClearObservations(); 805 806 Mock::VerifyAndClear(&external_data_manager_); 807 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 808 809 SetRegularUserAvatarPolicy(""); 810 811 EXPECT_TRUE(set_calls_.empty()); 812 EXPECT_TRUE(cleared_calls_.empty()); 813 EXPECT_TRUE(fetched_calls_.empty()); 814 ClearObservations(); 815} 816 817// Verifies that when the external data reference for a regular user is set 818// while the user is logging in, a corresponding notification is emitted and a 819// fetch is started. Further verifies that when the external data reference is 820// then cleared, a corresponding notification is emitted and no new fetch is 821// started. 822TEST_F(CloudExternalDataPolicyObserverTest, RegularUserClearSet) { 823 SetRegularUserAvatarPolicy(avatar_policy_1_); 824 825 CreateObserver(); 826 827 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)) 828 .Times(1) 829 .WillOnce(SaveArg<1>(&fetch_callback_)); 830 831 LogInAsRegularUser(); 832 833 EXPECT_TRUE(cleared_calls_.empty()); 834 EXPECT_TRUE(fetched_calls_.empty()); 835 ASSERT_EQ(1u, set_calls_.size()); 836 EXPECT_EQ(kRegularUserID, set_calls_.front()); 837 ClearObservations(); 838 839 Mock::VerifyAndClear(&external_data_manager_); 840 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 841 842 SetRegularUserAvatarPolicy(""); 843 844 EXPECT_TRUE(set_calls_.empty()); 845 EXPECT_TRUE(fetched_calls_.empty()); 846 ASSERT_EQ(1u, cleared_calls_.size()); 847 EXPECT_EQ(kRegularUserID, cleared_calls_.front()); 848 ClearObservations(); 849} 850 851 852// Verifies that when the external data reference for a regular user is not set 853// while the user is logging in, no notifications are emitted. Further verifies 854// that when the external data reference is then set, a corresponding 855// notification is emitted and a fetch is started. Also verifies that when the 856// fetch eventually succeeds, a notification containing the external data is 857// emitted. 858TEST_F(CloudExternalDataPolicyObserverTest, RegularUserSetUnset) { 859 CreateObserver(); 860 861 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 862 863 LogInAsRegularUser(); 864 865 EXPECT_TRUE(set_calls_.empty()); 866 EXPECT_TRUE(cleared_calls_.empty()); 867 EXPECT_TRUE(fetched_calls_.empty()); 868 ClearObservations(); 869 870 Mock::VerifyAndClear(&external_data_manager_); 871 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)) 872 .Times(1) 873 .WillOnce(SaveArg<1>(&fetch_callback_)); 874 875 SetRegularUserAvatarPolicy(avatar_policy_1_); 876 877 EXPECT_TRUE(cleared_calls_.empty()); 878 EXPECT_TRUE(fetched_calls_.empty()); 879 ASSERT_EQ(1u, set_calls_.size()); 880 EXPECT_EQ(kRegularUserID, set_calls_.front()); 881 ClearObservations(); 882 883 Mock::VerifyAndClear(&external_data_manager_); 884 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 885 886 fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_1_data_))); 887 888 EXPECT_TRUE(set_calls_.empty()); 889 EXPECT_TRUE(cleared_calls_.empty()); 890 ASSERT_EQ(1u, fetched_calls_.size()); 891 EXPECT_EQ(kRegularUserID, fetched_calls_.front().first); 892 EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second); 893 ClearObservations(); 894} 895 896// Verifies that when the external data reference for a regular user is set 897// while the user is logging in, a corresponding notification is emitted and a 898// fetch is started. Further verifies that when the external data reference is 899// then updated, a corresponding notification is emitted and the fetch is 900// restarted. Also verifies that when the fetch eventually succeeds, a 901// notification containing the external data is emitted. 902TEST_F(CloudExternalDataPolicyObserverTest, RegularUserSetSet) { 903 SetRegularUserAvatarPolicy(avatar_policy_1_); 904 905 CreateObserver(); 906 907 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)) 908 .Times(1) 909 .WillOnce(SaveArg<1>(&fetch_callback_)); 910 911 LogInAsRegularUser(); 912 913 EXPECT_TRUE(cleared_calls_.empty()); 914 EXPECT_TRUE(fetched_calls_.empty()); 915 ASSERT_EQ(1u, set_calls_.size()); 916 EXPECT_EQ(kRegularUserID, set_calls_.front()); 917 ClearObservations(); 918 919 Mock::VerifyAndClear(&external_data_manager_); 920 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)) 921 .Times(1) 922 .WillOnce(SaveArg<1>(&fetch_callback_)); 923 924 SetRegularUserAvatarPolicy(avatar_policy_2_); 925 926 EXPECT_TRUE(cleared_calls_.empty()); 927 EXPECT_TRUE(fetched_calls_.empty()); 928 ASSERT_EQ(1u, set_calls_.size()); 929 EXPECT_EQ(kRegularUserID, set_calls_.front()); 930 ClearObservations(); 931 932 Mock::VerifyAndClear(&external_data_manager_); 933 EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0); 934 935 fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_2_data_))); 936 937 EXPECT_TRUE(set_calls_.empty()); 938 EXPECT_TRUE(cleared_calls_.empty()); 939 ASSERT_EQ(1u, fetched_calls_.size()); 940 EXPECT_EQ(kRegularUserID, fetched_calls_.front().first); 941 EXPECT_EQ(avatar_policy_2_data_, fetched_calls_.front().second); 942 ClearObservations(); 943} 944 945} // namespace policy 946