Consolidate TestURLFetcherFactory::SetFakeResponse

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/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::Sequence;
+using ::testing::Invoke;
+using ::testing::InvokeWithoutArgs;
+using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
-using ::testing::DoAll;
+using ::testing::Sequence;
+using ::testing::SetArgPointee;
+using ::testing::StrictMock;
 using ::testing::_;
-using ::testing::NiceMock;
-using ::testing::StrictMock;
-using ::testing::Invoke;
-using ::testing::SetArgPointee;
-using ::testing::InvokeWithoutArgs;
 
 namespace cloud_print {
 
 namespace {
 
 using base::StringPrintf;
 
 const char kExampleCloudPrintServerURL[] = "https://www.google.com/cloudprint/";
 
 const char kExamplePrintTicket[] = "{\"MediaType\":\"plain\","
@@ skipping 150 matching lines @@
 std::string JobListResponse(int num_jobs) {
   std::string job_objects;
   for (int i = 0; i < num_jobs; i++) {
     job_objects = job_objects + StringPrintf(kExampleJobObject, i+1, i+1, i+1,
                                              i+1);
     if (i != num_jobs-1) job_objects = job_objects + ",";
   }
   return StringPrintf(kExampleJobListResponse, job_objects.c_str());
 }
 
-std::string JobListURI(const char* reason) {
-  return StringPrintf(kExamplePrinterJobListURI, reason);
+GURL JobListURI(const char* reason) {
+  return GURL(StringPrintf(kExamplePrinterJobListURI, reason));
 }
 
 std::string JobID(int job_num) {
   return StringPrintf(kExampleJobID, job_num);
 }
 
-std::string DoneURI(int job_num) {
-  return StringPrintf(kExampleUpdateDoneURI, job_num);
+GURL DoneURI(int job_num) {
+  return GURL(StringPrintf(kExampleUpdateDoneURI, job_num));
 }
 
-std::string ErrorURI(int job_num) {
-  return StringPrintf(kExampleUpdateErrorURI, job_num);
+GURL ErrorURI(int job_num) {
+  return GURL(StringPrintf(kExampleUpdateErrorURI, job_num));
 }
 
-std::string TicketURI(int job_num) {
-  return StringPrintf(kExamplePrintTicketURI, job_num);
+GURL TicketURI(int job_num) {
+  return GURL(StringPrintf(kExamplePrintTicketURI, job_num));
 }
 
-std::string DownloadURI(int job_num) {
-  return StringPrintf(kExamplePrintDownloadURI, job_num);
+GURL DownloadURI(int job_num) {
+  return GURL(StringPrintf(kExamplePrintDownloadURI, job_num));
 }
 
-// converts to string for consistency
-std::string InProgressURI(int job_num) {
+GURL InProgressURI(int job_num) {
   return GetUrlForJobStatusUpdate(GURL(kExampleCloudPrintServerURL),
                                   StringPrintf(kExampleJobID, job_num),
                                   PRINT_JOB_STATUS_IN_PROGRESS,
-                                  0).spec();
+                                  0);
 }
 
 std::string StatusResponse(int job_num, const char* status_string) {
   return StringPrintf(kExampleControlResponse,
                       status_string,
                       job_num,
                       status_string);
 }
 
 }  // namespace
@@ skipping 304 matching lines @@
 
   factory_.SetFakeResponse(DoneURI(job_num),
                            StatusResponse(job_num, "DONE"),
                            true);
   factory_.SetFakeResponse(InProgressURI(job_num),
                            StatusResponse(job_num, "IN_PROGRESS"),
                            true);
 
   // The times requirement is relaxed for the ticket URI
   // in order to accommodate TicketDownloadFailureTest
-  EXPECT_CALL(url_callback_, OnRequestCreate(
-      GURL(TicketURI(job_num)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(TicketURI(job_num), _))
       .Times(AtLeast(1));
 
-  EXPECT_CALL(url_callback_, OnRequestCreate(GURL(DownloadURI(job_num)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(DownloadURI(job_num), _))
       .Times(Exactly(1))
       .WillOnce(Invoke(this, &PrinterJobHandlerTest::AddMimeHeader));
 
-  EXPECT_CALL(url_callback_, OnRequestCreate(GURL(InProgressURI(job_num)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(InProgressURI(job_num), _))
       .Times(Exactly(1));
 
-  EXPECT_CALL(url_callback_, OnRequestCreate(GURL(DoneURI(job_num)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(DoneURI(job_num), _))
       .Times(Exactly(1));
 
   EXPECT_CALL(print_system_->JobSpooler(),
               Spool(kExamplePrintTicket, _, _, _, _, _, _))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this,
                                   &PrinterJobHandlerTest::PostSpoolSuccess));
 }
 
 void PrinterJobHandlerTest::BeginTest(int timeout_seconds) {
@@ skipping 74 matching lines @@
 // 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);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonQueryMore),
                            JobListResponse(0), true);
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonStartup)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(Exactly(1));
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonQueryMore)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonQueryMore), _))
       .Times(Exactly(1));
 
   SetUpJobSuccessTest(1);
   BeginTest(20);
 }
 
 TEST_F(PrinterJobHandlerTest, TicketDownloadFailureTest) {
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
                            JobListResponse(2), true);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
                            JobListResponse(2), true);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonQueryMore),
                            JobListResponse(0), true);
   factory_.SetFakeResponse(TicketURI(1), std::string(), false);
 
-  EXPECT_CALL(url_callback_, OnRequestCreate(GURL(TicketURI(1)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(TicketURI(1), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonStartup)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonQueryMore)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonQueryMore), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonFailure)), _))
+              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);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
                            JobListResponse(1), true);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonRetry),
                            JobListResponse(1), true);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonQueryMore),
                            JobListResponse(0), true);
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonStartup)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonQueryMore)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonQueryMore), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonFailure)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonFailure), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonRetry)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonRetry), _))
       .Times(AtLeast(1));
 
   SetUpJobSuccessTest(1);
 
   factory_.SetFakeResponse(TicketURI(1), std::string(), false);
 
   loop_.PostDelayedTask(FROM_HERE,
                         base::Bind(&net::FakeURLFetcherFactory::SetFakeResponse,
                                    base::Unretained(&factory_),
                                    TicketURI(1),
@@ skipping 12 matching lines @@
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonStartup),
                            JobListResponse(1), true);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonFailure),
                            JobListResponse(1), true);
   factory_.SetFakeResponse(JobListURI(kJobFetchReasonRetry),
                            JobListResponse(1), true);
   factory_.SetFakeResponse(ErrorURI(1), StatusResponse(1, "ERROR"), true);
   factory_.SetFakeResponse(TicketURI(1), std::string(), false);
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonStartup)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonStartup), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonFailure)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonFailure), _))
       .Times(AtLeast(1));
 
   EXPECT_CALL(url_callback_,
-              OnRequestCreate(GURL(JobListURI(kJobFetchReasonRetry)), _))
+              OnRequestCreate(JobListURI(kJobFetchReasonRetry), _))
       .Times(AtLeast(1));
 
-  EXPECT_CALL(url_callback_, OnRequestCreate(GURL(ErrorURI(1)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(ErrorURI(1), _))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(
           this, &PrinterJobHandlerTest::MakeJobFetchReturnNoJobs));
 
-  EXPECT_CALL(url_callback_, OnRequestCreate(GURL(TicketURI(1)), _))
+  EXPECT_CALL(url_callback_, OnRequestCreate(TicketURI(1), _))
       .Times(AtLeast(kNumRetriesBeforeAbandonJob));
 
   BeginTest(70);
 }
 
 }  // namespace cloud_print