[sync] Allow FakeURLFetcher to return an arbitrary URLRequestStatus

chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc

 // 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/chromeos/policy/cloud_external_data_manager_base.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/chromeos/policy/cloud_external_data_store.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/resource_cache.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/policy/policy_types.h"
 #include "net/http/http_status_code.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_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace policy {
 
 namespace {
 
 // A string policy.
@@ skipping 236 matching lines @@
   EXPECT_TRUE(callback_data_.find(2) != callback_data_.end());
   EXPECT_FALSE(callback_data_[2]);
   ResetCallbackData();
 }
 
 // Verifies that external data referenced by a policy is downloaded and cached
 // when first requested. Subsequent requests are served from the cache without
 // further download attempts.
 TEST_F(CloudExternalDataManagerBaseTest, DownloadAndCache) {
   // Serve valid external data for |k10BytePolicy|.
-  SetFakeResponse(k10BytePolicyURL, k10ByteData, net::HTTP_OK);
+  SetFakeResponse(k10BytePolicyURL, k10ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
   external_data_manager_->Connect(request_content_getter_);
 
   // Retrieve external data for |k10BytePolicy|. Verify that a download happens
   // and the callback is invoked with the downloaded data.
   external_data_manager_->Fetch(k10BytePolicy, ConstructFetchCallback(0));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   ASSERT_TRUE(callback_data_[0]);
   EXPECT_EQ(k10ByteData, *callback_data_[0]);
   ResetCallbackData();
@@ skipping 34 matching lines @@
                                      resource_cache_.get()).Load(
       k10BytePolicy, base::SHA1HashString(k10ByteData), 10, &data));
   EXPECT_EQ(k10ByteData, data);
 }
 
 // Verifies that a request to download and cache all external data referenced by
 // policies is carried out correctly. Subsequent requests for the data are
 // served from the cache without further download attempts.
 TEST_F(CloudExternalDataManagerBaseTest, DownloadAndCacheAll) {
   // Serve valid external data for |k10BytePolicy| and |k20BytePolicy|.
-  SetFakeResponse(k10BytePolicyURL, k10ByteData, net::HTTP_OK);
-  SetFakeResponse(k20BytePolicyURL, k20ByteData, net::HTTP_OK);
+  SetFakeResponse(k10BytePolicyURL, k10ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
+  SetFakeResponse(k20BytePolicyURL, k20ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
   external_data_manager_->Connect(request_content_getter_);
 
   // Request that external data referenced by all policies be downloaded.
   FetchAll();
   base::RunLoop().RunUntilIdle();
 
   // Stop serving external data for |k10BytePolicy| and |k20BytePolicy|.
   fetcher_factory_.ClearFakeResponses();
 
   // Retrieve external data for |k10BytePolicy| and |k20BytePolicy|. Verify that
@@ skipping 47 matching lines @@
 TEST_F(CloudExternalDataManagerBaseTest, DownloadAfterConnect) {
   // Attempt to retrieve external data for |k10BytePolicy|. Verify that the
   // callback is not invoked as the request remains pending.
   external_data_manager_->Fetch(k10BytePolicy, ConstructFetchCallback(0));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_data_.empty());
   ResetCallbackData();
 
   // Serve valid external data for |k10BytePolicy| and allow the
   // external_data_manager_ to perform downloads.
-  SetFakeResponse(k10BytePolicyURL, k10ByteData, net::HTTP_OK);
+  SetFakeResponse(k10BytePolicyURL, k10ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
   external_data_manager_->Connect(request_content_getter_);
 
   // Verify that a download happens and the callback is invoked with the
   // downloaded data.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   ASSERT_TRUE(callback_data_[0]);
   EXPECT_EQ(k10ByteData, *callback_data_[0]);
   ResetCallbackData();
 }
 
 // Verifies that when the external data referenced by a policy is not present in
 // the cache and cannot be downloaded at this time, a request to retrieve the
 // data is enqueued to be retried later.
 TEST_F(CloudExternalDataManagerBaseTest, DownloadError) {
   // Make attempts to download the external data for |k20BytePolicy| fail with
   // an error.
   SetFakeResponse(k20BytePolicyURL, std::string(),
-                  net::HTTP_INTERNAL_SERVER_ERROR);
+                  net::HTTP_INTERNAL_SERVER_ERROR,
+                  net::URLRequestStatus::FAILED);
   external_data_manager_->Connect(request_content_getter_);
 
   // Attempt to retrieve external data for |k20BytePolicy|. Verify that the
   // callback is not invoked as the download attempt fails and the request
   // remains pending.
   external_data_manager_->Fetch(k20BytePolicy, ConstructFetchCallback(0));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_data_.empty());
   ResetCallbackData();
 
@@ skipping 14 matching lines @@
 
   // Modify the external data reference for |k20BytePolicy|, allowing the
   // download to be retried immediately.
   SetExternalDataReference(
       k20BytePolicy,
       ConstructMetadata(k20BytePolicyURL, base::SHA1HashString(k20ByteData)));
   cloud_policy_store_.NotifyStoreLoaded();
 
   // Serve external data for |k20BytePolicy| that does not match the hash
   // specified in its current external data reference.
-  SetFakeResponse(k20BytePolicyURL, k10ByteData, net::HTTP_OK);
+  SetFakeResponse(k20BytePolicyURL, k10ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
   // Attempt to retrieve external data for |k20BytePolicy| again. Verify that
   // no callback is invoked still as the downloaded succeeds but returns data
   // that does not match the external data reference.
   external_data_manager_->Fetch(k20BytePolicy, ConstructFetchCallback(2));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_data_.empty());
   ResetCallbackData();
 
   // Modify the external data reference for |k20BytePolicy|, allowing the
@@ skipping 148 matching lines @@
   // Store external data for |k20BytePolicy| that is corrupted and does not
   // match the expected hash.
   EXPECT_TRUE(cache->Store(k20BytePolicy,
                            base::SHA1HashString(k20ByteData),
                            k10ByteData));
   cache.reset();
 
   SetUpExternalDataManager();
   // Serve external data for |k10BytePolicy| that exceeds the maximal external
   // data size allowed for that policy.
-  SetFakeResponse(k10BytePolicyURL, k20ByteData, net::HTTP_OK);
+  SetFakeResponse(k10BytePolicyURL, k20ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
   external_data_manager_->Connect(request_content_getter_);
 
   // Modify the external data reference for |k10BytePolicy| to match the
   // external data being served.
   SetExternalDataReference(
       k10BytePolicy,
       ConstructMetadata(k10BytePolicyURL, base::SHA1HashString(k20ByteData)));
   cloud_policy_store_.NotifyStoreLoaded();
 
   // Retrieve external data for |k10BytePolicy|. Verify that the callback is
   // not invoked as the cached and downloaded external data exceed the maximal
   // size allowed for this policy and the request remains pending.
   external_data_manager_->Fetch(k10BytePolicy, ConstructFetchCallback(0));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_data_.empty());
   ResetCallbackData();
 
   // Serve valid external data for |k20BytePolicy|.
-  SetFakeResponse(k20BytePolicyURL, k20ByteData, net::HTTP_OK);
+  SetFakeResponse(k20BytePolicyURL, k20ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
   // Retrieve external data for |k20BytePolicy|. Verify that the callback is
   // invoked with the valid downloaded data, not the invalid data in the cache.
   external_data_manager_->Fetch(k20BytePolicy, ConstructFetchCallback(1));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   ASSERT_TRUE(callback_data_[1]);
   EXPECT_EQ(k20ByteData, *callback_data_[1]);
   ResetCallbackData();
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(k20ByteData, data);
 }
 
 // Verifies that when the external data reference for a policy changes while a
 // download of the external data for that policy is pending, the download is
 // immediately retried using the new reference.
 TEST_F(CloudExternalDataManagerBaseTest, PolicyChangeWhileDownloadPending) {
   // Make attempts to download the external data for |k10BytePolicy| and
   // |k20BytePolicy| fail with an error.
   SetFakeResponse(k10BytePolicyURL, std::string(),
-                  net::HTTP_INTERNAL_SERVER_ERROR);
+                  net::HTTP_INTERNAL_SERVER_ERROR,
+                  net::URLRequestStatus::FAILED);
   SetFakeResponse(k20BytePolicyURL, std::string(),
-                  net::HTTP_INTERNAL_SERVER_ERROR);
+                  net::HTTP_INTERNAL_SERVER_ERROR,
+                  net::URLRequestStatus::FAILED);
   external_data_manager_->Connect(request_content_getter_);
 
   // Attempt to retrieve external data for |k10BytePolicy| and |k20BytePolicy|.
   // Verify that no callbacks are invoked as the download attempts fail and the
   // requests remain pending.
   external_data_manager_->Fetch(k10BytePolicy, ConstructFetchCallback(0));
   external_data_manager_->Fetch(k20BytePolicy, ConstructFetchCallback(1));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_data_.empty());
   ResetCallbackData();
 
   // Modify the external data reference for |k10BytePolicy| to be invalid.
   // Verify that the callback is invoked as the policy no longer has a valid
   // external data reference.
   cloud_policy_store_.policy_map_.Erase(k10BytePolicy);
   cloud_policy_store_.NotifyStoreLoaded();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   EXPECT_TRUE(callback_data_.find(0) != callback_data_.end());
   EXPECT_FALSE(callback_data_[0]);
   ResetCallbackData();
 
   // Serve valid external data for |k20BytePolicy|.
   fetcher_factory_.ClearFakeResponses();
-  SetFakeResponse(k20BytePolicyURL, k10ByteData, net::HTTP_OK);
+  SetFakeResponse(k20BytePolicyURL, k10ByteData, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
 
   // Modify the external data reference for |k20BytePolicy| to match the
   // external data now being served. Verify that the callback is invoked with
   // the downloaded data.
   SetExternalDataReference(
       k20BytePolicy,
       ConstructMetadata(k20BytePolicyURL, base::SHA1HashString(k10ByteData)));
   cloud_policy_store_.NotifyStoreLoaded();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   ASSERT_TRUE(callback_data_[1]);
   EXPECT_EQ(k10ByteData, *callback_data_[1]);
   ResetCallbackData();
 }
 
 }  // namespace policy