device_management_service_browsertest.cc revision 8bcbed890bc3ce4d7a057a8f32cab53fa534672e
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/cloud_policy_constants.h" 12#include "chrome/browser/policy/cloud/device_management_service.h" 13#include "chrome/browser/policy/cloud/mock_device_management_service.h" 14#include "chrome/browser/policy/cloud/test_request_interceptor.h" 15#include "chrome/browser/policy/test/local_policy_test_server.h" 16#include "chrome/test/base/in_process_browser_test.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 27using content::BrowserThread; 28using testing::DoAll; 29using testing::Invoke; 30using testing::InvokeWithoutArgs; 31using testing::_; 32 33namespace em = enterprise_management; 34 35namespace policy { 36 37namespace { 38 39// Parses the DeviceManagementRequest in |request_data| and writes a serialized 40// DeviceManagementResponse to |response_data|. 41void 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. 66net::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 92class 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 job->SetGaiaToken("gaia_auth_token"); 135 job->SetOAuthToken("oauth_token"); 136 job->SetClientID("testid"); 137 job->GetRequest()->mutable_register_request(); 138 job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone, 139 base::Unretained(this))); 140 base::MessageLoop::current()->Run(); 141 } 142 143 virtual void SetUpOnMainThread() OVERRIDE { 144 std::string service_url((this->*(GetParam()))()); 145 service_.reset(new DeviceManagementService( 146 scoped_ptr<DeviceManagementService::Configuration>( 147 new MockDeviceManagementServiceConfiguration(service_url)), 148 g_browser_process->system_request_context())); 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 177IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, Registration) { 178 PerformRegistration(); 179 EXPECT_FALSE(token_.empty()); 180} 181 182IN_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 job->SetDMToken(token_); 196 job->SetClientID("testid"); 197 em::DeviceServiceApiAccessRequest* request = 198 job->GetRequest()->mutable_service_api_access_request(); 199 request->add_auth_scope("authScope4Test"); 200 request->set_oauth2_client_id("oauth2ClientId4Test"); 201 job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone, 202 base::Unretained(this))); 203 base::MessageLoop::current()->Run(); 204 ASSERT_EQ("fake_auth_code", robot_auth_code_); 205} 206 207IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, PolicyFetch) { 208 PerformRegistration(); 209 210 ExpectRequest(); 211 EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _)) 212 .WillOnce(InvokeWithoutArgs(base::MessageLoop::current(), 213 &base::MessageLoop::Quit)); 214 scoped_ptr<DeviceManagementRequestJob> job( 215 service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH)); 216 job->SetDMToken(token_); 217 job->SetUserAffiliation(USER_AFFILIATION_NONE); 218 job->SetClientID("testid"); 219 em::DevicePolicyRequest* request = 220 job->GetRequest()->mutable_policy_request(); 221 request->add_request()->set_policy_type(dm_protocol::kChromeUserPolicyType); 222 job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone, 223 base::Unretained(this))); 224 base::MessageLoop::current()->Run(); 225} 226 227IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, Unregistration) { 228 PerformRegistration(); 229 230 ExpectRequest(); 231 EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _)) 232 .WillOnce(InvokeWithoutArgs(base::MessageLoop::current(), 233 &base::MessageLoop::Quit)); 234 scoped_ptr<DeviceManagementRequestJob> job( 235 service_->CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION)); 236 job->SetDMToken(token_); 237 job->SetClientID("testid"); 238 job->GetRequest()->mutable_unregister_request(); 239 job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone, 240 base::Unretained(this))); 241 base::MessageLoop::current()->Run(); 242} 243 244IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, AutoEnrollment) { 245 ExpectRequest(); 246 EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _, _)) 247 .WillOnce(InvokeWithoutArgs(base::MessageLoop::current(), 248 &base::MessageLoop::Quit)); 249 scoped_ptr<DeviceManagementRequestJob> job( 250 service_->CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT)); 251 job->SetClientID("testid"); 252 job->GetRequest()->mutable_auto_enrollment_request()->set_remainder(0); 253 job->GetRequest()->mutable_auto_enrollment_request()->set_modulus(1); 254 job->Start(base::Bind(&DeviceManagementServiceIntegrationTest::OnJobDone, 255 base::Unretained(this))); 256 base::MessageLoop::current()->Run(); 257} 258 259INSTANTIATE_TEST_CASE_P( 260 DeviceManagementServiceIntegrationTestInstance, 261 DeviceManagementServiceIntegrationTest, 262 testing::Values(&DeviceManagementServiceIntegrationTest::InitCannedResponse, 263 &DeviceManagementServiceIntegrationTest::InitTestServer)); 264 265} // namespace policy 266