Public Sessions: fetch device robot api token during enterprise enrollment.

chrome/browser/policy/cloud/device_management_service_browsertest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
@@ skipping 24 matching lines @@
 // DeviceManagementResponse to |response_data|.
 void ConstructResponse(const char* request_data,
                        uint64 request_data_length,
                        std::string* response_data) {
   em::DeviceManagementRequest request;
   ASSERT_TRUE(request.ParseFromArray(request_data, request_data_length));
   em::DeviceManagementResponse response;
   if (request.has_register_request()) {
     response.mutable_register_response()->set_device_management_token(
         "fake_token");
+  } else if (request.has_service_api_access_request()) {
+    response.mutable_service_api_access_response()->set_auth_code(
+        "fake_auth_code");
   } else if (request.has_unregister_request()) {
     response.mutable_unregister_response();
   } else if (request.has_policy_request()) {
     response.mutable_policy_response()->add_response();
   } else if (request.has_auto_enrollment_request()) {
     response.mutable_auto_enrollment_response();
   } else {
     FAIL() << "Failed to parse request.";
   }
   ASSERT_TRUE(response.SerializeToString(response_data));
@@ skipping 37 matching lines @@
   std::string InitCannedResponse() {
     interceptor_.reset(new TestRequestInterceptor("localhost"));
     return "http://localhost";
   }
 
   std::string InitTestServer() {
     StartTestServer();
     return test_server_->GetServiceURL().spec();
   }
 
+  void RecordAuthCode(DeviceManagementStatus status,
+                      const em::DeviceManagementResponse& response) {
+    robot_auth_code_ = response.service_api_access_response().auth_code();
+  }
+
  protected:
   void ExpectRequest() {
     if (interceptor_)
       interceptor_->PushJobCallback(base::Bind(&ResponseJob));
   }
 
   void PerformRegistration() {
     ExpectRequest();
     EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _))
         .WillOnce(
@@ skipping 29 matching lines @@
         new LocalPolicyTestServer("device_management_service_browsertest"));
     ASSERT_TRUE(test_server_->Start());
   }
 
   void RecordToken(DeviceManagementStatus status,
                    const em::DeviceManagementResponse& response) {
     token_ = response.register_response().device_management_token();
   }
 
   std::string token_;
+  std::string robot_auth_code_;
   scoped_ptr<DeviceManagementService> service_;
   scoped_ptr<LocalPolicyTestServer> test_server_;
   scoped_ptr<TestRequestInterceptor> interceptor_;
 };
 
 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, Registration) {
   PerformRegistration();
   EXPECT_FALSE(token_.empty());
 }
 
+IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,
+                       ApiAuthCodeFetch) {
+  PerformRegistration();
+
+  ExpectRequest();
+  EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _))
+      .WillOnce(
+          DoAll(Invoke(this,
+                       &DeviceManagementServiceIntegrationTest::RecordAuthCode),
+                InvokeWithoutArgs(MessageLoop::current(),
+                                  &MessageLoop::Quit)));
+  scoped_ptr<DeviceManagementRequestJob> job(service_->CreateJob(
+      DeviceManagementRequestJob::TYPE_API_AUTH_CODE_FETCH));
+  job->SetDMToken(token_);
+  job->SetClientID("testid");
+  em::DeviceServiceApiAccessRequest* request =
+      job->GetRequest()->mutable_service_api_access_request();
+  request->add_auth_scope("authScope4Test");
+  request->set_oauth2_client_id("oauth2ClientId4Test");
+  job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone,
+                        base::Unretained(this)));
+  MessageLoop::current()->Run();
+  ASSERT_EQ("fake_auth_code", robot_auth_code_);
+}
+
 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, PolicyFetch) {
   PerformRegistration();
 
   ExpectRequest();
   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _))
       .WillOnce(InvokeWithoutArgs(MessageLoop::current(), &MessageLoop::Quit));
   scoped_ptr<DeviceManagementRequestJob> job(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH));
   job->SetDMToken(token_);
   job->SetUserAffiliation(USER_AFFILIATION_NONE);
@@ skipping 36 matching lines @@
   MessageLoop::current()->Run();
 }
 
 INSTANTIATE_TEST_CASE_P(
     DeviceManagementServiceIntegrationTestInstance,
     DeviceManagementServiceIntegrationTest,
     testing::Values(&DeviceManagementServiceIntegrationTest::InitCannedResponse,
                     &DeviceManagementServiceIntegrationTest::InitTestServer));
 
 }  // namespace policy