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.
5 #ifndef NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
6 #define NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
13 #include "base/basictypes.h"
14 #include "base/compiler_specific.h"
15 #include "base/memory/ref_counted.h"
16 #include "base/memory/scoped_ptr.h"
17 #include "base/message_loop/message_loop_proxy.h"
18 #include "base/path_service.h"
19 #include "base/strings/string16.h"
20 #include "base/strings/string_util.h"
21 #include "base/strings/utf_string_conversions.h"
22 #include "base/time/time.h"
23 #include "net/base/io_buffer.h"
24 #include "net/base/load_timing_info.h"
25 #include "net/base/net_errors.h"
26 #include "net/base/network_delegate.h"
27 #include "net/base/request_priority.h"
28 #include "net/cert/cert_verifier.h"
29 #include "net/cookies/cookie_monster.h"
30 #include "net/disk_cache/disk_cache.h"
31 #include "net/ftp/ftp_network_layer.h"
32 #include "net/http/http_auth_handler_factory.h"
33 #include "net/http/http_cache.h"
34 #include "net/http/http_network_layer.h"
35 #include "net/http/http_network_session.h"
36 #include "net/http/http_request_headers.h"
37 #include "net/proxy/proxy_service.h"
38 #include "net/ssl/ssl_config_service_defaults.h"
39 #include "net/url_request/url_request.h"
40 #include "net/url_request/url_request_context.h"
41 #include "net/url_request/url_request_context_getter.h"
42 #include "net/url_request/url_request_context_storage.h"
43 #include "net/url_request/url_request_job_factory.h"
44 #include "url/url_util.h"
46 using base::TimeDelta;
50 //-----------------------------------------------------------------------------
52 class TestURLRequestContext : public URLRequestContext {
54 TestURLRequestContext();
55 // Default constructor like TestURLRequestContext() but does not call
56 // Init() in case |delay_initialization| is true. This allows modifying the
57 // URLRequestContext before it is constructed completely. If
58 // |delay_initialization| is true, Init() needs be be called manually.
59 explicit TestURLRequestContext(bool delay_initialization);
60 virtual ~TestURLRequestContext();
64 ClientSocketFactory* client_socket_factory() {
65 return client_socket_factory_;
67 void set_client_socket_factory(ClientSocketFactory* factory) {
68 client_socket_factory_ = factory;
71 void set_http_network_session_params(
72 const HttpNetworkSession::Params& params) {
78 // Optional parameters to override default values. Note that values that
79 // point to other objects the TestURLRequestContext creates will be
81 scoped_ptr<HttpNetworkSession::Params> http_network_session_params_;
84 ClientSocketFactory* client_socket_factory_;
87 URLRequestContextStorage context_storage_;
90 //-----------------------------------------------------------------------------
92 // Used to return a dummy context, which lives on the message loop
93 // given in the constructor.
94 class TestURLRequestContextGetter : public URLRequestContextGetter {
96 // |network_task_runner| must not be NULL.
97 explicit TestURLRequestContextGetter(
98 const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner);
100 // Use to pass a pre-initialized |context|.
101 TestURLRequestContextGetter(
102 const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
103 scoped_ptr<TestURLRequestContext> context);
105 // URLRequestContextGetter implementation.
106 virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE;
107 virtual scoped_refptr<base::SingleThreadTaskRunner>
108 GetNetworkTaskRunner() const OVERRIDE;
111 virtual ~TestURLRequestContextGetter();
114 const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
115 scoped_ptr<TestURLRequestContext> context_;
118 //-----------------------------------------------------------------------------
120 class TestURLRequest : public URLRequest {
122 TestURLRequest(const GURL& url,
123 RequestPriority priority,
125 TestURLRequestContext* context);
126 virtual ~TestURLRequest();
129 //-----------------------------------------------------------------------------
131 class TestDelegate : public URLRequest::Delegate {
134 virtual ~TestDelegate();
136 void set_cancel_in_received_redirect(bool val) { cancel_in_rr_ = val; }
137 void set_cancel_in_response_started(bool val) { cancel_in_rs_ = val; }
138 void set_cancel_in_received_data(bool val) { cancel_in_rd_ = val; }
139 void set_cancel_in_received_data_pending(bool val) {
140 cancel_in_rd_pending_ = val;
142 void set_quit_on_complete(bool val) { quit_on_complete_ = val; }
143 void set_quit_on_redirect(bool val) { quit_on_redirect_ = val; }
144 void set_quit_on_network_start(bool val) {
145 quit_on_before_network_start_ = val;
147 void set_allow_certificate_errors(bool val) {
148 allow_certificate_errors_ = val;
150 void set_credentials(const AuthCredentials& credentials) {
151 credentials_ = credentials;
155 const std::string& data_received() const { return data_received_; }
156 int bytes_received() const { return static_cast<int>(data_received_.size()); }
157 int response_started_count() const { return response_started_count_; }
158 int received_redirect_count() const { return received_redirect_count_; }
159 int received_before_network_start_count() const {
160 return received_before_network_start_count_;
162 bool received_data_before_response() const {
163 return received_data_before_response_;
165 bool request_failed() const { return request_failed_; }
166 bool have_certificate_errors() const { return have_certificate_errors_; }
167 bool certificate_errors_are_fatal() const {
168 return certificate_errors_are_fatal_;
170 bool auth_required_called() const { return auth_required_; }
171 bool have_full_request_headers() const { return have_full_request_headers_; }
172 const HttpRequestHeaders& full_request_headers() const {
173 return full_request_headers_;
175 void ClearFullRequestHeaders();
177 // URLRequest::Delegate:
178 virtual void OnReceivedRedirect(URLRequest* request, const GURL& new_url,
179 bool* defer_redirect) OVERRIDE;
180 virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) OVERRIDE;
181 virtual void OnAuthRequired(URLRequest* request,
182 AuthChallengeInfo* auth_info) OVERRIDE;
183 // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
184 // (Unit tests use this as a post-condition.) But for policy, this method
185 // consults |allow_certificate_errors_|.
186 virtual void OnSSLCertificateError(URLRequest* request,
187 const SSLInfo& ssl_info,
188 bool fatal) OVERRIDE;
189 virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
190 virtual void OnReadCompleted(URLRequest* request,
191 int bytes_read) OVERRIDE;
194 static const int kBufferSize = 4096;
196 virtual void OnResponseCompleted(URLRequest* request);
198 // options for controlling behavior
202 bool cancel_in_rd_pending_;
203 bool quit_on_complete_;
204 bool quit_on_redirect_;
205 bool quit_on_before_network_start_;
206 bool allow_certificate_errors_;
207 AuthCredentials credentials_;
209 // tracks status of callbacks
210 int response_started_count_;
211 int received_bytes_count_;
212 int received_redirect_count_;
213 int received_before_network_start_count_;
214 bool received_data_before_response_;
215 bool request_failed_;
216 bool have_certificate_errors_;
217 bool certificate_errors_are_fatal_;
219 std::string data_received_;
220 bool have_full_request_headers_;
221 HttpRequestHeaders full_request_headers_;
224 scoped_refptr<IOBuffer> buf_;
227 //-----------------------------------------------------------------------------
229 class TestNetworkDelegate : public NetworkDelegate {
232 NO_GET_COOKIES = 1 << 0,
233 NO_SET_COOKIE = 1 << 1,
236 TestNetworkDelegate();
237 virtual ~TestNetworkDelegate();
239 // Writes the LoadTimingInfo during the most recent call to OnBeforeRedirect.
240 bool GetLoadTimingInfoBeforeRedirect(
241 LoadTimingInfo* load_timing_info_before_redirect) const;
243 // Same as GetLoadTimingInfoBeforeRedirect, except for calls to
244 // AuthRequiredResponse.
245 bool GetLoadTimingInfoBeforeAuth(
246 LoadTimingInfo* load_timing_info_before_auth) const;
248 // Will redirect once to the given URL when the next set of headers are
250 void set_redirect_on_headers_received_url(
251 GURL redirect_on_headers_received_url) {
252 redirect_on_headers_received_url_ = redirect_on_headers_received_url;
255 void set_allowed_unsafe_redirect_url(GURL allowed_unsafe_redirect_url) {
256 allowed_unsafe_redirect_url_ = allowed_unsafe_redirect_url;
259 void set_cookie_options(int o) {cookie_options_bit_mask_ = o; }
261 int last_error() const { return last_error_; }
262 int error_count() const { return error_count_; }
263 int created_requests() const { return created_requests_; }
264 int destroyed_requests() const { return destroyed_requests_; }
265 int completed_requests() const { return completed_requests_; }
266 int canceled_requests() const { return canceled_requests_; }
267 int blocked_get_cookies_count() const { return blocked_get_cookies_count_; }
268 int blocked_set_cookie_count() const { return blocked_set_cookie_count_; }
269 int set_cookie_count() const { return set_cookie_count_; }
271 void set_can_access_files(bool val) { can_access_files_ = val; }
272 bool can_access_files() const { return can_access_files_; }
274 void set_can_throttle_requests(bool val) { can_throttle_requests_ = val; }
275 bool can_throttle_requests() const { return can_throttle_requests_; }
279 virtual int OnBeforeURLRequest(URLRequest* request,
280 const CompletionCallback& callback,
281 GURL* new_url) OVERRIDE;
282 virtual int OnBeforeSendHeaders(URLRequest* request,
283 const CompletionCallback& callback,
284 HttpRequestHeaders* headers) OVERRIDE;
285 virtual void OnSendHeaders(URLRequest* request,
286 const HttpRequestHeaders& headers) OVERRIDE;
287 virtual int OnHeadersReceived(
289 const CompletionCallback& callback,
290 const HttpResponseHeaders* original_response_headers,
291 scoped_refptr<HttpResponseHeaders>* override_response_headers,
292 GURL* allowed_unsafe_redirect_url) OVERRIDE;
293 virtual void OnBeforeRedirect(URLRequest* request,
294 const GURL& new_location) OVERRIDE;
295 virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
296 virtual void OnRawBytesRead(const URLRequest& request,
297 int bytes_read) OVERRIDE;
298 virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE;
299 virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE;
300 virtual void OnPACScriptError(int line_number,
301 const base::string16& error) OVERRIDE;
302 virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
304 const AuthChallengeInfo& auth_info,
305 const AuthCallback& callback,
306 AuthCredentials* credentials) OVERRIDE;
307 virtual bool OnCanGetCookies(const URLRequest& request,
308 const CookieList& cookie_list) OVERRIDE;
309 virtual bool OnCanSetCookie(const URLRequest& request,
310 const std::string& cookie_line,
311 CookieOptions* options) OVERRIDE;
312 virtual bool OnCanAccessFile(const URLRequest& request,
313 const base::FilePath& path) const OVERRIDE;
314 virtual bool OnCanThrottleRequest(
315 const URLRequest& request) const OVERRIDE;
316 virtual int OnBeforeSocketStreamConnect(
317 SocketStream* stream,
318 const CompletionCallback& callback) OVERRIDE;
320 void InitRequestStatesIfNew(int request_id);
322 GURL redirect_on_headers_received_url_;
323 // URL marked as safe for redirection at the onHeadersReceived stage.
324 GURL allowed_unsafe_redirect_url_;
328 int created_requests_;
329 int destroyed_requests_;
330 int completed_requests_;
331 int canceled_requests_;
332 int cookie_options_bit_mask_;
333 int blocked_get_cookies_count_;
334 int blocked_set_cookie_count_;
335 int set_cookie_count_;
337 // NetworkDelegate callbacks happen in a particular order (e.g.
338 // OnBeforeURLRequest is always called before OnBeforeSendHeaders).
339 // This bit-set indicates for each request id (key) what events may be sent
341 std::map<int, int> next_states_;
343 // A log that records for each request id (key) the order in which On...
344 // functions were called.
345 std::map<int, std::string> event_order_;
347 LoadTimingInfo load_timing_info_before_redirect_;
348 bool has_load_timing_info_before_redirect_;
350 LoadTimingInfo load_timing_info_before_auth_;
351 bool has_load_timing_info_before_auth_;
353 bool can_access_files_; // true by default
354 bool can_throttle_requests_; // true by default
357 // Overrides the host used by the LocalHttpTestServer in
358 // url_request_unittest.cc . This is used by the chrome_frame_net_tests due to
359 // a mysterious bug when tests execute over the loopback adapter. See
360 // http://crbug.com/114369 .
361 class ScopedCustomUrlRequestTestHttpHost {
363 // Sets the host name to be used. The previous hostname will be stored and
364 // restored upon destruction. Note that if the lifetimes of two or more
365 // instances of this class overlap, they must be strictly nested.
366 explicit ScopedCustomUrlRequestTestHttpHost(const std::string& new_value);
368 ~ScopedCustomUrlRequestTestHttpHost();
370 // Returns the current value to be used by HTTP tests in
371 // url_request_unittest.cc .
372 static const std::string& value();
375 static std::string value_;
376 const std::string old_value_;
377 const std::string new_value_;
379 DISALLOW_COPY_AND_ASSIGN(ScopedCustomUrlRequestTestHttpHost);
382 //-----------------------------------------------------------------------------
384 // A simple ProtocolHandler that returns a pre-built URLRequestJob only once.
385 class TestJobInterceptor : public URLRequestJobFactory::ProtocolHandler {
387 TestJobInterceptor();
389 virtual URLRequestJob* MaybeCreateJob(
391 NetworkDelegate* network_delegate) const OVERRIDE;
392 void set_main_intercept_job(URLRequestJob* job);
395 mutable URLRequestJob* main_intercept_job_;
400 #endif // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_