chrome/service/cloud_print/cloud_print_url_fetcher_unittest.cc

   1 // Copyright (c) 2012 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 "base/command_line.h"
   6 #include "base/memory/ref_counted.h"
   7 #include "base/message_loop/message_loop_proxy.h"
   8 #include "base/synchronization/waitable_event.h"
   9 #include "base/threading/thread.h"
  10 #include "base/values.h"
  11 #include "chrome/service/cloud_print/cloud_print_url_fetcher.h"
  12 #include "chrome/service/service_process.h"
  13 #include "net/test/spawned_test_server/spawned_test_server.h"
  14 #include "net/url_request/url_request_context_getter.h"
  15 #include "net/url_request/url_request_status.h"
  16 #include "net/url_request/url_request_test_util.h"
  17 #include "net/url_request/url_request_throttler_manager.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "url/gurl.h"
  20
  21 using base::Time;
  22 using base::TimeDelta;
  23
  24 namespace cloud_print {
  25
  26 const base::FilePath::CharType kDocRoot[] =
  27     FILE_PATH_LITERAL("chrome/test/data");
  28
  29 int g_request_context_getter_instances = 0;
  30 class TrackingTestURLRequestContextGetter
  31     : public net::TestURLRequestContextGetter {
  32  public:
  33   explicit TrackingTestURLRequestContextGetter(
  34       base::MessageLoopProxy* io_message_loop_proxy,
  35       net::URLRequestThrottlerManager* throttler_manager)
  36       : TestURLRequestContextGetter(io_message_loop_proxy),
  37         throttler_manager_(throttler_manager) {
  38     g_request_context_getter_instances++;
  39   }
  40
  41   virtual net::TestURLRequestContext* GetURLRequestContext() OVERRIDE {
  42     if (!context_.get()) {
  43       context_.reset(new net::TestURLRequestContext(true));
  44       context_->set_throttler_manager(throttler_manager_);
  45       context_->Init();
  46     }
  47     return context_.get();
  48   }
  49
  50  protected:
  51   virtual ~TrackingTestURLRequestContextGetter() {
  52     g_request_context_getter_instances--;
  53   }
  54
  55  private:
  56   // Not owned here.
  57   net::URLRequestThrottlerManager* throttler_manager_;
  58   scoped_ptr<net::TestURLRequestContext> context_;
  59 };
  60
  61 class TestCloudPrintURLFetcher : public CloudPrintURLFetcher {
  62  public:
  63   explicit TestCloudPrintURLFetcher(
  64       base::MessageLoopProxy* io_message_loop_proxy)
  65       : io_message_loop_proxy_(io_message_loop_proxy) {
  66   }
  67
  68   virtual net::URLRequestContextGetter* GetRequestContextGetter() OVERRIDE {
  69     return new TrackingTestURLRequestContextGetter(
  70         io_message_loop_proxy_.get(), throttler_manager());
  71   }
  72
  73   net::URLRequestThrottlerManager* throttler_manager() {
  74     return &throttler_manager_;
  75   }
  76
  77  private:
  78   virtual ~TestCloudPrintURLFetcher() {}
  79
  80   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
  81
  82   // We set this as the throttler manager for the
  83   // TestURLRequestContext we create.
  84   net::URLRequestThrottlerManager throttler_manager_;
  85 };
  86
  87 class CloudPrintURLFetcherTest : public testing::Test,
  88                                  public CloudPrintURLFetcherDelegate {
  89  public:
  90   CloudPrintURLFetcherTest() : max_retries_(0), fetcher_(NULL) { }
  91
  92   // Creates a URLFetcher, using the program's main thread to do IO.
  93   virtual void CreateFetcher(const GURL& url, int max_retries);
  94
  95   // CloudPrintURLFetcher::Delegate
  96   virtual CloudPrintURLFetcher::ResponseAction HandleRawResponse(
  97       const net::URLFetcher* source,
  98       const GURL& url,
  99       const net::URLRequestStatus& status,
 100       int response_code,
 101       const net::ResponseCookies& cookies,
 102       const std::string& data) OVERRIDE;
 103
 104   virtual CloudPrintURLFetcher::ResponseAction OnRequestAuthError() OVERRIDE {
 105     ADD_FAILURE();
 106     return CloudPrintURLFetcher::STOP_PROCESSING;
 107   }
 108
 109   virtual std::string GetAuthHeader() OVERRIDE {
 110     return std::string();
 111   }
 112
 113   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
 114     return io_message_loop_proxy_;
 115   }
 116
 117  protected:
 118   virtual void SetUp() {
 119     testing::Test::SetUp();
 120
 121     io_message_loop_proxy_ = base::MessageLoopProxy::current();
 122   }
 123
 124   virtual void TearDown() {
 125     fetcher_ = NULL;
 126     // Deleting the fetcher causes a task to be posted to the IO thread to
 127     // release references to the URLRequestContextGetter. We need to run all
 128     // pending tasks to execute that (this is the IO thread).
 129     base::MessageLoop::current()->RunUntilIdle();
 130     EXPECT_EQ(0, g_request_context_getter_instances);
 131   }
 132
 133   // URLFetcher is designed to run on the main UI thread, but in our tests
 134   // we assume that the current thread is the IO thread where the URLFetcher
 135   // dispatches its requests to.  When we wish to simulate being used from
 136   // a UI thread, we dispatch a worker thread to do so.
 137   base::MessageLoopForIO io_loop_;
 138   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 139   int max_retries_;
 140   Time start_time_;
 141   scoped_refptr<TestCloudPrintURLFetcher> fetcher_;
 142 };
 143
 144 class CloudPrintURLFetcherBasicTest : public CloudPrintURLFetcherTest {
 145  public:
 146   CloudPrintURLFetcherBasicTest()
 147       : handle_raw_response_(false), handle_raw_data_(false) { }
 148   // CloudPrintURLFetcher::Delegate
 149   virtual CloudPrintURLFetcher::ResponseAction HandleRawResponse(
 150       const net::URLFetcher* source,
 151       const GURL& url,
 152       const net::URLRequestStatus& status,
 153       int response_code,
 154       const net::ResponseCookies& cookies,
 155       const std::string& data) OVERRIDE;
 156
 157   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
 158       const net::URLFetcher* source,
 159       const GURL& url,
 160       const std::string& data) OVERRIDE;
 161
 162   virtual CloudPrintURLFetcher::ResponseAction HandleJSONData(
 163       const net::URLFetcher* source,
 164       const GURL& url,
 165       base::DictionaryValue* json_data,
 166       bool succeeded) OVERRIDE;
 167
 168   void SetHandleRawResponse(bool handle_raw_response) {
 169     handle_raw_response_ = handle_raw_response;
 170   }
 171   void SetHandleRawData(bool handle_raw_data) {
 172     handle_raw_data_ = handle_raw_data;
 173   }
 174  private:
 175   bool handle_raw_response_;
 176   bool handle_raw_data_;
 177 };
 178
 179 // Version of CloudPrintURLFetcherTest that tests overload protection.
 180 class CloudPrintURLFetcherOverloadTest : public CloudPrintURLFetcherTest {
 181  public:
 182   CloudPrintURLFetcherOverloadTest() : response_count_(0) {
 183   }
 184
 185   // CloudPrintURLFetcher::Delegate
 186   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
 187       const net::URLFetcher* source,
 188       const GURL& url,
 189       const std::string& data) OVERRIDE;
 190
 191  private:
 192   int response_count_;
 193 };
 194
 195 // Version of CloudPrintURLFetcherTest that tests backoff protection.
 196 class CloudPrintURLFetcherRetryBackoffTest : public CloudPrintURLFetcherTest {
 197  public:
 198   CloudPrintURLFetcherRetryBackoffTest() : response_count_(0) {
 199   }
 200
 201   // CloudPrintURLFetcher::Delegate
 202   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
 203       const net::URLFetcher* source,
 204       const GURL& url,
 205       const std::string& data) OVERRIDE;
 206
 207   virtual void OnRequestGiveUp() OVERRIDE;
 208
 209  private:
 210   int response_count_;
 211 };
 212
 213
 214 void CloudPrintURLFetcherTest::CreateFetcher(const GURL& url, int max_retries) {
 215   fetcher_ = new TestCloudPrintURLFetcher(io_message_loop_proxy().get());
 216
 217   // Registers an entry for test url. It only allows 3 requests to be sent
 218   // in 200 milliseconds.
 219   scoped_refptr<net::URLRequestThrottlerEntry>
 220   entry(new net::URLRequestThrottlerEntry(
 221       fetcher_->throttler_manager(), std::string(), 200, 3, 1, 2.0, 0.0, 256));
 222   fetcher_->throttler_manager()->OverrideEntryForTests(url, entry.get());
 223
 224   max_retries_ = max_retries;
 225   start_time_ = Time::Now();
 226   fetcher_->StartGetRequest(CloudPrintURLFetcher::REQUEST_MAX, url, this,
 227                             max_retries_, std::string());
 228 }
 229
 230 CloudPrintURLFetcher::ResponseAction
 231 CloudPrintURLFetcherTest::HandleRawResponse(
 232     const net::URLFetcher* source,
 233     const GURL& url,
 234     const net::URLRequestStatus& status,
 235     int response_code,
 236     const net::ResponseCookies& cookies,
 237     const std::string& data) {
 238   EXPECT_TRUE(status.is_success());
 239   EXPECT_EQ(200, response_code);  // HTTP OK
 240   EXPECT_FALSE(data.empty());
 241   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 242 }
 243
 244 CloudPrintURLFetcher::ResponseAction
 245 CloudPrintURLFetcherBasicTest::HandleRawResponse(
 246     const net::URLFetcher* source,
 247     const GURL& url,
 248     const net::URLRequestStatus& status,
 249     int response_code,
 250     const net::ResponseCookies& cookies,
 251     const std::string& data) {
 252   EXPECT_TRUE(status.is_success());
 253   EXPECT_EQ(200, response_code);  // HTTP OK
 254   EXPECT_FALSE(data.empty());
 255
 256   if (handle_raw_response_) {
 257     // If the current message loop is not the IO loop, it will be shut down when
 258     // the main loop returns and this thread subsequently goes out of scope.
 259     io_message_loop_proxy()->PostTask(FROM_HERE,
 260                                       base::MessageLoop::QuitClosure());
 261     return CloudPrintURLFetcher::STOP_PROCESSING;
 262   }
 263   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 264 }
 265
 266 CloudPrintURLFetcher::ResponseAction
 267 CloudPrintURLFetcherBasicTest::HandleRawData(
 268     const net::URLFetcher* source,
 269     const GURL& url,
 270     const std::string& data) {
 271   // We should never get here if we returned true in HandleRawResponse
 272   EXPECT_FALSE(handle_raw_response_);
 273   if (handle_raw_data_) {
 274     io_message_loop_proxy()->PostTask(FROM_HERE,
 275                                       base::MessageLoop::QuitClosure());
 276     return CloudPrintURLFetcher::STOP_PROCESSING;
 277   }
 278   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 279 }
 280
 281 CloudPrintURLFetcher::ResponseAction
 282 CloudPrintURLFetcherBasicTest::HandleJSONData(
 283     const net::URLFetcher* source,
 284     const GURL& url,
 285     base::DictionaryValue* json_data,
 286     bool succeeded) {
 287   // We should never get here if we returned true in one of the above methods.
 288   EXPECT_FALSE(handle_raw_response_);
 289   EXPECT_FALSE(handle_raw_data_);
 290   io_message_loop_proxy()->PostTask(FROM_HERE,
 291                                     base::MessageLoop::QuitClosure());
 292   return CloudPrintURLFetcher::STOP_PROCESSING;
 293 }
 294
 295 CloudPrintURLFetcher::ResponseAction
 296 CloudPrintURLFetcherOverloadTest::HandleRawData(
 297     const net::URLFetcher* source,
 298     const GURL& url,
 299     const std::string& data) {
 300   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
 301   response_count_++;
 302   if (response_count_ < 20) {
 303     fetcher_->StartGetRequest(CloudPrintURLFetcher::REQUEST_MAX, url, this,
 304                               max_retries_, std::string());
 305   } else {
 306     // We have already sent 20 requests continuously. And we expect that
 307     // it takes more than 1 second due to the overload protection settings.
 308     EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
 309     io_message_loop_proxy()->PostTask(FROM_HERE,
 310                                       base::MessageLoop::QuitClosure());
 311   }
 312   return CloudPrintURLFetcher::STOP_PROCESSING;
 313 }
 314
 315 CloudPrintURLFetcher::ResponseAction
 316 CloudPrintURLFetcherRetryBackoffTest::HandleRawData(
 317     const net::URLFetcher* source,
 318     const GURL& url,
 319     const std::string& data) {
 320   response_count_++;
 321   // First attempt + 11 retries = 12 total responses.
 322   EXPECT_LE(response_count_, 12);
 323   return CloudPrintURLFetcher::RETRY_REQUEST;
 324 }
 325
 326 void CloudPrintURLFetcherRetryBackoffTest::OnRequestGiveUp() {
 327   // It takes more than 200 ms to finish all 11 requests.
 328   EXPECT_TRUE(Time::Now() - start_time_ >= TimeDelta::FromMilliseconds(200));
 329   io_message_loop_proxy()->PostTask(FROM_HERE,
 330                                     base::MessageLoop::QuitClosure());
 331 }
 332
 333 TEST_F(CloudPrintURLFetcherBasicTest, HandleRawResponse) {
 334   net::SpawnedTestServer test_server(net::SpawnedTestServer::TYPE_HTTP,
 335                                      net::SpawnedTestServer::kLocalhost,
 336                                      base::FilePath(kDocRoot));
 337   ASSERT_TRUE(test_server.Start());
 338   SetHandleRawResponse(true);
 339
 340   CreateFetcher(test_server.GetURL("echo"), 0);
 341   base::MessageLoop::current()->Run();
 342 }
 343
 344 TEST_F(CloudPrintURLFetcherBasicTest, HandleRawData) {
 345   net::SpawnedTestServer test_server(net::SpawnedTestServer::TYPE_HTTP,
 346                                      net::SpawnedTestServer::kLocalhost,
 347                                      base::FilePath(kDocRoot));
 348   ASSERT_TRUE(test_server.Start());
 349
 350   SetHandleRawData(true);
 351   CreateFetcher(test_server.GetURL("echo"), 0);
 352   base::MessageLoop::current()->Run();
 353 }
 354
 355 TEST_F(CloudPrintURLFetcherOverloadTest, Protect) {
 356   net::SpawnedTestServer test_server(net::SpawnedTestServer::TYPE_HTTP,
 357                                      net::SpawnedTestServer::kLocalhost,
 358                                      base::FilePath(kDocRoot));
 359   ASSERT_TRUE(test_server.Start());
 360
 361   GURL url(test_server.GetURL("defaultresponse"));
 362   CreateFetcher(url, 11);
 363
 364   base::MessageLoop::current()->Run();
 365 }
 366
 367 TEST_F(CloudPrintURLFetcherRetryBackoffTest, GiveUp) {
 368   net::SpawnedTestServer test_server(net::SpawnedTestServer::TYPE_HTTP,
 369                                      net::SpawnedTestServer::kLocalhost,
 370                                      base::FilePath(kDocRoot));
 371   ASSERT_TRUE(test_server.Start());
 372
 373   GURL url(test_server.GetURL("defaultresponse"));
 374   CreateFetcher(url, 11);
 375
 376   base::MessageLoop::current()->Run();
 377 }
 378
 379 }  // namespace cloud_print