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|.
ConstructResponse(const char * request_data,uint64 request_data_length,std::string * 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.
ResponseJob(net::URLRequest * request,net::NetworkDelegate * network_delegate)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
InitCannedResponse()100 std::string InitCannedResponse() {
101 interceptor_.reset(new TestRequestInterceptor(
102 "localhost",
103 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
104 return "http://localhost";
105 }
106
InitTestServer()107 std::string InitTestServer() {
108 StartTestServer();
109 return test_server_->GetServiceURL().spec();
110 }
111
RecordAuthCode(DeviceManagementStatus status,int net_error,const em::DeviceManagementResponse & response)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:
ExpectRequest()119 void ExpectRequest() {
120 if (interceptor_)
121 interceptor_->PushJobCallback(base::Bind(&ResponseJob));
122 }
123
PerformRegistration()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
SetUpOnMainThread()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
CleanUpOnMainThread()152 virtual void CleanUpOnMainThread() OVERRIDE {
153 service_.reset();
154 test_server_.reset();
155 interceptor_.reset();
156 }
157
StartTestServer()158 void StartTestServer() {
159 test_server_.reset(
160 new LocalPolicyTestServer("device_management_service_browsertest"));
161 ASSERT_TRUE(test_server_->Start());
162 }
163
RecordToken(DeviceManagementStatus status,int net_error,const em::DeviceManagementResponse & response)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
IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,Registration)177 IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest, Registration) {
178 PerformRegistration();
179 EXPECT_FALSE(token_.empty());
180 }
181
IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,ApiAuthCodeFetch)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
IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,PolicyFetch)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
IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,Unregistration)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
IN_PROC_BROWSER_TEST_P(DeviceManagementServiceIntegrationTest,AutoEnrollment)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
270