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
17namespace net {
18
19namespace {
20
21URLRequestTestJob* job_a;
22
23URLRequestJob* 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
30URLRequestTestJob* job_b;
31
32URLRequestJob* 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
39URLRequestTestJob* job_c;
40
41class 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
52TEST(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
147