Home | History | Annotate | Download | only in cookies 
      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 <algorithm>
      6 
      7 #include "base/bind.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "base/strings/string_util.h"
     10 #include "base/strings/stringprintf.h"
     11 #include "base/test/perf_time_logger.h"
     12 #include "net/cookies/canonical_cookie.h"
     13 #include "net/cookies/cookie_monster.h"
     14 #include "net/cookies/cookie_monster_store_test.h"
     15 #include "net/cookies/parsed_cookie.h"
     16 #include "testing/gtest/include/gtest/gtest.h"
     17 #include "url/gurl.h"
     18 
     19 namespace net {
     20 
     21 namespace {
     22 
     23 const int kNumCookies = 20000;
     24 const char kCookieLine[] = "A  = \"b=;\\\"\"  ;secure;;;";
     25 const char kGoogleURL[] = "http://www.google.izzle";
     26 
     27 int CountInString(const std::string& str, char c) {
     28   return std::count(str.begin(), str.end(), c);
     29 }
     30 
     31 class CookieMonsterTest : public testing::Test {
     32  public:
     33   CookieMonsterTest() : message_loop_(new base::MessageLoopForIO()) {}
     34 
     35  private:
     36   scoped_ptr<base::MessageLoop> message_loop_;
     37 };
     38 
     39 class BaseCallback {
     40  public:
     41   BaseCallback() : has_run_(false) {}
     42 
     43  protected:
     44   void WaitForCallback() {
     45     // Note that the performance tests currently all operate on a loaded cookie
     46     // store (or, more precisely, one that has no backing persistent store).
     47     // Therefore, callbacks will actually always complete synchronously. If the
     48     // tests get more advanced we need to add other means of signaling
     49     // completion.
     50     base::MessageLoop::current()->RunUntilIdle();
     51     EXPECT_TRUE(has_run_);
     52     has_run_ = false;
     53   }
     54 
     55   void Run() {
     56     has_run_ = true;
     57   }
     58 
     59   bool has_run_;
     60 };
     61 
     62 class SetCookieCallback  : public BaseCallback {
     63  public:
     64   void SetCookie(
     65       CookieMonster* cm, const GURL& gurl, const std::string& cookie) {
     66     cm->SetCookieWithOptionsAsync(gurl, cookie, options_, base::Bind(
     67         &SetCookieCallback::Run, base::Unretained(this)));
     68     WaitForCallback();
     69   }
     70  private:
     71   void Run(bool success) {
     72     EXPECT_TRUE(success);
     73     BaseCallback::Run();
     74   }
     75   net::CookieOptions options_;
     76 };
     77 
     78 class GetCookiesCallback : public BaseCallback {
     79  public:
     80   const std::string& GetCookies(CookieMonster* cm, const GURL& gurl) {
     81     cm->GetCookiesWithOptionsAsync(gurl, options_, base::Bind(
     82         &GetCookiesCallback::Run, base::Unretained(this)));
     83     WaitForCallback();
     84     return cookies_;
     85   }
     86 
     87  private:
     88   void Run(const std::string& cookies) {
     89     cookies_ = cookies;
     90     BaseCallback::Run();
     91   }
     92   std::string cookies_;
     93   net::CookieOptions options_;
     94 };
     95 
     96 }  // namespace
     97 
     98 TEST(ParsedCookieTest, TestParseCookies) {
     99   std::string cookie(kCookieLine);
    100   base::PerfTimeLogger timer("Parsed_cookie_parse_cookies");
    101   for (int i = 0; i < kNumCookies; ++i) {
    102     ParsedCookie pc(cookie);
    103     EXPECT_TRUE(pc.IsValid());
    104   }
    105   timer.Done();
    106 }
    107 
    108 TEST(ParsedCookieTest, TestParseBigCookies) {
    109   std::string cookie(3800, 'z');
    110   cookie += kCookieLine;
    111   base::PerfTimeLogger timer("Parsed_cookie_parse_big_cookies");
    112   for (int i = 0; i < kNumCookies; ++i) {
    113     ParsedCookie pc(cookie);
    114     EXPECT_TRUE(pc.IsValid());
    115   }
    116   timer.Done();
    117 }
    118 
    119 TEST_F(CookieMonsterTest, TestAddCookiesOnSingleHost) {
    120   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
    121   std::vector<std::string> cookies;
    122   for (int i = 0; i < kNumCookies; i++) {
    123     cookies.push_back(base::StringPrintf("a%03d=b", i));
    124   }
    125 
    126   SetCookieCallback setCookieCallback;
    127 
    128   // Add a bunch of cookies on a single host
    129   base::PerfTimeLogger timer("Cookie_monster_add_single_host");
    130 
    131   for (std::vector<std::string>::const_iterator it = cookies.begin();
    132        it != cookies.end(); ++it) {
    133     setCookieCallback.SetCookie(cm.get(), GURL(kGoogleURL), *it);
    134   }
    135   timer.Done();
    136 
    137   GetCookiesCallback getCookiesCallback;
    138 
    139   base::PerfTimeLogger timer2("Cookie_monster_query_single_host");
    140   for (std::vector<std::string>::const_iterator it = cookies.begin();
    141        it != cookies.end(); ++it) {
    142     getCookiesCallback.GetCookies(cm.get(), GURL(kGoogleURL));
    143   }
    144   timer2.Done();
    145 
    146   base::PerfTimeLogger timer3("Cookie_monster_deleteall_single_host");
    147   cm->DeleteAllAsync(CookieMonster::DeleteCallback());
    148   base::MessageLoop::current()->RunUntilIdle();
    149   timer3.Done();
    150 }
    151 
    152 TEST_F(CookieMonsterTest, TestAddCookieOnManyHosts) {
    153   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
    154   std::string cookie(kCookieLine);
    155   std::vector<GURL> gurls;  // just wanna have ffffuunnn
    156   for (int i = 0; i < kNumCookies; ++i) {
    157     gurls.push_back(GURL(base::StringPrintf("https://a%04d.izzle", i)));
    158   }
    159 
    160   SetCookieCallback setCookieCallback;
    161 
    162   // Add a cookie on a bunch of host
    163   base::PerfTimeLogger timer("Cookie_monster_add_many_hosts");
    164   for (std::vector<GURL>::const_iterator it = gurls.begin();
    165        it != gurls.end(); ++it) {
    166     setCookieCallback.SetCookie(cm.get(), *it, cookie);
    167   }
    168   timer.Done();
    169 
    170   GetCookiesCallback getCookiesCallback;
    171 
    172   base::PerfTimeLogger timer2("Cookie_monster_query_many_hosts");
    173   for (std::vector<GURL>::const_iterator it = gurls.begin();
    174        it != gurls.end(); ++it) {
    175     getCookiesCallback.GetCookies(cm.get(), *it);
    176   }
    177   timer2.Done();
    178 
    179   base::PerfTimeLogger timer3("Cookie_monster_deleteall_many_hosts");
    180   cm->DeleteAllAsync(CookieMonster::DeleteCallback());
    181   base::MessageLoop::current()->RunUntilIdle();
    182   timer3.Done();
    183 }
    184 
    185 TEST_F(CookieMonsterTest, TestDomainTree) {
    186   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
    187   GetCookiesCallback getCookiesCallback;
    188   SetCookieCallback setCookieCallback;
    189   const char* domain_cookie_format_tree = "a=b; domain=%s";
    190   const std::string domain_base("top.com");
    191 
    192   std::vector<std::string> domain_list;
    193 
    194   // Create a balanced binary tree of domains on which the cookie is set.
    195   domain_list.push_back(domain_base);
    196   for (int i1 = 0; i1 < 2; i1++) {
    197     std::string domain_base_1((i1 ? "a." : "b.") + domain_base);
    198     EXPECT_EQ("top.com", cm->GetKey(domain_base_1));
    199     domain_list.push_back(domain_base_1);
    200     for (int i2 = 0; i2 < 2; i2++) {
    201       std::string domain_base_2((i2 ? "a." : "b.") + domain_base_1);
    202       EXPECT_EQ("top.com", cm->GetKey(domain_base_2));
    203       domain_list.push_back(domain_base_2);
    204       for (int i3 = 0; i3 < 2; i3++) {
    205         std::string domain_base_3((i3 ? "a." : "b.") + domain_base_2);
    206         EXPECT_EQ("top.com", cm->GetKey(domain_base_3));
    207         domain_list.push_back(domain_base_3);
    208         for (int i4 = 0; i4 < 2; i4++) {
    209           std::string domain_base_4((i4 ? "a." : "b.") + domain_base_3);
    210           EXPECT_EQ("top.com", cm->GetKey(domain_base_4));
    211           domain_list.push_back(domain_base_4);
    212         }
    213       }
    214     }
    215   }
    216 
    217 
    218   EXPECT_EQ(31u, domain_list.size());
    219   for (std::vector<std::string>::const_iterator it = domain_list.begin();
    220        it != domain_list.end(); it++) {
    221     GURL gurl("https://" + *it + "/");
    222     const std::string cookie = base::StringPrintf(domain_cookie_format_tree,
    223                                                   it->c_str());
    224     setCookieCallback.SetCookie(cm.get(), gurl, cookie);
    225   }
    226   EXPECT_EQ(31u, cm->GetAllCookies().size());
    227 
    228   GURL probe_gurl("https://b.a.b.a.top.com/");
    229   std::string cookie_line = getCookiesCallback.GetCookies(cm.get(), probe_gurl);
    230   EXPECT_EQ(5, CountInString(cookie_line, '='))
    231       << "Cookie line: " << cookie_line;
    232   base::PerfTimeLogger timer("Cookie_monster_query_domain_tree");
    233   for (int i = 0; i < kNumCookies; i++) {
    234     getCookiesCallback.GetCookies(cm.get(), probe_gurl);
    235   }
    236   timer.Done();
    237 }
    238 
    239 TEST_F(CookieMonsterTest, TestDomainLine) {
    240   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
    241   SetCookieCallback setCookieCallback;
    242   GetCookiesCallback getCookiesCallback;
    243   std::vector<std::string> domain_list;
    244   GURL probe_gurl("https://b.a.b.a.top.com/");
    245   std::string cookie_line;
    246 
    247   // Create a line of 32 domain cookies such that all cookies stored
    248   // by effective TLD+1 will apply to probe GURL.
    249   // (TLD + 1 is the level above .com/org/net/etc, e.g. "top.com"
    250   // or "google.com".  "Effective" is added to include sites like
    251   // bbc.co.uk, where the effetive TLD+1 is more than one level
    252   // below the top level.)
    253   domain_list.push_back("a.top.com");
    254   domain_list.push_back("b.a.top.com");
    255   domain_list.push_back("a.b.a.top.com");
    256   domain_list.push_back("b.a.b.a.top.com");
    257   EXPECT_EQ(4u, domain_list.size());
    258 
    259   const char* domain_cookie_format_line = "a%03d=b; domain=%s";
    260   for (int i = 0; i < 8; i++) {
    261     for (std::vector<std::string>::const_iterator it = domain_list.begin();
    262          it != domain_list.end(); it++) {
    263       GURL gurl("https://" + *it + "/");
    264       const std::string cookie = base::StringPrintf(domain_cookie_format_line,
    265                                                     i, it->c_str());
    266       setCookieCallback.SetCookie(cm.get(), gurl, cookie);
    267     }
    268   }
    269 
    270   cookie_line = getCookiesCallback.GetCookies(cm.get(), probe_gurl);
    271   EXPECT_EQ(32, CountInString(cookie_line, '='));
    272   base::PerfTimeLogger timer2("Cookie_monster_query_domain_line");
    273   for (int i = 0; i < kNumCookies; i++) {
    274     getCookiesCallback.GetCookies(cm.get(), probe_gurl);
    275   }
    276   timer2.Done();
    277 }
    278 
    279 TEST_F(CookieMonsterTest, TestImport) {
    280   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
    281   std::vector<CanonicalCookie*> initial_cookies;
    282   GetCookiesCallback getCookiesCallback;
    283 
    284   // We want to setup a fairly large backing store, with 300 domains of 50
    285   // cookies each.  Creation times must be unique.
    286   int64 time_tick(base::Time::Now().ToInternalValue());
    287 
    288   for (int domain_num = 0; domain_num < 300; domain_num++) {
    289     std::string domain_name(base::StringPrintf(".Domain_%d.com", domain_num));
    290     std::string gurl("www" + domain_name);
    291     for (int cookie_num = 0; cookie_num < 50; cookie_num++) {
    292       std::string cookie_line(base::StringPrintf("Cookie_%d=1; Path=/",
    293                                                  cookie_num));
    294       AddCookieToList(gurl, cookie_line,
    295                       base::Time::FromInternalValue(time_tick++),
    296                       &initial_cookies);
    297     }
    298   }
    299 
    300   store->SetLoadExpectation(true, initial_cookies);
    301 
    302   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
    303 
    304   // Import will happen on first access.
    305   GURL gurl("www.google.com");
    306   CookieOptions options;
    307   base::PerfTimeLogger timer("Cookie_monster_import_from_store");
    308   getCookiesCallback.GetCookies(cm.get(), gurl);
    309   timer.Done();
    310 
    311   // Just confirm keys were set as expected.
    312   EXPECT_EQ("domain_1.com", cm->GetKey("www.Domain_1.com"));
    313 }
    314 
    315 TEST_F(CookieMonsterTest, TestGetKey) {
    316   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
    317   base::PerfTimeLogger timer("Cookie_monster_get_key");
    318   for (int i = 0; i < kNumCookies; i++)
    319     cm->GetKey("www.google.com");
    320   timer.Done();
    321 }
    322 
    323 // This test is probing for whether garbage collection happens when it
    324 // shouldn't.  This will not in general be visible functionally, since
    325 // if GC runs twice in a row without any change to the store, the second
    326 // GC run will not do anything the first one didn't.  That's why this is
    327 // a performance test.  The test should be considered to pass if all the
    328 // times reported are approximately the same--this indicates that no GC
    329 // happened repeatedly for any case.
    330 TEST_F(CookieMonsterTest, TestGCTimes) {
    331   SetCookieCallback setCookieCallback;
    332 
    333   const struct TestCase {
    334     const char* name;
    335     size_t num_cookies;
    336     size_t num_old_cookies;
    337   } test_cases[] = {
    338     {
    339       // A whole lot of recent cookies; gc shouldn't happen.
    340       "all_recent",
    341       CookieMonster::kMaxCookies * 2,
    342       0,
    343     }, {
    344       // Some old cookies, but still overflowing max.
    345       "mostly_recent",
    346       CookieMonster::kMaxCookies * 2,
    347       CookieMonster::kMaxCookies / 2,
    348     }, {
    349       // Old cookies enough to bring us right down to our purge line.
    350       "balanced",
    351       CookieMonster::kMaxCookies * 2,
    352       CookieMonster::kMaxCookies + CookieMonster::kPurgeCookies + 1,
    353     }, {
    354       "mostly_old",
    355       // Old cookies enough to bring below our purge line (which we
    356       // shouldn't do).
    357       CookieMonster::kMaxCookies * 2,
    358       CookieMonster::kMaxCookies * 3 / 4,
    359     }, {
    360       "less_than_gc_thresh",
    361       // Few enough cookies that gc shouldn't happen at all.
    362       CookieMonster::kMaxCookies - 5,
    363       0,
    364     },
    365   };
    366   for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
    367     const TestCase& test_case(test_cases[ci]);
    368     scoped_refptr<CookieMonster> cm(
    369         CreateMonsterFromStoreForGC(
    370             test_case.num_cookies, test_case.num_old_cookies,
    371             CookieMonster::kSafeFromGlobalPurgeDays * 2));
    372 
    373     GURL gurl("http://google.com");
    374     std::string cookie_line("z=3");
    375     // Trigger the Garbage collection we're allowed.
    376     setCookieCallback.SetCookie(cm.get(), gurl, cookie_line);
    377 
    378     base::PerfTimeLogger timer((std::string("GC_") + test_case.name).c_str());
    379     for (int i = 0; i < kNumCookies; i++)
    380       setCookieCallback.SetCookie(cm.get(), gurl, cookie_line);
    381     timer.Done();
    382   }
    383 }
    384 
    385 }  // namespace net
    386