predictors: Version the resource_prefetch_predictor database.

chrome/browser/predictors/resource_prefetch_predictor_tables_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/request_priority.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace predictors {
 
 class ResourcePrefetchPredictorTablesTest : public testing::Test {
  public:
   ResourcePrefetchPredictorTablesTest();
   ~ResourcePrefetchPredictorTablesTest() override;
   void SetUp() override;
   void TearDown() override;
 
  protected:
+  void ReopenDatabase();
   void TestGetAllData();
   void TestUpdateData();
   void TestDeleteData();
   void TestDeleteSingleDataPoint();
   void TestDeleteAllData();
 
   base::MessageLoop loop_;
   content::TestBrowserThread db_thread_;
   TestingProfile profile_;
   std::unique_ptr<PredictorDatabase> db_;
   scoped_refptr<ResourcePrefetchPredictorTables> tables_;
 
+  using PrefetchDataMap = ResourcePrefetchPredictorTables::PrefetchDataMap;
+
  private:
-  typedef ResourcePrefetchPredictorTables::ResourceRow ResourceRow;
-  typedef std::vector<ResourceRow> ResourceRows;
-  typedef ResourcePrefetchPredictorTables::PrefetchData PrefetchData;
-  typedef ResourcePrefetchPredictorTables::PrefetchDataMap PrefetchDataMap;
+  using ResourceRow = ResourcePrefetchPredictorTables::ResourceRow;
+  using ResourceRows = std::vector<ResourceRow>;
+  using PrefetchData = ResourcePrefetchPredictorTables::PrefetchData;
 
   // Initializes the tables, |test_url_data_| and |test_host_data_|.
   void InitializeSampleData();
 
   // Checks that the input PrefetchData are the same, although the resources
   // can be in different order.
   void TestPrefetchDataAreEqual(const PrefetchDataMap& lhs,
                                 const PrefetchDataMap& rhs) const;
   void TestResourceRowsAreEqual(const ResourceRows& lhs,
                                 const ResourceRows& rhs) const;
@@ skipping 21 matching lines @@
 };
 
 class ResourcePrefetchPredictorTablesReopenTest
     : public ResourcePrefetchPredictorTablesTest {
  public:
   void SetUp() override {
     // Write data to the table, and then reopen the db.
     ResourcePrefetchPredictorTablesTest::SetUp();
     ResourcePrefetchPredictorTablesTest::TearDown();
 
-    db_.reset(new PredictorDatabase(&profile_));
-    base::RunLoop().RunUntilIdle();
-    tables_ = db_->resource_prefetch_tables();
+    ReopenDatabase();
   }
 };
 
 ResourcePrefetchPredictorTablesTest::ResourcePrefetchPredictorTablesTest()
     : loop_(base::MessageLoop::TYPE_DEFAULT),
       db_thread_(content::BrowserThread::DB, &loop_),
       db_(new PredictorDatabase(&profile_)),
       tables_(db_->resource_prefetch_tables()) {
   base::RunLoop().RunUntilIdle();
 }
@@ skipping 253 matching lines @@
     test_host_data_.clear();
     test_host_data_.insert(std::make_pair("www.facebook.com", facebook));
     test_host_data_.insert(std::make_pair("www.yahoo.com", yahoo));
 
     PrefetchData empty_url_data(PREFETCH_KEY_TYPE_URL, std::string());
     tables_->UpdateData(empty_url_data, facebook);
     tables_->UpdateData(empty_url_data, yahoo);
   }
 }
 
+void ResourcePrefetchPredictorTablesTest::ReopenDatabase() {
+  db_.reset(new PredictorDatabase(&profile_));
+  base::RunLoop().RunUntilIdle();
+  tables_ = db_->resource_prefetch_tables();
+}
+
 // Test cases.
 
 TEST_F(ResourcePrefetchPredictorTablesTest, ComputeScore) {
   typedef ResourcePrefetchPredictorTables::ResourceRow ResourceRow;
   ResourceRow js_resource(
       std::string(), "http://www.resources.google.com/script.js",
       content::RESOURCE_TYPE_SCRIPT, 11, 0, 0, 1., net::MEDIUM, false, false);
   ResourceRow image_resource(
       std::string(), "http://www.resources.google.com/image.jpg",
       content::RESOURCE_TYPE_IMAGE, 11, 0, 0, 1., net::MEDIUM, false, false);
@@ skipping 24 matching lines @@
 }
 
 TEST_F(ResourcePrefetchPredictorTablesTest, DeleteSingleDataPoint) {
   TestDeleteSingleDataPoint();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesTest, DeleteAllData) {
   TestDeleteAllData();
 }
 
+TEST_F(ResourcePrefetchPredictorTablesTest, DatabaseVersionIsSet) {
+  sql::Connection* db = tables_->DB();
+  const int version = ResourcePrefetchPredictorTables::kDatabaseVersion;
+  EXPECT_EQ(version, ResourcePrefetchPredictorTables::GetDatabaseVersion(db));
+}
+
+TEST_F(ResourcePrefetchPredictorTablesTest, DatabaseIsResetWhenIncompatible) {
+  const int version = ResourcePrefetchPredictorTables::kDatabaseVersion;
+  sql::Connection* db = tables_->DB();
+  ASSERT_TRUE(
+      ResourcePrefetchPredictorTables::SetDatabaseVersion(db, version + 1));
+  EXPECT_EQ(version + 1,
+            ResourcePrefetchPredictorTables::GetDatabaseVersion(db));
+
+  ReopenDatabase();
+
+  db = tables_->DB();
+  ASSERT_EQ(version, ResourcePrefetchPredictorTables::GetDatabaseVersion(db));
+
+  PrefetchDataMap url_data, host_data;
+  tables_->GetAllData(&url_data, &host_data);
+  EXPECT_TRUE(url_data.empty());
+  EXPECT_TRUE(host_data.empty());
+}
+
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, GetAllData) {
   TestGetAllData();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, UpdateData) {
   TestUpdateData();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, DeleteData) {
   TestDeleteData();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, DeleteSingleDataPoint) {
   TestDeleteSingleDataPoint();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, DeleteAllData) {
   TestDeleteAllData();
 }
 
 }  // namespace predictors