Home | History | Annotate | Download | only in proxy
      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 
     10 namespace net {
     11 namespace {
     12 
     13 void 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 
     22 TEST(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 
     98 TEST(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