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
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
100void MockCookieMonsterDelegate::OnLoaded() {}
101
102MockCookieMonsterDelegate::~MockCookieMonsterDelegate() {}
103
104CanonicalCookie 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
127void 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
139MockSimplePersistentCookieStore::MockSimplePersistentCookieStore()
140    : loaded_(false) {
141}
142
143void 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
158void 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
171void 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
177void 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
184void 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
192void MockSimplePersistentCookieStore::Flush(const base::Closure& callback) {
193  if (!callback.is_null())
194    base::MessageLoop::current()->PostTask(FROM_HERE, callback);
195}
196
197void MockSimplePersistentCookieStore::SetForceKeepSessionState() {
198}
199
200CookieMonster* 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
227MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {}
228
229}  // namespace net
230