1 // Copyright 2014 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 #ifndef NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_ 6 #define NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_ 7 8 #include "net/http/http_transaction.h" 9 10 #include <string> 11 12 #include "base/callback.h" 13 #include "base/compiler_specific.h" 14 #include "base/memory/weak_ptr.h" 15 #include "base/strings/string16.h" 16 #include "net/base/io_buffer.h" 17 #include "net/base/load_flags.h" 18 #include "net/base/net_errors.h" 19 #include "net/base/net_log.h" 20 #include "net/base/request_priority.h" 21 #include "net/base/test_completion_callback.h" 22 #include "net/disk_cache/disk_cache.h" 23 #include "net/http/http_cache.h" 24 #include "net/http/http_request_info.h" 25 #include "net/http/http_response_headers.h" 26 #include "net/http/http_response_info.h" 27 28 namespace net { 29 class HttpRequestHeaders; 30 class IOBuffer; 31 } 32 33 //----------------------------------------------------------------------------- 34 // mock transaction data 35 36 // these flags may be combined to form the test_mode field 37 enum { 38 TEST_MODE_NORMAL = 0, 39 TEST_MODE_SYNC_NET_START = 1 << 0, 40 TEST_MODE_SYNC_NET_READ = 1 << 1, 41 TEST_MODE_SYNC_CACHE_START = 1 << 2, 42 TEST_MODE_SYNC_CACHE_READ = 1 << 3, 43 TEST_MODE_SYNC_CACHE_WRITE = 1 << 4, 44 TEST_MODE_SYNC_ALL = (TEST_MODE_SYNC_NET_START | TEST_MODE_SYNC_NET_READ | 45 TEST_MODE_SYNC_CACHE_START | TEST_MODE_SYNC_CACHE_READ | 46 TEST_MODE_SYNC_CACHE_WRITE), 47 TEST_MODE_SLOW_READ = 1 << 5 48 }; 49 50 typedef void (*MockTransactionHandler)(const net::HttpRequestInfo* request, 51 std::string* response_status, 52 std::string* response_headers, 53 std::string* response_data); 54 55 struct MockTransaction { 56 const char* url; 57 const char* method; 58 // If |request_time| is unspecified, the current time will be used. 59 base::Time request_time; 60 const char* request_headers; 61 int load_flags; 62 const char* status; 63 const char* response_headers; 64 // If |response_time| is unspecified, the current time will be used. 65 base::Time response_time; 66 const char* data; 67 int test_mode; 68 MockTransactionHandler handler; 69 net::CertStatus cert_status; 70 // Value returned by MockNetworkTransaction::Start (potentially 71 // asynchronously if |!(test_mode & TEST_MODE_SYNC_NET_START)|.) 72 net::Error return_code; 73 }; 74 75 extern const MockTransaction kSimpleGET_Transaction; 76 extern const MockTransaction kSimplePOST_Transaction; 77 extern const MockTransaction kTypicalGET_Transaction; 78 extern const MockTransaction kETagGET_Transaction; 79 extern const MockTransaction kRangeGET_Transaction; 80 81 // returns the mock transaction for the given URL 82 const MockTransaction* FindMockTransaction(const GURL& url); 83 84 // Add/Remove a mock transaction that can be accessed via FindMockTransaction. 85 // There can be only one MockTransaction associated with a given URL. 86 void AddMockTransaction(const MockTransaction* trans); 87 void RemoveMockTransaction(const MockTransaction* trans); 88 89 struct ScopedMockTransaction : MockTransaction { ScopedMockTransactionScopedMockTransaction90 ScopedMockTransaction() { 91 AddMockTransaction(this); 92 } ScopedMockTransactionScopedMockTransaction93 explicit ScopedMockTransaction(const MockTransaction& t) 94 : MockTransaction(t) { 95 AddMockTransaction(this); 96 } ~ScopedMockTransactionScopedMockTransaction97 ~ScopedMockTransaction() { 98 RemoveMockTransaction(this); 99 } 100 }; 101 102 //----------------------------------------------------------------------------- 103 // mock http request 104 105 class MockHttpRequest : public net::HttpRequestInfo { 106 public: 107 explicit MockHttpRequest(const MockTransaction& t); 108 }; 109 110 //----------------------------------------------------------------------------- 111 // use this class to test completely consuming a transaction 112 113 class TestTransactionConsumer { 114 public: 115 TestTransactionConsumer(net::RequestPriority priority, 116 net::HttpTransactionFactory* factory); 117 virtual ~TestTransactionConsumer(); 118 119 void Start(const net::HttpRequestInfo* request, 120 const net::BoundNetLog& net_log); 121 is_done()122 bool is_done() const { return state_ == DONE; } error()123 int error() const { return error_; } 124 response_info()125 const net::HttpResponseInfo* response_info() const { 126 return trans_->GetResponseInfo(); 127 } content()128 const std::string& content() const { return content_; } 129 130 private: 131 enum State { 132 IDLE, 133 STARTING, 134 READING, 135 DONE 136 }; 137 138 void DidStart(int result); 139 void DidRead(int result); 140 void DidFinish(int result); 141 void Read(); 142 143 void OnIOComplete(int result); 144 145 State state_; 146 scoped_ptr<net::HttpTransaction> trans_; 147 std::string content_; 148 scoped_refptr<net::IOBuffer> read_buf_; 149 int error_; 150 151 static int quit_counter_; 152 }; 153 154 //----------------------------------------------------------------------------- 155 // mock network layer 156 157 class MockNetworkLayer; 158 159 // This transaction class inspects the available set of mock transactions to 160 // find data for the request URL. It supports IO operations that complete 161 // synchronously or asynchronously to help exercise different code paths in the 162 // HttpCache implementation. 163 class MockNetworkTransaction 164 : public net::HttpTransaction, 165 public base::SupportsWeakPtr<MockNetworkTransaction> { 166 typedef net::WebSocketHandshakeStreamBase::CreateHelper CreateHelper; 167 public: 168 MockNetworkTransaction(net::RequestPriority priority, 169 MockNetworkLayer* factory); 170 virtual ~MockNetworkTransaction(); 171 172 virtual int Start(const net::HttpRequestInfo* request, 173 const net::CompletionCallback& callback, 174 const net::BoundNetLog& net_log) OVERRIDE; 175 176 virtual int RestartIgnoringLastError( 177 const net::CompletionCallback& callback) OVERRIDE; 178 179 virtual int RestartWithCertificate( 180 net::X509Certificate* client_cert, 181 const net::CompletionCallback& callback) OVERRIDE; 182 183 virtual int RestartWithAuth( 184 const net::AuthCredentials& credentials, 185 const net::CompletionCallback& callback) OVERRIDE; 186 187 virtual bool IsReadyToRestartForAuth() OVERRIDE; 188 189 virtual int Read(net::IOBuffer* buf, int buf_len, 190 const net::CompletionCallback& callback) OVERRIDE; 191 192 virtual void StopCaching() OVERRIDE; 193 194 virtual bool GetFullRequestHeaders( 195 net::HttpRequestHeaders* headers) const OVERRIDE; 196 197 virtual int64 GetTotalReceivedBytes() const OVERRIDE; 198 199 virtual void DoneReading() OVERRIDE; 200 201 virtual const net::HttpResponseInfo* GetResponseInfo() const OVERRIDE; 202 203 virtual net::LoadState GetLoadState() const OVERRIDE; 204 205 virtual net::UploadProgress GetUploadProgress() const OVERRIDE; 206 207 virtual void SetQuicServerInfo( 208 net::QuicServerInfo* quic_server_info) OVERRIDE; 209 210 virtual bool GetLoadTimingInfo( 211 net::LoadTimingInfo* load_timing_info) const OVERRIDE; 212 213 virtual void SetPriority(net::RequestPriority priority) OVERRIDE; 214 215 virtual void SetWebSocketHandshakeStreamCreateHelper( 216 CreateHelper* create_helper) OVERRIDE; 217 218 virtual void SetBeforeNetworkStartCallback( 219 const BeforeNetworkStartCallback& callback) OVERRIDE; 220 221 virtual int ResumeNetworkStart() OVERRIDE; 222 websocket_handshake_stream_create_helper()223 CreateHelper* websocket_handshake_stream_create_helper() { 224 return websocket_handshake_stream_create_helper_; 225 } priority()226 net::RequestPriority priority() const { return priority_; } 227 228 private: 229 int StartInternal(const net::HttpRequestInfo* request, 230 const net::CompletionCallback& callback, 231 const net::BoundNetLog& net_log); 232 void CallbackLater(const net::CompletionCallback& callback, int result); 233 void RunCallback(const net::CompletionCallback& callback, int result); 234 235 base::WeakPtrFactory<MockNetworkTransaction> weak_factory_; 236 const net::HttpRequestInfo* request_; 237 net::HttpResponseInfo response_; 238 std::string data_; 239 int data_cursor_; 240 int test_mode_; 241 net::RequestPriority priority_; 242 CreateHelper* websocket_handshake_stream_create_helper_; 243 base::WeakPtr<MockNetworkLayer> transaction_factory_; 244 int64 received_bytes_; 245 246 // NetLog ID of the fake / non-existent underlying socket used by the 247 // connection. Requires Start() be passed a BoundNetLog with a real NetLog to 248 // be initialized. 249 unsigned int socket_log_id_; 250 }; 251 252 class MockNetworkLayer : public net::HttpTransactionFactory, 253 public base::SupportsWeakPtr<MockNetworkLayer> { 254 public: 255 MockNetworkLayer(); 256 virtual ~MockNetworkLayer(); 257 transaction_count()258 int transaction_count() const { return transaction_count_; } done_reading_called()259 bool done_reading_called() const { return done_reading_called_; } stop_caching_called()260 bool stop_caching_called() const { return stop_caching_called_; } 261 void TransactionDoneReading(); 262 void TransactionStopCaching(); 263 264 // Returns the last priority passed to CreateTransaction, or 265 // DEFAULT_PRIORITY if it hasn't been called yet. last_create_transaction_priority()266 net::RequestPriority last_create_transaction_priority() const { 267 return last_create_transaction_priority_; 268 } 269 270 // Returns the last transaction created by 271 // CreateTransaction. Returns a NULL WeakPtr if one has not been 272 // created yet, or the last transaction has been destroyed, or 273 // ClearLastTransaction() has been called and a new transaction 274 // hasn't been created yet. last_transaction()275 base::WeakPtr<MockNetworkTransaction> last_transaction() { 276 return last_transaction_; 277 } 278 279 // Makes last_transaction() return NULL until the next transaction 280 // is created. ClearLastTransaction()281 void ClearLastTransaction() { 282 last_transaction_.reset(); 283 } 284 285 // net::HttpTransactionFactory: 286 virtual int CreateTransaction( 287 net::RequestPriority priority, 288 scoped_ptr<net::HttpTransaction>* trans) OVERRIDE; 289 virtual net::HttpCache* GetCache() OVERRIDE; 290 virtual net::HttpNetworkSession* GetSession() OVERRIDE; 291 292 private: 293 int transaction_count_; 294 bool done_reading_called_; 295 bool stop_caching_called_; 296 net::RequestPriority last_create_transaction_priority_; 297 base::WeakPtr<MockNetworkTransaction> last_transaction_; 298 }; 299 300 //----------------------------------------------------------------------------- 301 // helpers 302 303 // read the transaction completely 304 int ReadTransaction(net::HttpTransaction* trans, std::string* result); 305 306 #endif // NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_ 307