1// Copyright (c) 2009 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/proxy/proxy_config.h"
6#include "net/proxy/proxy_config_service_common_unittest.h"
7#include "net/proxy/proxy_info.h"
8#include "testing/gtest/include/gtest/gtest.h"
9
10namespace net {
11namespace {
12
13void ExpectProxyServerEquals(const char* expectation,
14                             const ProxyServer& proxy_server) {
15  if (expectation == NULL) {
16    EXPECT_FALSE(proxy_server.is_valid());
17  } else {
18    EXPECT_EQ(expectation, proxy_server.ToURI());
19  }
20}
21
22TEST(ProxyConfigTest, Equals) {
23  // Test |ProxyConfig::auto_detect|.
24
25  ProxyConfig config1;
26  config1.set_auto_detect(true);
27
28  ProxyConfig config2;
29  config2.set_auto_detect(false);
30
31  EXPECT_FALSE(config1.Equals(config2));
32  EXPECT_FALSE(config2.Equals(config1));
33
34  config2.set_auto_detect(true);
35
36  EXPECT_TRUE(config1.Equals(config2));
37  EXPECT_TRUE(config2.Equals(config1));
38
39  // Test |ProxyConfig::pac_url|.
40
41  config2.set_pac_url(GURL("http://wpad/wpad.dat"));
42
43  EXPECT_FALSE(config1.Equals(config2));
44  EXPECT_FALSE(config2.Equals(config1));
45
46  config1.set_pac_url(GURL("http://wpad/wpad.dat"));
47
48  EXPECT_TRUE(config1.Equals(config2));
49  EXPECT_TRUE(config2.Equals(config1));
50
51  // Test |ProxyConfig::proxy_rules|.
52
53  config2.proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
54  config2.proxy_rules().single_proxy =
55      ProxyServer::FromURI("myproxy:80", ProxyServer::SCHEME_HTTP);
56
57  EXPECT_FALSE(config1.Equals(config2));
58  EXPECT_FALSE(config2.Equals(config1));
59
60  config1.proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
61  config1.proxy_rules().single_proxy =
62      ProxyServer::FromURI("myproxy:100", ProxyServer::SCHEME_HTTP);
63
64  EXPECT_FALSE(config1.Equals(config2));
65  EXPECT_FALSE(config2.Equals(config1));
66
67  config1.proxy_rules().single_proxy =
68      ProxyServer::FromURI("myproxy", ProxyServer::SCHEME_HTTP);
69
70  EXPECT_TRUE(config1.Equals(config2));
71  EXPECT_TRUE(config2.Equals(config1));
72
73  // Test |ProxyConfig::bypass_rules|.
74
75  config2.proxy_rules().bypass_rules.AddRuleFromString("*.google.com");
76
77  EXPECT_FALSE(config1.Equals(config2));
78  EXPECT_FALSE(config2.Equals(config1));
79
80  config1.proxy_rules().bypass_rules.AddRuleFromString("*.google.com");
81
82  EXPECT_TRUE(config1.Equals(config2));
83  EXPECT_TRUE(config2.Equals(config1));
84
85  // Test |ProxyConfig::proxy_rules.reverse_bypass|.
86
87  config2.proxy_rules().reverse_bypass = true;
88
89  EXPECT_FALSE(config1.Equals(config2));
90  EXPECT_FALSE(config2.Equals(config1));
91
92  config1.proxy_rules().reverse_bypass = true;
93
94  EXPECT_TRUE(config1.Equals(config2));
95  EXPECT_TRUE(config2.Equals(config1));
96}
97
98TEST(ProxyConfigTest, ParseProxyRules) {
99  const struct {
100    const char* proxy_rules;
101
102    ProxyConfig::ProxyRules::Type type;
103    const char* single_proxy;
104    const char* proxy_for_http;
105    const char* proxy_for_https;
106    const char* proxy_for_ftp;
107    const char* fallback_proxy;
108  } tests[] = {
109    // One HTTP proxy for all schemes.
110    {
111      "myproxy:80",
112
113      ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY,
114      "myproxy:80",
115      NULL,
116      NULL,
117      NULL,
118      NULL,
119    },
120
121    // Only specify a proxy server for "http://" urls.
122    {
123      "http=myproxy:80",
124
125      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
126      NULL,
127      "myproxy:80",
128      NULL,
129      NULL,
130      NULL,
131    },
132
133    // Specify an HTTP proxy for "ftp://" and a SOCKS proxy for "https://" urls.
134    {
135      "ftp=ftp-proxy ; https=socks4://foopy",
136
137      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
138      NULL,
139      NULL,
140      "socks4://foopy:1080",
141      "ftp-proxy:80",
142      NULL,
143    },
144
145    // Give a scheme-specific proxy as well as a non-scheme specific.
146    // The first entry "foopy" takes precedance marking this list as
147    // TYPE_SINGLE_PROXY.
148    {
149      "foopy ; ftp=ftp-proxy",
150
151      ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY,
152      "foopy:80",
153      NULL,
154      NULL,
155      NULL,
156      NULL,
157    },
158
159    // Give a scheme-specific proxy as well as a non-scheme specific.
160    // The first entry "ftp=ftp-proxy" takes precedance marking this list as
161    // TYPE_PROXY_PER_SCHEME.
162    {
163      "ftp=ftp-proxy ; foopy",
164
165      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
166      NULL,
167      NULL,
168      NULL,
169      "ftp-proxy:80",
170      NULL,
171    },
172
173    // Include duplicate entries -- last one wins.
174    {
175      "ftp=ftp1 ; ftp=ftp2 ; ftp=ftp3",
176
177      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
178      NULL,
179      NULL,
180      NULL,
181      "ftp3:80",
182      NULL,
183    },
184
185    // Only SOCKS proxy present, others being blank.
186    {
187      "socks=foopy",
188
189      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
190      NULL,
191      NULL,
192      NULL,
193      NULL,
194      "socks4://foopy:1080",
195      },
196
197    // SOCKS proxy present along with other proxies too
198    {
199      "http=httpproxy ; https=httpsproxy ; ftp=ftpproxy ; socks=foopy ",
200
201      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
202      NULL,
203      "httpproxy:80",
204      "httpsproxy:80",
205      "ftpproxy:80",
206      "socks4://foopy:1080",
207    },
208
209    // SOCKS proxy (with modifier) present along with some proxies
210    // (FTP being blank)
211    {
212      "http=httpproxy ; https=httpsproxy ; socks=socks5://foopy ",
213
214      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
215      NULL,
216      "httpproxy:80",
217      "httpsproxy:80",
218      NULL,
219      "socks5://foopy:1080",
220      },
221
222    // Include unsupported schemes -- they are discarded.
223    {
224      "crazy=foopy ; foo=bar ; https=myhttpsproxy",
225
226      ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
227      NULL,
228      NULL,
229      "myhttpsproxy:80",
230      NULL,
231      NULL,
232    },
233  };
234
235  ProxyConfig config;
236
237  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
238    config.proxy_rules().ParseFromString(tests[i].proxy_rules);
239
240    EXPECT_EQ(tests[i].type, config.proxy_rules().type);
241    ExpectProxyServerEquals(tests[i].single_proxy,
242                            config.proxy_rules().single_proxy);
243    ExpectProxyServerEquals(tests[i].proxy_for_http,
244                            config.proxy_rules().proxy_for_http);
245    ExpectProxyServerEquals(tests[i].proxy_for_https,
246                            config.proxy_rules().proxy_for_https);
247    ExpectProxyServerEquals(tests[i].proxy_for_ftp,
248                            config.proxy_rules().proxy_for_ftp);
249    ExpectProxyServerEquals(tests[i].fallback_proxy,
250                            config.proxy_rules().fallback_proxy);
251  }
252}
253
254}  // namespace
255}  // namespace net
256
257