net/http/mock_http_cache.h

   1 // Copyright (c) 2011 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 // This is a mock of the http cache and related testing classes. To be fair, it
   6 // is not really a mock http cache given that it uses the real implementation of
   7 // the http cache, but it has fake implementations of all required components,
   8 // so it is useful for unit tests at the http layer.
   9
  10 #ifndef NET_HTTP_MOCK_HTTP_CACHE_H_
  11 #define NET_HTTP_MOCK_HTTP_CACHE_H_
  12
  13 #include "base/containers/hash_tables.h"
  14 #include "net/disk_cache/disk_cache.h"
  15 #include "net/http/http_cache.h"
  16 #include "net/http/http_transaction_unittest.h"
  17
  18 //-----------------------------------------------------------------------------
  19 // Mock disk cache (a very basic memory cache implementation).
  20
  21 class MockDiskEntry : public disk_cache::Entry,
  22                       public base::RefCounted<MockDiskEntry> {
  23  public:
  24   MockDiskEntry();
  25   explicit MockDiskEntry(const std::string& key);
  26
  27   bool is_doomed() const { return doomed_; }
  28
  29   virtual void Doom() OVERRIDE;
  30   virtual void Close() OVERRIDE;
  31   virtual std::string GetKey() const OVERRIDE;
  32   virtual base::Time GetLastUsed() const OVERRIDE;
  33   virtual base::Time GetLastModified() const OVERRIDE;
  34   virtual int32 GetDataSize(int index) const OVERRIDE;
  35   virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
  36                        const net::CompletionCallback& callback) OVERRIDE;
  37   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
  38                         const net::CompletionCallback& callback,
  39                         bool truncate) OVERRIDE;
  40   virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
  41                              const net::CompletionCallback& callback) OVERRIDE;
  42   virtual int WriteSparseData(
  43       int64 offset, net::IOBuffer* buf, int buf_len,
  44       const net::CompletionCallback& callback) OVERRIDE;
  45   virtual int GetAvailableRange(
  46       int64 offset, int len, int64* start,
  47       const net::CompletionCallback& callback) OVERRIDE;
  48   virtual bool CouldBeSparse() const OVERRIDE;
  49   virtual void CancelSparseIO() OVERRIDE;
  50   virtual int ReadyForSparseIO(
  51       const net::CompletionCallback& completion_callback) OVERRIDE;
  52
  53   // Fail most subsequent requests.
  54   void set_fail_requests() { fail_requests_ = true; }
  55
  56   // If |value| is true, don't deliver any completion callbacks until called
  57   // again with |value| set to false.  Caution: remember to enable callbacks
  58   // again or all subsequent tests will fail.
  59   static void IgnoreCallbacks(bool value);
  60
  61  private:
  62   friend class base::RefCounted<MockDiskEntry>;
  63   struct CallbackInfo;
  64
  65   virtual ~MockDiskEntry();
  66
  67   // Unlike the callbacks for MockHttpTransaction, we want this one to run even
  68   // if the consumer called Close on the MockDiskEntry.  We achieve that by
  69   // leveraging the fact that this class is reference counted.
  70   void CallbackLater(const net::CompletionCallback& callback, int result);
  71
  72   void RunCallback(const net::CompletionCallback& callback, int result);
  73
  74   // When |store| is true, stores the callback to be delivered later; otherwise
  75   // delivers any callback previously stored.
  76   static void StoreAndDeliverCallbacks(bool store, MockDiskEntry* entry,
  77                                        const net::CompletionCallback& callback,
  78                                        int result);
  79
  80   static const int kNumCacheEntryDataIndices = 3;
  81
  82   std::string key_;
  83   std::vector<char> data_[kNumCacheEntryDataIndices];
  84   int test_mode_;
  85   bool doomed_;
  86   bool sparse_;
  87   bool fail_requests_;
  88   bool busy_;
  89   bool delayed_;
  90   static bool cancel_;
  91   static bool ignore_callbacks_;
  92 };
  93
  94 class MockDiskCache : public disk_cache::Backend {
  95  public:
  96   MockDiskCache();
  97   virtual ~MockDiskCache();
  98
  99   virtual net::CacheType GetCacheType() const OVERRIDE;
 100   virtual int32 GetEntryCount() const OVERRIDE;
 101   virtual int OpenEntry(const std::string& key, disk_cache::Entry** entry,
 102                         const net::CompletionCallback& callback) OVERRIDE;
 103   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
 104                           const net::CompletionCallback& callback) OVERRIDE;
 105   virtual int DoomEntry(const std::string& key,
 106                         const net::CompletionCallback& callback) OVERRIDE;
 107   virtual int DoomAllEntries(const net::CompletionCallback& callback) OVERRIDE;
 108   virtual int DoomEntriesBetween(
 109       base::Time initial_time,
 110       base::Time end_time,
 111       const net::CompletionCallback& callback) OVERRIDE;
 112   virtual int DoomEntriesSince(
 113       base::Time initial_time,
 114       const net::CompletionCallback& callback) OVERRIDE;
 115   virtual int OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
 116                             const net::CompletionCallback& callback) OVERRIDE;
 117   virtual void EndEnumeration(void** iter) OVERRIDE;
 118   virtual void GetStats(
 119       std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;
 120   virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
 121
 122   // Returns number of times a cache entry was successfully opened.
 123   int open_count() const { return open_count_; }
 124
 125   // Returns number of times a cache entry was successfully created.
 126   int create_count() const { return create_count_; }
 127
 128   // Fail any subsequent CreateEntry and OpenEntry.
 129   void set_fail_requests() { fail_requests_ = true; }
 130
 131   // Return entries that fail some of their requests.
 132   void set_soft_failures(bool value) { soft_failures_ = value; }
 133
 134   // Makes sure that CreateEntry is not called twice for a given key.
 135   void set_double_create_check(bool value) { double_create_check_ = value; }
 136
 137   void ReleaseAll();
 138
 139  private:
 140   typedef base::hash_map<std::string, MockDiskEntry*> EntryMap;
 141
 142   void CallbackLater(const net::CompletionCallback& callback, int result);
 143
 144   EntryMap entries_;
 145   int open_count_;
 146   int create_count_;
 147   bool fail_requests_;
 148   bool soft_failures_;
 149   bool double_create_check_;
 150 };
 151
 152 class MockBackendFactory : public net::HttpCache::BackendFactory {
 153  public:
 154   virtual int CreateBackend(net::NetLog* net_log,
 155                             disk_cache::Backend** backend,
 156                             const net::CompletionCallback& callback) OVERRIDE;
 157 };
 158
 159 class MockHttpCache {
 160  public:
 161   MockHttpCache();
 162   explicit MockHttpCache(net::HttpCache::BackendFactory* disk_cache_factory);
 163
 164   net::HttpCache* http_cache() { return &http_cache_; }
 165
 166   MockNetworkLayer* network_layer() {
 167     return static_cast<MockNetworkLayer*>(http_cache_.network_layer());
 168   }
 169   MockDiskCache* disk_cache();
 170
 171   // Helper function for reading response info from the disk cache.
 172   static bool ReadResponseInfo(disk_cache::Entry* disk_entry,
 173                                net::HttpResponseInfo* response_info,
 174                                bool* response_truncated);
 175
 176   // Helper function for writing response info into the disk cache.
 177   static bool WriteResponseInfo(disk_cache::Entry* disk_entry,
 178                                 const net::HttpResponseInfo* response_info,
 179                                 bool skip_transient_headers,
 180                                 bool response_truncated);
 181
 182   // Helper function to synchronously open a backend entry.
 183   bool OpenBackendEntry(const std::string& key, disk_cache::Entry** entry);
 184
 185   // Helper function to synchronously create a backend entry.
 186   bool CreateBackendEntry(const std::string& key, disk_cache::Entry** entry,
 187                           net::NetLog* net_log);
 188
 189   // Returns the test mode after considering the global override.
 190   static int GetTestMode(int test_mode);
 191
 192   // Overrides the test mode for a given operation. Remember to reset it after
 193   // the test! (by setting test_mode to zero).
 194   static void SetTestMode(int test_mode);
 195
 196  private:
 197   net::HttpCache http_cache_;
 198 };
 199
 200 // This version of the disk cache doesn't invoke CreateEntry callbacks.
 201 class MockDiskCacheNoCB : public MockDiskCache {
 202   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
 203                           const net::CompletionCallback& callback) OVERRIDE;
 204 };
 205
 206 class MockBackendNoCbFactory : public net::HttpCache::BackendFactory {
 207  public:
 208   virtual int CreateBackend(net::NetLog* net_log,
 209                             disk_cache::Backend** backend,
 210                             const net::CompletionCallback& callback) OVERRIDE;
 211 };
 212
 213 // This backend factory allows us to control the backend instantiation.
 214 class MockBlockingBackendFactory : public net::HttpCache::BackendFactory {
 215  public:
 216   MockBlockingBackendFactory();
 217   virtual ~MockBlockingBackendFactory();
 218
 219   virtual int CreateBackend(net::NetLog* net_log,
 220                             disk_cache::Backend** backend,
 221                             const net::CompletionCallback& callback) OVERRIDE;
 222
 223   // Completes the backend creation. Any blocked call will be notified via the
 224   // provided callback.
 225   void FinishCreation();
 226
 227   disk_cache::Backend** backend() { return backend_; }
 228   void set_fail(bool fail) { fail_ = fail; }
 229
 230   const net::CompletionCallback& callback() { return callback_; }
 231
 232  private:
 233   int Result() { return fail_ ? net::ERR_FAILED : net::OK; }
 234
 235   disk_cache::Backend** backend_;
 236   net::CompletionCallback callback_;
 237   bool block_;
 238   bool fail_;
 239 };
 240
 241 #endif  // NET_HTTP_MOCK_HTTP_CACHE_H_