Add support for mock DNS queries. This allows us to eliminate

flaky DNS queries from the unit tests.

Note: some unit tests still connect to www.google.com.  My plan
is to resolve those in a subsequent CL.

R=wtc
BUG=2635

Review URL: http://codereview.chromium.org/4022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@2545 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 86 insertions, 0 deletions

diff --git a/net/base/host_resolver_unittest.h b/net/base/host_resolver_unittest.h
new file mode 100644
index 0000000..c7ecea81
--- /dev/null
+++ b/net/base/host_resolver_unittest.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2006-2008 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.
+
+// This file defines ScopedHostMapper, which is a helper class for writing
+// tests that use HostResolver either directly or indirectly.
+//
+// In most cases, it is important that unit tests avoid making actual DNS
+// queries since the resulting tests can be flaky, especially if the network is
+// unreliable for some reason.  To simplify writing tests that avoid making
+// actual DNS queries, the following helper class may be used:
+//
+//   ScopedHostMapper scoped_host_mapper;
+//   scoped_host_mapper.AddRule("foo.com", "1.2.3.4");
+//   scoped_host_mapper.AddRule("bar.com", "2.3.4.5");
+//   ...
+//
+// The above rules define a static mapping from hostnames to IP address
+// literals.  The first parameter to AddRule specifies a host pattern to match
+// against, and the second parameter indicates what value should be used to
+// replace the given hostname.  So, the following is also supported:
+//
+//   scoped_host_mapper.AddRule("*.com", "127.0.0.1");
+//
+// If there are multiple ScopedHostMappers on the stack, then the last one
+// allocated will be used.  However, if it does not provide a matching rule,
+// then it will delegate to the previously allocated ScopedHostMapper.
+// Finally, if no HostMapper matches a given hostname, then the hostname will
+// be unmodified.
+
+#ifndef NET_BASE_HOST_RESOLVER_UNITTEST_H_
+#define NET_BASE_HOST_RESOLVER_UNITTEST_H_
+
+#ifdef UNIT_TEST
+
+#include <list>
+
+#include "base/string_util.h"
+#include "net/base/host_resolver.h"
+#include "net/base/net_errors.h"
+
+namespace net {
+
+// This class sets the HostResolverProc for a particular scope.
+class ScopedHostMapper : public HostMapper {
+ public:
+  ScopedHostMapper() {
+    previous_host_mapper_ = SetHostMapper(this);
+  }
+
+  ~ScopedHostMapper() {
+    SetHostMapper(previous_host_mapper_);
+  }
+
+  // Any hostname matching the given pattern will be replaced with the given
+  // replacement value.  Usually, replacement should be an IP address literal.
+  void AddRule(const char* host_pattern, const char* replacement) {
+    rules_.push_back(Rule(host_pattern, replacement));
+  }
+
+ private:
+  std::string Map(const std::string& host) {
+    RuleList::const_iterator r;
+    for (r = rules_.begin(); r != rules_.end(); ++r) {
+      if (MatchPattern(host, r->host_pattern))
+        return r->replacement;
+    }
+    return previous_host_mapper_ ? previous_host_mapper_->Map(host) : host;
+  }
+
+  struct Rule {
+    std::string host_pattern;
+    std::string replacement;
+    Rule(const char* h, const char* r) : host_pattern(h), replacement(r) {}
+  };
+  typedef std::list<Rule> RuleList;
+
+  HostMapper* previous_host_mapper_;
+  RuleList rules_;
+};
+
+}  // namespace net
+
+#endif  // UNIT_TEST
+
+#endif  // NET_BASE_HOST_RESOLVER_UNITTEST_H_