net/cookies/cookie_monster_store_test.cc

   1 // Copyright (c) 2012 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 #include "net/cookies/cookie_monster_store_test.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "base/time/time.h"
  11 #include "net/cookies/cookie_constants.h"
  12 #include "net/cookies/cookie_util.h"
  13 #include "net/cookies/parsed_cookie.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "url/gurl.h"
  16
  17 namespace net {
  18 LoadedCallbackTask::LoadedCallbackTask(LoadedCallback loaded_callback,
  19                                        std::vector<CanonicalCookie*> cookies)
  20     : loaded_callback_(loaded_callback),
  21       cookies_(cookies) {
  22 }
  23
  24 LoadedCallbackTask::~LoadedCallbackTask() {}
  25
  26 MockPersistentCookieStore::MockPersistentCookieStore()
  27     : load_return_value_(true),
  28       loaded_(false) {
  29 }
  30
  31 void MockPersistentCookieStore::SetLoadExpectation(
  32     bool return_value,
  33     const std::vector<CanonicalCookie*>& result) {
  34   load_return_value_ = return_value;
  35   load_result_ = result;
  36 }
  37
  38 void MockPersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
  39   std::vector<CanonicalCookie*> out_cookies;
  40   if (load_return_value_) {
  41     out_cookies = load_result_;
  42     loaded_ = true;
  43   }
  44   base::MessageLoop::current()->PostTask(
  45       FROM_HERE,
  46       base::Bind(&LoadedCallbackTask::Run,
  47                  new LoadedCallbackTask(loaded_callback, out_cookies)));
  48 }
  49
  50 void MockPersistentCookieStore::LoadCookiesForKey(
  51     const std::string& key,
  52     const LoadedCallback& loaded_callback) {
  53   if (!loaded_) {
  54     Load(loaded_callback);
  55   } else {
  56     base::MessageLoop::current()->PostTask(
  57         FROM_HERE,
  58         base::Bind(&LoadedCallbackTask::Run,
  59                    new LoadedCallbackTask(loaded_callback,
  60                                           std::vector<CanonicalCookie*>())));
  61   }
  62 }
  63
  64 void MockPersistentCookieStore::AddCookie(const CanonicalCookie& cookie) {
  65   commands_.push_back(
  66       CookieStoreCommand(CookieStoreCommand::ADD, cookie));
  67 }
  68
  69 void MockPersistentCookieStore::UpdateCookieAccessTime(
  70     const CanonicalCookie& cookie) {
  71   commands_.push_back(CookieStoreCommand(
  72       CookieStoreCommand::UPDATE_ACCESS_TIME, cookie));
  73 }
  74
  75 void MockPersistentCookieStore::DeleteCookie(const CanonicalCookie& cookie) {
  76   commands_.push_back(
  77       CookieStoreCommand(CookieStoreCommand::REMOVE, cookie));
  78 }
  79
  80 void MockPersistentCookieStore::Flush(const base::Closure& callback) {
  81   if (!callback.is_null())
  82     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
  83 }
  84
  85 void MockPersistentCookieStore::SetForceKeepSessionState() {
  86 }
  87
  88 MockPersistentCookieStore::~MockPersistentCookieStore() {}
  89
  90 MockCookieMonsterDelegate::MockCookieMonsterDelegate() {}
  91
  92 void MockCookieMonsterDelegate::OnCookieChanged(
  93     const CanonicalCookie& cookie,
  94     bool removed,
  95     CookieMonster::Delegate::ChangeCause cause) {
  96   CookieNotification notification(cookie, removed);
  97   changes_.push_back(notification);
  98 }
  99
 100 void MockCookieMonsterDelegate::OnLoaded() {}
 101
 102 MockCookieMonsterDelegate::~MockCookieMonsterDelegate() {}
 103
 104 CanonicalCookie BuildCanonicalCookie(const std::string& key,
 105                                      const std::string& cookie_line,
 106                                      const base::Time& creation_time) {
 107
 108   // Parse the cookie line.
 109   ParsedCookie pc(cookie_line);
 110   EXPECT_TRUE(pc.IsValid());
 111
 112   // This helper is simplistic in interpreting a parsed cookie, in order to
 113   // avoid duplicated CookieMonster's CanonPath() and CanonExpiration()
 114   // functions. Would be nice to export them, and re-use here.
 115   EXPECT_FALSE(pc.HasMaxAge());
 116   EXPECT_TRUE(pc.HasPath());
 117   base::Time cookie_expires = pc.HasExpires() ?
 118       cookie_util::ParseCookieTime(pc.Expires()) : base::Time();
 119   std::string cookie_path = pc.Path();
 120
 121   return CanonicalCookie(
 122       GURL(), pc.Name(), pc.Value(), key, cookie_path,
 123       creation_time, cookie_expires, creation_time,
 124       pc.IsSecure(), pc.IsHttpOnly(), pc.Priority());
 125 }
 126
 127 void AddCookieToList(
 128     const std::string& key,
 129     const std::string& cookie_line,
 130     const base::Time& creation_time,
 131     std::vector<CanonicalCookie*>* out_list) {
 132   scoped_ptr<CanonicalCookie> cookie(
 133       new CanonicalCookie(
 134           BuildCanonicalCookie(key, cookie_line, creation_time)));
 135
 136   out_list->push_back(cookie.release());
 137 }
 138
 139 MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
 140     : loaded_(false) {
 141 }
 142
 143 void MockSimplePersistentCookieStore::Load(
 144     const LoadedCallback& loaded_callback) {
 145   std::vector<CanonicalCookie*> out_cookies;
 146
 147   for (CanonicalCookieMap::const_iterator it = cookies_.begin();
 148        it != cookies_.end(); it++)
 149     out_cookies.push_back(new CanonicalCookie(it->second));
 150
 151   base::MessageLoop::current()->PostTask(
 152       FROM_HERE,
 153       base::Bind(&LoadedCallbackTask::Run,
 154                  new LoadedCallbackTask(loaded_callback, out_cookies)));
 155   loaded_ = true;
 156 }
 157
 158 void MockSimplePersistentCookieStore::LoadCookiesForKey(const std::string& key,
 159     const LoadedCallback& loaded_callback) {
 160   if (!loaded_) {
 161     Load(loaded_callback);
 162   } else {
 163     base::MessageLoop::current()->PostTask(
 164         FROM_HERE,
 165         base::Bind(&LoadedCallbackTask::Run,
 166                    new LoadedCallbackTask(loaded_callback,
 167                                           std::vector<CanonicalCookie*>())));
 168   }
 169 }
 170
 171 void MockSimplePersistentCookieStore::AddCookie(const CanonicalCookie& cookie) {
 172   int64 creation_time = cookie.CreationDate().ToInternalValue();
 173   EXPECT_TRUE(cookies_.find(creation_time) == cookies_.end());
 174   cookies_[creation_time] = cookie;
 175 }
 176
 177 void MockSimplePersistentCookieStore::UpdateCookieAccessTime(
 178     const CanonicalCookie& cookie) {
 179   int64 creation_time = cookie.CreationDate().ToInternalValue();
 180   ASSERT_TRUE(cookies_.find(creation_time) != cookies_.end());
 181   cookies_[creation_time].SetLastAccessDate(base::Time::Now());
 182 }
 183
 184 void MockSimplePersistentCookieStore::DeleteCookie(
 185     const CanonicalCookie& cookie) {
 186   int64 creation_time = cookie.CreationDate().ToInternalValue();
 187   CanonicalCookieMap::iterator it = cookies_.find(creation_time);
 188   ASSERT_TRUE(it != cookies_.end());
 189   cookies_.erase(it);
 190 }
 191
 192 void MockSimplePersistentCookieStore::Flush(const base::Closure& callback) {
 193   if (!callback.is_null())
 194     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 195 }
 196
 197 void MockSimplePersistentCookieStore::SetForceKeepSessionState() {
 198 }
 199
 200 CookieMonster* CreateMonsterFromStoreForGC(
 201     int num_cookies,
 202     int num_old_cookies,
 203     int days_old) {
 204   base::Time current(base::Time::Now());
 205   base::Time past_creation(base::Time::Now() - base::TimeDelta::FromDays(1000));
 206   scoped_refptr<MockSimplePersistentCookieStore> store(
 207       new MockSimplePersistentCookieStore);
 208   // Must expire to be persistent
 209   for (int i = 0; i < num_cookies; i++) {
 210     base::Time creation_time =
 211         past_creation + base::TimeDelta::FromMicroseconds(i);
 212     base::Time expiration_time = current + base::TimeDelta::FromDays(30);
 213     base::Time last_access_time =
 214         (i < num_old_cookies) ? current - base::TimeDelta::FromDays(days_old) :
 215                                 current;
 216
 217     CanonicalCookie cc(
 218         GURL(), "a", "1", base::StringPrintf("h%05d.izzle", i), "/path",
 219         creation_time, expiration_time, last_access_time, false, false,
 220         COOKIE_PRIORITY_DEFAULT);
 221     store->AddCookie(cc);
 222   }
 223
 224   return new CookieMonster(store.get(), NULL);
 225 }
 226
 227 MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {}
 228
 229 }  // namespace net