Home | History | Annotate | Download | only in http 
      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 {
     83   ScopedMockTransaction() {
     84     AddMockTransaction(this);
     85   }
     86   explicit ScopedMockTransaction(const MockTransaction& t)
     87       : MockTransaction(t) {
     88     AddMockTransaction(this);
     89   }
     90   ~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 
    114   bool is_done() const { return state_ == DONE; }
    115   int error() const { return error_; }
    116 
    117   const net::HttpResponseInfo* response_info() const {
    118     return trans_->GetResponseInfo();
    119   }
    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 
    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