| OLD | NEW |
|---|
| (Empty) |
| 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/dns/mapped_host_resolver.h" | |
| 6 | |
| 7 #include "net/base/address_list.h" | |
| 8 #include "net/base/net_errors.h" | |
| 9 #include "net/base/net_log.h" | |
| 10 #include "net/base/net_util.h" | |
| 11 #include "net/base/test_completion_callback.h" | |
| 12 #include "net/dns/mock_host_resolver.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 namespace net { | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 std::string FirstAddress(const AddressList& address_list) { | |
| 20 if (address_list.empty()) | |
| 21 return std::string(); | |
| 22 return address_list.front().ToString(); | |
| 23 } | |
| 24 | |
| 25 TEST(MappedHostResolverTest, Inclusion) { | |
| 26 // Create a mock host resolver, with specific hostname to IP mappings. | |
| 27 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); | |
| 28 resolver_impl->rules()->AddSimulatedFailure("*google.com"); | |
| 29 resolver_impl->rules()->AddRule("baz.com", "192.168.1.5"); | |
| 30 resolver_impl->rules()->AddRule("foo.com", "192.168.1.8"); | |
| 31 resolver_impl->rules()->AddRule("proxy", "192.168.1.11"); | |
| 32 | |
| 33 // Create a remapped resolver that uses |resolver_impl|. | |
| 34 scoped_ptr<MappedHostResolver> resolver( | |
| 35 new MappedHostResolver(resolver_impl.Pass())); | |
| 36 | |
| 37 int rv; | |
| 38 AddressList address_list; | |
| 39 | |
| 40 // Try resolving "www.google.com:80". There are no mappings yet, so this | |
| 41 // hits |resolver_impl| and fails. | |
| 42 TestCompletionCallback callback; | |
| 43 rv = resolver->Resolve( | |
| 44 HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), | |
| 45 DEFAULT_PRIORITY, | |
| 46 &address_list, | |
| 47 callback.callback(), | |
| 48 NULL, | |
| 49 BoundNetLog()); | |
| 50 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 51 rv = callback.WaitForResult(); | |
| 52 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); | |
| 53 | |
| 54 // Remap *.google.com to baz.com. | |
| 55 EXPECT_TRUE(resolver->AddRuleFromString("map *.google.com baz.com")); | |
| 56 | |
| 57 // Try resolving "www.google.com:80". Should be remapped to "baz.com:80". | |
| 58 rv = resolver->Resolve( | |
| 59 HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), | |
| 60 DEFAULT_PRIORITY, | |
| 61 &address_list, | |
| 62 callback.callback(), | |
| 63 NULL, | |
| 64 BoundNetLog()); | |
| 65 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 66 rv = callback.WaitForResult(); | |
| 67 EXPECT_EQ(OK, rv); | |
| 68 EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list)); | |
| 69 | |
| 70 // Try resolving "foo.com:77". This will NOT be remapped, so result | |
| 71 // is "foo.com:77". | |
| 72 rv = resolver->Resolve(HostResolver::RequestInfo(HostPortPair("foo.com", 77)), | |
| 73 DEFAULT_PRIORITY, | |
| 74 &address_list, | |
| 75 callback.callback(), | |
| 76 NULL, | |
| 77 BoundNetLog()); | |
| 78 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 79 rv = callback.WaitForResult(); | |
| 80 EXPECT_EQ(OK, rv); | |
| 81 EXPECT_EQ("192.168.1.8:77", FirstAddress(address_list)); | |
| 82 | |
| 83 // Remap "*.org" to "proxy:99". | |
| 84 EXPECT_TRUE(resolver->AddRuleFromString("Map *.org proxy:99")); | |
| 85 | |
| 86 // Try resolving "chromium.org:61". Should be remapped to "proxy:99". | |
| 87 rv = resolver->Resolve( | |
| 88 HostResolver::RequestInfo(HostPortPair("chromium.org", 61)), | |
| 89 DEFAULT_PRIORITY, | |
| 90 &address_list, | |
| 91 callback.callback(), | |
| 92 NULL, | |
| 93 BoundNetLog()); | |
| 94 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 95 rv = callback.WaitForResult(); | |
| 96 EXPECT_EQ(OK, rv); | |
| 97 EXPECT_EQ("192.168.1.11:99", FirstAddress(address_list)); | |
| 98 } | |
| 99 | |
| 100 // Tests that exclusions are respected. | |
| 101 TEST(MappedHostResolverTest, Exclusion) { | |
| 102 // Create a mock host resolver, with specific hostname to IP mappings. | |
| 103 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); | |
| 104 resolver_impl->rules()->AddRule("baz", "192.168.1.5"); | |
| 105 resolver_impl->rules()->AddRule("www.google.com", "192.168.1.3"); | |
| 106 | |
| 107 // Create a remapped resolver that uses |resolver_impl|. | |
| 108 scoped_ptr<MappedHostResolver> resolver( | |
| 109 new MappedHostResolver(resolver_impl.Pass())); | |
| 110 | |
| 111 int rv; | |
| 112 AddressList address_list; | |
| 113 TestCompletionCallback callback; | |
| 114 | |
| 115 // Remap "*.com" to "baz". | |
| 116 EXPECT_TRUE(resolver->AddRuleFromString("map *.com baz")); | |
| 117 | |
| 118 // Add an exclusion for "*.google.com". | |
| 119 EXPECT_TRUE(resolver->AddRuleFromString("EXCLUDE *.google.com")); | |
| 120 | |
| 121 // Try resolving "www.google.com". Should not be remapped due to exclusion). | |
| 122 rv = resolver->Resolve( | |
| 123 HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), | |
| 124 DEFAULT_PRIORITY, | |
| 125 &address_list, | |
| 126 callback.callback(), | |
| 127 NULL, | |
| 128 BoundNetLog()); | |
| 129 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 130 rv = callback.WaitForResult(); | |
| 131 EXPECT_EQ(OK, rv); | |
| 132 EXPECT_EQ("192.168.1.3:80", FirstAddress(address_list)); | |
| 133 | |
| 134 // Try resolving "chrome.com:80". Should be remapped to "baz:80". | |
| 135 rv = resolver->Resolve( | |
| 136 HostResolver::RequestInfo(HostPortPair("chrome.com", 80)), | |
| 137 DEFAULT_PRIORITY, | |
| 138 &address_list, | |
| 139 callback.callback(), | |
| 140 NULL, | |
| 141 BoundNetLog()); | |
| 142 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 143 rv = callback.WaitForResult(); | |
| 144 EXPECT_EQ(OK, rv); | |
| 145 EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list)); | |
| 146 } | |
| 147 | |
| 148 TEST(MappedHostResolverTest, SetRulesFromString) { | |
| 149 // Create a mock host resolver, with specific hostname to IP mappings. | |
| 150 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); | |
| 151 resolver_impl->rules()->AddRule("baz", "192.168.1.7"); | |
| 152 resolver_impl->rules()->AddRule("bar", "192.168.1.9"); | |
| 153 | |
| 154 // Create a remapped resolver that uses |resolver_impl|. | |
| 155 scoped_ptr<MappedHostResolver> resolver( | |
| 156 new MappedHostResolver(resolver_impl.Pass())); | |
| 157 | |
| 158 int rv; | |
| 159 AddressList address_list; | |
| 160 TestCompletionCallback callback; | |
| 161 | |
| 162 // Remap "*.com" to "baz", and *.net to "bar:60". | |
| 163 resolver->SetRulesFromString("map *.com baz , map *.net bar:60"); | |
| 164 | |
| 165 // Try resolving "www.google.com". Should be remapped to "baz". | |
| 166 rv = resolver->Resolve( | |
| 167 HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), | |
| 168 DEFAULT_PRIORITY, | |
| 169 &address_list, | |
| 170 callback.callback(), | |
| 171 NULL, | |
| 172 BoundNetLog()); | |
| 173 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 174 rv = callback.WaitForResult(); | |
| 175 EXPECT_EQ(OK, rv); | |
| 176 EXPECT_EQ("192.168.1.7:80", FirstAddress(address_list)); | |
| 177 | |
| 178 // Try resolving "chrome.net:80". Should be remapped to "bar:60". | |
| 179 rv = resolver->Resolve( | |
| 180 HostResolver::RequestInfo(HostPortPair("chrome.net", 80)), | |
| 181 DEFAULT_PRIORITY, | |
| 182 &address_list, | |
| 183 callback.callback(), | |
| 184 NULL, | |
| 185 BoundNetLog()); | |
| 186 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 187 rv = callback.WaitForResult(); | |
| 188 EXPECT_EQ(OK, rv); | |
| 189 EXPECT_EQ("192.168.1.9:60", FirstAddress(address_list)); | |
| 190 } | |
| 191 | |
| 192 // Parsing bad rules should silently discard the rule (and never crash). | |
| 193 TEST(MappedHostResolverTest, ParseInvalidRules) { | |
| 194 scoped_ptr<MappedHostResolver> resolver( | |
| 195 new MappedHostResolver(scoped_ptr<HostResolver>())); | |
| 196 | |
| 197 EXPECT_FALSE(resolver->AddRuleFromString("xyz")); | |
| 198 EXPECT_FALSE(resolver->AddRuleFromString(std::string())); | |
| 199 EXPECT_FALSE(resolver->AddRuleFromString(" ")); | |
| 200 EXPECT_FALSE(resolver->AddRuleFromString("EXCLUDE")); | |
| 201 EXPECT_FALSE(resolver->AddRuleFromString("EXCLUDE foo bar")); | |
| 202 EXPECT_FALSE(resolver->AddRuleFromString("INCLUDE")); | |
| 203 EXPECT_FALSE(resolver->AddRuleFromString("INCLUDE x")); | |
| 204 EXPECT_FALSE(resolver->AddRuleFromString("INCLUDE x :10")); | |
| 205 } | |
| 206 | |
| 207 // Test mapping hostnames to resolving failures. | |
| 208 TEST(MappedHostResolverTest, MapToError) { | |
| 209 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); | |
| 210 resolver_impl->rules()->AddRule("*", "192.168.1.5"); | |
| 211 | |
| 212 scoped_ptr<MappedHostResolver> resolver( | |
| 213 new MappedHostResolver(resolver_impl.Pass())); | |
| 214 | |
| 215 int rv; | |
| 216 AddressList address_list; | |
| 217 | |
| 218 // Remap *.google.com to resolving failures. | |
| 219 EXPECT_TRUE(resolver->AddRuleFromString("MAP *.google.com ~NOTFOUND")); | |
| 220 | |
| 221 // Try resolving www.google.com --> Should give an error. | |
| 222 TestCompletionCallback callback1; | |
| 223 rv = resolver->Resolve( | |
| 224 HostResolver::RequestInfo(HostPortPair("www.google.com", 80)), | |
| 225 DEFAULT_PRIORITY, | |
| 226 &address_list, | |
| 227 callback1.callback(), | |
| 228 NULL, | |
| 229 BoundNetLog()); | |
| 230 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); | |
| 231 | |
| 232 // Try resolving www.foo.com --> Should succeed. | |
| 233 TestCompletionCallback callback2; | |
| 234 rv = resolver->Resolve( | |
| 235 HostResolver::RequestInfo(HostPortPair("www.foo.com", 80)), | |
| 236 DEFAULT_PRIORITY, | |
| 237 &address_list, | |
| 238 callback2.callback(), | |
| 239 NULL, | |
| 240 BoundNetLog()); | |
| 241 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 242 rv = callback2.WaitForResult(); | |
| 243 EXPECT_EQ(OK, rv); | |
| 244 EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list)); | |
| 245 } | |
| 246 | |
| 247 } // namespace | |
| 248 | |
| 249 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master