components/domain_reliability/uploader_unittest.cc

   1 // Copyright 2014 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 "components/domain_reliability/uploader.h"
   6
   7 #include <algorithm>
   8 #include <cstring>
   9 #include <map>
  10
  11 #include "base/bind.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop/message_loop_proxy.h"
  14 #include "base/test/test_simple_task_runner.h"
  15 #include "components/domain_reliability/test_util.h"
  16 #include "net/base/load_flags.h"
  17 #include "net/base/net_errors.h"
  18 #include "net/http/http_response_headers.h"
  19 #include "net/url_request/test_url_fetcher_factory.h"
  20 #include "net/url_request/url_fetcher_delegate.h"
  21 #include "net/url_request/url_request_context_getter.h"
  22 #include "net/url_request/url_request_test_util.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace domain_reliability {
  26 namespace {
  27
  28 const char *kReportJSON = "{}";
  29 const char *kUploadURL = "https://example/upload";
  30
  31 class DomainReliabilityUploaderTest : public testing::Test {
  32  protected:
  33   DomainReliabilityUploaderTest()
  34       : network_task_runner_(new base::TestSimpleTaskRunner()),
  35         url_request_context_getter_(new net::TestURLRequestContextGetter(
  36             network_task_runner_)),
  37         uploader_(DomainReliabilityUploader::Create(
  38             &time_, url_request_context_getter_)) {
  39     uploader_->set_discard_uploads(false);
  40   }
  41
  42   DomainReliabilityUploader::UploadCallback MakeUploadCallback(size_t index) {
  43     return base::Bind(&DomainReliabilityUploaderTest::OnUploadComplete,
  44                       base::Unretained(this),
  45                       index);
  46   }
  47
  48   void OnUploadComplete(size_t index,
  49                         const DomainReliabilityUploader::UploadResult& result) {
  50     EXPECT_FALSE(upload_complete_[index]);
  51     upload_complete_[index] = true;
  52     upload_result_[index] = result;
  53   }
  54
  55   void SimulateUpload() {
  56     uploader_->UploadReport(kReportJSON,
  57                             GURL(kUploadURL),
  58                             MakeUploadCallback(0));
  59   }
  60
  61   void SimulateUploadRequest() {
  62     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
  63     EXPECT_TRUE(fetcher);
  64
  65     EXPECT_EQ(kReportJSON, fetcher->upload_data());
  66     EXPECT_EQ(GURL(kUploadURL), fetcher->GetOriginalURL());
  67     EXPECT_TRUE(fetcher->GetLoadFlags() & net::LOAD_DO_NOT_SAVE_COOKIES);
  68     EXPECT_TRUE(fetcher->GetLoadFlags() & net::LOAD_DO_NOT_SEND_COOKIES);
  69
  70     fetcher->set_url(GURL(kUploadURL));
  71   }
  72
  73   void SimulateNoUploadRequest() {
  74     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
  75     EXPECT_FALSE(fetcher);
  76   }
  77
  78   void SimulateUploadResponse(int response_code, const char* headers) {
  79     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
  80     EXPECT_TRUE(fetcher);
  81
  82     fetcher->set_status(net::URLRequestStatus());
  83     fetcher->set_response_code(response_code);
  84     fetcher->set_response_headers(new net::HttpResponseHeaders(
  85         net::HttpUtil::AssembleRawHeaders(headers, strlen(headers))));
  86     fetcher->SetResponseString("");
  87     fetcher->delegate()->OnURLFetchComplete(fetcher);
  88   }
  89
  90   void SimulateUploadError(int error) {
  91     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
  92     EXPECT_TRUE(fetcher);
  93
  94     net::URLRequestStatus status;
  95     status.set_status(net::URLRequestStatus::FAILED);
  96     status.set_error(error);
  97     fetcher->set_status(status);
  98     fetcher->set_response_code(-1);
  99     fetcher->delegate()->OnURLFetchComplete(fetcher);
 100   }
 101
 102   scoped_refptr<base::TestSimpleTaskRunner> network_task_runner_;
 103   net::TestURLFetcherFactory url_fetcher_factory_;
 104   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
 105   MockTime time_;
 106   scoped_ptr<DomainReliabilityUploader> uploader_;
 107
 108   // Whether the upload callback was called for a particular collector index.
 109   std::map<size_t, bool> upload_complete_;
 110   // The result of the last completed upload for a particular collector index.
 111   std::map<size_t, DomainReliabilityUploader::UploadResult> upload_result_;
 112 };
 113
 114 TEST_F(DomainReliabilityUploaderTest, Create) {
 115   SimulateNoUploadRequest();
 116 }
 117
 118 TEST_F(DomainReliabilityUploaderTest, SuccessfulUpload) {
 119   SimulateUpload();
 120   SimulateUploadRequest();
 121   EXPECT_FALSE(upload_complete_[0]);
 122   SimulateUploadResponse(200, "HTTP/1.1 200 OK\n\n");
 123   EXPECT_TRUE(upload_complete_[0]);
 124   EXPECT_TRUE(upload_result_[0].is_success());
 125 }
 126
 127 TEST_F(DomainReliabilityUploaderTest, NetworkFailedUpload) {
 128   SimulateUpload();
 129   SimulateUploadRequest();
 130   EXPECT_FALSE(upload_complete_[0]);
 131   SimulateUploadError(net::ERR_CONNECTION_REFUSED);
 132   EXPECT_TRUE(upload_complete_[0]);
 133   EXPECT_TRUE(upload_result_[0].is_failure());
 134 }
 135
 136 TEST_F(DomainReliabilityUploaderTest, ServerFailedUpload) {
 137   SimulateUpload();
 138   SimulateUploadRequest();
 139   EXPECT_FALSE(upload_complete_[0]);
 140   SimulateUploadResponse(500, "HTTP/1.1 500 Blargh\n\n");
 141   EXPECT_TRUE(upload_complete_[0]);
 142   EXPECT_TRUE(upload_result_[0].is_failure());
 143 }
 144
 145 TEST_F(DomainReliabilityUploaderTest, RetryAfterUpload) {
 146   SimulateUpload();
 147   SimulateUploadRequest();
 148   EXPECT_FALSE(upload_complete_[0]);
 149   SimulateUploadResponse(503, "HTTP/1.1 503 Ugh\nRetry-After: 3600\n\n");
 150   EXPECT_TRUE(upload_complete_[0]);
 151   EXPECT_TRUE(upload_result_[0].is_retry_after());
 152   EXPECT_EQ(base::TimeDelta::FromSeconds(3600), upload_result_[0].retry_after);
 153 }
 154
 155 TEST_F(DomainReliabilityUploaderTest, DiscardedUpload) {
 156   uploader_->set_discard_uploads(true);
 157   SimulateUpload();
 158   SimulateNoUploadRequest();
 159 }
 160
 161 }  // namespace
 162 }  // namespace domain_reliability