Wire the device requisition parameter for enterprise enrollment.

chrome/browser/policy/cloud/cloud_policy_client_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/policy/cloud/cloud_policy_client.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 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));
 
@@ skipping 166 matching lines @@
   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);
+                    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);
+                    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);
+                    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))
       .WillOnce(service_.FailJob(DM_STATUS_REQUEST_FAILED));
   EXPECT_CALL(service_, StartJob(_, _, _, _, _, _, _));
   EXPECT_CALL(observer_, OnClientError(_));
   client_->Register(em::DeviceRegisterRequest::USER,
-                    kOAuthToken, std::string(), false);
+                    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))
       .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);
+                    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_);
@@ skipping 228 matching lines @@
   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