src/chrome/browser/history/android/android_history_provider_service_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/history/android/android_history_provider_service.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "base/time/time.h"
   9 #include "chrome/browser/bookmarks/bookmark_test_helpers.h"
  10 #include "chrome/browser/history/android/android_history_types.h"
  11 #include "chrome/common/chrome_constants.h"
  12 #include "chrome/test/base/testing_browser_process.h"
  13 #include "chrome/test/base/testing_profile.h"
  14 #include "chrome/test/base/testing_profile_manager.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "content/public/test/test_browser_thread.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace {
  20
  21 using base::Bind;
  22 using base::Time;
  23 using content::BrowserThread;
  24 using history::AndroidStatement;
  25 using history::HistoryAndBookmarkRow;
  26 using history::SearchRow;
  27
  28 // The test cases in this file don't intent to test the detail features of
  29 // Android content provider which have been covered by
  30 // android_provider_backend_unittest.cc, instead, they verify the code path to
  31 // AndroidProviderBackend working fine.
  32
  33 class AndroidHistoryProviderServiceTest : public testing::Test {
  34  public:
  35   AndroidHistoryProviderServiceTest()
  36       : profile_manager_(
  37           TestingBrowserProcess::GetGlobal()),
  38         ui_thread_(BrowserThread::UI, &message_loop_),
  39         file_thread_(BrowserThread::FILE, &message_loop_) {
  40   }
  41   virtual ~AndroidHistoryProviderServiceTest() {
  42   }
  43
  44  protected:
  45   virtual void SetUp() OVERRIDE {
  46     // Setup the testing profile, so the bookmark_model_sql_handler could
  47     // get the bookmark model from it.
  48     ASSERT_TRUE(profile_manager_.SetUp());
  49     // It seems that the name has to be chrome::kInitialProfile, so it
  50     // could be found by ProfileManager::GetLastUsedProfile().
  51     testing_profile_ = profile_manager_.CreateTestingProfile(
  52         chrome::kInitialProfile);
  53
  54     testing_profile_->CreateBookmarkModel(true);
  55     test::WaitForBookmarkModelToLoad(testing_profile_);
  56     ASSERT_TRUE(testing_profile_->CreateHistoryService(true, false));
  57     service_.reset(new AndroidHistoryProviderService(testing_profile_));
  58   }
  59
  60   virtual void TearDown() OVERRIDE {
  61     testing_profile_->DestroyHistoryService();
  62     profile_manager_.DeleteTestingProfile(chrome::kInitialProfile);
  63     testing_profile_=NULL;
  64   }
  65
  66  protected:
  67   TestingProfileManager profile_manager_;
  68   base::MessageLoop message_loop_;
  69   content::TestBrowserThread ui_thread_;
  70   content::TestBrowserThread file_thread_;
  71   scoped_ptr<AndroidHistoryProviderService> service_;
  72   CancelableRequestConsumer cancelable_consumer_;
  73   TestingProfile* testing_profile_;
  74
  75  private:
  76   DISALLOW_COPY_AND_ASSIGN(AndroidHistoryProviderServiceTest);
  77 };
  78
  79 class CallbackHelper : public base::RefCountedThreadSafe<CallbackHelper> {
  80  public:
  81   CallbackHelper()
  82       : success_(false),
  83         statement_(NULL),
  84         cursor_position_(0),
  85         count_(0) {
  86   }
  87
  88   bool success() const {
  89     return success_;
  90   }
  91
  92   AndroidStatement* statement() const {
  93     return statement_;
  94   }
  95
  96   int cursor_position() const {
  97     return cursor_position_;
  98   }
  99
 100   int count() const {
 101     return count_;
 102   }
 103
 104   void OnInserted(AndroidHistoryProviderService::Handle handle,
 105                   bool success,
 106                   int64 id) {
 107     success_ = success;
 108     base::MessageLoop::current()->Quit();
 109   }
 110
 111   void OnQueryResult(AndroidHistoryProviderService::Handle handle,
 112                      bool success,
 113                      AndroidStatement* statement) {
 114     success_ = success;
 115     statement_ = statement;
 116     base::MessageLoop::current()->Quit();
 117   }
 118
 119   void OnUpdated(AndroidHistoryProviderService::Handle handle,
 120                  bool success,
 121                  int count) {
 122     success_ = success;
 123     count_ = count;
 124     base::MessageLoop::current()->Quit();
 125   }
 126
 127   void OnDeleted(AndroidHistoryProviderService::Handle handle,
 128                  bool success,
 129                  int count) {
 130     success_ = success;
 131     count_ = count;
 132     base::MessageLoop::current()->Quit();
 133   }
 134
 135   void OnStatementMoved(AndroidHistoryProviderService::Handle handle,
 136                         int cursor_position) {
 137     cursor_position_ = cursor_position;
 138     base::MessageLoop::current()->Quit();
 139   }
 140
 141  private:
 142   friend class base::RefCountedThreadSafe<CallbackHelper>;
 143   ~CallbackHelper() {
 144   }
 145
 146   bool success_;
 147   AndroidStatement* statement_;
 148   int cursor_position_;
 149   int count_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 152 };
 153
 154 TEST_F(AndroidHistoryProviderServiceTest, TestHistoryAndBookmark) {
 155   HistoryAndBookmarkRow row;
 156   row.set_raw_url("http://www.google.com");
 157   row.set_url(GURL("http://www.google.com"));
 158
 159   scoped_refptr<CallbackHelper> callback(new CallbackHelper());
 160
 161   // Insert a row and verify it succeeded.
 162   service_->InsertHistoryAndBookmark(row, &cancelable_consumer_,
 163       Bind(&CallbackHelper::OnInserted, callback.get()));
 164
 165   base::MessageLoop::current()->Run();
 166   EXPECT_TRUE(callback->success());
 167
 168   std::vector<HistoryAndBookmarkRow::ColumnID> projections;
 169   projections.push_back(HistoryAndBookmarkRow::ID);
 170
 171   // Query the inserted row.
 172   service_->QueryHistoryAndBookmarks(projections, std::string(),
 173       std::vector<string16>(), std::string(), &cancelable_consumer_,
 174       Bind(&CallbackHelper::OnQueryResult, callback.get()));
 175   base::MessageLoop::current()->Run();
 176   ASSERT_TRUE(callback->success());
 177
 178   // Move the cursor to the begining and verify whether we could get
 179   // the same result.
 180   AndroidStatement* statement = callback->statement();
 181   service_->MoveStatement(statement, 0, -1, &cancelable_consumer_,
 182       Bind(&CallbackHelper::OnStatementMoved, callback.get()));
 183   base::MessageLoop::current()->Run();
 184   EXPECT_EQ(-1, callback->cursor_position());
 185   EXPECT_TRUE(callback->statement()->statement()->Step());
 186   EXPECT_FALSE(callback->statement()->statement()->Step());
 187   service_->CloseStatement(statement);
 188
 189   // Update the row.
 190   HistoryAndBookmarkRow update_row;
 191   update_row.set_visit_count(3);
 192   service_->UpdateHistoryAndBookmarks(update_row, std::string(),
 193       std::vector<string16>(), &cancelable_consumer_,
 194       Bind(&CallbackHelper::OnUpdated, callback.get()));
 195   base::MessageLoop::current()->Run();
 196   EXPECT_TRUE(callback->success());
 197   EXPECT_EQ(1, callback->count());
 198
 199   // Delete the row.
 200   service_->DeleteHistoryAndBookmarks(std::string(), std::vector<string16>(),
 201       &cancelable_consumer_, Bind(&CallbackHelper::OnDeleted, callback.get()));
 202   base::MessageLoop::current()->Run();
 203   EXPECT_TRUE(callback->success());
 204   EXPECT_EQ(1, callback->count());
 205 }
 206
 207 TEST_F(AndroidHistoryProviderServiceTest, TestSearchTerm) {
 208   SearchRow search_row;
 209   search_row.set_search_term(UTF8ToUTF16("google"));
 210   search_row.set_url(GURL("http://google.com"));
 211   search_row.set_template_url_id(1);
 212   search_row.set_search_time(Time::Now());
 213
 214   scoped_refptr<CallbackHelper> callback(new CallbackHelper());
 215
 216   // Insert a row and verify it succeeded.
 217   service_->InsertSearchTerm(search_row, &cancelable_consumer_,
 218       Bind(&CallbackHelper::OnInserted, callback.get()));
 219
 220   base::MessageLoop::current()->Run();
 221   EXPECT_TRUE(callback->success());
 222
 223   std::vector<SearchRow::ColumnID> projections;
 224   projections.push_back(SearchRow::ID);
 225
 226   // Query the inserted row.
 227   service_->QuerySearchTerms(projections, std::string(),
 228       std::vector<string16>(), std::string(), &cancelable_consumer_,
 229       Bind(&CallbackHelper::OnQueryResult, callback.get()));
 230   base::MessageLoop::current()->Run();
 231   ASSERT_TRUE(callback->success());
 232
 233   // Move the cursor to the begining and verify whether we could get
 234   // the same result.
 235   AndroidStatement* statement = callback->statement();
 236   service_->MoveStatement(statement, 0, -1, &cancelable_consumer_,
 237       Bind(&CallbackHelper::OnStatementMoved, callback.get()));
 238   base::MessageLoop::current()->Run();
 239   EXPECT_EQ(-1, callback->cursor_position());
 240   EXPECT_TRUE(callback->statement()->statement()->Step());
 241   EXPECT_FALSE(callback->statement()->statement()->Step());
 242   service_->CloseStatement(statement);
 243
 244   // Update the row.
 245   SearchRow update_row;
 246   update_row.set_search_time(Time::Now());
 247   service_->UpdateSearchTerms(update_row, std::string(),
 248       std::vector<string16>(), &cancelable_consumer_,
 249       Bind(&CallbackHelper::OnUpdated, callback.get()));
 250   base::MessageLoop::current()->Run();
 251   EXPECT_TRUE(callback->success());
 252   EXPECT_EQ(1, callback->count());
 253
 254   // Delete the row.
 255   service_->DeleteSearchTerms(std::string(), std::vector<string16>(),
 256       &cancelable_consumer_, Bind(&CallbackHelper::OnDeleted, callback.get()));
 257   base::MessageLoop::current()->Run();
 258   EXPECT_TRUE(callback->success());
 259   EXPECT_EQ(1, callback->count());
 260 }
 261
 262 }  // namespace