chrome/browser/policy/cloud/external_policy_data_fetcher_unittest.cc - platform/external/chromium_org - Git at Google

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/policy/cloud/external_policy_data_fetcher.h"

 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/sequenced_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace policy {

 namespace {

 const char* kExternalPolicyDataURLs[] = {
     "http://localhost/data_1",
     "http://localhost/data_2"
 };

 const int64 kExternalPolicyDataMaxSize = 5 * 1024 * 1024;  // 5 MB.

 const char* kExternalPolicyDataPayload = "External policy data";

 }  // namespace

 class ExternalPolicyDataFetcherTest : public testing::Test {
  protected:
   ExternalPolicyDataFetcherTest();
   virtual ~ExternalPolicyDataFetcherTest();

   // testing::Test:
   virtual void SetUp() OVERRIDE;

   void StartJob(int index);
   void CancelJob(int index);

   void OnJobFinished(int job_index,
                      ExternalPolicyDataFetcher::Result result,
                      scoped_ptr<std::string> data);
   int GetAndResetCallbackCount();

   net::TestURLFetcherFactory fetcher_factory_;
   scoped_refptr<base::TestSimpleTaskRunner> owner_task_runner_;
   scoped_refptr<base::TestSimpleTaskRunner> io_task_runner_;
   scoped_ptr<ExternalPolicyDataFetcherBackend> fetcher_backend_;
   scoped_ptr<ExternalPolicyDataFetcher> fetcher_;

   std::map<int, ExternalPolicyDataFetcher::Job*> jobs_;  // Not owned.

   int callback_count_;
   int callback_job_index_;
   ExternalPolicyDataFetcher::Result callback_result_;
   scoped_ptr<std::string> callback_data_;

   DISALLOW_COPY_AND_ASSIGN(ExternalPolicyDataFetcherTest);
 };

 ExternalPolicyDataFetcherTest::ExternalPolicyDataFetcherTest()
     : callback_count_(0) {
 }

 ExternalPolicyDataFetcherTest::~ExternalPolicyDataFetcherTest() {
 }

 void ExternalPolicyDataFetcherTest::SetUp() {
   fetcher_factory_.set_remove_fetcher_on_delete(true);
   io_task_runner_ = new base::TestSimpleTaskRunner();
   owner_task_runner_ = new base::TestSimpleTaskRunner();
   fetcher_backend_.reset(new ExternalPolicyDataFetcherBackend(
       io_task_runner_,
       scoped_refptr<net::URLRequestContextGetter>()));
   fetcher_.reset(
       fetcher_backend_->CreateFrontend(owner_task_runner_).release());
 }

 void ExternalPolicyDataFetcherTest::StartJob(int index) {
   jobs_[index] = fetcher_->StartJob(
       GURL(kExternalPolicyDataURLs[index]),
       kExternalPolicyDataMaxSize,
       base::Bind(&ExternalPolicyDataFetcherTest::OnJobFinished,
                  base::Unretained(this), index));
   io_task_runner_->RunUntilIdle();
 }

 void ExternalPolicyDataFetcherTest::CancelJob(int index) {
   std::map<int, ExternalPolicyDataFetcher::Job*>::iterator it =
       jobs_.find(index);
   ASSERT_TRUE(it != jobs_.end());
   ExternalPolicyDataFetcher::Job* job = it->second;
   jobs_.erase(it);
   fetcher_->CancelJob(job);
 }

 void ExternalPolicyDataFetcherTest::OnJobFinished(
     int job_index,
     ExternalPolicyDataFetcher::Result result,
     scoped_ptr<std::string> data) {
   ++callback_count_;
   callback_job_index_ = job_index;
   callback_result_ = result;
   callback_data_.reset(data.release());
   jobs_.erase(job_index);
 }

 int ExternalPolicyDataFetcherTest::GetAndResetCallbackCount() {
   const int callback_count = callback_count_;
   callback_count_ = 0;
   return callback_count;
 }

 TEST_F(ExternalPolicyDataFetcherTest, Success) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Complete the fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the retrieved data.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
   ASSERT_TRUE(callback_data_);
   EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, MaxSizeExceeded) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Indicate that the data size will exceed maximum allowed.
   fetcher->delegate()->OnURLFetchDownloadProgress(
       fetcher,
       kExternalPolicyDataMaxSize + 1,
       -1);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the correct error code.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED, callback_result_);
   EXPECT_FALSE(callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, ConnectionInterrupted) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Make the fetch fail due to an interrupted connection.
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                             net::ERR_CONNECTION_RESET));
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the correct error code.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::CONNECTION_INTERRUPTED,
             callback_result_);
   EXPECT_FALSE(callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, NetworkError) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Make the fetch fail due to a network error.
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                             net::ERR_NETWORK_CHANGED));
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the correct error code.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::NETWORK_ERROR, callback_result_);
   EXPECT_FALSE(callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, ServerError) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Make the fetch fail with a server error.
   fetcher->set_response_code(500);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the correct error code.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SERVER_ERROR, callback_result_);
   EXPECT_FALSE(callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, ClientError) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Make the fetch fail with a client error.
   fetcher->set_response_code(400);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the correct error code.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::CLIENT_ERROR, callback_result_);
   EXPECT_FALSE(callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, HTTPError) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Make the fetch fail with an HTTP error.
   fetcher->set_response_code(300);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the correct error code.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::HTTP_ERROR, callback_result_);
   EXPECT_FALSE(callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, Canceled) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Cancel the fetch job.
   CancelJob(0);
   io_task_runner_->RunUntilIdle();

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is not invoked.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(0, GetAndResetCallbackCount());
 }

 TEST_F(ExternalPolicyDataFetcherTest, SuccessfulCanceled) {
   // Start a fetch job.
   StartJob(0);

   // Verify that the fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Complete the fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Cancel the fetch job before the successful fetch result has arrived from
   // the backend.
   CancelJob(0);

   // Verify that the callback is not invoked.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(0, GetAndResetCallbackCount());
 }

 TEST_F(ExternalPolicyDataFetcherTest, ParallelJobs) {
   // Start two fetch jobs.
   StartJob(0);
   StartJob(1);

   // Verify that the second fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(1);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

   // Verify that the first fetch has been started.
   fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Complete the first fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the first fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the retrieved data.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
   ASSERT_TRUE(callback_data_);
   EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);

   // Verify that the second fetch is still running.
   fetcher = fetcher_factory_.GetFetcherByID(1);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

   // Complete the second fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the second fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));

   // Verify that the callback is invoked with the retrieved data.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(1, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
   ASSERT_TRUE(callback_data_);
   EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, ParallelJobsFinishingOutOfOrder) {
   // Start two fetch jobs.
   StartJob(0);
   StartJob(1);

   // Verify that the first fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Verify that the second fetch has been started.
   fetcher = fetcher_factory_.GetFetcherByID(1);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

   // Complete the second fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the second fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));

   // Verify that the callback is invoked with the retrieved data.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(1, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
   ASSERT_TRUE(callback_data_);
   EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);

   // Verify that the first fetch is still running.
   fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Complete the first fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the first fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is invoked with the retrieved data.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(0, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
   ASSERT_TRUE(callback_data_);
   EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
 }

 TEST_F(ExternalPolicyDataFetcherTest, ParallelJobsWithCancel) {
   // Start two fetch jobs.
   StartJob(0);
   StartJob(1);

   // Verify that the second fetch has been started.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(1);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

   // Verify that the first fetch has been started.
   fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

   // Cancel the first fetch job.
   CancelJob(0);
   io_task_runner_->RunUntilIdle();

   // Verify that the first fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

   // Verify that the callback is not invoked.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(0, GetAndResetCallbackCount());

   // Verify that the second fetch is still running.
   fetcher = fetcher_factory_.GetFetcherByID(1);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

   // Complete the second fetch.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kExternalPolicyDataPayload);
   fetcher->delegate()->OnURLFetchComplete(fetcher);

   // Verify that the second fetch is no longer running.
   EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));

   // Verify that the callback is invoked with the retrieved data.
   owner_task_runner_->RunUntilIdle();
   EXPECT_EQ(1, GetAndResetCallbackCount());
   EXPECT_EQ(1, callback_job_index_);
   EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
   ASSERT_TRUE(callback_data_);
   EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
 }

 }  // namespace policy
	// Copyright 2013 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/policy/cloud/external_policy_data_fetcher.h"

	#include "base/bind.h"
	#include "base/bind_helpers.h"
	#include "base/compiler_specific.h"
	#include "base/sequenced_task_runner.h"
	#include "base/test/test_simple_task_runner.h"
	#include "net/base/net_errors.h"
	#include "net/url_request/test_url_fetcher_factory.h"
	#include "net/url_request/url_fetcher.h"
	#include "net/url_request/url_fetcher_delegate.h"
	#include "net/url_request/url_request_context_getter.h"
	#include "net/url_request/url_request_status.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace policy {

	namespace {

	const char* kExternalPolicyDataURLs[] = {
	"http://localhost/data_1",
	"http://localhost/data_2"
	};

	const int64 kExternalPolicyDataMaxSize = 5 * 1024 * 1024; // 5 MB.

	const char* kExternalPolicyDataPayload = "External policy data";

	} // namespace

	class ExternalPolicyDataFetcherTest : public testing::Test {
	protected:
	ExternalPolicyDataFetcherTest();
	virtual ~ExternalPolicyDataFetcherTest();

	// testing::Test:
	virtual void SetUp() OVERRIDE;

	void StartJob(int index);
	void CancelJob(int index);

	void OnJobFinished(int job_index,
	ExternalPolicyDataFetcher::Result result,
	scoped_ptr<std::string> data);
	int GetAndResetCallbackCount();

	net::TestURLFetcherFactory fetcher_factory_;
	scoped_refptr<base::TestSimpleTaskRunner> owner_task_runner_;
	scoped_refptr<base::TestSimpleTaskRunner> io_task_runner_;
	scoped_ptr<ExternalPolicyDataFetcherBackend> fetcher_backend_;
	scoped_ptr<ExternalPolicyDataFetcher> fetcher_;

	std::map<int, ExternalPolicyDataFetcher::Job*> jobs_; // Not owned.

	int callback_count_;
	int callback_job_index_;
	ExternalPolicyDataFetcher::Result callback_result_;
	scoped_ptr<std::string> callback_data_;

	DISALLOW_COPY_AND_ASSIGN(ExternalPolicyDataFetcherTest);
	};

	ExternalPolicyDataFetcherTest::ExternalPolicyDataFetcherTest()
	: callback_count_(0) {
	}

	ExternalPolicyDataFetcherTest::~ExternalPolicyDataFetcherTest() {
	}

	void ExternalPolicyDataFetcherTest::SetUp() {
	fetcher_factory_.set_remove_fetcher_on_delete(true);
	io_task_runner_ = new base::TestSimpleTaskRunner();
	owner_task_runner_ = new base::TestSimpleTaskRunner();
	fetcher_backend_.reset(new ExternalPolicyDataFetcherBackend(
	io_task_runner_,
	scoped_refptr<net::URLRequestContextGetter>()));
	fetcher_.reset(
	fetcher_backend_->CreateFrontend(owner_task_runner_).release());
	}

	void ExternalPolicyDataFetcherTest::StartJob(int index) {
	jobs_[index] = fetcher_->StartJob(
	GURL(kExternalPolicyDataURLs[index]),
	kExternalPolicyDataMaxSize,
	base::Bind(&ExternalPolicyDataFetcherTest::OnJobFinished,
	base::Unretained(this), index));
	io_task_runner_->RunUntilIdle();
	}

	void ExternalPolicyDataFetcherTest::CancelJob(int index) {
	std::map<int, ExternalPolicyDataFetcher::Job*>::iterator it =
	jobs_.find(index);
	ASSERT_TRUE(it != jobs_.end());
	ExternalPolicyDataFetcher::Job* job = it->second;
	jobs_.erase(it);
	fetcher_->CancelJob(job);
	}

	void ExternalPolicyDataFetcherTest::OnJobFinished(
	int job_index,
	ExternalPolicyDataFetcher::Result result,
	scoped_ptr<std::string> data) {
	++callback_count_;
	callback_job_index_ = job_index;
	callback_result_ = result;
	callback_data_.reset(data.release());
	jobs_.erase(job_index);
	}

	int ExternalPolicyDataFetcherTest::GetAndResetCallbackCount() {
	const int callback_count = callback_count_;
	callback_count_ = 0;
	return callback_count;
	}

	TEST_F(ExternalPolicyDataFetcherTest, Success) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Complete the fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the retrieved data.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
	ASSERT_TRUE(callback_data_);
	EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, MaxSizeExceeded) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Indicate that the data size will exceed maximum allowed.
	fetcher->delegate()->OnURLFetchDownloadProgress(
	fetcher,
	kExternalPolicyDataMaxSize + 1,
	-1);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the correct error code.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED, callback_result_);
	EXPECT_FALSE(callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, ConnectionInterrupted) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Make the fetch fail due to an interrupted connection.
	fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
	net::ERR_CONNECTION_RESET));
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the correct error code.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::CONNECTION_INTERRUPTED,
	callback_result_);
	EXPECT_FALSE(callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, NetworkError) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Make the fetch fail due to a network error.
	fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
	net::ERR_NETWORK_CHANGED));
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the correct error code.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::NETWORK_ERROR, callback_result_);
	EXPECT_FALSE(callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, ServerError) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Make the fetch fail with a server error.
	fetcher->set_response_code(500);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the correct error code.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SERVER_ERROR, callback_result_);
	EXPECT_FALSE(callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, ClientError) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Make the fetch fail with a client error.
	fetcher->set_response_code(400);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the correct error code.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::CLIENT_ERROR, callback_result_);
	EXPECT_FALSE(callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, HTTPError) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Make the fetch fail with an HTTP error.
	fetcher->set_response_code(300);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the correct error code.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::HTTP_ERROR, callback_result_);
	EXPECT_FALSE(callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, Canceled) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Cancel the fetch job.
	CancelJob(0);
	io_task_runner_->RunUntilIdle();

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is not invoked.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(0, GetAndResetCallbackCount());
	}

	TEST_F(ExternalPolicyDataFetcherTest, SuccessfulCanceled) {
	// Start a fetch job.
	StartJob(0);

	// Verify that the fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Complete the fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Cancel the fetch job before the successful fetch result has arrived from
	// the backend.
	CancelJob(0);

	// Verify that the callback is not invoked.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(0, GetAndResetCallbackCount());
	}

	TEST_F(ExternalPolicyDataFetcherTest, ParallelJobs) {
	// Start two fetch jobs.
	StartJob(0);
	StartJob(1);

	// Verify that the second fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(1);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

	// Verify that the first fetch has been started.
	fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Complete the first fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the first fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the retrieved data.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
	ASSERT_TRUE(callback_data_);
	EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);

	// Verify that the second fetch is still running.
	fetcher = fetcher_factory_.GetFetcherByID(1);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

	// Complete the second fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the second fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));

	// Verify that the callback is invoked with the retrieved data.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(1, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
	ASSERT_TRUE(callback_data_);
	EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, ParallelJobsFinishingOutOfOrder) {
	// Start two fetch jobs.
	StartJob(0);
	StartJob(1);

	// Verify that the first fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Verify that the second fetch has been started.
	fetcher = fetcher_factory_.GetFetcherByID(1);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

	// Complete the second fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the second fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));

	// Verify that the callback is invoked with the retrieved data.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(1, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
	ASSERT_TRUE(callback_data_);
	EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);

	// Verify that the first fetch is still running.
	fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Complete the first fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the first fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is invoked with the retrieved data.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(0, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
	ASSERT_TRUE(callback_data_);
	EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
	}

	TEST_F(ExternalPolicyDataFetcherTest, ParallelJobsWithCancel) {
	// Start two fetch jobs.
	StartJob(0);
	StartJob(1);

	// Verify that the second fetch has been started.
	net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(1);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

	// Verify that the first fetch has been started.
	fetcher = fetcher_factory_.GetFetcherByID(0);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[0]), fetcher->GetOriginalURL());

	// Cancel the first fetch job.
	CancelJob(0);
	io_task_runner_->RunUntilIdle();

	// Verify that the first fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(0));

	// Verify that the callback is not invoked.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(0, GetAndResetCallbackCount());

	// Verify that the second fetch is still running.
	fetcher = fetcher_factory_.GetFetcherByID(1);
	ASSERT_TRUE(fetcher);
	EXPECT_EQ(GURL(kExternalPolicyDataURLs[1]), fetcher->GetOriginalURL());

	// Complete the second fetch.
	fetcher->set_response_code(200);
	fetcher->SetResponseString(kExternalPolicyDataPayload);
	fetcher->delegate()->OnURLFetchComplete(fetcher);

	// Verify that the second fetch is no longer running.
	EXPECT_FALSE(fetcher_factory_.GetFetcherByID(1));

	// Verify that the callback is invoked with the retrieved data.
	owner_task_runner_->RunUntilIdle();
	EXPECT_EQ(1, GetAndResetCallbackCount());
	EXPECT_EQ(1, callback_job_index_);
	EXPECT_EQ(ExternalPolicyDataFetcher::SUCCESS, callback_result_);
	ASSERT_TRUE(callback_data_);
	EXPECT_EQ(kExternalPolicyDataPayload, *callback_data_);
	}

	} // namespace policy