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