chrome/browser/policy/cloud/device_management_service_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/bind_helpers.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/stl_util.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/policy/cloud/test_request_interceptor.h"
  12 #include "chrome/browser/policy/test/local_policy_test_server.h"
  13 #include "chrome/test/base/in_process_browser_test.h"
  14 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
  15 #include "components/policy/core/common/cloud/device_management_service.h"
  16 #include "components/policy/core/common/cloud/mock_device_management_service.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "net/base/upload_bytes_element_reader.h"
  19 #include "net/base/upload_data_stream.h"
  20 #include "net/url_request/url_fetcher.h"
  21 #include "net/url_request/url_request.h"
  22 #include "net/url_request/url_request_context_getter.h"
  23 #include "net/url_request/url_request_test_job.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 using content::BrowserThread;
  28 using testing::DoAll;
  29 using testing::Invoke;
  30 using testing::InvokeWithoutArgs;
  31 using testing::_;
  32
  33 namespace em = enterprise_management;
  34
  35 namespace policy {
  36
  37 namespace {
  38
  39 // Parses the DeviceManagementRequest in |request_data| and writes a serialized
  40 // DeviceManagementResponse to |response_data|.
  41 void ConstructResponse(const char* request_data,
  42                        uint64 request_data_length,
  43                        std::string* response_data) {
  44   em::DeviceManagementRequest request;
  45   ASSERT_TRUE(request.ParseFromArray(request_data, request_data_length));
  46   em::DeviceManagementResponse response;
  47   if (request.has_register_request()) {
  48     response.mutable_register_response()->set_device_management_token(
  49         "fake_token");
  50   } else if (request.has_service_api_access_request()) {
  51     response.mutable_service_api_access_response()->set_auth_code(
  52         "fake_auth_code");
  53   } else if (request.has_unregister_request()) {
  54     response.mutable_unregister_response();
  55   } else if (request.has_policy_request()) {
  56     response.mutable_policy_response()->add_response();
  57   } else if (request.has_auto_enrollment_request()) {
  58     response.mutable_auto_enrollment_response();
  59   } else {
  60     FAIL() << "Failed to parse request.";
  61   }
  62   ASSERT_TRUE(response.SerializeToString(response_data));
  63 }
  64
  65 // JobCallback for the interceptor.
  66 net::URLRequestJob* ResponseJob(
  67     net::URLRequest* request,
  68     net::NetworkDelegate* network_delegate) {
  69   const net::UploadDataStream* upload = request->get_upload();
  70   if (upload != NULL &&
  71       upload->element_readers().size() == 1 &&
  72       upload->element_readers()[0]->AsBytesReader()) {
  73     std::string response_data;
  74     const net::UploadBytesElementReader* bytes_reader =
  75         upload->element_readers()[0]->AsBytesReader();
  76     ConstructResponse(bytes_reader->bytes(),
  77                       bytes_reader->length(),
  78                       &response_data);
  79     return new net::URLRequestTestJob(
  80         request,
  81         network_delegate,
  82         net::URLRequestTestJob::test_headers(),
  83         response_data,
  84         true);
  85   }
  86
  87   return NULL;
  88 }
  89
  90 }  // namespace
  91
  92 class DeviceManagementServiceIntegrationTest
  93     : public InProcessBrowserTest,
  94       public testing::WithParamInterface<
  95           std::string (DeviceManagementServiceIntegrationTest::*)(void)> {
  96  public:
  97   MOCK_METHOD3(OnJobDone, void(DeviceManagementStatus, int,
  98                                const em::DeviceManagementResponse&));
  99
 100   std::string InitCannedResponse() {
 101     interceptor_.reset(new TestRequestInterceptor(
 102         "localhost",
 103         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
 104     return "http://localhost";
 105   }
 106
 107   std::string InitTestServer() {
 108     StartTestServer();
 109     return test_server_->GetServiceURL().spec();
 110   }
 111
 112   void RecordAuthCode(DeviceManagementStatus status,
 113                       int net_error,
 114                       const em::DeviceManagementResponse& response) {
 115     robot_auth_code_ = response.service_api_access_response().auth_code();
 116   }
 117
 118  protected:
 119   void ExpectRequest() {
 120     if (interceptor_)
 121       interceptor_->PushJobCallback(base::Bind(&ResponseJob));
 122   }
 123
 124   void PerformRegistration() {
 125     ExpectRequest();
 126     EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _))
 127         .WillOnce(
 128             DoAll(Invoke(this,
 129                          &DeviceManagementServiceIntegrationTest::RecordToken),
 130                   InvokeWithoutArgs(base::MessageLoop::current(),
 131                                     &base::MessageLoop::Quit)));
 132     scoped_ptr<DeviceManagementRequestJob> job(
 133         service_->CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION,
 134                             g_browser_process->system_request_context()));
 135     job->SetGaiaToken("gaia_auth_token");
 136     job->SetOAuthToken("oauth_token");
 137     job->SetClientID("testid");
 138     job->GetRequest()->mutable_register_request();
 139     job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone,
 140                           base::Unretained(this)));
 141     base::MessageLoop::current()->Run();
 142   }
 143
 144   virtual void SetUpOnMainThread() OVERRIDE {
 145     std::string service_url((this->*(GetParam()))());
 146     service_.reset(new DeviceManagementService(
 147         scoped_ptr<DeviceManagementService::Configuration>(
 148             new MockDeviceManagementServiceConfiguration(service_url))));
 149     service_->ScheduleInitialization(0);
 150   }
 151
 152   virtual void CleanUpOnMainThread() OVERRIDE {
 153     service_.reset();
 154     test_server_.reset();
 155     interceptor_.reset();
 156   }
 157
 158   void StartTestServer() {
 159     test_server_.reset(
 160         new LocalPolicyTestServer("device_management_service_browsertest"));
 161     ASSERT_TRUE(test_server_->Start());
 162   }
 163
 164   void RecordToken(DeviceManagementStatus status,
 165                    int net_error,
 166                    const em::DeviceManagementResponse& response) {
 167     token_ = response.register_response().device_management_token();
 168   }
 169
 170   std::string token_;
 171   std::string robot_auth_code_;
 172   scoped_ptr<DeviceManagementService> service_;
 173   scoped_ptr<LocalPolicyTestServer> test_server_;
 174   scoped_ptr<TestRequestInterceptor> interceptor_;
 175 };
 176
 177 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, Registration) {
 178   PerformRegistration();
 179   EXPECT_FALSE(token_.empty());
 180 }
 181
 182 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,
 183                        ApiAuthCodeFetch) {
 184   PerformRegistration();
 185
 186   ExpectRequest();
 187   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _))
 188       .WillOnce(
 189           DoAll(Invoke(this,
 190                        &DeviceManagementServiceIntegrationTest::RecordAuthCode),
 191                 InvokeWithoutArgs(base::MessageLoop::current(),
 192                                   &base::MessageLoop::Quit)));
 193   scoped_ptr<DeviceManagementRequestJob> job(service_->CreateJob(
 194       DeviceManagementRequestJob::TYPE_API_AUTH_CODE_FETCH,
 195       g_browser_process->system_request_context()));
 196   job->SetDMToken(token_);
 197   job->SetClientID("testid");
 198   em::DeviceServiceApiAccessRequest* request =
 199       job->GetRequest()->mutable_service_api_access_request();
 200   request->add_auth_scope("authScope4Test");
 201   request->set_oauth2_client_id("oauth2ClientId4Test");
 202   job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone,
 203                         base::Unretained(this)));
 204   base::MessageLoop::current()->Run();
 205   ASSERT_EQ("fake_auth_code", robot_auth_code_);
 206 }
 207
 208 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, PolicyFetch) {
 209   PerformRegistration();
 210
 211   ExpectRequest();
 212   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _))
 213       .WillOnce(InvokeWithoutArgs(base::MessageLoop::current(),
 214                                   &base::MessageLoop::Quit));
 215   scoped_ptr<DeviceManagementRequestJob> job(
 216       service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH,
 217                           g_browser_process->system_request_context()));
 218   job->SetDMToken(token_);
 219   job->SetUserAffiliation(USER_AFFILIATION_NONE);
 220   job->SetClientID("testid");
 221   em::DevicePolicyRequest* request =
 222       job->GetRequest()->mutable_policy_request();
 223   request->add_request()->set_policy_type(dm_protocol::kChromeUserPolicyType);
 224   job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone,
 225                         base::Unretained(this)));
 226   base::MessageLoop::current()->Run();
 227 }
 228
 229 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, Unregistration) {
 230   PerformRegistration();
 231
 232   ExpectRequest();
 233   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _))
 234       .WillOnce(InvokeWithoutArgs(base::MessageLoop::current(),
 235                                   &base::MessageLoop::Quit));
 236   scoped_ptr<DeviceManagementRequestJob> job(
 237       service_->CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION,
 238                           g_browser_process->system_request_context()));
 239   job->SetDMToken(token_);
 240   job->SetClientID("testid");
 241   job->GetRequest()->mutable_unregister_request();
 242   job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone,
 243                         base::Unretained(this)));
 244   base::MessageLoop::current()->Run();
 245 }
 246
 247 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, AutoEnrollment) {
 248   ExpectRequest();
 249   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _))
 250       .WillOnce(InvokeWithoutArgs(base::MessageLoop::current(),
 251                                   &base::MessageLoop::Quit));
 252   scoped_ptr<DeviceManagementRequestJob> job(
 253       service_->CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT,
 254                           g_browser_process->system_request_context()));
 255   job->SetClientID("testid");
 256   job->GetRequest()->mutable_auto_enrollment_request()->set_remainder(0);
 257   job->GetRequest()->mutable_auto_enrollment_request()->set_modulus(1);
 258   job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone,
 259                         base::Unretained(this)));
 260   base::MessageLoop::current()->Run();
 261 }
 262
 263 INSTANTIATE_TEST_CASE_P(
 264     DeviceManagementServiceIntegrationTestInstance,
 265     DeviceManagementServiceIntegrationTest,
 266     testing::Values(&DeviceManagementServiceIntegrationTest::InitCannedResponse,
 267                     &DeviceManagementServiceIntegrationTest::InitTestServer));
 268
 269 }  // namespace policy