Add three of the six extensions to PAC that Internet Explorer supports. ...

net/proxy/proxy_resolver_v8_unittest.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/path_service.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_log_unittest.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
 #include "net/proxy/proxy_resolver_v8.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 // Javascript bindings for ProxyResolverV8, which returns mock values.
 // Each time one of the bindings is called into, we push the input into a
 // list, for later verification.
 class MockJSBindings : public ProxyResolverJSBindings {
  public:
-  MockJSBindings() : my_ip_address_count(0) {}
+  MockJSBindings() : my_ip_address_count(0), my_ip_address_ex_count(0) {}
 
   virtual void Alert(const std::string& message) {
     LOG(INFO) << "PAC-alert: " << message;  // Helpful when debugging.
     alerts.push_back(message);
   }
 
   virtual std::string MyIpAddress() {
     my_ip_address_count++;
     return my_ip_address_result;
   }
 
+  virtual std::string MyIpAddressEx() {
+    my_ip_address_ex_count++;
+    return my_ip_address_ex_result;
+  }
+
   virtual std::string DnsResolve(const std::string& host) {
     dns_resolves.push_back(host);
     return dns_resolve_result;
   }
 
+  virtual std::string DnsResolveEx(const std::string& host) {
+    dns_resolves_ex.push_back(host);
+    return dns_resolve_ex_result;
+  }
+
   virtual void OnError(int line_number, const std::string& message) {
     // Helpful when debugging.
     LOG(INFO) << "PAC-error: [" << line_number << "] " << message;
 
     errors.push_back(message);
     errors_line_number.push_back(line_number);
   }
 
   // Mock values to return.
   std::string my_ip_address_result;
+  std::string my_ip_address_ex_result;
   std::string dns_resolve_result;
+  std::string dns_resolve_ex_result;
 
   // Inputs we got called with.
   std::vector<std::string> alerts;
   std::vector<std::string> errors;
   std::vector<int> errors_line_number;
   std::vector<std::string> dns_resolves;
+  std::vector<std::string> dns_resolves_ex;
   int my_ip_address_count;
+  int my_ip_address_ex_count;
 };
 
 // This is the same as ProxyResolverV8, but it uses mock bindings in place of
 // the default bindings, and has a helper function to load PAC scripts from
 // disk.
 class ProxyResolverV8WithMockBindings : public ProxyResolverV8 {
  public:
   ProxyResolverV8WithMockBindings() : ProxyResolverV8(new MockJSBindings()) {}
 
   MockJSBindings* mock_js_bindings() const {
@@ skipping 315 matching lines @@
   EXPECT_EQ("function fn() {}", bindings->dns_resolves[5]);
 
   // TODO(eroman): This isn't quite right... should probably stringize
   // to something like "['3']".
   EXPECT_EQ("3", bindings->dns_resolves[6]);
 
   EXPECT_EQ("arg1", bindings->dns_resolves[7]);
 
   // MyIpAddress was called two times.
   EXPECT_EQ(2, bindings->my_ip_address_count);
+
+  // MyIpAddressEx was called once.
+  EXPECT_EQ(1, bindings->my_ip_address_ex_count);
+
+  // DnsResolveEx was called 2 times.
+  ASSERT_EQ(2U, bindings->dns_resolves_ex.size());
+  EXPECT_EQ("is_resolvable", bindings->dns_resolves_ex[0]);
+  EXPECT_EQ("foobar", bindings->dns_resolves_ex[1]);
 }
 
 // Test that calls to the myIpAddress() and dnsResolve() bindings get
 // logged to the LoadLog parameter.
 TEST(ProxyResolverV8Test, LoadLog) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("simple.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
@@ skipping 53 matching lines @@
 
   ProxyInfo proxy_info;
   scoped_refptr<LoadLog> log(new LoadLog);
   result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL, log);
 
   EXPECT_EQ(OK, result);
   EXPECT_FALSE(proxy_info.is_direct());
   EXPECT_EQ("success:3", proxy_info.proxy_server().ToURI());
 }
 
+// Test the return values from myIpAddress(), myIpAddressEx(), dnsResolve(),
+// dnsResolveEx(), isResolvable(), isResolvableEx(), when the the binding
+// returns empty string (failure). This simulates the return values from
+// those functions when the underlying DNS resolution fails.
+TEST(ProxyResolverV8Test, DNSResolutionFailure) {
+  ProxyResolverV8WithMockBindings resolver;
+  int result = resolver.SetPacScriptFromDisk("dns_fail.js");
+  EXPECT_EQ(OK, result);
+
+  ProxyInfo proxy_info;
+  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL, NULL);
+
+  EXPECT_EQ(OK, result);
+  EXPECT_FALSE(proxy_info.is_direct());
+  EXPECT_EQ("success:80", proxy_info.proxy_server().ToURI());
+}
+
 }  // namespace
 }  // namespace net