src/net/url_request/url_request_filter_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 "net/url_request/url_request_filter.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "net/base/request_priority.h"
   9 #include "net/url_request/url_request.h"
  10 #include "net/url_request/url_request_context.h"
  11 #include "net/url_request/url_request_interceptor.h"
  12 #include "net/url_request/url_request_job.h"
  13 #include "net/url_request/url_request_test_job.h"
  14 #include "net/url_request/url_request_test_util.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace net {
  18
  19 namespace {
  20
  21 URLRequestTestJob* job_a;
  22
  23 URLRequestJob* FactoryA(URLRequest* request,
  24                         NetworkDelegate* network_delegate,
  25                         const std::string& scheme) {
  26   job_a = new URLRequestTestJob(request, network_delegate);
  27   return job_a;
  28 }
  29
  30 URLRequestTestJob* job_b;
  31
  32 URLRequestJob* FactoryB(URLRequest* request,
  33                         NetworkDelegate* network_delegate,
  34                         const std::string& scheme) {
  35   job_b = new URLRequestTestJob(request, network_delegate);
  36   return job_b;
  37 }
  38
  39 URLRequestTestJob* job_c;
  40
  41 class TestURLRequestInterceptor : public URLRequestInterceptor {
  42  public:
  43   virtual ~TestURLRequestInterceptor() {}
  44
  45   virtual URLRequestJob* MaybeInterceptRequest(
  46       URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
  47     job_c = new URLRequestTestJob(request, network_delegate);
  48     return job_c;
  49   }
  50 };
  51
  52 TEST(URLRequestFilter, BasicMatching) {
  53   TestDelegate delegate;
  54   TestURLRequestContext request_context;
  55   URLRequestFilter* filter = URLRequestFilter::GetInstance();
  56
  57   const GURL kUrl1("http://foo.com/");
  58   scoped_ptr<URLRequest> request1(request_context.CreateRequest(
  59       kUrl1, DEFAULT_PRIORITY, &delegate, NULL));
  60
  61   const GURL kUrl2("http://bar.com/");
  62   scoped_ptr<URLRequest> request2(request_context.CreateRequest(
  63       kUrl2, DEFAULT_PRIORITY, &delegate, NULL));
  64
  65   // Check AddUrlHandler checks for invalid URLs.
  66   EXPECT_FALSE(filter->AddUrlHandler(GURL(), &FactoryA));
  67
  68   // Check URL matching.
  69   filter->ClearHandlers();
  70   EXPECT_TRUE(filter->AddUrlHandler(kUrl1, &FactoryA));
  71   {
  72     scoped_refptr<URLRequestJob> found =
  73         filter->MaybeInterceptRequest(request1.get(), NULL);
  74     EXPECT_EQ(job_a, found.get());
  75     EXPECT_TRUE(job_a != NULL);
  76     job_a = NULL;
  77   }
  78   EXPECT_EQ(filter->hit_count(), 1);
  79
  80   // Check we don't match other URLs.
  81   EXPECT_TRUE(filter->MaybeInterceptRequest(request2.get(), NULL) == NULL);
  82   EXPECT_EQ(1, filter->hit_count());
  83
  84   // Check we can remove URL matching.
  85   filter->RemoveUrlHandler(kUrl1);
  86   EXPECT_TRUE(filter->MaybeInterceptRequest(request1.get(), NULL) == NULL);
  87   EXPECT_EQ(1, filter->hit_count());
  88
  89   // Check hostname matching.
  90   filter->ClearHandlers();
  91   EXPECT_EQ(0, filter->hit_count());
  92   filter->AddHostnameHandler(kUrl1.scheme(), kUrl1.host(), &FactoryB);
  93   {
  94     scoped_refptr<URLRequestJob> found =
  95         filter->MaybeInterceptRequest(request1.get(), NULL);
  96     EXPECT_EQ(job_b, found.get());
  97     EXPECT_TRUE(job_b != NULL);
  98     job_b = NULL;
  99   }
 100   EXPECT_EQ(1, filter->hit_count());
 101
 102   // Check we don't match other hostnames.
 103   EXPECT_TRUE(filter->MaybeInterceptRequest(request2.get(), NULL) == NULL);
 104   EXPECT_EQ(1, filter->hit_count());
 105
 106   // Check we can remove hostname matching.
 107   filter->RemoveHostnameHandler(kUrl1.scheme(), kUrl1.host());
 108   EXPECT_TRUE(filter->MaybeInterceptRequest(request1.get(), NULL) == NULL);
 109   EXPECT_EQ(1, filter->hit_count());
 110
 111   // Check URLRequestInterceptor hostname matching.
 112   filter->ClearHandlers();
 113   EXPECT_EQ(0, filter->hit_count());
 114   filter->AddHostnameInterceptor(
 115       kUrl1.scheme(), kUrl1.host(),
 116       scoped_ptr<net::URLRequestInterceptor>(new TestURLRequestInterceptor()));
 117   {
 118     scoped_refptr<URLRequestJob> found =
 119         filter->MaybeInterceptRequest(request1.get(), NULL);
 120     EXPECT_EQ(job_c, found.get());
 121     EXPECT_TRUE(job_c != NULL);
 122     job_c = NULL;
 123   }
 124   EXPECT_EQ(1, filter->hit_count());
 125
 126   // Check URLRequestInterceptor URL matching.
 127   filter->ClearHandlers();
 128   EXPECT_EQ(0, filter->hit_count());
 129   filter->AddUrlInterceptor(
 130       kUrl2,
 131       scoped_ptr<net::URLRequestInterceptor>(new TestURLRequestInterceptor()));
 132   {
 133     scoped_refptr<URLRequestJob> found =
 134         filter->MaybeInterceptRequest(request2.get(), NULL);
 135     EXPECT_EQ(job_c, found.get());
 136     EXPECT_TRUE(job_c != NULL);
 137     job_c = NULL;
 138   }
 139   EXPECT_EQ(1, filter->hit_count());
 140
 141   filter->ClearHandlers();
 142 }
 143
 144 }  // namespace
 145
 146 }  // namespace net