1 // Copyright 2013 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 "components/policy/core/common/cloud/external_policy_data_fetcher.h"
6
7 #include "base/bind.h"
8 #include "base/bind_helpers.h"
9 #include "base/compiler_specific.h"
10 #include "base/sequenced_task_runner.h"
11 #include "base/test/test_simple_task_runner.h"
12 #include "net/base/net_errors.h"
13 #include "net/url_request/test_url_fetcher_factory.h"
14 #include "net/url_request/url_fetcher.h"
15 #include "net/url_request/url_fetcher_delegate.h"
16 #include "net/url_request/url_request_context_getter.h"
17 #include "net/url_request/url_request_status.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19
20 namespace policy {
21
22 namespace {
23
24 const char* kExternalPolicyDataURLs[] = {
25 "http://localhost/data_1",
26 "http://localhost/data_2"
27 };
28
29 const int64 kExternalPolicyDataMaxSize = 5 * 1024 * 1024; // 5 MB.
30
31 const char* kExternalPolicyDataPayload = "External policy data";
32
33 } // namespace
34
35 class ExternalPolicyDataFetcherTest : public testing::Test {
36 protected:
37 ExternalPolicyDataFetcherTest();
38 virtual ~ExternalPolicyDataFetcherTest();
39
40 // testing::Test:
41 virtual void SetUp() OVERRIDE;
42
43 void StartJob(int index);
44 void CancelJob(int index);
45
46 void OnJobFinished(int job_index,
47 ExternalPolicyDataFetcher::Result result,
48 scoped_ptr<std::string> data);
49 int GetAndResetCallbackCount();
50
51 net::TestURLFetcherFactory fetcher_factory_;
52 scoped_refptr<base::TestSimpleTaskRunner> owner_task_runner_;
53 scoped_refptr<base::TestSimpleTaskRunner> io_task_runner_;
54 scoped_ptr<ExternalPolicyDataFetcherBackend> fetcher_backend_;
55 scoped_ptr<ExternalPolicyDataFetcher> fetcher_;
56
57 std::map<int, ExternalPolicyDataFetcher::Job*> jobs_; // Not owned.
58
59 int callback_count_;
60 int callback_job_index_;
61 ExternalPolicyDataFetcher::Result callback_result_;
62 scoped_ptr<std::string> callback_data_;
63
64 DISALLOW_COPY_AND_ASSIGN(ExternalPolicyDataFetcherTest);
65 };
66
ExternalPolicyDataFetcherTest()67 ExternalPolicyDataFetcherTest::ExternalPolicyDataFetcherTest()
68 : callback_count_(0) {
69 }
70
~ExternalPolicyDataFetcherTest()71 ExternalPolicyDataFetcherTest::~ExternalPolicyDataFetcherTest() {
72 }
73
SetUp()74 void ExternalPolicyDataFetcherTest::SetUp() {
75 fetcher_factory_.set_remove_fetcher_on_delete(true);
76 io_task_runner_ = new base::TestSimpleTaskRunner();
77 owner_task_runner_ = new base::TestSimpleTaskRunner();
78 fetcher_backend_.reset(new ExternalPolicyDataFetcherBackend(
79 io_task_runner_,
80 scoped_refptr<net::URLRequestContextGetter>()));
81 fetcher_.reset(
82 fetcher_backend_->CreateFrontend(owner_task_runner_).release());
83 }
84
StartJob(int index)85 void ExternalPolicyDataFetcherTest::StartJob(int index) {
86 jobs_[index] = fetcher_->StartJob(
87 GURL(kExternalPolicyDataURLs[index]),
88 kExternalPolicyDataMaxSize,
89 base::Bind(&ExternalPolicyDataFetcherTest::OnJobFinished,
90 base::Unretained(this), index));
91 io_task_runner_->RunUntilIdle();
92 }
93
CancelJob(int index)94 void ExternalPolicyDataFetcherTest::CancelJob(int index) {
95 std::map<int, ExternalPolicyDataFetcher::Job*>::iterator it =
96 jobs_.find(index);
97 ASSERT_TRUE(it != jobs_.end());
98 ExternalPolicyDataFetcher::Job* job = it->second;
99 jobs_.erase(it);
100 fetcher_->CancelJob(job);
101 }
102
OnJobFinished(int job_index,ExternalPolicyDataFetcher::Result result,scoped_ptr<std::string> data)103 void ExternalPolicyDataFetcherTest::OnJobFinished(
104 int job_index,
105 ExternalPolicyDataFetcher::Result result,
106 scoped_ptr<std::string> data) {
107 ++callback_count_;
108 callback_job_index_ = job_index;
109 callback_result_ = result;
110 callback_data_.reset(data.release());
111 jobs_.erase(job_index);
112 }
113
GetAndResetCallbackCount()114 int ExternalPolicyDataFetcherTest::GetAndResetCallbackCount() {
115 const int callback_count = callback_count_;
116 callback_count_ = 0;
117 return callback_count;
118 }
119
TEST_F(ExternalPolicyDataFetcherTest,Success)120 TEST_F(ExternalPolicyDataFetcherTest, Success) {
121 // Start a fetch job.
122 StartJob(0);
123
124 // Verify that the fetch has been started.
125 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
126 ASSERT_TRUE(fetcher);
127 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
128
129 // Complete the fetch.
130 fetcher->set_response_code(200);
131 fetcher->SetResponseString(kExternalPolicyDataPayload);
132 fetcher->delegate()->OnURLFetchComplete(fetcher);
133
134 // Verify that the fetch is no longer running.
135 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
136
137 // Verify that the callback is invoked with the retrieved data.
138 owner_task_runner_->RunUntilIdle();
139 EXPECT_EQ(1, GetAndResetCallbackCount());
140 EXPECT_EQ(0, callback_job_index_);
141 EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
142 ASSERT_TRUE(callback_data_);
143 EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
144 }
145
TEST_F(ExternalPolicyDataFetcherTest,MaxSizeExceeded)146 TEST_F(ExternalPolicyDataFetcherTest, MaxSizeExceeded) {
147 // Start a fetch job.
148 StartJob(0);
149
150 // Verify that the fetch has been started.
151 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
152 ASSERT_TRUE(fetcher);
153 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
154
155 // Indicate that the data size will exceed maximum allowed.
156 fetcher->delegate()->OnURLFetchDownloadProgress(
157 fetcher,
158 kExternalPolicyDataMaxSize + 1,
159 -1);
160
161 // Verify that the fetch is no longer running.
162 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
163
164 // Verify that the callback is invoked with the correct error code.
165 owner_task_runner_->RunUntilIdle();
166 EXPECT_EQ(1, GetAndResetCallbackCount());
167 EXPECT_EQ(0, callback_job_index_);
168 EXPECT_EQ(ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED, callback_result_);
169 EXPECT_FALSE(callback_data_);
170 }
171
TEST_F(ExternalPolicyDataFetcherTest,ConnectionInterrupted)172 TEST_F(ExternalPolicyDataFetcherTest, ConnectionInterrupted) {
173 // Start a fetch job.
174 StartJob(0);
175
176 // Verify that the fetch has been started.
177 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
178 ASSERT_TRUE(fetcher);
179 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
180
181 // Make the fetch fail due to an interrupted connection.
182 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
183 net::ERR_CONNECTION_RESET));
184 fetcher->delegate()->OnURLFetchComplete(fetcher);
185
186 // Verify that the fetch is no longer running.
187 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
188
189 // Verify that the callback is invoked with the correct error code.
190 owner_task_runner_->RunUntilIdle();
191 EXPECT_EQ(1, GetAndResetCallbackCount());
192 EXPECT_EQ(0, callback_job_index_);
193 EXPECT_EQ(ExternalPolicyDataFetcher::CONNECTION_INTERRUPTED,
194 callback_result_);
195 EXPECT_FALSE(callback_data_);
196 }
197
TEST_F(ExternalPolicyDataFetcherTest,NetworkError)198 TEST_F(ExternalPolicyDataFetcherTest, NetworkError) {
199 // Start a fetch job.
200 StartJob(0);
201
202 // Verify that the fetch has been started.
203 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
204 ASSERT_TRUE(fetcher);
205 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
206
207 // Make the fetch fail due to a network error.
208 fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
209 net::ERR_NETWORK_CHANGED));
210 fetcher->delegate()->OnURLFetchComplete(fetcher);
211
212 // Verify that the fetch is no longer running.
213 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
214
215 // Verify that the callback is invoked with the correct error code.
216 owner_task_runner_->RunUntilIdle();
217 EXPECT_EQ(1, GetAndResetCallbackCount());
218 EXPECT_EQ(0, callback_job_index_);
219 EXPECT_EQ(ExternalPolicyDataFetcher::NETWORK_ERROR, callback_result_);
220 EXPECT_FALSE(callback_data_);
221 }
222
TEST_F(ExternalPolicyDataFetcherTest,ServerError)223 TEST_F(ExternalPolicyDataFetcherTest, ServerError) {
224 // Start a fetch job.
225 StartJob(0);
226
227 // Verify that the fetch has been started.
228 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
229 ASSERT_TRUE(fetcher);
230 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
231
232 // Make the fetch fail with a server error.
233 fetcher->set_response_code(500);
234 fetcher->delegate()->OnURLFetchComplete(fetcher);
235
236 // Verify that the fetch is no longer running.
237 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
238
239 // Verify that the callback is invoked with the correct error code.
240 owner_task_runner_->RunUntilIdle();
241 EXPECT_EQ(1, GetAndResetCallbackCount());
242 EXPECT_EQ(0, callback_job_index_);
243 EXPECT_EQ(ExternalPolicyDataFetcher::SERVER_ERROR, callback_result_);
244 EXPECT_FALSE(callback_data_);
245 }
246
TEST_F(ExternalPolicyDataFetcherTest,ClientError)247 TEST_F(ExternalPolicyDataFetcherTest, ClientError) {
248 // Start a fetch job.
249 StartJob(0);
250
251 // Verify that the fetch has been started.
252 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
253 ASSERT_TRUE(fetcher);
254 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
255
256 // Make the fetch fail with a client error.
257 fetcher->set_response_code(400);
258 fetcher->delegate()->OnURLFetchComplete(fetcher);
259
260 // Verify that the fetch is no longer running.
261 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
262
263 // Verify that the callback is invoked with the correct error code.
264 owner_task_runner_->RunUntilIdle();
265 EXPECT_EQ(1, GetAndResetCallbackCount());
266 EXPECT_EQ(0, callback_job_index_);
267 EXPECT_EQ(ExternalPolicyDataFetcher::CLIENT_ERROR, callback_result_);
268 EXPECT_FALSE(callback_data_);
269 }
270
TEST_F(ExternalPolicyDataFetcherTest,HTTPError)271 TEST_F(ExternalPolicyDataFetcherTest, HTTPError) {
272 // Start a fetch job.
273 StartJob(0);
274
275 // Verify that the fetch has been started.
276 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
277 ASSERT_TRUE(fetcher);
278 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
279
280 // Make the fetch fail with an HTTP error.
281 fetcher->set_response_code(300);
282 fetcher->delegate()->OnURLFetchComplete(fetcher);
283
284 // Verify that the fetch is no longer running.
285 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
286
287 // Verify that the callback is invoked with the correct error code.
288 owner_task_runner_->RunUntilIdle();
289 EXPECT_EQ(1, GetAndResetCallbackCount());
290 EXPECT_EQ(0, callback_job_index_);
291 EXPECT_EQ(ExternalPolicyDataFetcher::HTTP_ERROR, callback_result_);
292 EXPECT_FALSE(callback_data_);
293 }
294
TEST_F(ExternalPolicyDataFetcherTest,Canceled)295 TEST_F(ExternalPolicyDataFetcherTest, Canceled) {
296 // Start a fetch job.
297 StartJob(0);
298
299 // Verify that the fetch has been started.
300 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
301 ASSERT_TRUE(fetcher);
302 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
303
304 // Cancel the fetch job.
305 CancelJob(0);
306 io_task_runner_->RunUntilIdle();
307
308 // Verify that the fetch is no longer running.
309 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
310
311 // Verify that the callback is not invoked.
312 owner_task_runner_->RunUntilIdle();
313 EXPECT_EQ(0, GetAndResetCallbackCount());
314 }
315
TEST_F(ExternalPolicyDataFetcherTest,SuccessfulCanceled)316 TEST_F(ExternalPolicyDataFetcherTest, SuccessfulCanceled) {
317 // Start a fetch job.
318 StartJob(0);
319
320 // Verify that the fetch has been started.
321 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
322 ASSERT_TRUE(fetcher);
323 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
324
325 // Complete the fetch.
326 fetcher->set_response_code(200);
327 fetcher->SetResponseString(kExternalPolicyDataPayload);
328 fetcher->delegate()->OnURLFetchComplete(fetcher);
329
330 // Verify that the fetch is no longer running.
331 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
332
333 // Cancel the fetch job before the successful fetch result has arrived from
334 // the backend.
335 CancelJob(0);
336
337 // Verify that the callback is not invoked.
338 owner_task_runner_->RunUntilIdle();
339 EXPECT_EQ(0, GetAndResetCallbackCount());
340 }
341
TEST_F(ExternalPolicyDataFetcherTest,ParallelJobs)342 TEST_F(ExternalPolicyDataFetcherTest, ParallelJobs) {
343 // Start two fetch jobs.
344 StartJob(0);
345 StartJob(1);
346
347 // Verify that the second fetch has been started.
348 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(1);
349 ASSERT_TRUE(fetcher);
350 EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());
351
352 // Verify that the first fetch has been started.
353 fetcher = fetcher_factory_.GetFetcherByID(0);
354 ASSERT_TRUE(fetcher);
355 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
356
357 // Complete the first fetch.
358 fetcher->set_response_code(200);
359 fetcher->SetResponseString(kExternalPolicyDataPayload);
360 fetcher->delegate()->OnURLFetchComplete(fetcher);
361
362 // Verify that the first fetch is no longer running.
363 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
364
365 // Verify that the callback is invoked with the retrieved data.
366 owner_task_runner_->RunUntilIdle();
367 EXPECT_EQ(1, GetAndResetCallbackCount());
368 EXPECT_EQ(0, callback_job_index_);
369 EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
370 ASSERT_TRUE(callback_data_);
371 EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
372
373 // Verify that the second fetch is still running.
374 fetcher = fetcher_factory_.GetFetcherByID(1);
375 ASSERT_TRUE(fetcher);
376 EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());
377
378 // Complete the second fetch.
379 fetcher->set_response_code(200);
380 fetcher->SetResponseString(kExternalPolicyDataPayload);
381 fetcher->delegate()->OnURLFetchComplete(fetcher);
382
383 // Verify that the second fetch is no longer running.
384 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));
385
386 // Verify that the callback is invoked with the retrieved data.
387 owner_task_runner_->RunUntilIdle();
388 EXPECT_EQ(1, GetAndResetCallbackCount());
389 EXPECT_EQ(1, callback_job_index_);
390 EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
391 ASSERT_TRUE(callback_data_);
392 EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
393 }
394
TEST_F(ExternalPolicyDataFetcherTest,ParallelJobsFinishingOutOfOrder)395 TEST_F(ExternalPolicyDataFetcherTest, ParallelJobsFinishingOutOfOrder) {
396 // Start two fetch jobs.
397 StartJob(0);
398 StartJob(1);
399
400 // Verify that the first fetch has been started.
401 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
402 ASSERT_TRUE(fetcher);
403 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
404
405 // Verify that the second fetch has been started.
406 fetcher = fetcher_factory_.GetFetcherByID(1);
407 ASSERT_TRUE(fetcher);
408 EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());
409
410 // Complete the second fetch.
411 fetcher->set_response_code(200);
412 fetcher->SetResponseString(kExternalPolicyDataPayload);
413 fetcher->delegate()->OnURLFetchComplete(fetcher);
414
415 // Verify that the second fetch is no longer running.
416 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));
417
418 // Verify that the callback is invoked with the retrieved data.
419 owner_task_runner_->RunUntilIdle();
420 EXPECT_EQ(1, GetAndResetCallbackCount());
421 EXPECT_EQ(1, callback_job_index_);
422 EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
423 ASSERT_TRUE(callback_data_);
424 EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
425
426 // Verify that the first fetch is still running.
427 fetcher = fetcher_factory_.GetFetcherByID(0);
428 ASSERT_TRUE(fetcher);
429 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
430
431 // Complete the first fetch.
432 fetcher->set_response_code(200);
433 fetcher->SetResponseString(kExternalPolicyDataPayload);
434 fetcher->delegate()->OnURLFetchComplete(fetcher);
435
436 // Verify that the first fetch is no longer running.
437 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
438
439 // Verify that the callback is invoked with the retrieved data.
440 owner_task_runner_->RunUntilIdle();
441 EXPECT_EQ(1, GetAndResetCallbackCount());
442 EXPECT_EQ(0, callback_job_index_);
443 EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
444 ASSERT_TRUE(callback_data_);
445 EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
446 }
447
TEST_F(ExternalPolicyDataFetcherTest,ParallelJobsWithCancel)448 TEST_F(ExternalPolicyDataFetcherTest, ParallelJobsWithCancel) {
449 // Start two fetch jobs.
450 StartJob(0);
451 StartJob(1);
452
453 // Verify that the second fetch has been started.
454 net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(1);
455 ASSERT_TRUE(fetcher);
456 EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());
457
458 // Verify that the first fetch has been started.
459 fetcher = fetcher_factory_.GetFetcherByID(0);
460 ASSERT_TRUE(fetcher);
461 EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());
462
463 // Cancel the first fetch job.
464 CancelJob(0);
465 io_task_runner_->RunUntilIdle();
466
467 // Verify that the first fetch is no longer running.
468 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));
469
470 // Verify that the callback is not invoked.
471 owner_task_runner_->RunUntilIdle();
472 EXPECT_EQ(0, GetAndResetCallbackCount());
473
474 // Verify that the second fetch is still running.
475 fetcher = fetcher_factory_.GetFetcherByID(1);
476 ASSERT_TRUE(fetcher);
477 EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());
478
479 // Complete the second fetch.
480 fetcher->set_response_code(200);
481 fetcher->SetResponseString(kExternalPolicyDataPayload);
482 fetcher->delegate()->OnURLFetchComplete(fetcher);
483
484 // Verify that the second fetch is no longer running.
485 EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));
486
487 // Verify that the callback is invoked with the retrieved data.
488 owner_task_runner_->RunUntilIdle();
489 EXPECT_EQ(1, GetAndResetCallbackCount());
490 EXPECT_EQ(1, callback_job_index_);
491 EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
492 ASSERT_TRUE(callback_data_);
493 EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
494 }
495
496 } // namespace policy
497