chrome/browser/predictors/autocomplete_action_predictor_unittest.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 "chrome/browser/predictors/autocomplete_action_predictor.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "base/command_line.h"
   9 #include "base/guid.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/time/time.h"
  15 #include "chrome/browser/autocomplete/autocomplete_match.h"
  16 #include "chrome/browser/history/history_service.h"
  17 #include "chrome/browser/history/history_service_factory.h"
  18 #include "chrome/browser/history/in_memory_database.h"
  19 #include "chrome/browser/history/url_database.h"
  20 #include "chrome/browser/prerender/prerender_field_trial.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/test/base/testing_profile.h"
  23 #include "content/public/test/test_browser_thread.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 using base::ASCIIToUTF16;
  27 using content::BrowserThread;
  28 using predictors::AutocompleteActionPredictor;
  29
  30 namespace {
  31
  32 struct TestUrlInfo {
  33   GURL url;
  34   base::string16 title;
  35   int days_from_now;
  36   base::string16 user_text;
  37   int number_of_hits;
  38   int number_of_misses;
  39   AutocompleteActionPredictor::Action expected_action;
  40 } test_url_db[] = {
  41   { GURL("http://www.testsite.com/a.html"),
  42     ASCIIToUTF16("Test - site - just a test"), 1,
  43     ASCIIToUTF16("j"), 5, 0,
  44     AutocompleteActionPredictor::ACTION_PRERENDER },
  45   { GURL("http://www.testsite.com/b.html"),
  46     ASCIIToUTF16("Test - site - just a test"), 1,
  47     ASCIIToUTF16("ju"), 3, 0,
  48     AutocompleteActionPredictor::ACTION_PRERENDER },
  49   { GURL("http://www.testsite.com/c.html"),
  50     ASCIIToUTF16("Test - site - just a test"), 5,
  51     ASCIIToUTF16("just"), 3, 1,
  52     AutocompleteActionPredictor::ACTION_PRECONNECT },
  53   { GURL("http://www.testsite.com/d.html"),
  54     ASCIIToUTF16("Test - site - just a test"), 5,
  55     ASCIIToUTF16("just"), 3, 0,
  56     AutocompleteActionPredictor::ACTION_PRERENDER },
  57   { GURL("http://www.testsite.com/e.html"),
  58     ASCIIToUTF16("Test - site - just a test"), 8,
  59     ASCIIToUTF16("just"), 3, 1,
  60     AutocompleteActionPredictor::ACTION_PRECONNECT },
  61   { GURL("http://www.testsite.com/f.html"),
  62     ASCIIToUTF16("Test - site - just a test"), 8,
  63     ASCIIToUTF16("just"), 3, 0,
  64     AutocompleteActionPredictor::ACTION_PRERENDER },
  65   { GURL("http://www.testsite.com/g.html"),
  66     ASCIIToUTF16("Test - site - just a test"), 12,
  67     base::string16(), 5, 0,
  68     AutocompleteActionPredictor::ACTION_NONE },
  69   { GURL("http://www.testsite.com/h.html"),
  70     ASCIIToUTF16("Test - site - just a test"), 21,
  71     ASCIIToUTF16("just a test"), 2, 0,
  72     AutocompleteActionPredictor::ACTION_NONE },
  73   { GURL("http://www.testsite.com/i.html"),
  74     ASCIIToUTF16("Test - site - just a test"), 28,
  75     ASCIIToUTF16("just a test"), 2, 0,
  76     AutocompleteActionPredictor::ACTION_NONE }
  77 };
  78
  79 }  // end namespace
  80
  81 namespace predictors {
  82
  83 class AutocompleteActionPredictorTest : public testing::Test {
  84  public:
  85   AutocompleteActionPredictorTest()
  86       : ui_thread_(BrowserThread::UI, &loop_),
  87         db_thread_(BrowserThread::DB, &loop_),
  88         file_thread_(BrowserThread::FILE, &loop_),
  89         profile_(new TestingProfile()),
  90         predictor_(new AutocompleteActionPredictor(profile_.get())) {
  91   }
  92
  93   virtual ~AutocompleteActionPredictorTest() {
  94     predictor_.reset(NULL);
  95     profile_.reset(NULL);
  96     loop_.RunUntilIdle();
  97   }
  98
  99   virtual void SetUp() {
 100     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
 101         switches::kPrerenderFromOmnibox,
 102         switches::kPrerenderFromOmniboxSwitchValueEnabled);
 103
 104     predictor_->CreateLocalCachesFromDatabase();
 105     ASSERT_TRUE(profile_->CreateHistoryService(true, false));
 106     profile_->BlockUntilHistoryProcessesPendingRequests();
 107
 108     ASSERT_TRUE(predictor_->initialized_);
 109     ASSERT_TRUE(db_cache()->empty());
 110     ASSERT_TRUE(db_id_cache()->empty());
 111   }
 112
 113   virtual void TearDown() {
 114     profile_->DestroyHistoryService();
 115     predictor_->Shutdown();
 116   }
 117
 118  protected:
 119   typedef AutocompleteActionPredictor::DBCacheKey DBCacheKey;
 120   typedef AutocompleteActionPredictor::DBCacheValue DBCacheValue;
 121   typedef AutocompleteActionPredictor::DBCacheMap DBCacheMap;
 122   typedef AutocompleteActionPredictor::DBIdCacheMap DBIdCacheMap;
 123
 124   void AddAllRowsToHistory() {
 125     for (size_t i = 0; i < arraysize(test_url_db); ++i)
 126       ASSERT_TRUE(AddRowToHistory(test_url_db[i]));
 127   }
 128
 129   history::URLID AddRowToHistory(const TestUrlInfo& test_row) {
 130     HistoryService* history =
 131         HistoryServiceFactory::GetForProfile(profile_.get(),
 132                                              Profile::EXPLICIT_ACCESS);
 133     CHECK(history);
 134     history::URLDatabase* url_db = history->InMemoryDatabase();
 135     CHECK(url_db);
 136
 137     const base::Time visit_time =
 138         base::Time::Now() - base::TimeDelta::FromDays(
 139             test_row.days_from_now);
 140
 141     history::URLRow row(test_row.url);
 142     row.set_title(test_row.title);
 143     row.set_last_visit(visit_time);
 144
 145     return url_db->AddURL(row);
 146   }
 147
 148   AutocompleteActionPredictorTable::Row CreateRowFromTestUrlInfo(
 149       const TestUrlInfo& test_row) const {
 150     AutocompleteActionPredictorTable::Row row;
 151     row.id = base::GenerateGUID();
 152     row.user_text = test_row.user_text;
 153     row.url = test_row.url;
 154     row.number_of_hits = test_row.number_of_hits;
 155     row.number_of_misses = test_row.number_of_misses;
 156     return row;
 157   }
 158
 159   void AddAllRows() {
 160     for (size_t i = 0; i < arraysize(test_url_db); ++i)
 161       AddRow(test_url_db[i]);
 162   }
 163
 164   std::string AddRow(const TestUrlInfo& test_row) {
 165     AutocompleteActionPredictorTable::Row row =
 166         CreateRowFromTestUrlInfo(test_row);
 167     predictor_->AddAndUpdateRows(
 168         AutocompleteActionPredictorTable::Rows(1, row),
 169         AutocompleteActionPredictorTable::Rows());
 170
 171     return row.id;
 172   }
 173
 174   void UpdateRow(const AutocompleteActionPredictorTable::Row& row) {
 175     AutocompleteActionPredictor::DBCacheKey key = { row.user_text, row.url };
 176     ASSERT_TRUE(db_cache()->find(key) != db_cache()->end());
 177     predictor_->AddAndUpdateRows(
 178         AutocompleteActionPredictorTable::Rows(),
 179         AutocompleteActionPredictorTable::Rows(1, row));
 180   }
 181
 182   void DeleteAllRows() {
 183     predictor_->DeleteAllRows();
 184   }
 185
 186   void DeleteRowsWithURLs(const history::URLRows& rows) {
 187     predictor_->DeleteRowsWithURLs(rows);
 188   }
 189
 190   void DeleteOldIdsFromCaches(
 191       std::vector<AutocompleteActionPredictorTable::Row::Id>* id_list) {
 192     HistoryService* history_service =
 193         HistoryServiceFactory::GetForProfile(profile_.get(),
 194                                              Profile::EXPLICIT_ACCESS);
 195     ASSERT_TRUE(history_service);
 196
 197     history::URLDatabase* url_db = history_service->InMemoryDatabase();
 198     ASSERT_TRUE(url_db);
 199
 200     // Reset the predictor's |initialized_| flag for the life of this call,
 201     // since outside of testing this function is only supposed to be reached
 202     // before initialization is completed.
 203     base::AutoReset<bool> initialized_reset(&predictor_->initialized_, false);
 204     predictor_->DeleteOldIdsFromCaches(url_db, id_list);
 205   }
 206
 207   AutocompleteActionPredictor* predictor() { return predictor_.get(); }
 208
 209   DBCacheMap* db_cache() { return &predictor_->db_cache_; }
 210   DBIdCacheMap* db_id_cache() { return &predictor_->db_id_cache_; }
 211
 212   static int maximum_days_to_keep_entry() {
 213     return AutocompleteActionPredictor::kMaximumDaysToKeepEntry;
 214   }
 215
 216  private:
 217   base::MessageLoop loop_;
 218   content::TestBrowserThread ui_thread_;
 219   content::TestBrowserThread db_thread_;
 220   content::TestBrowserThread file_thread_;
 221   scoped_ptr<TestingProfile> profile_;
 222   scoped_ptr<AutocompleteActionPredictor> predictor_;
 223 };
 224
 225
 226 TEST_F(AutocompleteActionPredictorTest, AddRow) {
 227   // Add a test entry to the predictor.
 228   std::string guid = AddRow(test_url_db[0]);
 229
 230   // Get the data back out of the cache.
 231   const DBCacheKey key = { test_url_db[0].user_text, test_url_db[0].url };
 232   DBCacheMap::const_iterator it = db_cache()->find(key);
 233   EXPECT_TRUE(it != db_cache()->end());
 234
 235   const DBCacheValue value = { test_url_db[0].number_of_hits,
 236                                test_url_db[0].number_of_misses };
 237   EXPECT_EQ(value.number_of_hits, it->second.number_of_hits);
 238   EXPECT_EQ(value.number_of_misses, it->second.number_of_misses);
 239
 240   DBIdCacheMap::const_iterator id_it = db_id_cache()->find(key);
 241   EXPECT_TRUE(id_it != db_id_cache()->end());
 242   EXPECT_EQ(guid, id_it->second);
 243 }
 244
 245 TEST_F(AutocompleteActionPredictorTest, UpdateRow) {
 246   ASSERT_NO_FATAL_FAILURE(AddAllRows());
 247
 248   EXPECT_EQ(arraysize(test_url_db), db_cache()->size());
 249   EXPECT_EQ(arraysize(test_url_db), db_id_cache()->size());
 250
 251   // Get the data back out of the cache.
 252   const DBCacheKey key = { test_url_db[0].user_text, test_url_db[0].url };
 253   DBCacheMap::const_iterator it = db_cache()->find(key);
 254   EXPECT_TRUE(it != db_cache()->end());
 255
 256   DBIdCacheMap::const_iterator id_it = db_id_cache()->find(key);
 257   EXPECT_TRUE(id_it != db_id_cache()->end());
 258
 259   AutocompleteActionPredictorTable::Row update_row;
 260   update_row.id = id_it->second;
 261   update_row.user_text = key.user_text;
 262   update_row.url = key.url;
 263   update_row.number_of_hits = it->second.number_of_hits + 1;
 264   update_row.number_of_misses = it->second.number_of_misses + 2;
 265
 266   UpdateRow(update_row);
 267
 268   // Get the updated version.
 269   DBCacheMap::const_iterator update_it = db_cache()->find(key);
 270   EXPECT_TRUE(update_it != db_cache()->end());
 271
 272   EXPECT_EQ(update_row.number_of_hits, update_it->second.number_of_hits);
 273   EXPECT_EQ(update_row.number_of_misses, update_it->second.number_of_misses);
 274
 275   DBIdCacheMap::const_iterator update_id_it = db_id_cache()->find(key);
 276   EXPECT_TRUE(update_id_it != db_id_cache()->end());
 277
 278   EXPECT_EQ(id_it->second, update_id_it->second);
 279 }
 280
 281 TEST_F(AutocompleteActionPredictorTest, DeleteAllRows) {
 282   ASSERT_NO_FATAL_FAILURE(AddAllRows());
 283
 284   EXPECT_EQ(arraysize(test_url_db), db_cache()->size());
 285   EXPECT_EQ(arraysize(test_url_db), db_id_cache()->size());
 286
 287   DeleteAllRows();
 288
 289   EXPECT_TRUE(db_cache()->empty());
 290   EXPECT_TRUE(db_id_cache()->empty());
 291 }
 292
 293 TEST_F(AutocompleteActionPredictorTest, DeleteRowsWithURLs) {
 294   ASSERT_NO_FATAL_FAILURE(AddAllRows());
 295
 296   EXPECT_EQ(arraysize(test_url_db), db_cache()->size());
 297   EXPECT_EQ(arraysize(test_url_db), db_id_cache()->size());
 298
 299   history::URLRows rows;
 300   for (size_t i = 0; i < 2; ++i)
 301     rows.push_back(history::URLRow(test_url_db[i].url));
 302
 303   DeleteRowsWithURLs(rows);
 304
 305   EXPECT_EQ(arraysize(test_url_db) - 2, db_cache()->size());
 306   EXPECT_EQ(arraysize(test_url_db) - 2, db_id_cache()->size());
 307
 308   for (size_t i = 0; i < arraysize(test_url_db); ++i) {
 309     DBCacheKey key = { test_url_db[i].user_text, test_url_db[i].url };
 310
 311     bool deleted = (i < 2);
 312     EXPECT_EQ(deleted, db_cache()->find(key) == db_cache()->end());
 313     EXPECT_EQ(deleted, db_id_cache()->find(key) == db_id_cache()->end());
 314   }
 315 }
 316
 317 TEST_F(AutocompleteActionPredictorTest, DeleteOldIdsFromCaches) {
 318   std::vector<AutocompleteActionPredictorTable::Row::Id> expected;
 319   std::vector<AutocompleteActionPredictorTable::Row::Id> all_ids;
 320
 321   for (size_t i = 0; i < arraysize(test_url_db); ++i) {
 322     std::string row_id = AddRow(test_url_db[i]);
 323     all_ids.push_back(row_id);
 324
 325     bool exclude_url = StartsWithASCII(test_url_db[i].url.path(), "/d", true) ||
 326         (test_url_db[i].days_from_now > maximum_days_to_keep_entry());
 327
 328     if (exclude_url)
 329       expected.push_back(row_id);
 330     else
 331       ASSERT_TRUE(AddRowToHistory(test_url_db[i]));
 332   }
 333
 334   std::vector<AutocompleteActionPredictorTable::Row::Id> id_list;
 335   DeleteOldIdsFromCaches(&id_list);
 336   EXPECT_EQ(expected.size(), id_list.size());
 337   EXPECT_EQ(all_ids.size() - expected.size(), db_cache()->size());
 338   EXPECT_EQ(all_ids.size() - expected.size(), db_id_cache()->size());
 339
 340   for (std::vector<AutocompleteActionPredictorTable::Row::Id>::iterator it =
 341        all_ids.begin();
 342        it != all_ids.end(); ++it) {
 343     bool in_expected =
 344         (std::find(expected.begin(), expected.end(), *it) != expected.end());
 345     bool in_list =
 346         (std::find(id_list.begin(), id_list.end(), *it) != id_list.end());
 347     EXPECT_EQ(in_expected, in_list);
 348   }
 349 }
 350
 351 TEST_F(AutocompleteActionPredictorTest, RecommendActionURL) {
 352   ASSERT_NO_FATAL_FAILURE(AddAllRows());
 353
 354   AutocompleteMatch match;
 355   match.type = AutocompleteMatchType::HISTORY_URL;
 356
 357   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_url_db); ++i) {
 358     match.destination_url = GURL(test_url_db[i].url);
 359     EXPECT_EQ(test_url_db[i].expected_action,
 360               predictor()->RecommendAction(test_url_db[i].user_text, match))
 361         << "Unexpected action for " << match.destination_url;
 362   }
 363 }
 364
 365 TEST_F(AutocompleteActionPredictorTest, RecommendActionSearch) {
 366   ASSERT_NO_FATAL_FAILURE(AddAllRows());
 367
 368   AutocompleteMatch match;
 369   match.type = AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED;
 370
 371   for (size_t i = 0; i < arraysize(test_url_db); ++i) {
 372     match.destination_url = GURL(test_url_db[i].url);
 373     AutocompleteActionPredictor::Action expected_action =
 374         (test_url_db[i].expected_action ==
 375          AutocompleteActionPredictor::ACTION_PRERENDER) ?
 376         AutocompleteActionPredictor::ACTION_PRECONNECT :
 377         test_url_db[i].expected_action;
 378     EXPECT_EQ(expected_action,
 379               predictor()->RecommendAction(test_url_db[i].user_text, match))
 380         << "Unexpected action for " << match.destination_url;
 381   }
 382 }
 383
 384 }  // namespace predictors