[sync] Allow FakeURLFetcher to return arbitrary HTTP response codes

chrome/service/cloud_print/printer_job_handler_unittest.cc

 // Copyright (c) 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 "base/files/file_path.h"
 #include "base/md5.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/cloud_print_token_store.h"
 #include "chrome/service/cloud_print/print_system.h"
 #include "chrome/service/cloud_print/printer_job_handler.h"
 #include "net/http/http_response_headers.h"
+#include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "printing/backend/print_backend.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Exactly;
 using ::testing::Invoke;
@@ skipping 246 matching lines @@
 // This class handles the callback from FakeURLFetcher
 // It is a separate class because callback methods must be
 // on RefCounted classes
 
 class TestURLFetcherCallback {
  public:
   scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* d,
       const std::string& response_data,
-      bool success) {
+      net::HttpStatusCode response_code) {
     scoped_ptr<net::FakeURLFetcher> fetcher(
-        new net::FakeURLFetcher(url, d, response_data, success));
+        new net::FakeURLFetcher(url, d, response_data, response_code));
     OnRequestCreate(url, fetcher.get());
     return fetcher.Pass();
   }
   MOCK_METHOD2(OnRequestCreate,
                void(const GURL&, net::FakeURLFetcher*));
 };
 
 
 class MockPrinterJobHandlerDelegate
     : public PrinterJobHandler::Delegate {
@@ skipping 193 matching lines @@
       .WillByDefault(Invoke(this, &PrinterJobHandlerTest::GetPrinterInfo));
 
   ON_CALL(*print_system_.get(), GetPrinterCapsAndDefaults(_, _))
       .WillByDefault(Invoke(this, &PrinterJobHandlerTest::SendCapsAndDefaults));
 
   CloudPrintURLFetcher::set_factory(&cloud_print_factory_);
 }
 
 void PrinterJobHandlerTest::MakeJobFetchReturnNoJobs() {
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
-                           JobListResponse(0), true);
+                           JobListResponse(0), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
-                           JobListResponse(0), true);
+                           JobListResponse(0), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonRetry),
-                           JobListResponse(0), true);
+                           JobListResponse(0), net::HTTP_OK);
 }
 
 void PrinterJobHandlerTest::MessageLoopQuitNowHelper(
     base::MessageLoop* message_loop) {
   message_loop->QuitWhenIdle();
 }
 
 void PrinterJobHandlerTest::MessageLoopQuitSoonHelper(
     base::MessageLoop* message_loop) {
   message_loop->message_loop_proxy()->PostTask(
@@ skipping 21 matching lines @@
 void PrinterJobHandlerTest::AddMimeHeader(const GURL& url,
                                           net::FakeURLFetcher* fetcher) {
   scoped_refptr<net::HttpResponseHeaders> download_headers =
       new net::HttpResponseHeaders(kExampleJobDownloadResponseHeaders);
   fetcher->set_response_headers(download_headers);
 }
 
 
 void PrinterJobHandlerTest::SetUpJobSuccessTest(int job_num) {
   factory_.SetFakeResponse(TicketURI(job_num),
-                           kExamplePrintTicket, true);
+                           kExamplePrintTicket, net::HTTP_OK);
   factory_.SetFakeResponse(DownloadURI(job_num),
-                           kExamplePrintData, true);
+                           kExamplePrintData, net::HTTP_OK);
 
   factory_.SetFakeResponse(DoneURI(job_num),
                            StatusResponse(job_num, "DONE"),
-                           true);
+                           net::HTTP_OK);
   factory_.SetFakeResponse(InProgressURI(job_num),
                            StatusResponse(job_num, "IN_PROGRESS"),
-                           true);
+                           net::HTTP_OK);
 
   // The times requirement is relaxed for the ticket URI
   // in order to accommodate TicketDownloadFailureTest
   EXPECT_CALL(url_callback_, OnRequestCreate(TicketURI(job_num), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_, OnRequestCreate(DownloadURI(job_num), _))
       .Times(Exactly(1))
       .WillOnce(Invoke(this, &PrinterJobHandlerTest::AddMimeHeader));
 
@@ skipping 83 matching lines @@
 
   ON_CALL(*this, ValidatePrintTicket(_, _)).
       WillByDefault(Return(true));
 };
 
 // This test simulates an end-to-end printing of a document
 // but tests only non-failure cases.
 // Disabled - http://crbug.com/184245
 TEST_F(PrinterJobHandlerTest, DISABLED_HappyPathTest) {
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
-                           JobListResponse(1), true);
+                           JobListResponse(1), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonQueryMore),
-                           JobListResponse(0), true);
+                           JobListResponse(0), net::HTTP_OK);
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(Exactly(1));
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonQueryMore), _))
       .Times(Exactly(1));
 
   SetUpJobSuccessTest(1);
   BeginTest(20);
 }
 
 TEST_F(PrinterJobHandlerTest, TicketDownloadFailureTest) {
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
-                           JobListResponse(2), true);
+                           JobListResponse(2), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
-                           JobListResponse(2), true);
+                           JobListResponse(2), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonQueryMore),
-                           JobListResponse(0), true);
-  factory_.SetFakeResponse(TicketURI(1), std::string(), false);
+                           JobListResponse(0), net::HTTP_OK);
+  factory_.SetFakeResponse(TicketURI(1), std::string(),
+                           net::HTTP_INTERNAL_SERVER_ERROR);
 
   EXPECT_CALL(url_callback_, OnRequestCreate(TicketURI(1), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonQueryMore), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonFailure), _))
       .Times(AtLeast(1));
 
   SetUpJobSuccessTest(2);
   BeginTest(20);
 }
 
 // TODO(noamsml): Figure out how to make this test not take 1 second and
 // re-enable it
 TEST_F(PrinterJobHandlerTest, DISABLED_ManyFailureTest) {
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
-                           JobListResponse(1), true);
+                           JobListResponse(1), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
-                           JobListResponse(1), true);
+                           JobListResponse(1), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonRetry),
-                           JobListResponse(1), true);
+                           JobListResponse(1), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonQueryMore),
-                           JobListResponse(0), true);
+                           JobListResponse(0), net::HTTP_OK);
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonQueryMore), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonFailure), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonRetry), _))
       .Times(AtLeast(1));
 
   SetUpJobSuccessTest(1);
 
-  factory_.SetFakeResponse(TicketURI(1), std::string(), false);
+  factory_.SetFakeResponse(TicketURI(1),
+                           std::string(),
+                           net::HTTP_INTERNAL_SERVER_ERROR);
 
   loop_.PostDelayedTask(FROM_HERE,
                         base::Bind(&net::FakeURLFetcherFactory::SetFakeResponse,
                                    base::Unretained(&factory_),
                                    TicketURI(1),
                                    kExamplePrintTicket,
-                                   true),
+                                   net::HTTP_OK),
                         base::TimeDelta::FromSeconds(1));
 
 
   BeginTest(5);
 }
 
 
 // TODO(noamsml): Figure out how to make this test not take ~64-~2048 (depending
 // constant values) seconds and re-enable it
 TEST_F(PrinterJobHandlerTest, DISABLED_CompleteFailureTest) {
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
-                           JobListResponse(1), true);
+                           JobListResponse(1), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
-                           JobListResponse(1), true);
+                           JobListResponse(1), net::HTTP_OK);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonRetry),
-                           JobListResponse(1), true);
-  factory_.SetFakeResponse(ErrorURI(1), StatusResponse(1, "ERROR"), true);
-  factory_.SetFakeResponse(TicketURI(1), std::string(), false);
+                           JobListResponse(1), net::HTTP_OK);
+  factory_.SetFakeResponse(ErrorURI(1), StatusResponse(1, "ERROR"),
+                           net::HTTP_OK);
+  factory_.SetFakeResponse(TicketURI(1), std::string(),
+                           net::HTTP_INTERNAL_SERVER_ERROR);
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonFailure), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
               OnRequestCreate(JobListURI(kJobFetchReasonRetry), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_, OnRequestCreate(ErrorURI(1), _))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(
           this, &PrinterJobHandlerTest::MakeJobFetchReturnNoJobs));
 
   EXPECT_CALL(url_callback_, OnRequestCreate(TicketURI(1), _))
       .Times(AtLeast(kNumRetriesBeforeAbandonJob));
 
   BeginTest(70);
 }
 
 }  // namespace cloud_print