1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
// 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.
#ifndef NET_BASE_MOCK_HOST_RESOLVER_H_
#define NET_BASE_MOCK_HOST_RESOLVER_H_
#include <list>
#include "base/waitable_event.h"
#include "net/base/host_resolver_impl.h"
#include "net/base/host_resolver_proc.h"
namespace net {
class RuleBasedHostResolverProc;
// 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, pass a MockHostResolver as the HostResolver dependency.
// The socket addresses returned can be configured using the
// RuleBasedHostResolverProc:
//
// host_resolver->rules()->AddRule("foo.com", "1.2.3.4");
// host_resolver->rules()->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:
//
// host_mapper->AddRule("*.com", "127.0.0.1");
//
// Replacement doesn't have to be string representing an IP address. It can
// re-map one hostname to another as well.
// Base class shared by MockHostResolver and MockCachingHostResolver.
class MockHostResolverBase : public HostResolver {
public:
virtual ~MockHostResolverBase() {}
// HostResolver methods:
virtual int Resolve(const RequestInfo& info, AddressList* addresses,
CompletionCallback* callback, RequestHandle* out_req);
virtual void CancelRequest(RequestHandle req);
virtual void AddObserver(Observer* observer);
virtual void RemoveObserver(Observer* observer);
// TODO(eroman): temp hack for http://crbug.com/15513
virtual void Shutdown();
RuleBasedHostResolverProc* rules() { return rules_; }
// Controls whether resolutions complete synchronously or asynchronously.
void set_synchronous_mode(bool is_synchronous) {
synchronous_mode_ = is_synchronous;
}
// Resets the mock.
void Reset(HostResolverProc* interceptor);
protected:
MockHostResolverBase(bool use_caching);
private:
scoped_refptr<HostResolverImpl> impl_;
scoped_refptr<RuleBasedHostResolverProc> rules_;
bool synchronous_mode_;
bool use_caching_;
};
class MockHostResolver : public MockHostResolverBase {
public:
MockHostResolver() : MockHostResolverBase(false /*use_caching*/) {}
};
// Same as MockHostResolver, except internally it uses a host-cache.
//
// Note that tests are advised to use MockHostResolver instead, since it is
// more predictable. (MockHostResolver also can be put into synchronous
// operation mode in case that is what you needed from the caching version).
class MockCachingHostResolver : public MockHostResolverBase {
public:
MockCachingHostResolver() : MockHostResolverBase(true /*use_caching*/) {}
};
// RuleBasedHostResolverProc applies a set of rules to map a host string to
// a replacement host string. It then uses the system host resolver to return
// a socket address. Generally the replacement should be an IPv4 literal so
// there is no network dependency.
class RuleBasedHostResolverProc : public HostResolverProc {
public:
explicit RuleBasedHostResolverProc(HostResolverProc* previous);
~RuleBasedHostResolverProc();
// 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 std::string& host_pattern,
const std::string& replacement);
// Same as AddRule(), but the replacement is expected to be an IPV6 literal.
// You should use this in place of AddRule(), since the system's host resolver
// may not support IPv6 literals on all systems. Whereas this variant
// constructs the socket address directly so it will always work.
void AddIPv6Rule(const std::string& host_pattern,
const std::string& ipv6_literal);
void AddRuleWithLatency(const std::string& host_pattern,
const std::string& replacement,
int latency_ms);
// Make sure that |host| will not be re-mapped or even processed by underlying
// host resolver procedures. It can also be a pattern.
void AllowDirectLookup(const std::string& host);
// Simulate a lookup failure for |host| (it also can be a pattern).
void AddSimulatedFailure(const std::string& host);
// HostResolverProc methods:
virtual int Resolve(const std::string& host, AddressList* addrlist);
private:
struct Rule;
typedef std::list<Rule> RuleList;
RuleList rules_;
};
// Using WaitingHostResolverProc you can simulate very long lookups.
class WaitingHostResolverProc : public HostResolverProc {
public:
explicit WaitingHostResolverProc(HostResolverProc* previous)
: HostResolverProc(previous), event_(false, false) {}
void Signal() {
event_.Signal();
}
// HostResolverProc methods:
virtual int Resolve(const std::string& host, AddressList* addrlist) {
event_.Wait();
return ResolveUsingPrevious(host, addrlist);
}
base::WaitableEvent event_;
};
// This class sets the HostResolverProc for a particular scope. If there are
// multiple ScopedDefaultHostResolverProc in existence, then the last one
// allocated will be used. However, if it does not provide a matching rule,
// then it should delegate to the previously set HostResolverProc.
//
// NOTE: Only use this as a catch-all safety net. Individual tests should use
// MockHostResolver.
class ScopedDefaultHostResolverProc {
public:
ScopedDefaultHostResolverProc() {}
explicit ScopedDefaultHostResolverProc(HostResolverProc* proc);
~ScopedDefaultHostResolverProc();
void Init(HostResolverProc* proc);
private:
scoped_refptr<HostResolverProc> current_proc_;
scoped_refptr<HostResolverProc> previous_proc_;
};
} // namespace net
#endif // NET_BASE_MOCK_HOST_RESOLVER_H_
|
