OLD | NEW |
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/chromeos/policy/upload_job.h" | 5 #include "chrome/browser/chromeos/policy/upload_job.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <queue> | 9 #include <queue> |
10 #include <set> | 10 #include <set> |
11 #include <utility> | 11 #include <utility> |
12 | 12 |
13 #include "base/bind.h" | 13 #include "base/bind.h" |
14 #include "base/bind_helpers.h" | 14 #include "base/bind_helpers.h" |
15 #include "base/location.h" | 15 #include "base/location.h" |
16 #include "base/macros.h" | 16 #include "base/macros.h" |
| 17 #include "base/memory/ptr_util.h" |
17 #include "base/run_loop.h" | 18 #include "base/run_loop.h" |
18 #include "base/single_thread_task_runner.h" | 19 #include "base/single_thread_task_runner.h" |
19 #include "base/thread_task_runner_handle.h" | 20 #include "base/thread_task_runner_handle.h" |
20 #include "base/time/time.h" | 21 #include "base/time/time.h" |
21 #include "chrome/browser/chromeos/policy/upload_job_impl.h" | 22 #include "chrome/browser/chromeos/policy/upload_job_impl.h" |
22 #include "content/public/test/test_browser_thread_bundle.h" | 23 #include "content/public/test/test_browser_thread_bundle.h" |
23 #include "google_apis/gaia/fake_oauth2_token_service.h" | 24 #include "google_apis/gaia/fake_oauth2_token_service.h" |
24 #include "google_apis/gaia/google_service_auth_error.h" | 25 #include "google_apis/gaia/google_service_auth_error.h" |
25 #include "net/http/http_status_code.h" | 26 #include "net/http/http_status_code.h" |
26 #include "net/test/embedded_test_server/embedded_test_server.h" | 27 #include "net/test/embedded_test_server/embedded_test_server.h" |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
166 // policy::UploadJob::Delegate: | 167 // policy::UploadJob::Delegate: |
167 void OnFailure(UploadJob::ErrorCode error_code) override { | 168 void OnFailure(UploadJob::ErrorCode error_code) override { |
168 if (expected_error_ && *expected_error_.get() == error_code) | 169 if (expected_error_ && *expected_error_.get() == error_code) |
169 run_loop_.Quit(); | 170 run_loop_.Quit(); |
170 else | 171 else |
171 FAIL(); | 172 FAIL(); |
172 } | 173 } |
173 | 174 |
174 const GURL GetServerURL() const { return test_server_.GetURL(kUploadPath); } | 175 const GURL GetServerURL() const { return test_server_.GetURL(kUploadPath); } |
175 | 176 |
176 void SetExpectedError(scoped_ptr<UploadJob::ErrorCode> expected_error) { | 177 void SetExpectedError(std::unique_ptr<UploadJob::ErrorCode> expected_error) { |
177 expected_error_ = std::move(expected_error); | 178 expected_error_ = std::move(expected_error); |
178 } | 179 } |
179 | 180 |
180 // testing::Test: | 181 // testing::Test: |
181 void SetUp() override { | 182 void SetUp() override { |
182 request_context_getter_ = new net::TestURLRequestContextGetter( | 183 request_context_getter_ = new net::TestURLRequestContextGetter( |
183 base::ThreadTaskRunnerHandle::Get()); | 184 base::ThreadTaskRunnerHandle::Get()); |
184 oauth2_service_.AddAccount("robot@gmail.com"); | 185 oauth2_service_.AddAccount("robot@gmail.com"); |
185 ASSERT_TRUE(test_server_.Start()); | 186 ASSERT_TRUE(test_server_.Start()); |
186 } | 187 } |
187 | 188 |
188 // testing::Test: | 189 // testing::Test: |
189 void TearDown() override { | 190 void TearDown() override { |
190 ASSERT_TRUE(test_server_.ShutdownAndWaitUntilComplete()); | 191 ASSERT_TRUE(test_server_.ShutdownAndWaitUntilComplete()); |
191 } | 192 } |
192 | 193 |
193 protected: | 194 protected: |
194 scoped_ptr<UploadJob> PrepareUploadJob(scoped_ptr< | 195 std::unique_ptr<UploadJob> PrepareUploadJob( |
195 UploadJobImpl::MimeBoundaryGenerator> mime_boundary_generator) { | 196 std::unique_ptr<UploadJobImpl::MimeBoundaryGenerator> |
196 scoped_ptr<UploadJob> upload_job( | 197 mime_boundary_generator) { |
| 198 std::unique_ptr<UploadJob> upload_job( |
197 new UploadJobImpl(GetServerURL(), kRobotAccountId, &oauth2_service_, | 199 new UploadJobImpl(GetServerURL(), kRobotAccountId, &oauth2_service_, |
198 request_context_getter_.get(), this, | 200 request_context_getter_.get(), this, |
199 std::move(mime_boundary_generator))); | 201 std::move(mime_boundary_generator))); |
200 | 202 |
201 std::map<std::string, std::string> header_entries; | 203 std::map<std::string, std::string> header_entries; |
202 header_entries.insert(std::make_pair(kCustomField1, "CUSTOM1")); | 204 header_entries.insert(std::make_pair(kCustomField1, "CUSTOM1")); |
203 scoped_ptr<std::string> data(new std::string(kTestPayload1)); | 205 std::unique_ptr<std::string> data(new std::string(kTestPayload1)); |
204 upload_job->AddDataSegment("Name1", "file1.ext", header_entries, | 206 upload_job->AddDataSegment("Name1", "file1.ext", header_entries, |
205 std::move(data)); | 207 std::move(data)); |
206 | 208 |
207 header_entries.insert(std::make_pair(kCustomField2, "CUSTOM2")); | 209 header_entries.insert(std::make_pair(kCustomField2, "CUSTOM2")); |
208 scoped_ptr<std::string> data2(new std::string(kTestPayload2)); | 210 std::unique_ptr<std::string> data2(new std::string(kTestPayload2)); |
209 upload_job->AddDataSegment("Name2", "", header_entries, std::move(data2)); | 211 upload_job->AddDataSegment("Name2", "", header_entries, std::move(data2)); |
210 return upload_job; | 212 return upload_job; |
211 } | 213 } |
212 | 214 |
213 content::TestBrowserThreadBundle test_browser_thread_bundle_; | 215 content::TestBrowserThreadBundle test_browser_thread_bundle_; |
214 base::RunLoop run_loop_; | 216 base::RunLoop run_loop_; |
215 net::EmbeddedTestServer test_server_; | 217 net::EmbeddedTestServer test_server_; |
216 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; | 218 scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_; |
217 MockOAuth2TokenService oauth2_service_; | 219 MockOAuth2TokenService oauth2_service_; |
218 | 220 |
219 scoped_ptr<UploadJob::ErrorCode> expected_error_; | 221 std::unique_ptr<UploadJob::ErrorCode> expected_error_; |
220 }; | 222 }; |
221 | 223 |
222 class UploadFlowTest : public UploadJobTestBase { | 224 class UploadFlowTest : public UploadJobTestBase { |
223 public: | 225 public: |
224 UploadFlowTest() {} | 226 UploadFlowTest() {} |
225 | 227 |
226 // UploadJobTestBase: | 228 // UploadJobTestBase: |
227 void SetUp() override { | 229 void SetUp() override { |
228 UploadJobTestBase::SetUp(); | 230 UploadJobTestBase::SetUp(); |
229 test_server_.RegisterRequestHandler( | 231 test_server_.RegisterRequestHandler( |
230 base::Bind(&UploadFlowTest::HandlePostRequest, base::Unretained(this))); | 232 base::Bind(&UploadFlowTest::HandlePostRequest, base::Unretained(this))); |
231 } | 233 } |
232 | 234 |
233 scoped_ptr<net::test_server::HttpResponse> HandlePostRequest( | 235 std::unique_ptr<net::test_server::HttpResponse> HandlePostRequest( |
234 const net::test_server::HttpRequest& request) { | 236 const net::test_server::HttpRequest& request) { |
235 EXPECT_TRUE(request.headers.find("Authorization") != request.headers.end()); | 237 EXPECT_TRUE(request.headers.find("Authorization") != request.headers.end()); |
236 const std::string authorization_header = | 238 const std::string authorization_header = |
237 request.headers.at("Authorization"); | 239 request.headers.at("Authorization"); |
238 scoped_ptr<net::test_server::BasicHttpResponse> response( | 240 std::unique_ptr<net::test_server::BasicHttpResponse> response( |
239 new net::test_server::BasicHttpResponse); | 241 new net::test_server::BasicHttpResponse); |
240 const size_t pos = authorization_header.find(" "); | 242 const size_t pos = authorization_header.find(" "); |
241 if (pos == std::string::npos) { | 243 if (pos == std::string::npos) { |
242 response->set_code(net::HTTP_UNAUTHORIZED); | 244 response->set_code(net::HTTP_UNAUTHORIZED); |
243 return std::move(response); | 245 return std::move(response); |
244 } | 246 } |
245 | 247 |
246 const std::string token = authorization_header.substr(pos + 1); | 248 const std::string token = authorization_header.substr(pos + 1); |
247 response->set_code(oauth2_service_.IsTokenValid(token) | 249 response->set_code(oauth2_service_.IsTokenValid(token) |
248 ? net::HTTP_OK | 250 ? net::HTTP_OK |
249 : net::HTTP_UNAUTHORIZED); | 251 : net::HTTP_UNAUTHORIZED); |
250 return std::move(response); | 252 return std::move(response); |
251 } | 253 } |
252 }; | 254 }; |
253 | 255 |
254 TEST_F(UploadFlowTest, SuccessfulUpload) { | 256 TEST_F(UploadFlowTest, SuccessfulUpload) { |
255 oauth2_service_.SetTokenValid(kTokenValid); | 257 oauth2_service_.SetTokenValid(kTokenValid); |
256 oauth2_service_.AddTokenToQueue(kTokenValid); | 258 oauth2_service_.AddTokenToQueue(kTokenValid); |
257 scoped_ptr<UploadJob> upload_job = PrepareUploadJob( | 259 std::unique_ptr<UploadJob> upload_job = PrepareUploadJob( |
258 make_scoped_ptr(new UploadJobImpl::RandomMimeBoundaryGenerator)); | 260 base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator)); |
259 upload_job->Start(); | 261 upload_job->Start(); |
260 run_loop_.Run(); | 262 run_loop_.Run(); |
261 } | 263 } |
262 | 264 |
263 TEST_F(UploadFlowTest, TokenExpired) { | 265 TEST_F(UploadFlowTest, TokenExpired) { |
264 oauth2_service_.SetTokenValid(kTokenValid); | 266 oauth2_service_.SetTokenValid(kTokenValid); |
265 oauth2_service_.AddTokenToQueue(kTokenExpired); | 267 oauth2_service_.AddTokenToQueue(kTokenExpired); |
266 oauth2_service_.AddTokenToQueue(kTokenValid); | 268 oauth2_service_.AddTokenToQueue(kTokenValid); |
267 scoped_ptr<UploadJob> upload_job = PrepareUploadJob( | 269 std::unique_ptr<UploadJob> upload_job = PrepareUploadJob( |
268 make_scoped_ptr(new UploadJobImpl::RandomMimeBoundaryGenerator)); | 270 base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator)); |
269 upload_job->Start(); | 271 upload_job->Start(); |
270 run_loop_.Run(); | 272 run_loop_.Run(); |
271 } | 273 } |
272 | 274 |
273 TEST_F(UploadFlowTest, TokenInvalid) { | 275 TEST_F(UploadFlowTest, TokenInvalid) { |
274 oauth2_service_.AddTokenToQueue(kTokenInvalid); | 276 oauth2_service_.AddTokenToQueue(kTokenInvalid); |
275 oauth2_service_.AddTokenToQueue(kTokenInvalid); | 277 oauth2_service_.AddTokenToQueue(kTokenInvalid); |
276 SetExpectedError(scoped_ptr<UploadJob::ErrorCode>( | 278 SetExpectedError(std::unique_ptr<UploadJob::ErrorCode>( |
277 new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR))); | 279 new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR))); |
278 | 280 |
279 scoped_ptr<UploadJob> upload_job = PrepareUploadJob( | 281 std::unique_ptr<UploadJob> upload_job = PrepareUploadJob( |
280 make_scoped_ptr(new UploadJobImpl::RandomMimeBoundaryGenerator)); | 282 base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator)); |
281 upload_job->Start(); | 283 upload_job->Start(); |
282 run_loop_.Run(); | 284 run_loop_.Run(); |
283 } | 285 } |
284 | 286 |
285 TEST_F(UploadFlowTest, TokenFetchFailure) { | 287 TEST_F(UploadFlowTest, TokenFetchFailure) { |
286 SetExpectedError(scoped_ptr<UploadJob::ErrorCode>( | 288 SetExpectedError(std::unique_ptr<UploadJob::ErrorCode>( |
287 new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR))); | 289 new UploadJob::ErrorCode(UploadJob::AUTHENTICATION_ERROR))); |
288 | 290 |
289 scoped_ptr<UploadJob> upload_job = PrepareUploadJob( | 291 std::unique_ptr<UploadJob> upload_job = PrepareUploadJob( |
290 make_scoped_ptr(new UploadJobImpl::RandomMimeBoundaryGenerator)); | 292 base::WrapUnique(new UploadJobImpl::RandomMimeBoundaryGenerator)); |
291 upload_job->Start(); | 293 upload_job->Start(); |
292 run_loop_.Run(); | 294 run_loop_.Run(); |
293 } | 295 } |
294 | 296 |
295 class UploadRequestTest : public UploadJobTestBase { | 297 class UploadRequestTest : public UploadJobTestBase { |
296 public: | 298 public: |
297 UploadRequestTest() {} | 299 UploadRequestTest() {} |
298 | 300 |
299 // UploadJobTestBase: | 301 // UploadJobTestBase: |
300 void SetUp() override { | 302 void SetUp() override { |
301 UploadJobTestBase::SetUp(); | 303 UploadJobTestBase::SetUp(); |
302 test_server_.RegisterRequestHandler(base::Bind( | 304 test_server_.RegisterRequestHandler(base::Bind( |
303 &UploadRequestTest::HandlePostRequest, base::Unretained(this))); | 305 &UploadRequestTest::HandlePostRequest, base::Unretained(this))); |
304 } | 306 } |
305 | 307 |
306 scoped_ptr<net::test_server::HttpResponse> HandlePostRequest( | 308 std::unique_ptr<net::test_server::HttpResponse> HandlePostRequest( |
307 const net::test_server::HttpRequest& request) { | 309 const net::test_server::HttpRequest& request) { |
308 scoped_ptr<net::test_server::BasicHttpResponse> response( | 310 std::unique_ptr<net::test_server::BasicHttpResponse> response( |
309 new net::test_server::BasicHttpResponse); | 311 new net::test_server::BasicHttpResponse); |
310 response->set_code(net::HTTP_OK); | 312 response->set_code(net::HTTP_OK); |
311 EXPECT_EQ(expected_content_, request.content); | 313 EXPECT_EQ(expected_content_, request.content); |
312 return std::move(response); | 314 return std::move(response); |
313 } | 315 } |
314 | 316 |
315 void SetExpectedRequestContent(const std::string& expected_content) { | 317 void SetExpectedRequestContent(const std::string& expected_content) { |
316 expected_content_ = expected_content; | 318 expected_content_ = expected_content; |
317 } | 319 } |
318 | 320 |
319 protected: | 321 protected: |
320 std::string expected_content_; | 322 std::string expected_content_; |
321 }; | 323 }; |
322 | 324 |
323 TEST_F(UploadRequestTest, TestRequestStructure) { | 325 TEST_F(UploadRequestTest, TestRequestStructure) { |
324 oauth2_service_.SetTokenValid(kTokenValid); | 326 oauth2_service_.SetTokenValid(kTokenValid); |
325 oauth2_service_.AddTokenToQueue(kTokenValid); | 327 oauth2_service_.AddTokenToQueue(kTokenValid); |
326 scoped_ptr<UploadJob> upload_job = PrepareUploadJob( | 328 std::unique_ptr<UploadJob> upload_job = PrepareUploadJob( |
327 make_scoped_ptr(new RepeatingMimeBoundaryGenerator('A'))); | 329 base::WrapUnique(new RepeatingMimeBoundaryGenerator('A'))); |
328 SetExpectedRequestContent( | 330 SetExpectedRequestContent( |
329 "--AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n" | 331 "--AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n" |
330 "Content-Disposition: form-data; " | 332 "Content-Disposition: form-data; " |
331 "name=\"Name1\"; filename=\"file1.ext\"\r\n" | 333 "name=\"Name1\"; filename=\"file1.ext\"\r\n" |
332 "customfield1: CUSTOM1\r\n" | 334 "customfield1: CUSTOM1\r\n" |
333 "\r\n" | 335 "\r\n" |
334 "**||--||PAYLOAD1||--||**\r\n" | 336 "**||--||PAYLOAD1||--||**\r\n" |
335 "--AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n" | 337 "--AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n" |
336 "Content-Disposition: form-data; name=\"Name2\"\r\n" | 338 "Content-Disposition: form-data; name=\"Name2\"\r\n" |
337 "customfield1: CUSTOM1\r\n" | 339 "customfield1: CUSTOM1\r\n" |
338 "customfield2: CUSTOM2\r\n" | 340 "customfield2: CUSTOM2\r\n" |
339 "\r\n" | 341 "\r\n" |
340 "**||--||PAYLOAD2||--||**\r\n--" | 342 "**||--||PAYLOAD2||--||**\r\n--" |
341 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA--\r\n"); | 343 "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA--\r\n"); |
342 | 344 |
343 upload_job->Start(); | 345 upload_job->Start(); |
344 run_loop_.Run(); | 346 run_loop_.Run(); |
345 } | 347 } |
346 | 348 |
347 } // namespace policy | 349 } // namespace policy |
OLD | NEW |