net/base/layered_network_delegate_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 "net/base/layered_network_delegate.h"
   6
   7 #include <map>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_path.h"
  11 #include "base/macros.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "net/base/auth.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/base/network_delegate_impl.h"
  17 #include "net/base/request_priority.h"
  18 #include "net/base/test_completion_callback.h"
  19 #include "net/http/http_response_headers.h"
  20 #include "net/proxy/proxy_config_service.h"
  21 #include "net/proxy/proxy_info.h"
  22 #include "net/proxy/proxy_service.h"
  23 #include "net/url_request/url_request.h"
  24 #include "net/url_request/url_request_test_util.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "url/gurl.h"
  27
  28 namespace net {
  29 namespace {
  30
  31 typedef std::map<const char*, int> CountersMap;
  32
  33 class TestNetworkDelegateImpl : public NetworkDelegateImpl {
  34  public:
  35   TestNetworkDelegateImpl(CountersMap* layered_network_delegate_counters)
  36       : layered_network_delegate_counters_(layered_network_delegate_counters) {}
  37
  38   ~TestNetworkDelegateImpl() override {}
  39
  40   // NetworkDelegateImpl implementation:
  41   int OnBeforeURLRequest(URLRequest* request,
  42                          const CompletionCallback& callback,
  43                          GURL* new_url) override {
  44     IncrementAndCompareCounter("on_before_url_request_count");
  45     return OK;
  46   }
  47
  48   void OnResolveProxy(const GURL& url,
  49                       int load_flags,
  50                       const ProxyService& proxy_service,
  51                       ProxyInfo* result) override {
  52     IncrementAndCompareCounter("on_resolve_proxy_count");
  53   }
  54
  55   void OnProxyFallback(const ProxyServer& bad_proxy, int net_error) override {
  56     IncrementAndCompareCounter("on_proxy_fallback_count");
  57   }
  58
  59   int OnBeforeSendHeaders(URLRequest* request,
  60                           const CompletionCallback& callback,
  61                           HttpRequestHeaders* headers) override {
  62     IncrementAndCompareCounter("on_before_send_headers_count");
  63     return OK;
  64   }
  65
  66   void OnBeforeSendProxyHeaders(URLRequest* request,
  67                                 const ProxyInfo& proxy_info,
  68                                 HttpRequestHeaders* headers) override {
  69     IncrementAndCompareCounter("on_before_send_proxy_headers_count");
  70   }
  71
  72   void OnSendHeaders(URLRequest* request,
  73                      const HttpRequestHeaders& headers) override {
  74     IncrementAndCompareCounter("on_send_headers_count");
  75   }
  76
  77   int OnHeadersReceived(
  78       URLRequest* request,
  79       const CompletionCallback& callback,
  80       const HttpResponseHeaders* original_response_headers,
  81       scoped_refptr<HttpResponseHeaders>* override_response_headers,
  82       GURL* allowed_unsafe_redirect_url) override {
  83     IncrementAndCompareCounter("on_headers_received_count");
  84     return OK;
  85   }
  86
  87   void OnBeforeRedirect(URLRequest* request,
  88                         const GURL& new_location) override {
  89     IncrementAndCompareCounter("on_before_redirect_count");
  90   }
  91
  92   void OnResponseStarted(URLRequest* request) override {
  93     IncrementAndCompareCounter("on_response_started_count");
  94   }
  95
  96   void OnRawBytesRead(const URLRequest& request, int bytes_read) override {
  97     IncrementAndCompareCounter("on_raw_bytes_read_count");
  98   }
  99
 100   void OnCompleted(URLRequest* request, bool started) override {
 101     IncrementAndCompareCounter("on_completed_count");
 102   }
 103
 104   void OnURLRequestDestroyed(URLRequest* request) override {
 105     IncrementAndCompareCounter("on_url_request_destroyed_count");
 106   }
 107
 108   void OnPACScriptError(int line_number, const base::string16& error) override {
 109     IncrementAndCompareCounter("on_pac_script_error_count");
 110   }
 111
 112   AuthRequiredResponse OnAuthRequired(URLRequest* request,
 113                                       const AuthChallengeInfo& auth_info,
 114                                       const AuthCallback& callback,
 115                                       AuthCredentials* credentials) override {
 116     IncrementAndCompareCounter("on_auth_required_count");
 117     return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 118   }
 119
 120   bool OnCanGetCookies(const URLRequest& request,
 121                        const CookieList& cookie_list) override {
 122     IncrementAndCompareCounter("on_can_get_cookies_count");
 123     return false;
 124   }
 125
 126   bool OnCanSetCookie(const URLRequest& request,
 127                       const std::string& cookie_line,
 128                       CookieOptions* options) override {
 129     IncrementAndCompareCounter("on_can_set_cookie_count");
 130     return false;
 131   }
 132
 133   bool OnCanAccessFile(const URLRequest& request,
 134                        const base::FilePath& path) const override {
 135     IncrementAndCompareCounter("on_can_access_file_count");
 136     return false;
 137   }
 138
 139   bool OnCanEnablePrivacyMode(
 140       const GURL& url,
 141       const GURL& first_party_for_cookies) const override {
 142     IncrementAndCompareCounter("on_can_enable_privacy_mode_count");
 143     return false;
 144   }
 145
 146   bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
 147       const URLRequest& request,
 148       const GURL& target_url,
 149       const GURL& referrer_url) const override {
 150     IncrementAndCompareCounter(
 151         "on_cancel_url_request_with_policy_violating_referrer_header_count");
 152     return false;
 153   }
 154
 155  private:
 156   void IncrementAndCompareCounter(const char* counter_name) const {
 157     ++counters_[counter_name];
 158     EXPECT_EQ((*layered_network_delegate_counters_)[counter_name],
 159               counters_[counter_name]);
 160   }
 161
 162   mutable CountersMap counters_;
 163   mutable CountersMap* layered_network_delegate_counters_;
 164
 165   DISALLOW_COPY_AND_ASSIGN(TestNetworkDelegateImpl);
 166 };
 167
 168 class TestLayeredNetworkDelegate : public LayeredNetworkDelegate {
 169  public:
 170   TestLayeredNetworkDelegate(scoped_ptr<NetworkDelegate> network_delegate,
 171                              CountersMap* counters)
 172       : LayeredNetworkDelegate(network_delegate.Pass()),
 173         context_(true),
 174         counters_(counters) {
 175     context_.Init();
 176   }
 177
 178   ~TestLayeredNetworkDelegate() override {}
 179
 180   void CallAndVerify() {
 181     scoped_refptr<AuthChallengeInfo> auth_challenge(new AuthChallengeInfo());
 182     scoped_ptr<URLRequest> request =
 183         context_.CreateRequest(GURL(), IDLE, &delegate_);
 184     scoped_ptr<HttpRequestHeaders> request_headers(new HttpRequestHeaders());
 185     scoped_refptr<HttpResponseHeaders> response_headers(
 186         new HttpResponseHeaders(""));
 187     TestCompletionCallback completion_callback;
 188     scoped_ptr<ProxyService> proxy_service(ProxyService::CreateDirect());
 189     scoped_ptr<ProxyInfo> proxy_info(new ProxyInfo());
 190
 191     EXPECT_EQ(OK, OnBeforeURLRequest(request.get(),
 192                                      completion_callback.callback(), NULL));
 193     OnResolveProxy(GURL(), 0, *proxy_service, proxy_info.get());
 194     OnProxyFallback(ProxyServer(), 0);
 195     EXPECT_EQ(OK, OnBeforeSendHeaders(NULL, completion_callback.callback(),
 196                                       request_headers.get()));
 197     OnBeforeSendProxyHeaders(NULL, ProxyInfo(), request_headers.get());
 198     OnSendHeaders(NULL, *request_headers);
 199     EXPECT_EQ(OK, OnHeadersReceived(NULL, completion_callback.callback(),
 200                                     response_headers.get(), NULL, NULL));
 201     OnResponseStarted(request.get());
 202     OnRawBytesRead(*request, 0);
 203     OnCompleted(request.get(), false);
 204     OnURLRequestDestroyed(request.get());
 205     OnPACScriptError(0, base::string16());
 206     EXPECT_EQ(
 207         NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION,
 208         OnAuthRequired(request.get(), *auth_challenge, AuthCallback(), NULL));
 209     EXPECT_FALSE(OnCanGetCookies(*request, CookieList()));
 210     EXPECT_FALSE(OnCanSetCookie(*request, std::string(), NULL));
 211     EXPECT_FALSE(OnCanAccessFile(*request, base::FilePath()));
 212     EXPECT_FALSE(OnCanEnablePrivacyMode(GURL(), GURL()));
 213     EXPECT_FALSE(OnCancelURLRequestWithPolicyViolatingReferrerHeader(
 214         *request, GURL(), GURL()));
 215   }
 216
 217  protected:
 218   void OnBeforeURLRequestInternal(URLRequest* request,
 219                                   const CompletionCallback& callback,
 220                                   GURL* new_url) override {
 221     ++(*counters_)["on_before_url_request_count"];
 222     EXPECT_EQ(1, (*counters_)["on_before_url_request_count"]);
 223   }
 224
 225   void OnResolveProxyInternal(const GURL& url,
 226                               int load_flags,
 227                               const ProxyService& proxy_service,
 228                               ProxyInfo* result) override {
 229     ++(*counters_)["on_resolve_proxy_count"];
 230     EXPECT_EQ(1, (*counters_)["on_resolve_proxy_count"]);
 231   }
 232
 233   void OnProxyFallbackInternal(const ProxyServer& bad_proxy,
 234                                int net_error) override {
 235     ++(*counters_)["on_proxy_fallback_count"];
 236     EXPECT_EQ(1, (*counters_)["on_proxy_fallback_count"]);
 237   }
 238
 239   void OnBeforeSendHeadersInternal(URLRequest* request,
 240                                    const CompletionCallback& callback,
 241                                    HttpRequestHeaders* headers) override {
 242     ++(*counters_)["on_before_send_headers_count"];
 243     EXPECT_EQ(1, (*counters_)["on_before_send_headers_count"]);
 244   }
 245
 246   void OnBeforeSendProxyHeadersInternal(URLRequest* request,
 247                                         const ProxyInfo& proxy_info,
 248                                         HttpRequestHeaders* headers) override {
 249     ++(*counters_)["on_before_send_proxy_headers_count"];
 250     EXPECT_EQ(1, (*counters_)["on_before_send_proxy_headers_count"]);
 251   }
 252
 253   void OnSendHeadersInternal(URLRequest* request,
 254                              const HttpRequestHeaders& headers) override {
 255     ++(*counters_)["on_send_headers_count"];
 256     EXPECT_EQ(1, (*counters_)["on_send_headers_count"]);
 257   }
 258
 259   void OnHeadersReceivedInternal(
 260       URLRequest* request,
 261       const CompletionCallback& callback,
 262       const HttpResponseHeaders* original_response_headers,
 263       scoped_refptr<HttpResponseHeaders>* override_response_headers,
 264       GURL* allowed_unsafe_redirect_url) override {
 265     ++(*counters_)["on_headers_received_count"];
 266     EXPECT_EQ(1, (*counters_)["on_headers_received_count"]);
 267   }
 268
 269   void OnBeforeRedirectInternal(URLRequest* request,
 270                                 const GURL& new_location) override {
 271     ++(*counters_)["on_before_redirect_count"];
 272     EXPECT_EQ(1, (*counters_)["on_before_redirect_count"]);
 273   }
 274
 275   void OnResponseStartedInternal(URLRequest* request) override {
 276     ++(*counters_)["on_response_started_count"];
 277     EXPECT_EQ(1, (*counters_)["on_response_started_count"]);
 278   }
 279
 280   void OnRawBytesReadInternal(const URLRequest& request,
 281                               int bytes_read) override {
 282     ++(*counters_)["on_raw_bytes_read_count"];
 283     EXPECT_EQ(1, (*counters_)["on_raw_bytes_read_count"]);
 284   }
 285
 286   void OnCompletedInternal(URLRequest* request, bool started) override {
 287     ++(*counters_)["on_completed_count"];
 288     EXPECT_EQ(1, (*counters_)["on_completed_count"]);
 289   }
 290
 291   void OnURLRequestDestroyedInternal(URLRequest* request) override {
 292     ++(*counters_)["on_url_request_destroyed_count"];
 293     EXPECT_EQ(1, (*counters_)["on_url_request_destroyed_count"]);
 294   }
 295
 296   void OnPACScriptErrorInternal(int line_number,
 297                                 const base::string16& error) override {
 298     ++(*counters_)["on_pac_script_error_count"];
 299     EXPECT_EQ(1, (*counters_)["on_pac_script_error_count"]);
 300   }
 301
 302   void OnAuthRequiredInternal(URLRequest* request,
 303                               const AuthChallengeInfo& auth_info,
 304                               const AuthCallback& callback,
 305                               AuthCredentials* credentials) override {
 306     ++(*counters_)["on_auth_required_count"];
 307     EXPECT_EQ(1, (*counters_)["on_auth_required_count"]);
 308   }
 309
 310   void OnCanGetCookiesInternal(const URLRequest& request,
 311                                const CookieList& cookie_list) override {
 312     ++(*counters_)["on_can_get_cookies_count"];
 313     EXPECT_EQ(1, (*counters_)["on_can_get_cookies_count"]);
 314   }
 315
 316   void OnCanSetCookieInternal(const URLRequest& request,
 317                               const std::string& cookie_line,
 318                               CookieOptions* options) override {
 319     ++(*counters_)["on_can_set_cookie_count"];
 320     EXPECT_EQ(1, (*counters_)["on_can_set_cookie_count"]);
 321   }
 322
 323   void OnCanAccessFileInternal(const URLRequest& request,
 324                                const base::FilePath& path) const override {
 325     ++(*counters_)["on_can_access_file_count"];
 326     EXPECT_EQ(1, (*counters_)["on_can_access_file_count"]);
 327   }
 328
 329   void OnCanEnablePrivacyModeInternal(
 330       const GURL& url,
 331       const GURL& first_party_for_cookies) const override {
 332     ++(*counters_)["on_can_enable_privacy_mode_count"];
 333     EXPECT_EQ(1, (*counters_)["on_can_enable_privacy_mode_count"]);
 334   }
 335
 336   void OnCancelURLRequestWithPolicyViolatingReferrerHeaderInternal(
 337       const URLRequest& request,
 338       const GURL& target_url,
 339       const GURL& referrer_url) const override {
 340     ++(*counters_)
 341         ["on_cancel_url_request_with_policy_"
 342          "violating_referrer_header_count"];
 343     EXPECT_EQ(1, (*counters_)
 344                      ["on_cancel_url_request_with_policy_"
 345                       "violating_referrer_header_count"]);
 346   }
 347
 348  private:
 349   TestURLRequestContext context_;
 350   TestDelegate delegate_;
 351   mutable CountersMap* counters_;
 352
 353   DISALLOW_COPY_AND_ASSIGN(TestLayeredNetworkDelegate);
 354 };
 355
 356 }  // namespace
 357
 358 class LayeredNetworkDelegateTest : public testing::Test {
 359  public:
 360   LayeredNetworkDelegateTest() {
 361     scoped_ptr<TestNetworkDelegateImpl> test_network_delegate(
 362         new TestNetworkDelegateImpl(&layered_network_delegate_counters));
 363     test_network_delegate_ = test_network_delegate.get();
 364     layered_network_delegate_ =
 365         scoped_ptr<TestLayeredNetworkDelegate>(new TestLayeredNetworkDelegate(
 366             test_network_delegate.Pass(), &layered_network_delegate_counters));
 367   }
 368
 369   CountersMap layered_network_delegate_counters;
 370   TestNetworkDelegateImpl* test_network_delegate_;
 371   scoped_ptr<TestLayeredNetworkDelegate> layered_network_delegate_;
 372 };
 373
 374 TEST_F(LayeredNetworkDelegateTest, VerifyLayeredNetworkDelegateInternal) {
 375   layered_network_delegate_->CallAndVerify();
 376 }
 377
 378 }  // namespace net