proxy_server_unittest.cc 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  1. // Copyright (c) 2010 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. #include "net/base/proxy_server.h"
  5. #include "base/strings/string_number_conversions.h"
  6. #include "net/base/proxy_string_util.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. #include "third_party/abseil-cpp/absl/types/optional.h"
  9. namespace net {
  10. namespace {
  11. TEST(ProxyServerTest, DefaultConstructor) {
  12. ProxyServer proxy_server;
  13. EXPECT_FALSE(proxy_server.is_valid());
  14. }
  15. TEST(ProxyServerTest, FromSchemeHostAndPort) {
  16. const struct {
  17. const ProxyServer::Scheme input_scheme;
  18. const char* const input_host;
  19. const absl::optional<uint16_t> input_port;
  20. const char* const input_port_str;
  21. const char* const expected_host;
  22. const uint16_t expected_port;
  23. } tests[] = {
  24. {ProxyServer::SCHEME_HTTP, "foopy", 80, "80", "foopy", 80},
  25. // Non-standard port
  26. {ProxyServer::SCHEME_HTTP, "foopy", 10, "10", "foopy", 10},
  27. {ProxyServer::SCHEME_HTTP, "foopy", 0, "0", "foopy", 0},
  28. // Hostname canonicalization
  29. {ProxyServer::SCHEME_HTTP, "FoOpY", 80, "80", "foopy", 80},
  30. {ProxyServer::SCHEME_HTTP, "f\u00fcpy", 80, "80", "xn--fpy-hoa", 80},
  31. // IPv4 literal
  32. {ProxyServer::SCHEME_HTTP, "1.2.3.4", 80, "80", "1.2.3.4", 80},
  33. // IPv4 literal canonicalization
  34. {ProxyServer::SCHEME_HTTP, "127.1", 80, "80", "127.0.0.1", 80},
  35. {ProxyServer::SCHEME_HTTP, "0x7F.0x1", 80, "80", "127.0.0.1", 80},
  36. {ProxyServer::SCHEME_HTTP, "0177.01", 80, "80", "127.0.0.1", 80},
  37. // IPv6 literal
  38. {ProxyServer::SCHEME_HTTP, "[3ffe:2a00:100:7031::1]", 80, "80",
  39. "[3ffe:2a00:100:7031::1]", 80},
  40. {ProxyServer::SCHEME_HTTP, "3ffe:2a00:100:7031::1", 80, "80",
  41. "[3ffe:2a00:100:7031::1]", 80},
  42. // IPv6 literal canonicalization
  43. {ProxyServer::SCHEME_HTTP, "FEDC:BA98:7654:3210:FEDC:BA98:7654:3210", 80,
  44. "80", "[fedc:ba98:7654:3210:fedc:ba98:7654:3210]", 80},
  45. {ProxyServer::SCHEME_HTTP, "::192.9.5.5", 80, "80", "[::c009:505]", 80},
  46. // Other schemes
  47. {ProxyServer::SCHEME_HTTPS, "foopy", 111, "111", "foopy", 111},
  48. {ProxyServer::SCHEME_QUIC, "foopy", 111, "111", "foopy", 111},
  49. {ProxyServer::SCHEME_SOCKS4, "foopy", 111, "111", "foopy", 111},
  50. {ProxyServer::SCHEME_SOCKS5, "foopy", 111, "111", "foopy", 111},
  51. // Default ports
  52. {ProxyServer::SCHEME_HTTP, "foopy", absl::nullopt, "", "foopy", 80},
  53. {ProxyServer::SCHEME_HTTPS, "foopy", absl::nullopt, "", "foopy", 443},
  54. {ProxyServer::SCHEME_QUIC, "foopy", absl::nullopt, "", "foopy", 443},
  55. {ProxyServer::SCHEME_SOCKS4, "foopy", absl::nullopt, "", "foopy", 1080},
  56. {ProxyServer::SCHEME_SOCKS5, "foopy", absl::nullopt, "", "foopy", 1080},
  57. };
  58. for (size_t i = 0; i < std::size(tests); ++i) {
  59. SCOPED_TRACE(base::NumberToString(i) + ": " + tests[i].input_host + ":" +
  60. base::NumberToString(tests[i].input_port.value_or(-1)));
  61. auto proxy = ProxyServer::FromSchemeHostAndPort(
  62. tests[i].input_scheme, tests[i].input_host, tests[i].input_port);
  63. ASSERT_TRUE(proxy.is_valid());
  64. EXPECT_EQ(proxy.scheme(), tests[i].input_scheme);
  65. EXPECT_EQ(proxy.GetHost(), tests[i].expected_host);
  66. EXPECT_EQ(proxy.GetPort(), tests[i].expected_port);
  67. auto proxy_from_string_port = ProxyServer::FromSchemeHostAndPort(
  68. tests[i].input_scheme, tests[i].input_host, tests[i].input_port_str);
  69. EXPECT_TRUE(proxy_from_string_port.is_valid());
  70. EXPECT_EQ(proxy, proxy_from_string_port);
  71. }
  72. }
  73. TEST(ProxyServerTest, InvalidHostname) {
  74. const char* const tests[]{
  75. "",
  76. "[]",
  77. "[foo]",
  78. "foo:",
  79. "foo:80",
  80. ":",
  81. "http://foo",
  82. "3ffe:2a00:100:7031::1]",
  83. "[3ffe:2a00:100:7031::1",
  84. "foo.80",
  85. };
  86. for (size_t i = 0; i < std::size(tests); ++i) {
  87. SCOPED_TRACE(base::NumberToString(i) + ": " + tests[i]);
  88. auto proxy = ProxyServer::FromSchemeHostAndPort(ProxyServer::SCHEME_HTTP,
  89. tests[i], 80);
  90. EXPECT_FALSE(proxy.is_valid());
  91. }
  92. }
  93. TEST(ProxyServerTest, InvalidPort) {
  94. const char* const tests[]{
  95. "-1",
  96. "65536",
  97. "foo",
  98. "0x35",
  99. };
  100. for (size_t i = 0; i < std::size(tests); ++i) {
  101. SCOPED_TRACE(base::NumberToString(i) + ": " + tests[i]);
  102. auto proxy = ProxyServer::FromSchemeHostAndPort(ProxyServer::SCHEME_HTTP,
  103. "foopy", tests[i]);
  104. EXPECT_FALSE(proxy.is_valid());
  105. }
  106. }
  107. TEST(ProxyServerTest, ComparatorAndEquality) {
  108. const struct {
  109. // Inputs.
  110. ProxyServer server1;
  111. ProxyServer server2;
  112. // Expectation.
  113. // -1 means server1 is less than server2
  114. // 0 means server1 equals server2
  115. // 1 means server1 is greater than server2
  116. int expected_comparison;
  117. } kTests[] = {
  118. {// Equal.
  119. ProxyUriToProxyServer("foo:11", ProxyServer::SCHEME_HTTP),
  120. ProxyUriToProxyServer("http://foo:11", ProxyServer::SCHEME_HTTP), 0},
  121. {// Port is different.
  122. ProxyUriToProxyServer("foo:333", ProxyServer::SCHEME_HTTP),
  123. ProxyUriToProxyServer("foo:444", ProxyServer::SCHEME_HTTP), -1},
  124. {// Host is different.
  125. ProxyUriToProxyServer("foo:33", ProxyServer::SCHEME_HTTP),
  126. ProxyUriToProxyServer("bar:33", ProxyServer::SCHEME_HTTP), 1},
  127. {// Scheme is different.
  128. ProxyUriToProxyServer("socks4://foo:33", ProxyServer::SCHEME_HTTP),
  129. ProxyUriToProxyServer("http://foo:33", ProxyServer::SCHEME_HTTP), 1},
  130. };
  131. for (const auto& test : kTests) {
  132. EXPECT_TRUE(test.server1.is_valid());
  133. EXPECT_TRUE(test.server2.is_valid());
  134. switch (test.expected_comparison) {
  135. case -1:
  136. EXPECT_TRUE(test.server1 < test.server2);
  137. EXPECT_FALSE(test.server2 < test.server1);
  138. EXPECT_FALSE(test.server2 == test.server1);
  139. EXPECT_FALSE(test.server1 == test.server2);
  140. break;
  141. case 0:
  142. EXPECT_FALSE(test.server1 < test.server2);
  143. EXPECT_FALSE(test.server2 < test.server1);
  144. EXPECT_TRUE(test.server2 == test.server1);
  145. EXPECT_TRUE(test.server1 == test.server2);
  146. break;
  147. case 1:
  148. EXPECT_FALSE(test.server1 < test.server2);
  149. EXPECT_TRUE(test.server2 < test.server1);
  150. EXPECT_FALSE(test.server2 == test.server1);
  151. EXPECT_FALSE(test.server1 == test.server2);
  152. break;
  153. default:
  154. FAIL() << "Invalid expectation. Can be only -1, 0, 1";
  155. }
  156. }
  157. }
  158. // Tests the various "is_*()" methods on ProxyServer.
  159. TEST(ProxyServerTest, Properties) {
  160. // HTTP proxy.
  161. {
  162. auto proxy = PacResultElementToProxyServer("PROXY foo");
  163. ASSERT_TRUE(proxy.is_valid());
  164. EXPECT_TRUE(proxy.is_http());
  165. EXPECT_FALSE(proxy.is_https());
  166. EXPECT_TRUE(proxy.is_http_like());
  167. EXPECT_FALSE(proxy.is_secure_http_like());
  168. }
  169. // HTTPS proxy.
  170. {
  171. auto proxy = PacResultElementToProxyServer("HTTPS foo");
  172. ASSERT_TRUE(proxy.is_valid());
  173. EXPECT_FALSE(proxy.is_http());
  174. EXPECT_TRUE(proxy.is_https());
  175. EXPECT_TRUE(proxy.is_http_like());
  176. EXPECT_TRUE(proxy.is_secure_http_like());
  177. }
  178. // QUIC proxy.
  179. {
  180. auto proxy = PacResultElementToProxyServer("QUIC foo");
  181. ASSERT_TRUE(proxy.is_valid());
  182. EXPECT_FALSE(proxy.is_http());
  183. EXPECT_FALSE(proxy.is_https());
  184. EXPECT_TRUE(proxy.is_http_like());
  185. EXPECT_TRUE(proxy.is_secure_http_like());
  186. }
  187. // SOCKS5 proxy.
  188. {
  189. auto proxy = PacResultElementToProxyServer("SOCKS5 foo");
  190. ASSERT_TRUE(proxy.is_valid());
  191. EXPECT_FALSE(proxy.is_http());
  192. EXPECT_FALSE(proxy.is_https());
  193. EXPECT_FALSE(proxy.is_http_like());
  194. EXPECT_FALSE(proxy.is_secure_http_like());
  195. }
  196. // DIRECT
  197. {
  198. auto proxy = PacResultElementToProxyServer("DIRECT");
  199. ASSERT_TRUE(proxy.is_valid());
  200. EXPECT_FALSE(proxy.is_http());
  201. EXPECT_FALSE(proxy.is_https());
  202. EXPECT_FALSE(proxy.is_http_like());
  203. EXPECT_FALSE(proxy.is_secure_http_like());
  204. }
  205. }
  206. } // namespace
  207. } // namespace net