1 // Copyright (c) 2010 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 #pragma once 8 9 #include "net/http/http_transaction.h" 10 11 #include <string> 12 13 #include "base/callback.h" 14 #include "base/compiler_specific.h" 15 #include "base/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/test_completion_callback.h" 20 #include "net/disk_cache/disk_cache.h" 21 #include "net/http/http_cache.h" 22 #include "net/http/http_request_info.h" 23 #include "net/http/http_response_headers.h" 24 #include "net/http/http_response_info.h" 25 26 namespace net { 27 class IOBuffer; 28 } 29 30 //----------------------------------------------------------------------------- 31 // mock transaction data 32 33 // these flags may be combined to form the test_mode field 34 enum { 35 TEST_MODE_NORMAL = 0, 36 TEST_MODE_SYNC_NET_START = 1 << 0, 37 TEST_MODE_SYNC_NET_READ = 1 << 1, 38 TEST_MODE_SYNC_CACHE_START = 1 << 2, 39 TEST_MODE_SYNC_CACHE_READ = 1 << 3, 40 TEST_MODE_SYNC_CACHE_WRITE = 1 << 4, 41 TEST_MODE_SYNC_ALL = (TEST_MODE_SYNC_NET_START | TEST_MODE_SYNC_NET_READ | 42 TEST_MODE_SYNC_CACHE_START | TEST_MODE_SYNC_CACHE_READ | 43 TEST_MODE_SYNC_CACHE_WRITE) 44 }; 45 46 typedef void (*MockTransactionHandler)(const net::HttpRequestInfo* request, 47 std::string* response_status, 48 std::string* response_headers, 49 std::string* response_data); 50 51 struct MockTransaction { 52 const char* url; 53 const char* method; 54 // If |request_time| is unspecified, the current time will be used. 55 base::Time request_time; 56 const char* request_headers; 57 int load_flags; 58 const char* status; 59 const char* response_headers; 60 // If |response_time| is unspecified, the current time will be used. 61 base::Time response_time; 62 const char* data; 63 int test_mode; 64 MockTransactionHandler handler; 65 int cert_status; 66 }; 67 68 extern const MockTransaction kSimpleGET_Transaction; 69 extern const MockTransaction kSimplePOST_Transaction; 70 extern const MockTransaction kTypicalGET_Transaction; 71 extern const MockTransaction kETagGET_Transaction; 72 extern const MockTransaction kRangeGET_Transaction; 73 74 // returns the mock transaction for the given URL 75 const MockTransaction* FindMockTransaction(const GURL& url); 76 77 // Add/Remove a mock transaction that can be accessed via FindMockTransaction. 78 // There can be only one MockTransaction associated with a given URL. 79 void AddMockTransaction(const MockTransaction* trans); 80 void RemoveMockTransaction(const MockTransaction* trans); 81 82 struct ScopedMockTransaction : MockTransaction { ScopedMockTransactionScopedMockTransaction83 ScopedMockTransaction() { 84 AddMockTransaction(this); 85 } ScopedMockTransactionScopedMockTransaction86 explicit ScopedMockTransaction(const MockTransaction& t) 87 : MockTransaction(t) { 88 AddMockTransaction(this); 89 } ~ScopedMockTransactionScopedMockTransaction90 ~ScopedMockTransaction() { 91 RemoveMockTransaction(this); 92 } 93 }; 94 95 //----------------------------------------------------------------------------- 96 // mock http request 97 98 class MockHttpRequest : public net::HttpRequestInfo { 99 public: 100 explicit MockHttpRequest(const MockTransaction& t); 101 }; 102 103 //----------------------------------------------------------------------------- 104 // use this class to test completely consuming a transaction 105 106 class TestTransactionConsumer : public CallbackRunner< Tuple1<int> > { 107 public: 108 explicit TestTransactionConsumer(net::HttpTransactionFactory* factory); 109 virtual ~TestTransactionConsumer(); 110 111 void Start(const net::HttpRequestInfo* request, 112 const net::BoundNetLog& net_log); 113 is_done()114 bool is_done() const { return state_ == DONE; } error()115 int error() const { return error_; } 116 response_info()117 const net::HttpResponseInfo* response_info() const { 118 return trans_->GetResponseInfo(); 119 } content()120 const std::string& content() const { return content_; } 121 122 private: 123 enum State { 124 IDLE, 125 STARTING, 126 READING, 127 DONE 128 }; 129 130 void DidStart(int result); 131 void DidRead(int result); 132 void DidFinish(int result); 133 void Read(); 134 135 // Callback implementation: 136 virtual void RunWithParams(const Tuple1<int>& params); 137 138 State state_; 139 scoped_ptr<net::HttpTransaction> trans_; 140 std::string content_; 141 scoped_refptr<net::IOBuffer> read_buf_; 142 int error_; 143 144 static int quit_counter_; 145 }; 146 147 //----------------------------------------------------------------------------- 148 // mock network layer 149 150 // This transaction class inspects the available set of mock transactions to 151 // find data for the request URL. It supports IO operations that complete 152 // synchronously or asynchronously to help exercise different code paths in the 153 // HttpCache implementation. 154 class MockNetworkTransaction : public net::HttpTransaction { 155 public: 156 MockNetworkTransaction(); 157 virtual ~MockNetworkTransaction(); 158 159 virtual int Start(const net::HttpRequestInfo* request, 160 net::CompletionCallback* callback, 161 const net::BoundNetLog& net_log); 162 163 virtual int RestartIgnoringLastError(net::CompletionCallback* callback); 164 165 virtual int RestartWithCertificate(net::X509Certificate* client_cert, 166 net::CompletionCallback* callback); 167 168 virtual int RestartWithAuth(const string16& username, 169 const string16& password, 170 net::CompletionCallback* callback); 171 172 virtual bool IsReadyToRestartForAuth(); 173 174 virtual int Read(net::IOBuffer* buf, int buf_len, 175 net::CompletionCallback* callback); 176 177 virtual void StopCaching(); 178 179 virtual const net::HttpResponseInfo* GetResponseInfo() const; 180 181 virtual net::LoadState GetLoadState() const; 182 183 virtual uint64 GetUploadProgress() const; 184 185 private: 186 void CallbackLater(net::CompletionCallback* callback, int result); 187 void RunCallback(net::CompletionCallback* callback, int result); 188 189 ScopedRunnableMethodFactory<MockNetworkTransaction> task_factory_; 190 net::HttpResponseInfo response_; 191 std::string data_; 192 int data_cursor_; 193 int test_mode_; 194 }; 195 196 class MockNetworkLayer : public net::HttpTransactionFactory { 197 public: 198 MockNetworkLayer(); 199 virtual ~MockNetworkLayer(); 200 transaction_count()201 int transaction_count() const { return transaction_count_; } 202 203 // net::HttpTransactionFactory: 204 virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans); 205 virtual net::HttpCache* GetCache(); 206 virtual net::HttpNetworkSession* GetSession(); 207 virtual void Suspend(bool suspend); 208 209 private: 210 int transaction_count_; 211 }; 212 213 //----------------------------------------------------------------------------- 214 // helpers 215 216 // read the transaction completely 217 int ReadTransaction(net::HttpTransaction* trans, std::string* result); 218 219 #endif // NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_ 220