net/http/http_transaction_test_util.h

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