Translate device-local account IDs to user IDs

chrome/browser/chromeos/policy/device_local_account_policy_service_unittest.cc

 // Copyright (c) 2012 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/device_local_account_policy_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
+#include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_provider.h"
+#include "chrome/browser/chromeos/settings/cros_settings.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_client.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/cloud_policy_service.h"
 #include "chrome/browser/policy/cloud/mock_device_management_service.h"
 #include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
 #include "chromeos/dbus/power_policy_controller.h"
 #include "policy/policy_constants.h"
@@ skipping 13 matching lines @@
     : public DeviceLocalAccountPolicyService::Observer {
  public:
   MOCK_METHOD1(OnPolicyUpdated, void(const std::string&));
   MOCK_METHOD0(OnDeviceLocalAccountsChanged, void(void));
 };
 
 class DeviceLocalAccountPolicyServiceTest
     : public chromeos::DeviceSettingsTestBase {
  public:
   DeviceLocalAccountPolicyServiceTest()
-      : service_(&device_settings_test_helper_, &device_settings_service_) {}
+      : public_session_user_id_(GenerateDeviceLocalAccountUserId(
+            PolicyBuilder::kFakeUsername,
+            DeviceLocalAccount::TYPE_PUBLIC_SESSION)),
+        service_(&device_settings_test_helper_,
+                 chromeos::DeviceSettingsService::Get(),
+                 chromeos::CrosSettings::Get()) {}
 
   virtual void SetUp() OVERRIDE {
     DeviceSettingsTestBase::SetUp();
 
     // Values implicitly enforced for public accounts.
     expected_policy_map_.Set(key::kLidCloseAction,
                              POLICY_LEVEL_MANDATORY,
                              POLICY_SCOPE_USER,
                              base::Value::CreateIntegerValue(
                                  chromeos::PowerPolicyController::
@@ skipping 45 matching lines @@
 
   void InstallDevicePolicy() {
     EXPECT_CALL(service_observer_, OnDeviceLocalAccountsChanged());
     device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
     ReloadDeviceSettings();
     Mock::VerifyAndClearExpectations(&service_observer_);
   }
 
   MOCK_METHOD1(OnRefreshDone, void(bool));
 
+  const std::string public_session_user_id_;
+
   PolicyMap expected_policy_map_;
   UserPolicyBuilder device_local_account_policy_;
+  chromeos::ScopedTestCrosSettings test_cros_settings_;

[Mattias Nissler (ping if slow), 2013/05/15 09:38:47]

Wait, doesn't this conflict with DeviceSettingsTestBase? You probably have two
DeviceSettingsService instances now.

[bartfab (slow), 2013/05/17 11:14:28]

Done.

   MockDeviceLocalAccountPolicyServiceObserver service_observer_;
   MockDeviceManagementService mock_device_management_service_;
   DeviceLocalAccountPolicyService service_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceLocalAccountPolicyServiceTest);
 };
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, NoAccounts) {
-  EXPECT_FALSE(service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername));
+  EXPECT_FALSE(service_.GetBrokerForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, GetBroker) {
   InstallDevicePolicy();
 
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
-  EXPECT_EQ(PolicyBuilder::kFakeUsername, broker->account_id());
+  EXPECT_EQ(public_session_user_id_, broker->user_id());
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_OK, broker->core()->store()->status());
   EXPECT_FALSE(broker->core()->client());
   EXPECT_TRUE(broker->core()->store()->policy_map().empty());
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, LoadNoPolicy) {
   InstallDevicePolicy();
 
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
 
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_LOAD_ERROR,
             broker->core()->store()->status());
   EXPECT_TRUE(broker->core()->store()->policy_map().empty());
-  EXPECT_FALSE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_FALSE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, LoadValidationFailure) {
   device_local_account_policy_.policy_data().set_policy_type(
       dm_protocol::kChromeUserPolicyType);
   device_local_account_policy_.Build();
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   InstallDevicePolicy();
 
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
 
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_VALIDATION_ERROR,
             broker->core()->store()->status());
   EXPECT_TRUE(broker->core()->store()->policy_map().empty());
-  EXPECT_FALSE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_FALSE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, LoadPolicy) {
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   InstallDevicePolicy();
 
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
 
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_OK,
             broker->core()->store()->status());
   ASSERT_TRUE(broker->core()->store()->policy());
   EXPECT_EQ(device_local_account_policy_.policy_data().SerializeAsString(),
             broker->core()->store()->policy()->SerializeAsString());
   EXPECT_TRUE(expected_policy_map_.Equals(
       broker->core()->store()->policy_map()));
-  EXPECT_TRUE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_TRUE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, StoreValidationFailure) {
   device_local_account_policy_.policy_data().set_policy_type(
       dm_protocol::kChromeUserPolicyType);
   device_local_account_policy_.Build();
   InstallDevicePolicy();
 
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   ASSERT_TRUE(broker->core()->store());
   broker->core()->store()->Store(device_local_account_policy_.policy());
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
 
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_VALIDATION_ERROR,
             broker->core()->store()->status());
   EXPECT_EQ(CloudPolicyValidatorBase::VALIDATION_WRONG_POLICY_TYPE,
             broker->core()->store()->validation_status());
-  EXPECT_FALSE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_FALSE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, StorePolicy) {
   InstallDevicePolicy();
 
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   ASSERT_TRUE(broker->core()->store());
   broker->core()->store()->Store(device_local_account_policy_.policy());
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
 
   EXPECT_EQ(device_local_account_policy_.GetBlob(),
             device_settings_test_helper_.device_local_account_policy_blob(
                 PolicyBuilder::kFakeUsername));
-  EXPECT_TRUE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_TRUE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, DevicePolicyChange) {
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   InstallDevicePolicy();
 
   EXPECT_CALL(service_observer_, OnDeviceLocalAccountsChanged());
   device_policy_.payload().mutable_device_local_accounts()->clear_account();
   device_policy_.Build();
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
-  device_settings_service_.PropertyChangeComplete(true);
+  chromeos::DeviceSettingsService::Get()->PropertyChangeComplete(true);
   FlushDeviceSettings();
-  EXPECT_FALSE(service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername));
+  EXPECT_FALSE(service_.GetBrokerForUser(public_session_user_id_));
   Mock::VerifyAndClearExpectations(&service_observer_);
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, DuplicateAccounts) {
   InstallDevicePolicy();
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
 
   // Add a second entry with a duplicate account name to device policy.
   em::DeviceLocalAccountInfoProto* account =
       device_policy_.payload().mutable_device_local_accounts()->add_account();
   account->set_account_id(PolicyBuilder::kFakeUsername);
   account->set_type(
       em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
   device_policy_.Build();
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
 
   EXPECT_CALL(service_observer_, OnDeviceLocalAccountsChanged());
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
-  device_settings_service_.PropertyChangeComplete(true);
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
+  chromeos::DeviceSettingsService::Get()->PropertyChangeComplete(true);
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
 
   // Make sure the broker is accessible and policy got loaded.
-  broker = service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+  broker = service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
-  EXPECT_EQ(PolicyBuilder::kFakeUsername, broker->account_id());
+  EXPECT_EQ(public_session_user_id_, broker->user_id());
   EXPECT_TRUE(broker->core()->store()->policy());
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, FetchPolicy) {
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   InstallDevicePolicy();
 
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
 
   service_.Connect(&mock_device_management_service_);
   EXPECT_TRUE(broker->core()->client());
 
   em::DeviceManagementRequest request;
   em::DeviceManagementResponse response;
   response.mutable_policy_response()->add_response()->CopyFrom(
       device_local_account_policy_.policy());
   EXPECT_CALL(mock_device_management_service_,
               CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH))
       .WillOnce(mock_device_management_service_.SucceedJob(response));
   EXPECT_CALL(mock_device_management_service_,
               StartJob(dm_protocol::kValueRequestPolicy,
                        std::string(), std::string(),
                        device_policy_.policy_data().request_token(),
                        dm_protocol::kValueUserAffiliationManaged,
                        device_policy_.policy_data().device_id(),
                        _))
       .WillOnce(SaveArg<6>(&request));
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   broker->core()->client()->FetchPolicy();
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
   Mock::VerifyAndClearExpectations(&mock_device_management_service_);
   EXPECT_TRUE(request.has_policy_request());
   EXPECT_EQ(1, request.policy_request().request_size());
   EXPECT_EQ(dm_protocol::kChromePublicAccountPolicyType,
             request.policy_request().request(0).policy_type());
   EXPECT_FALSE(request.policy_request().request(0).has_machine_id());
   EXPECT_EQ(PolicyBuilder::kFakeUsername,
             request.policy_request().request(0).settings_entity_id());
 
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_OK,
             broker->core()->store()->status());
   ASSERT_TRUE(broker->core()->store()->policy());
   EXPECT_EQ(device_local_account_policy_.policy_data().SerializeAsString(),
             broker->core()->store()->policy()->SerializeAsString());
   EXPECT_TRUE(expected_policy_map_.Equals(
       broker->core()->store()->policy_map()));
-  EXPECT_TRUE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_TRUE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 
-  EXPECT_CALL(service_observer_,
-              OnPolicyUpdated(PolicyBuilder::kFakeUsername)).Times(0);
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_))
+      .Times(0);
   service_.Disconnect();
   EXPECT_FALSE(broker->core()->client());
   Mock::VerifyAndClearExpectations(&service_observer_);
-  EXPECT_TRUE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_TRUE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 TEST_F(DeviceLocalAccountPolicyServiceTest, RefreshPolicy) {
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   InstallDevicePolicy();
 
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
 
   service_.Connect(&mock_device_management_service_);
   ASSERT_TRUE(broker->core()->service());
 
   em::DeviceManagementResponse response;
   response.mutable_policy_response()->add_response()->CopyFrom(
       device_local_account_policy_.policy());
   EXPECT_CALL(mock_device_management_service_, CreateJob(_))
       .WillOnce(mock_device_management_service_.SucceedJob(response));
   EXPECT_CALL(mock_device_management_service_, StartJob(_, _, _, _, _, _, _));
   EXPECT_CALL(*this, OnRefreshDone(true)).Times(1);
-  EXPECT_CALL(service_observer_, OnPolicyUpdated(PolicyBuilder::kFakeUsername));
+  EXPECT_CALL(service_observer_, OnPolicyUpdated(public_session_user_id_));
   broker->core()->service()->RefreshPolicy(
       base::Bind(&DeviceLocalAccountPolicyServiceTest::OnRefreshDone,
                  base::Unretained(this)));
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&service_observer_);
   Mock::VerifyAndClearExpectations(this);
   Mock::VerifyAndClearExpectations(&mock_device_management_service_);
 
   ASSERT_TRUE(broker->core()->store());
   EXPECT_EQ(CloudPolicyStore::STATUS_OK,
             broker->core()->store()->status());
   EXPECT_TRUE(expected_policy_map_.Equals(
       broker->core()->store()->policy_map()));
-  EXPECT_TRUE(service_.IsPolicyAvailableForAccount(
-      PolicyBuilder::kFakeUsername));
+  EXPECT_TRUE(service_.IsPolicyAvailableForUser(public_session_user_id_));
 }
 
 class DeviceLocalAccountPolicyProviderTest
     : public DeviceLocalAccountPolicyServiceTest {
  protected:
   DeviceLocalAccountPolicyProviderTest()
-      : provider_(PolicyBuilder::kFakeUsername, &service_) {}
+      : provider_(
+            GenerateDeviceLocalAccountUserId(
+                PolicyBuilder::kFakeUsername,
+                DeviceLocalAccount::TYPE_PUBLIC_SESSION),
+            &service_) {}
 
   virtual void SetUp() OVERRIDE {
     DeviceLocalAccountPolicyServiceTest::SetUp();
     provider_.Init();
     provider_.AddObserver(&provider_observer_);
 
     EXPECT_CALL(service_observer_, OnPolicyUpdated(_)).Times(AnyNumber());
     EXPECT_CALL(service_observer_, OnDeviceLocalAccountsChanged())
         .Times(AnyNumber());
   }
@@ skipping 51 matching lines @@
   EXPECT_TRUE(expected_policy_bundle.Equals(provider_.policies()));
 
   // Policy change should be reported.
   EXPECT_CALL(provider_observer_, OnUpdatePolicy(&provider_)).Times(AtLeast(1));
   device_local_account_policy_.payload().mutable_disablespdy()->set_value(
       false);
   device_local_account_policy_.Build();
   device_settings_test_helper_.set_device_local_account_policy_blob(
       PolicyBuilder::kFakeUsername, device_local_account_policy_.GetBlob());
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   broker->core()->store()->Load();
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&provider_observer_);
 
   expected_policy_bundle.Get(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(key::kDisableSpdy,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_USER,
@@ skipping 24 matching lines @@
   device_policy_.Build();
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
   Mock::VerifyAndClearExpectations(&provider_observer_);
 
   EXPECT_TRUE(expected_policy_bundle.Equals(provider_.policies()));
 }
 
 TEST_F(DeviceLocalAccountPolicyProviderTest, RefreshPolicies) {
   // If there's no device policy, the refresh completes immediately.
-  EXPECT_FALSE(service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername));
+  EXPECT_FALSE(service_.GetBrokerForUser(public_session_user_id_));
   EXPECT_CALL(provider_observer_, OnUpdatePolicy(&provider_)).Times(AtLeast(1));
   provider_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&provider_observer_);
 
   // Make device settings appear.
   EXPECT_CALL(provider_observer_, OnUpdatePolicy(&provider_))
       .Times(AnyNumber());
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
   Mock::VerifyAndClearExpectations(&provider_observer_);
-  EXPECT_TRUE(service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername));
+  EXPECT_TRUE(service_.GetBrokerForUser(public_session_user_id_));
 
   // If there's no cloud connection, refreshes are still immediate.
   DeviceLocalAccountPolicyBroker* broker =
-      service_.GetBrokerForAccount(PolicyBuilder::kFakeUsername);
+      service_.GetBrokerForUser(public_session_user_id_);
   ASSERT_TRUE(broker);
   EXPECT_FALSE(broker->core()->client());
   EXPECT_CALL(provider_observer_, OnUpdatePolicy(&provider_)).Times(AtLeast(1));
   provider_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&provider_observer_);
 
   // Bring up the cloud connection. The refresh scheduler may fire refreshes at
   // this point which are not relevant for the test.
   EXPECT_CALL(mock_device_management_service_, CreateJob(_))
       .WillRepeatedly(
@@ skipping 20 matching lines @@
   ASSERT_TRUE(request_job);
   em::DeviceManagementResponse response;
   response.mutable_policy_response()->add_response()->CopyFrom(
       device_local_account_policy_.policy());
   request_job->SendResponse(DM_STATUS_SUCCESS, response);
   FlushDeviceSettings();
   Mock::VerifyAndClearExpectations(&provider_observer_);
 }
 
 }  // namespace policy