Add CloudExternalDataPolicyObserverChromeOS

chrome/browser/chromeos/policy/cloud_external_data_policy_observer_chromeos_unittest.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/policy/cloud_external_data_policy_observer_chromeos.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/json/json_writer.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/path_service.h"
+#include "base/run_loop.h"
+#include "base/sha1.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/values.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/login/fake_user_manager.h"
+#include "chrome/browser/chromeos/policy/device_local_account.h"
+#include "chrome/browser/chromeos/policy/device_local_account_external_data_manager.h"
+#include "chrome/browser/chromeos/policy/device_local_account_policy_provider.h"
+#include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
+#include "chrome/browser/policy/cloud/cloud_policy_core.h"
+#include "chrome/browser/policy/cloud/cloud_policy_store.h"
+#include "chrome/browser/policy/cloud/mock_cloud_external_data_manager.h"
+#include "chrome/browser/policy/cloud/policy_builder.h"
+#include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "chrome/browser/policy/policy_service.h"
+#include "chrome/browser/policy/policy_service_impl.h"
+#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/test/base/testing_profile.h"
+#include "components/policy/core/common/external_data_fetcher.h"
+#include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_types.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_status.h"
+#include "policy/policy_constants.h"
+#include "policy/proto/cloud_policy.pb.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace em = enterprise_management;
+
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::SaveArg;
+using ::testing::_;
+
+namespace policy {
+
+namespace {
+
+const char kDeviceLocalAccount[] = "device_local_account@localhost";
+
+const char kRegularUserID[] = "user@example.com";
+
+const char kAvatar1URL[] = "http://localhost/avatar1.jpg";
+const char kAvatar2URL[] = "http://localhost/avatar2.jpg";
+
+void ConstructAvatarPolicy(const std::string& file_name,
+                           const std::string& url,
+                           std::string* policy_data,
+                           std::string* policy) {
+  base::FilePath test_data_dir;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
+  ASSERT_TRUE(base::ReadFileToString(
+      test_data_dir.Append("policy").Append(file_name),
+      policy_data));
+  const std::string sha1 = base::SHA1HashString(*policy_data);
+
+  base::DictionaryValue dict;
+  dict.SetString("url", url);
+  dict.SetString("hash", base::HexEncode(sha1.data(), sha1.size()));
+  base::JSONWriter::Write(&dict, policy);
+}
+
+}  // namespace
+
+class MockCloudExternalDataPolicyObserverChromeOS
+    : public CloudExternalDataPolicyObserverChromeOS {
+ public:
+  typedef std::pair<std::string, linked_ptr<std::string> > FetchedCall;

[Joao da Silva, 2013/11/27 14:33:59]

Could be pair<string, string>, and you could use swap() to avoid unnecessary
copying.

[bartfab (slow), 2013/11/27 20:10:15]

Done.

+
+  MockCloudExternalDataPolicyObserverChromeOS(
+      chromeos::CrosSettings* cros_settings,
+      chromeos::UserManager* user_manager,
+      DeviceLocalAccountPolicyService* device_local_account_policy_service,
+      const std::string& policy);
+  virtual ~MockCloudExternalDataPolicyObserverChromeOS() OVERRIDE;
+
+  const std::vector<std::string>* GetSetCalls();
+  const std::vector<std::string>* GetClearedCalls();
+  const std::vector<FetchedCall>* GetFetchedCalls();
+
+  void ClearObservations();
+
+  virtual void OnExternalDataSet(const std::string& user_id) OVERRIDE;
+  virtual void OnExternalDataCleared(const std::string& user_id) OVERRIDE;
+  virtual void OnExternalDataFetched(const std::string& user_id,
+                                     scoped_ptr<std::string> data) OVERRIDE;
+
+  std::vector<std::string> set_calls_;

[Joao da Silva, 2013/11/27 14:33:59]

private:?

DISALLOW_COPY_AND_ASSIGN?

[bartfab (slow), 2013/11/27 20:10:15]

The class is gone altogether now.

+  std::vector<std::string> cleared_calls_;
+  std::vector<FetchedCall> fetched_calls_;
+};
+
+MockCloudExternalDataPolicyObserverChromeOS::
+    MockCloudExternalDataPolicyObserverChromeOS(
+        chromeos::CrosSettings* cros_settings,
+        chromeos::UserManager* user_manager,
+        DeviceLocalAccountPolicyService* device_local_account_policy_service,
+        const std::string& policy)
+    : CloudExternalDataPolicyObserverChromeOS(
+          cros_settings,
+          user_manager,
+          device_local_account_policy_service,
+          policy) {
+}
+
+MockCloudExternalDataPolicyObserverChromeOS::
+    ~MockCloudExternalDataPolicyObserverChromeOS() {
+}
+
+const std::vector<std::string>* MockCloudExternalDataPolicyObserverChromeOS::
+    GetSetCalls() {
+  return &set_calls_;
+}
+
+const std::vector<std::string>* MockCloudExternalDataPolicyObserverChromeOS::
+    GetClearedCalls() {
+  return &cleared_calls_;
+}
+
+const std::vector<MockCloudExternalDataPolicyObserverChromeOS::FetchedCall>*
+    MockCloudExternalDataPolicyObserverChromeOS::GetFetchedCalls() {
+  return &fetched_calls_;
+}
+
+void MockCloudExternalDataPolicyObserverChromeOS::ClearObservations() {
+  set_calls_.clear();
+  cleared_calls_.clear();
+  fetched_calls_.clear();
+}
+
+void MockCloudExternalDataPolicyObserverChromeOS::OnExternalDataSet(
+    const std::string& user_id) {
+  set_calls_.push_back(user_id);
+}
+
+void MockCloudExternalDataPolicyObserverChromeOS::OnExternalDataCleared(
+    const std::string& user_id) {
+  cleared_calls_.push_back(user_id);
+}
+
+void MockCloudExternalDataPolicyObserverChromeOS::OnExternalDataFetched(
+    const std::string& user_id,
+    scoped_ptr<std::string> data) {
+  fetched_calls_.push_back(
+      std::make_pair(user_id, make_linked_ptr(data.release())));

[Joao da Silva, 2013/11/27 14:33:59]

If you change FetchedCall to pair<string, string> then this could be

  fetched_calls_.push_back(make_pair(user_id, std::string()));
  fetched_calls_.back().second.swap(*data);

[bartfab (slow), 2013/11/27 20:10:15]

Done.

+}
+
+class CloudExternalDataPolicyObserverChromeOSTest
+    : public chromeos::DeviceSettingsTestBase {
+ public:
+  CloudExternalDataPolicyObserverChromeOSTest();
+  virtual ~CloudExternalDataPolicyObserverChromeOSTest();
+
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
+
+  void CreateObserver();
+
+  void SetDeviceLocalAccountAvatarPolicy(const std::string& account_id,
+                                         const std::string& value);
+
+  void AddDeviceLocalAccount(const std::string& account_id);
+  void RemoveDeviceLocalAccount(const std::string& account_id);
+
+  DeviceLocalAccountPolicyBroker* GetBrokerForDeviceLocalAccountUser();
+
+  void RefreshDeviceLocalAccountPolicy(DeviceLocalAccountPolicyBroker* broker);
+
+  void LogInAsDeviceLocalAccount(const std::string& user_id);
+
+  void SetRegularUserAvatarPolicy(const std::string& value);
+
+  void LogInAsRegularUser();
+
+  const std::string device_local_account_user_id_;
+
+  std::string avatar_policy_1_data_;
+  std::string avatar_policy_2_data_;
+  std::string avatar_policy_1_;
+  std::string avatar_policy_2_;
+
+  chromeos::CrosSettings cros_settings_;
+  chromeos::FakeUserManager user_manager_;
+  scoped_ptr<DeviceLocalAccountPolicyService>
+      device_local_account_policy_service_;
+  net::TestURLFetcherFactory url_fetcher_factory_;
+
+  scoped_ptr<DeviceLocalAccountPolicyProvider>
+      device_local_account_policy_provider_;
+
+  MockCloudExternalDataManager external_data_manager_;
+  MockConfigurationPolicyProvider user_policy_provider_;
+
+  scoped_ptr<TestingProfile> profile_;
+
+  scoped_ptr<MockCloudExternalDataPolicyObserverChromeOS> observer_;
+  const std::vector<std::string>* set_calls_;
+  const std::vector<std::string>* cleared_calls_;
+  const std::vector<MockCloudExternalDataPolicyObserverChromeOS::FetchedCall>*
+      fetched_calls_;
+
+  ExternalDataFetcher::FetchCallback fetch_callback_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CloudExternalDataPolicyObserverChromeOSTest);
+};
+
+CloudExternalDataPolicyObserverChromeOSTest::
+    CloudExternalDataPolicyObserverChromeOSTest()
+    : device_local_account_user_id_(GenerateDeviceLocalAccountUserId(
+          kDeviceLocalAccount,
+          DeviceLocalAccount::TYPE_PUBLIC_SESSION)),
+      cros_settings_(&device_settings_service_),
+      set_calls_(NULL),
+      cleared_calls_(NULL),
+      fetched_calls_(NULL) {
+}
+
+CloudExternalDataPolicyObserverChromeOSTest::
+    ~CloudExternalDataPolicyObserverChromeOSTest() {
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::SetUp() {
+  chromeos::DeviceSettingsTestBase::SetUp();
+  device_local_account_policy_service_.reset(
+      new DeviceLocalAccountPolicyService(&device_settings_test_helper_,
+                                          &device_settings_service_,
+                                          &cros_settings_,
+                                          loop_.message_loop_proxy(),
+                                          loop_.message_loop_proxy(),
+                                          loop_.message_loop_proxy(),
+                                          loop_.message_loop_proxy(),
+                                          NULL));
+  url_fetcher_factory_.set_remove_fetcher_on_delete(true);
+
+  EXPECT_CALL(user_policy_provider_, IsInitializationComplete(_))
+      .WillRepeatedly(Return(true));
+  user_policy_provider_.Init();
+
+  ConstructAvatarPolicy("avatar1.jpg",
+                        kAvatar1URL,
+                        &avatar_policy_1_data_,
+                        &avatar_policy_1_);
+  ConstructAvatarPolicy("avatar2.jpg",
+                        kAvatar2URL,
+                        &avatar_policy_2_data_,
+                        &avatar_policy_2_);
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::TearDown() {
+  if (observer_)
+    observer_->Shutdown();
+  user_policy_provider_.Shutdown();
+  profile_.reset();
+  if (device_local_account_policy_provider_) {
+    device_local_account_policy_provider_->Shutdown();
+    device_local_account_policy_provider_.reset();
+  }
+  device_local_account_policy_service_->Shutdown();
+  device_local_account_policy_service_.reset();
+  chromeos::DeviceSettingsTestBase::TearDown();
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::CreateObserver() {
+  observer_.reset(new MockCloudExternalDataPolicyObserverChromeOS(
+      &cros_settings_,
+      &user_manager_,
+      device_local_account_policy_service_.get(),
+      key::kAvatar));
+  observer_->Init();
+  set_calls_ = observer_->GetSetCalls();
+  cleared_calls_ = observer_->GetClearedCalls();
+  fetched_calls_ = observer_->GetFetchedCalls();
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::
+    SetDeviceLocalAccountAvatarPolicy(const std::string& account_id,
+                                      const std::string& value) {
+  UserPolicyBuilder builder;
+  builder.policy_data().set_policy_type(
+      dm_protocol::kChromePublicAccountPolicyType);
+  builder.policy_data().set_settings_entity_id(account_id);
+  builder.policy_data().set_username(account_id);
+  if (!value.empty())
+    builder.payload().mutable_avatar()->set_value(value);
+  builder.Build();
+  device_settings_test_helper_.set_device_local_account_policy_blob(
+      account_id,
+      builder.GetBlob());
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::AddDeviceLocalAccount(
+    const std::string& account_id) {
+  em::DeviceLocalAccountInfoProto* account =
+      device_policy_.payload().mutable_device_local_accounts()->add_account();
+  account->set_account_id(account_id);
+  account->set_type(
+      em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
+  device_policy_.Build();
+  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
+  ReloadDeviceSettings();
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::RemoveDeviceLocalAccount(
+    const std::string& account_id) {
+  em::DeviceLocalAccountsProto* accounts =
+      device_policy_.payload().mutable_device_local_accounts();
+  std::vector<std::string> account_ids;
+  for (int i = 0; i < accounts->account_size(); ++i) {
+    if (accounts->account(i).account_id() != account_id)
+      account_ids.push_back(accounts->account(i).account_id());
+  }
+  accounts->clear_account();
+  for (std::vector<std::string>::const_iterator it = account_ids.begin();
+       it != account_ids.end(); ++it) {
+    em::DeviceLocalAccountInfoProto* account = accounts->add_account();
+    account->set_account_id(*it);
+    account->set_type(
+        em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
+  }
+  device_policy_.Build();
+  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
+  ReloadDeviceSettings();
+}
+
+DeviceLocalAccountPolicyBroker* CloudExternalDataPolicyObserverChromeOSTest::
+    GetBrokerForDeviceLocalAccountUser() {
+  return device_local_account_policy_service_->GetBrokerForUser(
+      device_local_account_user_id_);
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::
+    RefreshDeviceLocalAccountPolicy(DeviceLocalAccountPolicyBroker* broker) {
+  broker->core()->store()->Load();
+  device_settings_test_helper_.Flush();
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::LogInAsDeviceLocalAccount(
+    const std::string& user_id) {
+  device_local_account_policy_provider_.reset(
+      new DeviceLocalAccountPolicyProvider(
+          user_id,
+          device_local_account_policy_service_.get()));
+
+  PolicyServiceImpl::Providers providers;
+  providers.push_back(device_local_account_policy_provider_.get());
+  TestingProfile::Builder builder;
+  builder.SetPolicyService(scoped_ptr<PolicyService>(new PolicyServiceImpl(
+      providers,
+      PolicyServiceImpl::PreprocessCallback())));
+
+  profile_.reset(builder.Build().release());

[Joao da Silva, 2013/11/27 14:33:59]

profile_ = builder.Build();

[bartfab (slow), 2013/11/27 20:10:15]

Done.

+  profile_->set_profile_name(user_id);
+
+  user_manager_.AddUser(user_id);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources(),
+      content::Details<Profile>(profile_.get()));
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::SetRegularUserAvatarPolicy(
+    const std::string& value) {
+  PolicyMap policy_map;
+  if (!value.empty()) {
+    policy_map.Set(
+        key::kAvatar,
+        POLICY_LEVEL_MANDATORY,
+        POLICY_SCOPE_USER,
+        new base::StringValue(value),
+        external_data_manager_.CreateExternalDataFetcher(
+            key::kAvatar).release());
+  }
+  user_policy_provider_.UpdateChromePolicy(policy_map);
+}
+
+void CloudExternalDataPolicyObserverChromeOSTest::LogInAsRegularUser() {
+  PolicyServiceImpl::Providers providers;
+  providers.push_back(&user_policy_provider_);
+  TestingProfile::Builder builder;
+  builder.SetPolicyService(scoped_ptr<PolicyService>(new PolicyServiceImpl(
+      providers,
+      PolicyServiceImpl::PreprocessCallback())));
+
+  profile_.reset(builder.Build().release());

[Joao da Silva, 2013/11/27 14:33:59]

profile_ = builder.Build()

[bartfab (slow), 2013/11/27 20:10:15]

Done.

+  profile_->set_profile_name(kRegularUserID);
+
+  user_manager_.AddUser(kRegularUserID);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+      content::NotificationService::AllSources(),
+      content::Details<Profile>(profile_.get()));
+}
+
+// Verifies that when an external data reference is set for a device-local
+// account, a corresponding notification is emitted and a fetch is started.
+// Further verifies that when the fetch succeeds, a notification containing the
+// external data is emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountFetchSuccess) {
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  fetcher->SetResponseString(avatar_policy_1_data_);
+  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
+                                            net::OK));
+  fetcher->set_response_code(200);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_1_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1));
+}
+
+// Verifies that when an external data reference is set for a device-local
+// account, a corresponding notification is emitted and a fetch is started.
+// Further verifies that when the fetch fails, no notification is emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountFetchFailure) {
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
+                                            net::OK));
+  fetcher->set_response_code(400);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1));
+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially not set, no notifications are emitted. Further verifies that when
+// the external data reference is then cleared (which is a no-op), again, no
+// notifications are emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountClearUnset) {
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0));
+
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, "");
+  RefreshDeviceLocalAccountPolicy(broker);
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0));
+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially set, a corresponding notification is emitted and a fetch is
+// started. Further verifies that when the external data reference is then
+// cleared, a corresponding notification is emitted and the fetch is canceled.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountClearSet) {
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, "");
+  RefreshDeviceLocalAccountPolicy(broker);
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, cleared_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, cleared_calls_->front());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0));

[Joao da Silva, 2013/11/27 14:33:59]

1?

[bartfab (slow), 2013/11/27 20:10:15]

Fetch 0 started but was never completed. This verifies that the fetch got
canceled in the meantime.

+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially not set, no notifications are emitted. Further verifies that when
+// the external data reference is then set, a corresponding notification is
+// emitted and a fetch is started. Also verifies that when the fetch eventually
+// succeeds, a notification containing the external data is emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountSetUnset) {
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  RefreshDeviceLocalAccountPolicy(broker);
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  fetcher->SetResponseString(avatar_policy_1_data_);
+  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
+                                            net::OK));
+  fetcher->set_response_code(200);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_1_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1));
+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially set, a corresponding notification is emitted and a fetch is
+// started. Further verifies that when the external data reference is then
+// updated, a corresponding notification is emitted and the fetch is restarted.
+// Also verifies that when the fetch eventually succeeds, a notification
+// containing the external data is emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountSetSet) {
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_2_);
+  RefreshDeviceLocalAccountPolicy(broker);
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  fetcher = url_fetcher_factory_.GetFetcherByID(1);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar2URL), fetcher->GetOriginalURL());
+
+  fetcher->SetResponseString(avatar_policy_2_data_);
+  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
+                                            net::OK));
+  fetcher->set_response_code(200);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_2_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1));

[Joao da Silva, 2013/11/27 14:33:59]

2?

[bartfab (slow), 2013/11/27 20:10:15]

Done.

+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially not set, no notifications are emitted during login into the
+// account. Further verifies that when the external data reference is then set,
+// a corresponding notification is emitted only once and a fetch is started.
+// Also verifies that when the fetch eventually succeeds, a notification
+// containing the external data is emitted, again, only once.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountSetAfterLogin) {
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  LogInAsDeviceLocalAccount(kDeviceLocalAccount);
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  RefreshDeviceLocalAccountPolicy(broker);
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  fetcher->SetResponseString(avatar_policy_1_data_);
+  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
+                                            net::OK));
+  fetcher->set_response_code(200);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_1_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(1));
+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially not set, no notifications are emitted. Further verifies that when
+// the device-local account is then removed, again, no notifications are sent.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountRemoveAccountUnset) {
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0));
+
+  RemoveDeviceLocalAccount(kDeviceLocalAccount);
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0));
+}
+
+// Verifies that when the external data reference for a device-local account is
+// initially set, a corresponding notification is emitted and a fetch is
+// started. Further verifies that when the device-local account is then removed,
+// a notification indicating that the external data reference has been cleared
+// is emitted and the fetch is canceled.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest,
+       ExistingDeviceLocalAccountRemoveAccountSet) {
+  SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
+  AddDeviceLocalAccount(kDeviceLocalAccount);
+
+  DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
+  ASSERT_TRUE(broker);
+  broker->external_data_manager()->Connect(NULL);
+  base::RunLoop().RunUntilIdle();
+
+  CreateObserver();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, set_calls_->front());
+  observer_->ClearObservations();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  EXPECT_EQ(GURL(kAvatar1URL), fetcher->GetOriginalURL());
+
+  RemoveDeviceLocalAccount(kDeviceLocalAccount);
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, cleared_calls_->size());
+  EXPECT_EQ(device_local_account_user_id_, cleared_calls_->front());
+  observer_->ClearObservations();
+
+  EXPECT_FALSE(url_fetcher_factory_.GetFetcherByID(0));

[Joao da Silva, 2013/11/27 14:33:59]

1?

[bartfab (slow), 2013/11/27 20:10:15]

Fetch 0 started but was never completed. This verifies that the fetch got
canceled in the meantime.

+}
+
+// Verifies that when an external data reference is set for a regular user and
+// the user logs in, a corresponding notification is emitted and a fetch is
+// started. Further verifies that when the fetch succeeds, a notification
+// containing the external data is emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest, RegularUserFetchSuccess) {
+  SetRegularUserAvatarPolicy(avatar_policy_1_);
+
+  CreateObserver();
+
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&fetch_callback_));
+
+  LogInAsRegularUser();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(kRegularUserID, set_calls_->front());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_1_data_)));
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(kRegularUserID, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_1_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+}
+
+// Verifies that when the external data reference for a regular user is not set
+// while the user is logging in, no notifications are emitted. Further verifies
+// that when the external data reference is then cleared (which is a no-op),
+// again, no notifications are emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest, RegularUserClearUnset) {
+  CreateObserver();
+
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  LogInAsRegularUser();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  SetRegularUserAvatarPolicy("");
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+}
+
+// Verifies that when the external data reference for a regular user is set
+// while the user is logging in, a corresponding notification is emitted and a
+// fetch is started. Further verifies that when the external data reference is
+// then cleared, a corresponding notification is emitted and no new fetch is
+// started.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest, RegularUserClearSet) {
+  SetRegularUserAvatarPolicy(avatar_policy_1_);
+
+  CreateObserver();
+
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&fetch_callback_));
+
+  LogInAsRegularUser();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(kRegularUserID, set_calls_->front());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  SetRegularUserAvatarPolicy("");
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, cleared_calls_->size());
+  EXPECT_EQ(kRegularUserID, cleared_calls_->front());
+  observer_->ClearObservations();
+}
+
+
+// Verifies that when the external data reference for a regular user is not set
+// while the user is logging in, no notifications are emitted. Further verifies
+// that when the external data reference is then set, a corresponding
+// notification is emitted and a fetch is started. Also verifies that when the
+// fetch eventually succeeds, a notification containing the external data is
+// emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest, RegularUserSetUnset) {
+  CreateObserver();
+
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  LogInAsRegularUser();
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&fetch_callback_));
+
+  SetRegularUserAvatarPolicy(avatar_policy_1_);
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(kRegularUserID, set_calls_->front());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_1_data_)));
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(kRegularUserID, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_1_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+}
+
+// Verifies that when the external data reference for a regular user is set
+// while the user is logging in, a corresponding notification is emitted and a
+// fetch is started. Further verifies that when the external data reference is
+// then updated, a corresponding notification is emitted and the fetch is
+// restarted. Also verifies that when the fetch eventually succeeds, a
+// notification containing the external data is emitted.
+TEST_F(CloudExternalDataPolicyObserverChromeOSTest, RegularUserSetSet) {
+  SetRegularUserAvatarPolicy(avatar_policy_1_);
+
+  CreateObserver();
+
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&fetch_callback_));
+
+  LogInAsRegularUser();
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(kRegularUserID, set_calls_->front());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&fetch_callback_));
+
+  SetRegularUserAvatarPolicy(avatar_policy_2_);
+
+  EXPECT_TRUE(cleared_calls_->empty());
+  EXPECT_TRUE(fetched_calls_->empty());
+  ASSERT_EQ(1u, set_calls_->size());
+  EXPECT_EQ(kRegularUserID, set_calls_->front());
+  observer_->ClearObservations();
+
+  Mock::VerifyAndClear(&external_data_manager_);
+  EXPECT_CALL(external_data_manager_, Fetch(key::kAvatar, _)).Times(0);
+
+  fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_2_data_)));
+
+  EXPECT_TRUE(set_calls_->empty());
+  EXPECT_TRUE(cleared_calls_->empty());
+  ASSERT_EQ(1u, fetched_calls_->size());
+  EXPECT_EQ(kRegularUserID, fetched_calls_->front().first);
+  ASSERT_TRUE(fetched_calls_->front().second.get());
+  EXPECT_EQ(avatar_policy_2_data_, *fetched_calls_->front().second);
+  observer_->ClearObservations();
+}

[Joao da Silva, 2013/11/27 14:33:59]

Could we have a test verifying that, when available, fetch() uses cached data
and doesn't trigger a new network request? And that the observer gets that data?

[bartfab (slow), 2013/11/27 20:10:15]

The caching is not part of this class. It is handled by
CloudExternalDataManagerBase, which is not under test here.
CloudExternalDataManagerBase does have unit tests that do verify it uses caching
correctly of course.

+
+}  // namespace policy