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