Move policy code into components/policy.

chrome/browser/policy/cloud/cloud_policy_client_unittest.cc

Index: chrome/browser/policy/cloud/cloud_policy_client_unittest.cc
diff --git a/chrome/browser/policy/cloud/cloud_policy_client_unittest.cc b/chrome/browser/policy/cloud/cloud_policy_client_unittest.cc
deleted file mode 100644
index ce2fcd92e6b59af507c8c9cb882f97f8cdb95347..0000000000000000000000000000000000000000
--- a/chrome/browser/policy/cloud/cloud_policy_client_unittest.cc
+++ /dev/null
@@ -1,589 +0,0 @@
-// 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/policy/cloud/cloud_policy_client.h"
-
-#include <map>
-#include <set>
-
-#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "chrome/browser/policy/cloud/mock_cloud_policy_client.h"
-#include "chrome/browser/policy/cloud/mock_device_management_service.h"
-#include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
-#include "net/url_request/url_request_context_getter.h"
-#include "net/url_request/url_request_test_util.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::Mock;
-using testing::Return;
-using testing::SaveArg;
-using testing::StrictMock;
-using testing::_;
-
-namespace em = enterprise_management;
-
-namespace policy {
-
-namespace {
-
-const char kClientID[] = "fake-client-id";
-const char kMachineID[] = "fake-machine-id";
-const char kMachineModel[] = "fake-machine-model";
-const char kOAuthToken[] = "fake-oauth-token";
-const char kDMToken[] = "fake-dm-token";
-const char kDeviceCertificate[] = "fake-device-certificate";
-const char kRequisition[] = "fake-requisition";
-
-class MockStatusProvider : public CloudPolicyClient::StatusProvider {
- public:
-  MockStatusProvider() {}
-  virtual ~MockStatusProvider() {}
-
-  MOCK_METHOD1(GetDeviceStatus, bool(em::DeviceStatusReportRequest* status));
-  MOCK_METHOD1(GetSessionStatus, bool(em::SessionStatusReportRequest* status));
-  MOCK_METHOD0(OnSubmittedSuccessfully, void(void));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockStatusProvider);
-};
-
-MATCHER_P(MatchProto, expected, "matches protobuf") {
-  return arg.SerializePartialAsString() == expected.SerializePartialAsString();
-}
-
-// A mock class to allow us to set expectations on upload certificate callbacks.
-class MockUploadCertificateObserver {
- public:
-  MockUploadCertificateObserver() {}
-  virtual ~MockUploadCertificateObserver() {}
-
-  MOCK_METHOD1(OnUploadComplete, void(bool));
-};
-
-}  // namespace
-
-class CloudPolicyClientTest : public testing::Test {
- protected:
-  CloudPolicyClientTest()
-      : client_id_(kClientID),
-        policy_ns_key_(dm_protocol::kChromeUserPolicyType, std::string()) {
-    em::DeviceRegisterRequest* register_request =
-        registration_request_.mutable_register_request();
-    register_request->set_type(em::DeviceRegisterRequest::USER);
-    register_request->set_machine_id(kMachineID);
-    register_request->set_machine_model(kMachineModel);
-    registration_response_.mutable_register_response()->
-        set_device_management_token(kDMToken);
-
-    em::PolicyFetchRequest* policy_fetch_request =
-        policy_request_.mutable_policy_request()->add_request();
-    policy_fetch_request->set_policy_type(dm_protocol::kChromeUserPolicyType);
-#if defined(OS_CHROMEOS)
-    policy_fetch_request->set_signature_type(em::PolicyFetchRequest::SHA1_RSA);
-#else
-    policy_fetch_request->set_signature_type(em::PolicyFetchRequest::NONE);
-#endif
-    policy_response_.mutable_policy_response()->add_response()->set_policy_data(
-        CreatePolicyData("fake-policy-data"));
-
-    unregistration_request_.mutable_unregister_request();
-    unregistration_response_.mutable_unregister_response();
-    upload_certificate_request_.mutable_cert_upload_request()->
-        set_device_certificate(kDeviceCertificate);
-    upload_certificate_response_.mutable_cert_upload_response();
-  }
-
-  virtual void SetUp() OVERRIDE {
-    EXPECT_CALL(status_provider_, GetDeviceStatus(_))
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(status_provider_, GetSessionStatus(_))
-        .WillRepeatedly(Return(false));
-    CreateClient(USER_AFFILIATION_NONE);
-  }
-
-  virtual void TearDown() OVERRIDE {
-    client_->RemoveObserver(&observer_);
-  }
-
-  void Register() {
-    EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-    client_->SetupRegistration(kDMToken, client_id_);
-  }
-
-  void CreateClient(UserAffiliation user_affiliation) {
-    if (client_.get())
-      client_->RemoveObserver(&observer_);
-
-    request_context_ = new net::TestURLRequestContextGetter(
-        loop_.message_loop_proxy());
-    client_.reset(new CloudPolicyClient(kMachineID, kMachineModel,
-                                        user_affiliation, &status_provider_,
-                                        &service_,
-                                        request_context_));
-    client_->AddNamespaceToFetch(policy_ns_key_);
-    client_->AddObserver(&observer_);
-  }
-
-  void ExpectRegistration(const std::string& oauth_token) {
-    EXPECT_CALL(service_,
-                CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION,
-                          request_context_))
-        .WillOnce(service_.SucceedJob(registration_response_));
-    EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestRegister,
-                                   "", oauth_token, "", "", _,
-                                   MatchProto(registration_request_)))
-        .WillOnce(SaveArg<5>(&client_id_));
-  }
-
-  void ExpectPolicyFetch(const std::string& dm_token,
-                         const std::string& user_affiliation) {
-    EXPECT_CALL(service_,
-                CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH,
-                          request_context_))
-        .WillOnce(service_.SucceedJob(policy_response_));
-    EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestPolicy,
-                                   "", "", dm_token, user_affiliation,
-                                   client_id_,
-                                   MatchProto(policy_request_)));
-  }
-
-  void ExpectUnregistration(const std::string& dm_token) {
-    EXPECT_CALL(service_,
-                CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION,
-                          request_context_))
-        .WillOnce(service_.SucceedJob(unregistration_response_));
-    EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestUnregister,
-                                   "", "", dm_token, "", client_id_,
-                                   MatchProto(unregistration_request_)));
-  }
-
-  void ExpectUploadCertificate() {
-    EXPECT_CALL(service_,
-                CreateJob(DeviceManagementRequestJob::TYPE_UPLOAD_CERTIFICATE,
-                          request_context_))
-        .WillOnce(service_.SucceedJob(upload_certificate_response_));
-    EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestUploadCertificate,
-                                   "", "", kDMToken, "", client_id_,
-                                   MatchProto(upload_certificate_request_)));
-  }
-
-  void CheckPolicyResponse() {
-    ASSERT_TRUE(client_->GetPolicyFor(policy_ns_key_));
-    EXPECT_THAT(*client_->GetPolicyFor(policy_ns_key_),
-                MatchProto(policy_response_.policy_response().response(0)));
-  }
-
-  std::string CreatePolicyData(const std::string& policy_value) {
-    em::PolicyData policy_data;
-    policy_data.set_policy_type(dm_protocol::kChromeUserPolicyType);
-    policy_data.set_policy_value(policy_value);
-    return policy_data.SerializeAsString();
-  }
-
-  // Request protobufs used as expectations for the client requests.
-  em::DeviceManagementRequest registration_request_;
-  em::DeviceManagementRequest policy_request_;
-  em::DeviceManagementRequest unregistration_request_;
-  em::DeviceManagementRequest upload_certificate_request_;
-
-  // Protobufs used in successful responses.
-  em::DeviceManagementResponse registration_response_;
-  em::DeviceManagementResponse policy_response_;
-  em::DeviceManagementResponse unregistration_response_;
-  em::DeviceManagementResponse upload_certificate_response_;
-
-  base::MessageLoop loop_;
-  std::string client_id_;
-  PolicyNamespaceKey policy_ns_key_;
-  MockDeviceManagementService service_;
-  StrictMock<MockStatusProvider> status_provider_;
-  StrictMock<MockCloudPolicyClientObserver> observer_;
-  StrictMock<MockUploadCertificateObserver> upload_certificate_observer_;
-  scoped_ptr<CloudPolicyClient> client_;
-  // Cached weak pointer to the client's request context.
-  net::URLRequestContextGetter* request_context_;
-};
-
-TEST_F(CloudPolicyClientTest, Init) {
-  EXPECT_CALL(service_, CreateJob(_, _)).Times(0);
-  EXPECT_FALSE(client_->is_registered());
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-  EXPECT_EQ(0, client_->fetched_invalidation_version());
-}
-
-TEST_F(CloudPolicyClientTest, SetupRegistrationAndPolicyFetch) {
-  EXPECT_CALL(service_, CreateJob(_, _)).Times(0);
-  EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-  client_->SetupRegistration(kDMToken, client_id_);
-  EXPECT_TRUE(client_->is_registered());
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-  CheckPolicyResponse();
-}
-
-TEST_F(CloudPolicyClientTest, RegistrationAndPolicyFetch) {
-  ExpectRegistration(kOAuthToken);
-  EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    kOAuthToken, std::string(), false, std::string());
-  EXPECT_TRUE(client_->is_registered());
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-  CheckPolicyResponse();
-}
-
-TEST_F(CloudPolicyClientTest, RegistrationParameters) {
-  registration_request_.mutable_register_request()->set_reregister(true);
-  registration_request_.mutable_register_request()->set_auto_enrolled(true);
-  registration_request_.mutable_register_request()->set_requisition(
-      kRequisition);
-  ExpectRegistration(kOAuthToken);
-  EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    kOAuthToken, kClientID, true, kRequisition);
-  EXPECT_EQ(kClientID, client_id_);
-}
-
-TEST_F(CloudPolicyClientTest, RegistrationNoToken) {
-  registration_response_.mutable_register_response()->
-      clear_device_management_token();
-  ExpectRegistration(kOAuthToken);
-  EXPECT_CALL(observer_, OnClientError(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    kOAuthToken, std::string(), false, std::string());
-  EXPECT_FALSE(client_->is_registered());
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-  EXPECT_EQ(DM_STATUS_RESPONSE_DECODING_ERROR, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, RegistrationFailure) {
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION,
-                        request_context_))
-      .WillOnce(service_.FailJob(DM_STATUS_REQUEST_FAILED));
-  EXPECT_CALL(service_, StartJob(_, _, _, _, _, _, _));
-  EXPECT_CALL(observer_, OnClientError(_));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    kOAuthToken, std::string(), false, std::string());
-  EXPECT_FALSE(client_->is_registered());
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-  EXPECT_EQ(DM_STATUS_REQUEST_FAILED, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, RetryRegistration) {
-  // First registration does not set the re-register flag.
-  EXPECT_FALSE(
-      registration_request_.mutable_register_request()->has_reregister());
-  MockDeviceManagementJob* register_job = NULL;
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION,
-                        request_context_))
-      .WillOnce(service_.CreateAsyncJob(&register_job));
-  EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestRegister,
-                                 "", kOAuthToken, "", "", _,
-                                 MatchProto(registration_request_)));
-  client_->Register(em::DeviceRegisterRequest::USER,
-                    kOAuthToken, std::string(), false, std::string());
-  EXPECT_FALSE(client_->is_registered());
-  Mock::VerifyAndClearExpectations(&service_);
-
-  // Simulate a retry callback before proceeding; the re-register flag is set.
-  registration_request_.mutable_register_request()->set_reregister(true);
-  EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestRegister,
-                                 "", kOAuthToken, "", "", _,
-                                 MatchProto(registration_request_)));
-  register_job->RetryJob();
-  Mock::VerifyAndClearExpectations(&service_);
-
-  // Subsequent retries keep the flag set.
-  EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestRegister,
-                                 "", kOAuthToken, "", "", _,
-                                 MatchProto(registration_request_)));
-  register_job->RetryJob();
-  Mock::VerifyAndClearExpectations(&service_);
-}
-
-TEST_F(CloudPolicyClientTest, PolicyUpdate) {
-  Register();
-
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  CheckPolicyResponse();
-
-  policy_response_.mutable_policy_response()->clear_response();
-  policy_response_.mutable_policy_response()->add_response()->set_policy_data(
-      CreatePolicyData("updated-fake-policy-data"));
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-  CheckPolicyResponse();
-}
-
-TEST_F(CloudPolicyClientTest, PolicyFetchWithMetaData) {
-  Register();
-
-  const base::Time timestamp(
-      base::Time::UnixEpoch() + base::TimeDelta::FromDays(20));
-  client_->set_submit_machine_id(true);
-  client_->set_last_policy_timestamp(timestamp);
-  client_->set_public_key_version(42);
-  em::PolicyFetchRequest* policy_fetch_request =
-      policy_request_.mutable_policy_request()->mutable_request(0);
-  policy_fetch_request->set_machine_id(kMachineID);
-  policy_fetch_request->set_timestamp(
-      (timestamp - base::Time::UnixEpoch()).InMilliseconds());
-  policy_fetch_request->set_public_key_version(42);
-
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  CheckPolicyResponse();
-}
-
-TEST_F(CloudPolicyClientTest, PolicyFetchWithInvalidation) {
-  Register();
-
-  int64 previous_version = client_->fetched_invalidation_version();
-  client_->SetInvalidationInfo(12345, "12345");
-  EXPECT_EQ(previous_version, client_->fetched_invalidation_version());
-  em::PolicyFetchRequest* policy_fetch_request =
-      policy_request_.mutable_policy_request()->mutable_request(0);
-  policy_fetch_request->set_invalidation_version(12345);
-  policy_fetch_request->set_invalidation_payload("12345");
-
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  CheckPolicyResponse();
-  EXPECT_EQ(12345, client_->fetched_invalidation_version());
-}
-
-TEST_F(CloudPolicyClientTest, PolicyFetchWithInvalidationNoPayload) {
-  Register();
-
-  int64 previous_version = client_->fetched_invalidation_version();
-  client_->SetInvalidationInfo(-12345, std::string());
-  EXPECT_EQ(previous_version, client_->fetched_invalidation_version());
-
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  CheckPolicyResponse();
-  EXPECT_EQ(-12345, client_->fetched_invalidation_version());
-}
-
-TEST_F(CloudPolicyClientTest, BadPolicyResponse) {
-  Register();
-
-  policy_response_.clear_policy_response();
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnClientError(_));
-  client_->FetchPolicy();
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-  EXPECT_EQ(DM_STATUS_RESPONSE_DECODING_ERROR, client_->status());
-
-  policy_response_.mutable_policy_response()->add_response()->set_policy_data(
-      CreatePolicyData("fake-policy-data"));
-  policy_response_.mutable_policy_response()->add_response()->set_policy_data(
-      CreatePolicyData("excess-fake-policy-data"));
-  ExpectPolicyFetch(kDMToken, dm_protocol::kValueUserAffiliationNone);
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  client_->FetchPolicy();
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-  CheckPolicyResponse();
-}
-
-TEST_F(CloudPolicyClientTest, PolicyRequestFailure) {
-  Register();
-
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH,
-                        request_context_))
-      .WillOnce(service_.FailJob(DM_STATUS_REQUEST_FAILED));
-  EXPECT_CALL(service_, StartJob(_, _, _, _, _, _, _));
-  EXPECT_CALL(observer_, OnClientError(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully()).Times(0);
-  client_->FetchPolicy();
-  EXPECT_EQ(DM_STATUS_REQUEST_FAILED, client_->status());
-  EXPECT_FALSE(client_->GetPolicyFor(policy_ns_key_));
-}
-
-TEST_F(CloudPolicyClientTest, Unregister) {
-  Register();
-
-  ExpectUnregistration(kDMToken);
-  EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-  client_->Unregister();
-  EXPECT_FALSE(client_->is_registered());
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, UnregisterEmpty) {
-  Register();
-
-  unregistration_response_.clear_unregister_response();
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION,
-                        request_context_))
-      .WillOnce(service_.SucceedJob(unregistration_response_));
-  EXPECT_CALL(service_, StartJob(_, _, _, _, _, _, _));
-  EXPECT_CALL(observer_, OnRegistrationStateChanged(_));
-  client_->Unregister();
-  EXPECT_FALSE(client_->is_registered());
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, UnregisterFailure) {
-  Register();
-
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION,
-                        request_context_))
-      .WillOnce(service_.FailJob(DM_STATUS_REQUEST_FAILED));
-  EXPECT_CALL(service_, StartJob(_, _, _, _, _, _, _));
-  EXPECT_CALL(observer_, OnClientError(_));
-  client_->Unregister();
-  EXPECT_TRUE(client_->is_registered());
-  EXPECT_EQ(DM_STATUS_REQUEST_FAILED, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, PolicyFetchWithExtensionPolicy) {
-  Register();
-
-  // Setup the |expected_responses| and |policy_response_|.
-  static const char* kExtensions[] = {
-    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-    "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-    "cccccccccccccccccccccccccccccccc",
-  };
-  typedef std::map<PolicyNamespaceKey, em::PolicyFetchResponse> ResponseMap;
-  ResponseMap expected_responses;
-  std::set<PolicyNamespaceKey> expected_namespaces;
-  PolicyNamespaceKey key(dm_protocol::kChromeUserPolicyType, std::string());
-  // Copy the user policy fetch request.
-  expected_responses[key].CopyFrom(
-      policy_response_.policy_response().response(0));
-  expected_namespaces.insert(key);
-  key.first = dm_protocol::kChromeExtensionPolicyType;
-  for (size_t i = 0; i < arraysize(kExtensions); ++i) {
-    key.second = kExtensions[i];
-    em::PolicyData policy_data;
-    policy_data.set_policy_type(key.first);
-    policy_data.set_settings_entity_id(key.second);
-    expected_responses[key].set_policy_data(policy_data.SerializeAsString());
-    policy_response_.mutable_policy_response()->add_response()->CopyFrom(
-        expected_responses[key]);
-    expected_namespaces.insert(key);
-  }
-
-  // Make a policy fetch.
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH,
-                        request_context_))
-      .WillOnce(service_.SucceedJob(policy_response_));
-  EXPECT_CALL(service_, StartJob(dm_protocol::kValueRequestPolicy, "", "",
-                                 kDMToken,
-                                 dm_protocol::kValueUserAffiliationNone,
-                                 client_id_, _))
-      .WillOnce(SaveArg<6>(&policy_request_));
-  EXPECT_CALL(observer_, OnPolicyFetched(_));
-  EXPECT_CALL(status_provider_, OnSubmittedSuccessfully());
-  for (size_t i = 0; i < arraysize(kExtensions); ++i) {
-    client_->AddNamespaceToFetch(PolicyNamespaceKey(
-        dm_protocol::kChromeExtensionPolicyType, kExtensions[i]));
-  }
-  client_->FetchPolicy();
-
-  // Verify that the request includes the expected namespaces.
-  ASSERT_TRUE(policy_request_.has_policy_request());
-  const em::DevicePolicyRequest& policy_request =
-      policy_request_.policy_request();
-  ASSERT_EQ(static_cast<int>(1 + arraysize(kExtensions)),
-            policy_request.request_size());
-  for (int i = 0; i < policy_request.request_size(); ++i) {
-    const em::PolicyFetchRequest& fetch_request = policy_request.request(i);
-    ASSERT_TRUE(fetch_request.has_policy_type());
-    std::string entity_id;
-    if (fetch_request.has_settings_entity_id())
-      entity_id = fetch_request.settings_entity_id();
-    PolicyNamespaceKey key(fetch_request.policy_type(), entity_id);
-    EXPECT_EQ(1u, expected_namespaces.erase(key));
-  }
-  EXPECT_TRUE(expected_namespaces.empty());
-
-  // Verify that the client got all the responses mapped to their namespaces.
-  for (ResponseMap::iterator it = expected_responses.begin();
-       it != expected_responses.end(); ++it) {
-    const em::PolicyFetchResponse* response = client_->GetPolicyFor(it->first);
-    ASSERT_TRUE(response);
-    EXPECT_EQ(it->second.SerializeAsString(), response->SerializeAsString());
-  }
-}
-
-TEST_F(CloudPolicyClientTest, UploadCertificate) {
-  Register();
-
-  ExpectUploadCertificate();
-  EXPECT_CALL(upload_certificate_observer_, OnUploadComplete(true)).Times(1);
-  CloudPolicyClient::StatusCallback callback = base::Bind(
-      &MockUploadCertificateObserver::OnUploadComplete,
-      base::Unretained(&upload_certificate_observer_));
-  client_->UploadCertificate(kDeviceCertificate, callback);
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, UploadCertificateEmpty) {
-  Register();
-
-  upload_certificate_response_.clear_cert_upload_response();
-  ExpectUploadCertificate();
-  EXPECT_CALL(upload_certificate_observer_, OnUploadComplete(false)).Times(1);
-  CloudPolicyClient::StatusCallback callback = base::Bind(
-      &MockUploadCertificateObserver::OnUploadComplete,
-      base::Unretained(&upload_certificate_observer_));
-  client_->UploadCertificate(kDeviceCertificate, callback);
-  EXPECT_EQ(DM_STATUS_SUCCESS, client_->status());
-}
-
-TEST_F(CloudPolicyClientTest, UploadCertificateFailure) {
-  Register();
-
-  EXPECT_CALL(upload_certificate_observer_, OnUploadComplete(false)).Times(1);
-  EXPECT_CALL(service_,
-              CreateJob(DeviceManagementRequestJob::TYPE_UPLOAD_CERTIFICATE,
-                        request_context_))
-      .WillOnce(service_.FailJob(DM_STATUS_REQUEST_FAILED));
-  EXPECT_CALL(service_, StartJob(_, _, _, _, _, _, _));
-  EXPECT_CALL(observer_, OnClientError(_));
-  CloudPolicyClient::StatusCallback callback = base::Bind(
-      &MockUploadCertificateObserver::OnUploadComplete,
-      base::Unretained(&upload_certificate_observer_));
-  client_->UploadCertificate(kDeviceCertificate, callback);
-  EXPECT_EQ(DM_STATUS_REQUEST_FAILED, client_->status());
-}
-
-}  // namespace policy