components/webdata/common/web_database_migration_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 <string>
   6
   7 #include "base/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/guid.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/path_service.h"
  12 #include "base/stl_util.h"
  13 #include "base/strings/string16.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/time/time.h"
  18 #include "base/values.h"
  19 #include "components/autofill/core/browser/autofill_country.h"
  20 #include "components/autofill/core/browser/autofill_profile.h"
  21 #include "components/autofill/core/browser/autofill_type.h"
  22 #include "components/autofill/core/browser/credit_card.h"
  23 #include "components/autofill/core/browser/webdata/autofill_change.h"
  24 #include "components/autofill/core/browser/webdata/autofill_entry.h"
  25 #include "components/autofill/core/browser/webdata/autofill_table.h"
  26 #include "components/password_manager/core/browser/webdata/logins_table.h"
  27 #include "components/search_engines/keyword_table.h"
  28 #include "components/signin/core/browser/webdata/token_service_table.h"
  29 #include "components/webdata/common/web_database.h"
  30 #include "sql/statement.h"
  31 #include "testing/gtest/include/gtest/gtest.h"
  32
  33 using autofill::AutofillProfile;
  34 using autofill::AutofillTable;
  35 using autofill::CreditCard;
  36 using base::ASCIIToUTF16;
  37 using base::Time;
  38
  39 namespace {
  40
  41 void AutofillProfile31FromStatement(const sql::Statement& s,
  42                                     AutofillProfile* profile,
  43                                     base::string16* label,
  44                                     int* unique_id,
  45                                     int64* date_modified) {
  46   DCHECK(profile);
  47   DCHECK(label);
  48   DCHECK(unique_id);
  49   DCHECK(date_modified);
  50   *label = s.ColumnString16(0);
  51   *unique_id = s.ColumnInt(1);
  52   profile->SetRawInfo(autofill::NAME_FIRST, s.ColumnString16(2));
  53   profile->SetRawInfo(autofill::NAME_MIDDLE, s.ColumnString16(3));
  54   profile->SetRawInfo(autofill::NAME_LAST, s.ColumnString16(4));
  55   profile->SetRawInfo(autofill::EMAIL_ADDRESS, s.ColumnString16(5));
  56   profile->SetRawInfo(autofill::COMPANY_NAME, s.ColumnString16(6));
  57   profile->SetRawInfo(autofill::ADDRESS_HOME_LINE1, s.ColumnString16(7));
  58   profile->SetRawInfo(autofill::ADDRESS_HOME_LINE2, s.ColumnString16(8));
  59   profile->SetRawInfo(autofill::ADDRESS_HOME_CITY, s.ColumnString16(9));
  60   profile->SetRawInfo(autofill::ADDRESS_HOME_STATE, s.ColumnString16(10));
  61   profile->SetRawInfo(autofill::ADDRESS_HOME_ZIP, s.ColumnString16(11));
  62   profile->SetInfo(
  63       autofill::AutofillType(autofill::ADDRESS_HOME_COUNTRY),
  64       s.ColumnString16(12), "en-US");
  65   profile->SetRawInfo(autofill::PHONE_HOME_WHOLE_NUMBER, s.ColumnString16(13));
  66   *date_modified = s.ColumnInt64(15);
  67   profile->set_guid(s.ColumnString(16));
  68   EXPECT_TRUE(base::IsValidGUID(profile->guid()));
  69 }
  70
  71 void AutofillProfile33FromStatement(const sql::Statement& s,
  72                                     AutofillProfile* profile,
  73                                     int64* date_modified) {
  74   DCHECK(profile);
  75   DCHECK(date_modified);
  76   profile->set_guid(s.ColumnString(0));
  77   EXPECT_TRUE(base::IsValidGUID(profile->guid()));
  78   profile->SetRawInfo(autofill::COMPANY_NAME, s.ColumnString16(1));
  79   profile->SetRawInfo(autofill::ADDRESS_HOME_STREET_ADDRESS,
  80                       s.ColumnString16(2));
  81   profile->SetRawInfo(autofill::ADDRESS_HOME_CITY, s.ColumnString16(3));
  82   profile->SetRawInfo(autofill::ADDRESS_HOME_STATE, s.ColumnString16(4));
  83   profile->SetRawInfo(autofill::ADDRESS_HOME_ZIP, s.ColumnString16(5));
  84   profile->SetInfo(
  85       autofill::AutofillType(autofill::ADDRESS_HOME_COUNTRY),
  86       s.ColumnString16(6), "en-US");
  87   *date_modified = s.ColumnInt64(7);
  88 }
  89
  90 void CreditCard31FromStatement(const sql::Statement& s,
  91                               CreditCard* credit_card,
  92                               base::string16* label,
  93                               int* unique_id,
  94                               std::string* encrypted_number,
  95                               int64* date_modified) {
  96   DCHECK(credit_card);
  97   DCHECK(label);
  98   DCHECK(unique_id);
  99   DCHECK(encrypted_number);
 100   DCHECK(date_modified);
 101   *label = s.ColumnString16(0);
 102   *unique_id = s.ColumnInt(1);
 103   credit_card->SetRawInfo(autofill::CREDIT_CARD_NAME, s.ColumnString16(2));
 104   credit_card->SetRawInfo(autofill::CREDIT_CARD_TYPE, s.ColumnString16(3));
 105   credit_card->SetRawInfo(autofill::CREDIT_CARD_EXP_MONTH, s.ColumnString16(5));
 106   credit_card->SetRawInfo(
 107       autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(6));
 108   int encrypted_number_len = s.ColumnByteLength(10);
 109   if (encrypted_number_len) {
 110     encrypted_number->resize(encrypted_number_len);
 111     memcpy(&(*encrypted_number)[0], s.ColumnBlob(10), encrypted_number_len);
 112   }
 113   *date_modified = s.ColumnInt64(12);
 114   credit_card->set_guid(s.ColumnString(13));
 115   EXPECT_TRUE(base::IsValidGUID(credit_card->guid()));
 116 }
 117
 118 void CreditCard32FromStatement(const sql::Statement& s,
 119                                CreditCard* credit_card,
 120                                std::string* encrypted_number,
 121                                int64* date_modified) {
 122   DCHECK(credit_card);
 123   DCHECK(encrypted_number);
 124   DCHECK(date_modified);
 125   credit_card->set_guid(s.ColumnString(0));
 126   EXPECT_TRUE(base::IsValidGUID(credit_card->guid()));
 127   credit_card->SetRawInfo(autofill::CREDIT_CARD_NAME, s.ColumnString16(1));
 128   credit_card->SetRawInfo(autofill::CREDIT_CARD_EXP_MONTH, s.ColumnString16(2));
 129   credit_card->SetRawInfo(
 130       autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(3));
 131   int encrypted_number_len = s.ColumnByteLength(4);
 132   if (encrypted_number_len) {
 133     encrypted_number->resize(encrypted_number_len);
 134     memcpy(&(*encrypted_number)[0], s.ColumnBlob(4), encrypted_number_len);
 135   }
 136   *date_modified = s.ColumnInt64(5);
 137 }
 138
 139 void CheckHasBackupData(sql::MetaTable* meta_table) {
 140   std::string value;
 141   EXPECT_TRUE(meta_table->GetValue(
 142       "Default Search Provider ID Backup", &value));
 143   EXPECT_TRUE(meta_table->GetValue(
 144       "Default Search Provider ID Backup Signature", &value));
 145 }
 146
 147 void CheckNoBackupData(const sql::Connection& connection,
 148                        sql::MetaTable* meta_table) {
 149   std::string value;
 150   EXPECT_FALSE(meta_table->GetValue(
 151       "Default Search Provider ID Backup", &value));
 152   EXPECT_FALSE(meta_table->GetValue(
 153       "Default Search Provider ID Backup Signature", &value));
 154   EXPECT_FALSE(connection.DoesTableExist("keywords_backup"));
 155 }
 156
 157 std::string RemoveQuotes(const std::string& has_quotes) {
 158   std::string no_quotes;
 159   // SQLite quotes: http://www.sqlite.org/lang_keywords.html
 160   base::RemoveChars(has_quotes, "\"[]`", &no_quotes);
 161   return no_quotes;
 162 }
 163
 164 }  // anonymous namespace
 165
 166 // The WebDatabaseMigrationTest encapsulates testing of database migrations.
 167 // Specifically, these tests are intended to exercise any schema changes in
 168 // the WebDatabase and data migrations that occur in
 169 // |WebDatabase::MigrateOldVersionsAsNeeded()|.
 170 class WebDatabaseMigrationTest : public testing::Test {
 171  public:
 172   WebDatabaseMigrationTest() {}
 173   virtual ~WebDatabaseMigrationTest() {}
 174
 175   virtual void SetUp() {
 176     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 177   }
 178
 179   // Load the database via the WebDatabase class and migrate the database to
 180   // the current version.
 181   void DoMigration() {
 182     // TODO(joi): This whole unit test file needs to stay in //chrome
 183     // for now, as it needs to know about all the different table
 184     // types. Once all webdata datatypes have been componentized, this
 185     // could move to components_unittests.
 186     AutofillTable autofill_table("en-US");
 187     KeywordTable keyword_table;
 188     LoginsTable logins_table;
 189     TokenServiceTable token_service_table;
 190
 191     WebDatabase db;
 192     db.AddTable(&autofill_table);
 193     db.AddTable(&keyword_table);
 194     db.AddTable(&logins_table);
 195     db.AddTable(&token_service_table);
 196
 197     // This causes the migration to occur.
 198     ASSERT_EQ(sql::INIT_OK, db.Init(GetDatabasePath()));
 199   }
 200
 201  protected:
 202   // Current tested version number.  When adding a migration in
 203   // |WebDatabase::MigrateOldVersionsAsNeeded()| and changing the version number
 204   // |kCurrentVersionNumber| this value should change to reflect the new version
 205   // number and a new migration test added below.
 206   static const int kCurrentTestedVersionNumber;
 207
 208   base::FilePath GetDatabasePath() {
 209     const base::FilePath::CharType kWebDatabaseFilename[] =
 210         FILE_PATH_LITERAL("TestWebDatabase.sqlite3");
 211     return temp_dir_.path().Append(base::FilePath(kWebDatabaseFilename));
 212   }
 213
 214   // The textual contents of |file| are read from
 215   // "components/test/data/web_database" and returned in the string |contents|.
 216   // Returns true if the file exists and is read successfully, false otherwise.
 217   bool GetWebDatabaseData(const base::FilePath& file, std::string* contents) {
 218     base::FilePath source_path;
 219     PathService::Get(base::DIR_SOURCE_ROOT, &source_path);
 220     source_path = source_path.AppendASCII("components");
 221     source_path = source_path.AppendASCII("test");
 222     source_path = source_path.AppendASCII("data");
 223     source_path = source_path.AppendASCII("web_database");
 224     source_path = source_path.Append(file);
 225     return base::PathExists(source_path) &&
 226         base::ReadFileToString(source_path, contents);
 227   }
 228
 229   static int VersionFromConnection(sql::Connection* connection) {
 230     // Get version.
 231     sql::Statement s(connection->GetUniqueStatement(
 232         "SELECT value FROM meta WHERE key='version'"));
 233     if (!s.Step())
 234       return 0;
 235     return s.ColumnInt(0);
 236   }
 237
 238   // The sql files located in "chrome/test/data/web_database" were generated by
 239   // launching the Chromium application prior to schema change, then using the
 240   // sqlite3 command-line application to dump the contents of the "Web Data"
 241   // database.
 242   // Like this:
 243   //   > .output version_nn.sql
 244   //   > .dump
 245   void LoadDatabase(const base::FilePath::StringType& file);
 246
 247  private:
 248   base::ScopedTempDir temp_dir_;
 249
 250   DISALLOW_COPY_AND_ASSIGN(WebDatabaseMigrationTest);
 251 };
 252
 253 const int WebDatabaseMigrationTest::kCurrentTestedVersionNumber = 58;
 254
 255 void WebDatabaseMigrationTest::LoadDatabase(
 256     const base::FilePath::StringType& file) {
 257   std::string contents;
 258   ASSERT_TRUE(GetWebDatabaseData(base::FilePath(file), &contents));
 259
 260   sql::Connection connection;
 261   ASSERT_TRUE(connection.Open(GetDatabasePath()));
 262   ASSERT_TRUE(connection.Execute(contents.data()));
 263 }
 264
 265 // Tests that migrating from the golden files version_XX.sql results in the same
 266 // schema as migrating from an empty database.
 267 TEST_F(WebDatabaseMigrationTest, VersionXxSqlFilesAreGolden) {
 268   DoMigration();
 269   sql::Connection connection;
 270   ASSERT_TRUE(connection.Open(GetDatabasePath()));
 271   const std::string& expected_schema = RemoveQuotes(connection.GetSchema());
 272   static const int kFirstVersion = 53;
 273   for (int i = kFirstVersion; i < kCurrentTestedVersionNumber; ++i) {
 274     connection.Raze();
 275     const base::FilePath& file_name = base::FilePath::FromUTF8Unsafe(
 276         "version_" + base::IntToString(i) + ".sql");
 277     ASSERT_NO_FATAL_FAILURE(LoadDatabase(file_name.value()))
 278         << "Failed to load " << file_name.MaybeAsASCII();
 279     DoMigration();
 280     EXPECT_EQ(expected_schema, RemoveQuotes(connection.GetSchema()));
 281   }
 282 }
 283
 284 // Tests that the all migrations from an empty database succeed.
 285 TEST_F(WebDatabaseMigrationTest, MigrateEmptyToCurrent) {
 286   DoMigration();
 287
 288   // Verify post-conditions.  These are expectations for current version of the
 289   // database.
 290   {
 291     sql::Connection connection;
 292     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 293
 294     // Check version.
 295     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 296
 297     // Check that expected tables are present.
 298     EXPECT_TRUE(connection.DoesTableExist("autofill"));
 299     // The autofill_dates table is obsolete. (It's been merged into the autofill
 300     // table.)
 301     EXPECT_FALSE(connection.DoesTableExist("autofill_dates"));
 302     EXPECT_TRUE(connection.DoesTableExist("autofill_profiles"));
 303     EXPECT_TRUE(connection.DoesTableExist("credit_cards"));
 304     EXPECT_TRUE(connection.DoesTableExist("keywords"));
 305     // The logins table is obsolete. (We used to store saved passwords here.)
 306     EXPECT_FALSE(connection.DoesTableExist("logins"));
 307     EXPECT_TRUE(connection.DoesTableExist("meta"));
 308     EXPECT_TRUE(connection.DoesTableExist("token_service"));
 309     // The web_apps and web_apps_icons tables are obsolete as of version 58.
 310     EXPECT_FALSE(connection.DoesTableExist("web_apps"));
 311     EXPECT_FALSE(connection.DoesTableExist("web_app_icons"));
 312     // The web_intents and web_intents_defaults tables are obsolete as of
 313     // version 58.
 314     EXPECT_FALSE(connection.DoesTableExist("web_intents"));
 315     EXPECT_FALSE(connection.DoesTableExist("web_intents_defaults"));
 316   }
 317 }
 318
 319 // Tests that absent Autofill tables do not create any problems when migrating
 320 // from a DB written by the earliest publicly released version of Chrome.
 321 TEST_F(WebDatabaseMigrationTest, MigrateVersion20ToCurrent) {
 322   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_20.sql")));
 323
 324   // Verify pre-conditions.
 325   {
 326     sql::Connection connection;
 327     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 328
 329     EXPECT_FALSE(connection.DoesTableExist("autofill"));
 330     EXPECT_FALSE(connection.DoesTableExist("autofill_profiles"));
 331     EXPECT_FALSE(connection.DoesTableExist("credit_cards"));
 332   }
 333
 334   DoMigration();
 335
 336   // Verify post-conditions.  These are expectations for current version of the
 337   // database.
 338   {
 339     sql::Connection connection;
 340     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 341
 342     // Check version.
 343     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 344
 345     // Mostly this test just verifies that no SQL errors occur during migration;
 346     // but might as well verify that the tables were created as well.
 347     EXPECT_TRUE(connection.DoesTableExist("autofill"));
 348     EXPECT_TRUE(connection.DoesTableExist("autofill_profiles"));
 349     EXPECT_TRUE(connection.DoesTableExist("credit_cards"));
 350   }
 351 }
 352
 353 // Tests that rows with empty values get removed from the autofill tables.
 354 TEST_F(WebDatabaseMigrationTest, MigrateVersion21ToCurrent) {
 355   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_21.sql")));
 356
 357   // Verify pre-conditions.
 358   {
 359     sql::Connection connection;
 360     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 361
 362     // Both empty and non-empty values are allowed in a version 21 database.
 363     sql::Statement s_autofill(connection.GetUniqueStatement(
 364         "SELECT name, value, value_lower, pair_id, count FROM autofill"));
 365     sql::Statement s_dates(connection.GetUniqueStatement(
 366         "SELECT pair_id, date_created FROM autofill_dates"));
 367
 368     // An entry with a non-empty value.
 369     ASSERT_TRUE(s_autofill.Step());
 370     EXPECT_EQ(ASCIIToUTF16("Name"), s_autofill.ColumnString16(0));
 371     EXPECT_EQ(ASCIIToUTF16("John Doe"), s_autofill.ColumnString16(1));
 372     EXPECT_EQ(ASCIIToUTF16("john doe"), s_autofill.ColumnString16(2));
 373     EXPECT_EQ(10, s_autofill.ColumnInt(3));
 374     EXPECT_EQ(1, s_autofill.ColumnInt(4));
 375     ASSERT_TRUE(s_dates.Step());
 376     EXPECT_EQ(10, s_dates.ColumnInt(0));
 377     EXPECT_EQ(1384299100, s_dates.ColumnInt64(1));
 378
 379     // An entry with an empty value.
 380     ASSERT_TRUE(s_autofill.Step());
 381     EXPECT_EQ(ASCIIToUTF16("Name"), s_autofill.ColumnString16(0));
 382     EXPECT_EQ(base::string16(), s_autofill.ColumnString16(1));
 383     EXPECT_EQ(base::string16(), s_autofill.ColumnString16(2));
 384     EXPECT_EQ(11, s_autofill.ColumnInt(3));
 385     EXPECT_EQ(1, s_autofill.ColumnInt(4));
 386     ASSERT_TRUE(s_dates.Step());
 387     EXPECT_EQ(11, s_dates.ColumnInt(0));
 388     EXPECT_EQ(1384299200, s_dates.ColumnInt64(1));
 389
 390     // Another entry with a non-empty value.
 391     ASSERT_TRUE(s_autofill.Step());
 392     EXPECT_EQ(ASCIIToUTF16("Email"), s_autofill.ColumnString16(0));
 393     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s_autofill.ColumnString16(1));
 394     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s_autofill.ColumnString16(2));
 395     EXPECT_EQ(20, s_autofill.ColumnInt(3));
 396     EXPECT_EQ(3, s_autofill.ColumnInt(4));
 397     ASSERT_TRUE(s_dates.Step());
 398     EXPECT_EQ(20, s_dates.ColumnInt(0));
 399     EXPECT_EQ(1384299300, s_dates.ColumnInt64(1));
 400     ASSERT_TRUE(s_dates.Step());
 401     EXPECT_EQ(20, s_dates.ColumnInt(0));
 402     EXPECT_EQ(1384299301, s_dates.ColumnInt64(1));
 403
 404     // Another entry with an empty value.
 405     ASSERT_TRUE(s_autofill.Step());
 406     EXPECT_EQ(ASCIIToUTF16("Email"), s_autofill.ColumnString16(0));
 407     EXPECT_EQ(base::string16(), s_autofill.ColumnString16(1));
 408     EXPECT_EQ(base::string16(), s_autofill.ColumnString16(2));
 409     EXPECT_EQ(21, s_autofill.ColumnInt(3));
 410     EXPECT_EQ(4, s_autofill.ColumnInt(4));
 411     ASSERT_TRUE(s_dates.Step());
 412     EXPECT_EQ(21, s_dates.ColumnInt(0));
 413     EXPECT_EQ(1384299401, s_dates.ColumnInt64(1));
 414     ASSERT_TRUE(s_dates.Step());
 415     EXPECT_EQ(21, s_dates.ColumnInt(0));
 416     EXPECT_EQ(1384299400, s_dates.ColumnInt64(1));
 417     ASSERT_TRUE(s_dates.Step());
 418     EXPECT_EQ(21, s_dates.ColumnInt(0));
 419     EXPECT_EQ(1384299403, s_dates.ColumnInt64(1));
 420     ASSERT_TRUE(s_dates.Step());
 421     EXPECT_EQ(21, s_dates.ColumnInt(0));
 422     EXPECT_EQ(1384299402, s_dates.ColumnInt64(1));
 423
 424     // No more entries expected.
 425     ASSERT_FALSE(s_autofill.Step());
 426     ASSERT_FALSE(s_dates.Step());
 427   }
 428
 429   DoMigration();
 430
 431   // Verify post-conditions.  These are expectations for current version of the
 432   // database.
 433   {
 434     sql::Connection connection;
 435     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 436
 437     // Check version.
 438     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 439
 440     // Entries with empty values should have been dropped.  The remaining
 441     // entries should have been preserved.
 442     sql::Statement s(
 443         connection.GetUniqueStatement(
 444             "SELECT name, value, value_lower, date_created, date_last_used,"
 445             " count "
 446             "FROM autofill "
 447             "ORDER BY name, value ASC"));
 448
 449     // "jane@example.com"
 450     ASSERT_TRUE(s.Step());
 451     EXPECT_EQ(ASCIIToUTF16("Email"), s.ColumnString16(0));
 452     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s.ColumnString16(1));
 453     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s.ColumnString16(2));
 454     EXPECT_EQ(1384299300, s.ColumnInt64(3));
 455     EXPECT_EQ(1384299301, s.ColumnInt64(4));
 456     EXPECT_EQ(3, s.ColumnInt(5));
 457
 458     // "John Doe"
 459     ASSERT_TRUE(s.Step());
 460     EXPECT_EQ(ASCIIToUTF16("Name"), s.ColumnString16(0));
 461     EXPECT_EQ(ASCIIToUTF16("John Doe"), s.ColumnString16(1));
 462     EXPECT_EQ(ASCIIToUTF16("john doe"), s.ColumnString16(2));
 463     EXPECT_EQ(1384299100, s.ColumnInt64(3));
 464     EXPECT_EQ(1384299100, s.ColumnInt64(4));
 465     EXPECT_EQ(1, s.ColumnInt(5));
 466
 467     // No more entries expected.
 468     ASSERT_FALSE(s.Step());
 469   }
 470 }
 471
 472 // Tests that the |credit_card| table gets added to the schema for a version 22
 473 // database.
 474 TEST_F(WebDatabaseMigrationTest, MigrateVersion22ToCurrent) {
 475   // This schema is taken from a build prior to the addition of the
 476   // |credit_card| table.  Version 22 of the schema.  Contrast this with the
 477   // corrupt version below.
 478   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_22.sql")));
 479
 480   // Verify pre-conditions.
 481   {
 482     sql::Connection connection;
 483     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 484
 485     // No |credit_card| table prior to version 23.
 486     ASSERT_FALSE(connection.DoesColumnExist("credit_cards", "guid"));
 487     ASSERT_FALSE(
 488         connection.DoesColumnExist("credit_cards", "card_number_encrypted"));
 489   }
 490
 491   DoMigration();
 492
 493   // Verify post-conditions.  These are expectations for current version of the
 494   // database.
 495   {
 496     sql::Connection connection;
 497     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 498
 499     // Check version.
 500     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 501
 502     // |credit_card| table now exists.
 503     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "guid"));
 504     EXPECT_TRUE(
 505         connection.DoesColumnExist("credit_cards", "card_number_encrypted"));
 506   }
 507 }
 508
 509 // Tests that the |credit_card| table gets added to the schema for a corrupt
 510 // version 22 database.  The corruption is that the |credit_cards| table exists
 511 // but the schema version number was not set correctly to 23 or later.  This
 512 // test exercises code introduced to fix bug http://crbug.com/50699 that
 513 // resulted from the corruption.
 514 TEST_F(WebDatabaseMigrationTest, MigrateVersion22CorruptedToCurrent) {
 515   // This schema is taken from a build after the addition of the |credit_card|
 516   // table.  Due to a bug in the migration logic the version is set incorrectly
 517   // to 22 (it should have been updated to 23 at least).
 518   ASSERT_NO_FATAL_FAILURE(
 519       LoadDatabase(FILE_PATH_LITERAL("version_22_corrupt.sql")));
 520
 521   // Verify pre-conditions.  These are expectations for corrupt version 22 of
 522   // the database.
 523   {
 524     sql::Connection connection;
 525     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 526
 527     // Columns existing and not existing before current version.
 528     ASSERT_TRUE(connection.DoesColumnExist("credit_cards", "unique_id"));
 529     ASSERT_TRUE(
 530         connection.DoesColumnExist("credit_cards", "card_number_encrypted"));
 531     ASSERT_TRUE(connection.DoesColumnExist("keywords", "id"));
 532   }
 533
 534   DoMigration();
 535
 536   // Verify post-conditions.  These are expectations for current version of the
 537   // database.
 538   {
 539     sql::Connection connection;
 540     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 541
 542     // Check version.
 543     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 544
 545
 546     // Columns existing and not existing before version 25.
 547     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "unique_id"));
 548     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "guid"));
 549     EXPECT_TRUE(
 550         connection.DoesColumnExist("credit_cards", "card_number_encrypted"));
 551     EXPECT_TRUE(connection.DoesColumnExist("keywords", "id"));
 552   }
 553 }
 554
 555 // Tests that the |keywords| |created_by_policy| column gets added to the schema
 556 // for a version 25 database.
 557 TEST_F(WebDatabaseMigrationTest, MigrateVersion25ToCurrent) {
 558   // This schema is taken from a build prior to the addition of the |keywords|
 559   // |created_by_policy| column.
 560   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_25.sql")));
 561
 562   // Verify pre-conditions.  These are expectations for version 25 of the
 563   // database.
 564   {
 565     sql::Connection connection;
 566     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 567   }
 568
 569   DoMigration();
 570
 571   // Verify post-conditions.  These are expectations for current version of the
 572   // database.
 573   {
 574     sql::Connection connection;
 575     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 576
 577     // Check version.
 578     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 579
 580     // |keywords| |created_by_policy| column should have been added.
 581     EXPECT_TRUE(connection.DoesColumnExist("keywords", "id"));
 582     EXPECT_TRUE(connection.DoesColumnExist("keywords", "created_by_policy"));
 583   }
 584 }
 585
 586 // Tests that the credit_cards.billing_address column is changed from a string
 587 // to an int whilst preserving the associated billing address. This version of
 588 // the test makes sure a stored label is converted to an ID.
 589 TEST_F(WebDatabaseMigrationTest, MigrateVersion26ToCurrentStringLabels) {
 590   // This schema is taken from a build prior to the change of column type for
 591   // credit_cards.billing_address from string to int.
 592   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_26.sql")));
 593
 594   // Verify pre-conditions. These are expectations for version 26 of the
 595   // database.
 596   {
 597     sql::Connection connection;
 598     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 599
 600     // Columns existing and not existing before current version.
 601     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "billing_address"));
 602
 603     std::string stmt = "INSERT INTO autofill_profiles"
 604       "(label, unique_id, first_name, middle_name, last_name, email,"
 605       " company_name, address_line_1, address_line_2, city, state, zipcode,"
 606       " country, phone, fax)"
 607       "VALUES ('Home',1,'','','','','','','','','','','','','')";
 608     sql::Statement s(connection.GetUniqueStatement(stmt.c_str()));
 609     ASSERT_TRUE(s.Run());
 610
 611     // Insert a CC linked to an existing address.
 612     std::string stmt2 = "INSERT INTO credit_cards"
 613       "(label, unique_id, name_on_card, type, card_number,"
 614       " expiration_month, expiration_year, verification_code, billing_address,"
 615       " shipping_address, card_number_encrypted, verification_code_encrypted)"
 616       "VALUES ('label',2,'Jack','Visa','1234',2,2012,'','Home','','','')";
 617     sql::Statement s2(connection.GetUniqueStatement(stmt2.c_str()));
 618     ASSERT_TRUE(s2.Run());
 619
 620     // |billing_address| is a string.
 621     std::string stmt3 = "SELECT billing_address FROM credit_cards";
 622     sql::Statement s3(connection.GetUniqueStatement(stmt3.c_str()));
 623     ASSERT_TRUE(s3.Step());
 624     EXPECT_EQ(s3.ColumnType(0), sql::COLUMN_TYPE_TEXT);
 625   }
 626
 627   DoMigration();
 628
 629   // Verify post-conditions.  These are expectations for current version of the
 630   // database.
 631   {
 632     sql::Connection connection;
 633     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 634
 635     // Check version.
 636     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 637     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "billing_address"));
 638
 639     // Verify the credit card data is converted.
 640     sql::Statement s(connection.GetUniqueStatement(
 641         "SELECT guid, name_on_card, expiration_month, expiration_year, "
 642         "card_number_encrypted, date_modified "
 643         "FROM credit_cards"));
 644     ASSERT_TRUE(s.Step());
 645     EXPECT_EQ("Jack", s.ColumnString(1));
 646     EXPECT_EQ(2, s.ColumnInt(2));
 647     EXPECT_EQ(2012, s.ColumnInt(3));
 648     // Column 5 is encrypted number blob.
 649     // Column 6 is date_modified.
 650   }
 651 }
 652
 653 // Tests that the credit_cards.billing_address column is changed from a string
 654 // to an int whilst preserving the associated billing address. This version of
 655 // the test makes sure a stored string ID is converted to an integer ID.
 656 TEST_F(WebDatabaseMigrationTest, MigrateVersion26ToCurrentStringIDs) {
 657   // This schema is taken from a build prior to the change of column type for
 658   // credit_cards.billing_address from string to int.
 659   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_26.sql")));
 660
 661   // Verify pre-conditions. These are expectations for version 26 of the
 662   // database.
 663   {
 664     sql::Connection connection;
 665     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 666     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "billing_address"));
 667
 668     std::string stmt = "INSERT INTO autofill_profiles"
 669       "(label, unique_id, first_name, middle_name, last_name, email,"
 670       " company_name, address_line_1, address_line_2, city, state, zipcode,"
 671       " country, phone, fax)"
 672       "VALUES ('Home',1,'','','','','','','','','','','','','')";
 673     sql::Statement s(connection.GetUniqueStatement(stmt.c_str()));
 674     ASSERT_TRUE(s.Run());
 675
 676     // Insert a CC linked to an existing address.
 677     std::string stmt2 = "INSERT INTO credit_cards"
 678       "(label, unique_id, name_on_card, type, card_number,"
 679       " expiration_month, expiration_year, verification_code, billing_address,"
 680       " shipping_address, card_number_encrypted, verification_code_encrypted)"
 681       "VALUES ('label',2,'Jack','Visa','1234',2,2012,'','1','','','')";
 682     sql::Statement s2(connection.GetUniqueStatement(stmt2.c_str()));
 683     ASSERT_TRUE(s2.Run());
 684
 685     // |billing_address| is a string.
 686     std::string stmt3 = "SELECT billing_address FROM credit_cards";
 687     sql::Statement s3(connection.GetUniqueStatement(stmt3.c_str()));
 688     ASSERT_TRUE(s3.Step());
 689     EXPECT_EQ(s3.ColumnType(0), sql::COLUMN_TYPE_TEXT);
 690   }
 691
 692   DoMigration();
 693
 694   // Verify post-conditions.  These are expectations for current version of the
 695   // database.
 696   {
 697     sql::Connection connection;
 698     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 699
 700     // Check version.
 701     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 702
 703     // |keywords| |created_by_policy| column should have been added.
 704     EXPECT_TRUE(connection.DoesColumnExist("keywords", "id"));
 705     EXPECT_TRUE(connection.DoesColumnExist("keywords", "created_by_policy"));
 706     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "billing_address"));
 707
 708     // Verify the credit card data is converted.
 709     sql::Statement s(connection.GetUniqueStatement(
 710         "SELECT guid, name_on_card, expiration_month, expiration_year, "
 711         "card_number_encrypted, date_modified "
 712         "FROM credit_cards"));
 713     ASSERT_TRUE(s.Step());
 714     EXPECT_EQ("Jack", s.ColumnString(1));
 715     EXPECT_EQ(2, s.ColumnInt(2));
 716     EXPECT_EQ(2012, s.ColumnInt(3));
 717     // Column 5 is encrypted credit card number blo b.
 718     // Column 6 is date_modified.
 719   }
 720 }
 721
 722 // Makes sure instant_url is added correctly to keywords.
 723 TEST_F(WebDatabaseMigrationTest, MigrateVersion27ToCurrent) {
 724   // Initialize the database.
 725   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_27.sql")));
 726
 727   // Verify pre-conditions. These are expectations for version 27 of the
 728   // database.
 729   {
 730     sql::Connection connection;
 731     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 732
 733     ASSERT_FALSE(connection.DoesColumnExist("keywords", "instant_url"));
 734   }
 735
 736   DoMigration();
 737
 738   // Verify post-conditions.  These are expectations for current version of the
 739   // database.
 740   {
 741     sql::Connection connection;
 742     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 743
 744     // Check version.
 745     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 746
 747     // Make sure supports_instant (added in Version 28) was ultimately dropped
 748     // again and instant_url was added.
 749     EXPECT_FALSE(connection.DoesColumnExist("keywords", "supports_instant"));
 750     EXPECT_TRUE(connection.DoesColumnExist("keywords", "instant_url"));
 751
 752     // Check that instant_url is empty.
 753     std::string stmt = "SELECT instant_url FROM keywords";
 754     sql::Statement s(connection.GetUniqueStatement(stmt.c_str()));
 755     ASSERT_TRUE(s.Step());
 756     EXPECT_EQ(std::string(), s.ColumnString(0));
 757
 758     // Verify the data made it over.
 759     stmt = "SELECT " + KeywordTable::GetKeywordColumns() + " FROM keywords";
 760     sql::Statement s2(connection.GetUniqueStatement(stmt.c_str()));
 761     ASSERT_TRUE(s2.Step());
 762     EXPECT_EQ(2, s2.ColumnInt(0));
 763     EXPECT_EQ("Google", s2.ColumnString(1));
 764     EXPECT_EQ("google.com", s2.ColumnString(2));
 765     EXPECT_EQ("http://www.google.com/favicon.ico", s2.ColumnString(3));
 766     EXPECT_EQ("{google:baseURL}search?{google:RLZ}{google:acceptedSuggestion}"\
 767         "{google:originalQueryForSuggestion}sourceid=chrome&ie={inputEncoding}"\
 768         "&q={searchTerms}",
 769         s2.ColumnString(4));
 770     EXPECT_TRUE(s2.ColumnBool(5));
 771     EXPECT_EQ(std::string(), s2.ColumnString(6));
 772     EXPECT_EQ(0, s2.ColumnInt(7));
 773     EXPECT_EQ(0, s2.ColumnInt(8));
 774     EXPECT_EQ(std::string("UTF-8"), s2.ColumnString(9));
 775     EXPECT_TRUE(s2.ColumnBool(10));
 776     EXPECT_EQ(std::string("{google:baseSuggestURL}search?client=chrome&hl="
 777                           "{language}&q={searchTerms}"), s2.ColumnString(11));
 778     EXPECT_EQ(1, s2.ColumnInt(12));
 779     EXPECT_FALSE(s2.ColumnBool(13));
 780     EXPECT_EQ(std::string(), s2.ColumnString(14));
 781     EXPECT_EQ(0, s2.ColumnInt(15));
 782     EXPECT_EQ(std::string(), s2.ColumnString(16));
 783   }
 784 }
 785
 786 // Makes sure date_modified is added correctly to autofill_profiles and
 787 // credit_cards.
 788 TEST_F(WebDatabaseMigrationTest, MigrateVersion29ToCurrent) {
 789   // Initialize the database.
 790   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_29.sql")));
 791
 792   // Verify pre-conditions.  These are expectations for version 29 of the
 793   // database.
 794   {
 795     sql::Connection connection;
 796     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 797
 798     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles",
 799                                             "date_modified"));
 800     EXPECT_FALSE(connection.DoesColumnExist("credit_cards",
 801                                             "date_modified"));
 802   }
 803
 804   Time pre_creation_time = Time::Now();
 805   DoMigration();
 806   Time post_creation_time = Time::Now();
 807
 808   // Verify post-conditions.  These are expectations for current version of the
 809   // database.
 810   {
 811     sql::Connection connection;
 812     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 813
 814     // Check version.
 815     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 816
 817     // Check that the columns were created.
 818     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
 819                                            "date_modified"));
 820     EXPECT_TRUE(connection.DoesColumnExist("credit_cards",
 821                                            "date_modified"));
 822
 823     sql::Statement s_profiles(connection.GetUniqueStatement(
 824         "SELECT date_modified FROM autofill_profiles "));
 825     ASSERT_TRUE(s_profiles.is_valid());
 826     while (s_profiles.Step()) {
 827       EXPECT_GE(s_profiles.ColumnInt64(0),
 828                 pre_creation_time.ToTimeT());
 829       EXPECT_LE(s_profiles.ColumnInt64(0),
 830                 post_creation_time.ToTimeT());
 831     }
 832     EXPECT_TRUE(s_profiles.Succeeded());
 833
 834     sql::Statement s_credit_cards(connection.GetUniqueStatement(
 835         "SELECT date_modified FROM credit_cards "));
 836     ASSERT_TRUE(s_credit_cards.is_valid());
 837     while (s_credit_cards.Step()) {
 838       EXPECT_GE(s_credit_cards.ColumnInt64(0),
 839                 pre_creation_time.ToTimeT());
 840       EXPECT_LE(s_credit_cards.ColumnInt64(0),
 841                 post_creation_time.ToTimeT());
 842     }
 843     EXPECT_TRUE(s_credit_cards.Succeeded());
 844   }
 845 }
 846
 847 // Makes sure guids are added to autofill_profiles and credit_cards tables.
 848 TEST_F(WebDatabaseMigrationTest, MigrateVersion30ToCurrent) {
 849   // Initialize the database.
 850   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_30.sql")));
 851
 852   // Verify pre-conditions. These are expectations for version 29 of the
 853   // database.
 854   {
 855     sql::Connection connection;
 856     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 857
 858     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "guid"));
 859     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "guid"));
 860   }
 861
 862   DoMigration();
 863
 864   // Verify post-conditions.  These are expectations for current version of the
 865   // database.
 866   {
 867     sql::Connection connection;
 868     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 869
 870     // Check version.
 871     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 872
 873     ASSERT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
 874     ASSERT_TRUE(connection.DoesColumnExist("credit_cards", "guid"));
 875
 876     // Check that guids are non-null, non-empty, conforms to guid format, and
 877     // are different.
 878     sql::Statement s(
 879         connection.GetUniqueStatement("SELECT guid FROM autofill_profiles"));
 880
 881     ASSERT_TRUE(s.Step());
 882     std::string guid1 = s.ColumnString(0);
 883     EXPECT_TRUE(base::IsValidGUID(guid1));
 884
 885     ASSERT_TRUE(s.Step());
 886     std::string guid2 = s.ColumnString(0);
 887     EXPECT_TRUE(base::IsValidGUID(guid2));
 888
 889     EXPECT_NE(guid1, guid2);
 890   }
 891 }
 892
 893 // Removes unique IDs and make GUIDs the primary key.  Also removes unused
 894 // columns.
 895 TEST_F(WebDatabaseMigrationTest, MigrateVersion31ToCurrent) {
 896   // Initialize the database.
 897   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_31.sql")));
 898
 899   // Verify pre-conditions. These are expectations for version 30 of the
 900   // database.
 901   AutofillProfile profile;
 902   base::string16 profile_label;
 903   int profile_unique_id = 0;
 904   int64 profile_date_modified = 0;
 905   CreditCard credit_card;
 906   base::string16 cc_label;
 907   int cc_unique_id = 0;
 908   std::string cc_number_encrypted;
 909   int64 cc_date_modified = 0;
 910   {
 911     sql::Connection connection;
 912     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 913
 914     // Verify existence of columns we'll be changing.
 915     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
 916     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "unique_id"));
 917     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "guid"));
 918     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "unique_id"));
 919     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "type"));
 920     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "card_number"));
 921     EXPECT_TRUE(connection.DoesColumnExist("credit_cards",
 922                                            "verification_code"));
 923     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "billing_address"));
 924     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "shipping_address"));
 925     EXPECT_TRUE(connection.DoesColumnExist("credit_cards",
 926                                            "verification_code_encrypted"));
 927
 928     // Fetch data in the database prior to migration.
 929     sql::Statement s1(
 930         connection.GetUniqueStatement(
 931             "SELECT label, unique_id, first_name, middle_name, last_name, "
 932             "email, company_name, address_line_1, address_line_2, city, state, "
 933             "zipcode, country, phone, fax, date_modified, guid "
 934             "FROM autofill_profiles"));
 935     ASSERT_TRUE(s1.Step());
 936     EXPECT_NO_FATAL_FAILURE(AutofillProfile31FromStatement(
 937         s1, &profile, &profile_label, &profile_unique_id,
 938         &profile_date_modified));
 939
 940     sql::Statement s2(
 941         connection.GetUniqueStatement(
 942             "SELECT label, unique_id, name_on_card, type, card_number, "
 943             "expiration_month, expiration_year, verification_code, "
 944             "billing_address, shipping_address, card_number_encrypted, "
 945             "verification_code_encrypted, date_modified, guid "
 946             "FROM credit_cards"));
 947     ASSERT_TRUE(s2.Step());
 948     EXPECT_NO_FATAL_FAILURE(CreditCard31FromStatement(s2,
 949                                                       &credit_card,
 950                                                       &cc_label,
 951                                                       &cc_unique_id,
 952                                                       &cc_number_encrypted,
 953                                                       &cc_date_modified));
 954
 955     EXPECT_NE(profile_unique_id, cc_unique_id);
 956     EXPECT_NE(profile.guid(), credit_card.guid());
 957   }
 958
 959   DoMigration();
 960
 961   // Verify post-conditions.  These are expectations for current version of the
 962   // database.
 963   {
 964     sql::Connection connection;
 965     ASSERT_TRUE(connection.Open(GetDatabasePath()));
 966
 967     // Check version.
 968     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
 969
 970     // Verify existence of columns we'll be changing.
 971     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
 972     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "unique_id"));
 973     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "guid"));
 974     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "unique_id"));
 975     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "type"));
 976     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "card_number"));
 977     EXPECT_FALSE(connection.DoesColumnExist("credit_cards",
 978                                             "verification_code"));
 979     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "billing_address"));
 980     EXPECT_FALSE(connection.DoesColumnExist("credit_cards",
 981                                             "shipping_address"));
 982     EXPECT_FALSE(connection.DoesColumnExist("credit_cards",
 983                                             "verification_code_encrypted"));
 984
 985     // Verify data in the database after the migration.
 986     sql::Statement s1(
 987         connection.GetUniqueStatement(
 988             "SELECT guid, company_name, street_address, city, state, zipcode,"
 989             " country_code, date_modified "
 990             "FROM autofill_profiles"));
 991     ASSERT_TRUE(s1.Step());
 992
 993     AutofillProfile profile_a;
 994     int64 profile_date_modified_a = 0;
 995     EXPECT_NO_FATAL_FAILURE(AutofillProfile33FromStatement(
 996         s1, &profile_a, &profile_date_modified_a));
 997     EXPECT_EQ(profile.guid(), profile_a.guid());
 998     EXPECT_EQ(profile.GetRawInfo(autofill::COMPANY_NAME),
 999               profile_a.GetRawInfo(autofill::COMPANY_NAME));
1000     EXPECT_EQ(profile.GetRawInfo(autofill::ADDRESS_HOME_LINE1),
1001               profile_a.GetRawInfo(autofill::ADDRESS_HOME_LINE1));
1002     EXPECT_EQ(profile.GetRawInfo(autofill::ADDRESS_HOME_LINE2),
1003               profile_a.GetRawInfo(autofill::ADDRESS_HOME_LINE2));
1004     EXPECT_EQ(profile.GetRawInfo(autofill::ADDRESS_HOME_CITY),
1005               profile_a.GetRawInfo(autofill::ADDRESS_HOME_CITY));
1006     EXPECT_EQ(profile.GetRawInfo(autofill::ADDRESS_HOME_STATE),
1007               profile_a.GetRawInfo(autofill::ADDRESS_HOME_STATE));
1008     EXPECT_EQ(profile.GetRawInfo(autofill::ADDRESS_HOME_ZIP),
1009               profile_a.GetRawInfo(autofill::ADDRESS_HOME_ZIP));
1010     EXPECT_EQ(profile.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY),
1011               profile_a.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY));
1012     EXPECT_EQ(profile_date_modified, profile_date_modified_a);
1013
1014     sql::Statement s2(
1015         connection.GetUniqueStatement(
1016             "SELECT guid, name_on_card, expiration_month, "
1017             "expiration_year, card_number_encrypted, date_modified "
1018             "FROM credit_cards"));
1019     ASSERT_TRUE(s2.Step());
1020
1021     CreditCard credit_card_a;
1022     base::string16 cc_label_a;
1023     std::string cc_number_encrypted_a;
1024     int64 cc_date_modified_a = 0;
1025     EXPECT_NO_FATAL_FAILURE(CreditCard32FromStatement(s2,
1026                                                       &credit_card_a,
1027                                                       &cc_number_encrypted_a,
1028                                                       &cc_date_modified_a));
1029     EXPECT_EQ(credit_card, credit_card_a);
1030     EXPECT_EQ(cc_label, cc_label_a);
1031     EXPECT_EQ(cc_number_encrypted, cc_number_encrypted_a);
1032     EXPECT_EQ(cc_date_modified, cc_date_modified_a);
1033   }
1034 }
1035
1036 // Factor |autofill_profiles| address information separately from name, email,
1037 // and phone.
1038 TEST_F(WebDatabaseMigrationTest, MigrateVersion32ToCurrent) {
1039   // Initialize the database.
1040   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_32.sql")));
1041
1042   // Verify pre-conditions. These are expectations for version 32 of the
1043   // database.
1044   {
1045     sql::Connection connection;
1046     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1047
1048     // Verify existence of columns we'll be changing.
1049     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
1050     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "label"));
1051     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "first_name"));
1052     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "middle_name"));
1053     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "last_name"));
1054     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "email"));
1055     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1056                                            "company_name"));
1057     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1058                                            "address_line_1"));
1059     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1060                                            "address_line_2"));
1061     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "city"));
1062     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "state"));
1063     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "zipcode"));
1064     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "country"));
1065     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "phone"));
1066     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "fax"));
1067     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1068                                            "date_modified"));
1069
1070     EXPECT_FALSE(connection.DoesTableExist("autofill_profile_names"));
1071     EXPECT_FALSE(connection.DoesTableExist("autofill_profile_emails"));
1072     EXPECT_FALSE(connection.DoesTableExist("autofill_profile_phones"));
1073
1074     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "label"));
1075   }
1076
1077   DoMigration();
1078
1079   // Verify post-conditions.  These are expectations for current version of the
1080   // database.
1081   {
1082     sql::Connection connection;
1083     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1084
1085     // Check version.
1086     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1087
1088     // Verify changes to columns.
1089     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
1090     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "label"));
1091     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "first_name"));
1092     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles",
1093                                             "middle_name"));
1094     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "last_name"));
1095     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "email"));
1096     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1097                                            "company_name"));
1098     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1099                                            "street_address"));
1100     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "city"));
1101     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "state"));
1102     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "zipcode"));
1103     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1104                                            "country_code"));
1105     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "phone"));
1106     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "fax"));
1107     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1108                                            "date_modified"));
1109
1110     // New "names" table.
1111     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_names", "guid"));
1112     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_names",
1113                                            "first_name"));
1114     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_names",
1115                                            "middle_name"));
1116     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_names",
1117                                            "last_name"));
1118
1119     // New "emails" table.
1120     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_emails", "guid"));
1121     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_emails", "email"));
1122
1123     // New "phones" table.
1124     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_phones", "guid"));
1125     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_phones",
1126                                            "number"));
1127
1128     EXPECT_FALSE(connection.DoesColumnExist("credit_cards", "label"));
1129
1130     // Verify data in the database after the migration.
1131     sql::Statement s1(
1132         connection.GetUniqueStatement(
1133             "SELECT guid, company_name, street_address, city, state, zipcode, "
1134             " country_code, date_modified "
1135             "FROM autofill_profiles"));
1136
1137     // John Doe.
1138     ASSERT_TRUE(s1.Step());
1139     EXPECT_EQ("00580526-FF81-EE2A-0546-1AC593A32E2F", s1.ColumnString(0));
1140     EXPECT_EQ(ASCIIToUTF16("Doe Enterprises"), s1.ColumnString16(1));
1141     EXPECT_EQ(ASCIIToUTF16("1 Main St\n"
1142                            "Apt 1"),
1143               s1.ColumnString16(2));
1144     EXPECT_EQ(ASCIIToUTF16("Los Altos"), s1.ColumnString16(3));
1145     EXPECT_EQ(ASCIIToUTF16("CA"), s1.ColumnString16(4));
1146     EXPECT_EQ(ASCIIToUTF16("94022"), s1.ColumnString16(5));
1147     EXPECT_EQ(ASCIIToUTF16("US"), s1.ColumnString16(6));
1148     EXPECT_EQ(1297882100L, s1.ColumnInt64(7));
1149
1150     // John P. Doe.
1151     // Gets merged during migration from 35 to 37 due to multi-valued fields.
1152
1153     // Dave Smith.
1154     ASSERT_TRUE(s1.Step());
1155     EXPECT_EQ("4C74A9D8-7EEE-423E-F9C2-E7FA70ED1396", s1.ColumnString(0));
1156     EXPECT_EQ(base::string16(), s1.ColumnString16(1));
1157     EXPECT_EQ(ASCIIToUTF16("2 Main Street"), s1.ColumnString16(2));
1158     EXPECT_EQ(ASCIIToUTF16("Los Altos"), s1.ColumnString16(3));
1159     EXPECT_EQ(ASCIIToUTF16("CA"), s1.ColumnString16(4));
1160     EXPECT_EQ(ASCIIToUTF16("94022"), s1.ColumnString16(5));
1161     EXPECT_EQ(ASCIIToUTF16("US"), s1.ColumnString16(6));
1162     EXPECT_EQ(1297882100L, s1.ColumnInt64(7));
1163
1164     // Dave Smith (Part 2).
1165     ASSERT_TRUE(s1.Step());
1166     EXPECT_EQ("722DF5C4-F74A-294A-46F0-31FFDED0D635", s1.ColumnString(0));
1167     EXPECT_EQ(base::string16(), s1.ColumnString16(1));
1168     EXPECT_EQ(ASCIIToUTF16("2 Main St"), s1.ColumnString16(2));
1169     EXPECT_EQ(ASCIIToUTF16("Los Altos"), s1.ColumnString16(3));
1170     EXPECT_EQ(ASCIIToUTF16("CA"), s1.ColumnString16(4));
1171     EXPECT_EQ(ASCIIToUTF16("94022"), s1.ColumnString16(5));
1172     EXPECT_EQ(ASCIIToUTF16("US"), s1.ColumnString16(6));
1173     EXPECT_EQ(1297882100L, s1.ColumnInt64(7));
1174
1175     // Alfred E Newman.
1176     // Gets culled during migration from 35 to 36 due to incomplete address.
1177
1178     // 3 Main St.
1179     ASSERT_TRUE(s1.Step());
1180     EXPECT_EQ("9E5FE298-62C7-83DF-6293-381BC589183F", s1.ColumnString(0));
1181     EXPECT_EQ(base::string16(), s1.ColumnString16(1));
1182     EXPECT_EQ(ASCIIToUTF16("3 Main St"), s1.ColumnString16(2));
1183     EXPECT_EQ(ASCIIToUTF16("Los Altos"), s1.ColumnString16(3));
1184     EXPECT_EQ(ASCIIToUTF16("CA"), s1.ColumnString16(4));
1185     EXPECT_EQ(ASCIIToUTF16("94022"), s1.ColumnString16(5));
1186     EXPECT_EQ(ASCIIToUTF16("US"), s1.ColumnString16(6));
1187     EXPECT_EQ(1297882100L, s1.ColumnInt64(7));
1188
1189     // That should be all.
1190     EXPECT_FALSE(s1.Step());
1191
1192     sql::Statement s2(
1193         connection.GetUniqueStatement(
1194             "SELECT guid, first_name, middle_name, last_name "
1195             "FROM autofill_profile_names"));
1196
1197     // John Doe.
1198     ASSERT_TRUE(s2.Step());
1199     EXPECT_EQ("00580526-FF81-EE2A-0546-1AC593A32E2F", s2.ColumnString(0));
1200     EXPECT_EQ(ASCIIToUTF16("John"), s2.ColumnString16(1));
1201     EXPECT_EQ(base::string16(), s2.ColumnString16(2));
1202     EXPECT_EQ(ASCIIToUTF16("Doe"), s2.ColumnString16(3));
1203
1204     // John P. Doe.  Note same guid as above due to merging of multi-valued
1205     // fields.
1206     ASSERT_TRUE(s2.Step());
1207     EXPECT_EQ("00580526-FF81-EE2A-0546-1AC593A32E2F", s2.ColumnString(0));
1208     EXPECT_EQ(ASCIIToUTF16("John"), s2.ColumnString16(1));
1209     EXPECT_EQ(ASCIIToUTF16("P."), s2.ColumnString16(2));
1210     EXPECT_EQ(ASCIIToUTF16("Doe"), s2.ColumnString16(3));
1211
1212     // Dave Smith.
1213     ASSERT_TRUE(s2.Step());
1214     EXPECT_EQ("4C74A9D8-7EEE-423E-F9C2-E7FA70ED1396", s2.ColumnString(0));
1215     EXPECT_EQ(ASCIIToUTF16("Dave"), s2.ColumnString16(1));
1216     EXPECT_EQ(base::string16(), s2.ColumnString16(2));
1217     EXPECT_EQ(ASCIIToUTF16("Smith"), s2.ColumnString16(3));
1218
1219     // Dave Smith (Part 2).
1220     ASSERT_TRUE(s2.Step());
1221     EXPECT_EQ("722DF5C4-F74A-294A-46F0-31FFDED0D635", s2.ColumnString(0));
1222     EXPECT_EQ(ASCIIToUTF16("Dave"), s2.ColumnString16(1));
1223     EXPECT_EQ(base::string16(), s2.ColumnString16(2));
1224     EXPECT_EQ(ASCIIToUTF16("Smith"), s2.ColumnString16(3));
1225
1226     // Alfred E Newman.
1227     // Gets culled during migration from 35 to 36 due to incomplete address.
1228
1229     // 3 Main St.
1230     ASSERT_TRUE(s2.Step());
1231     EXPECT_EQ("9E5FE298-62C7-83DF-6293-381BC589183F", s2.ColumnString(0));
1232     EXPECT_EQ(base::string16(), s2.ColumnString16(1));
1233     EXPECT_EQ(base::string16(), s2.ColumnString16(2));
1234     EXPECT_EQ(base::string16(), s2.ColumnString16(3));
1235
1236     // Should be all.
1237     EXPECT_FALSE(s2.Step());
1238
1239     sql::Statement s3(
1240         connection.GetUniqueStatement(
1241             "SELECT guid, email "
1242             "FROM autofill_profile_emails"));
1243
1244     // John Doe.
1245     ASSERT_TRUE(s3.Step());
1246     EXPECT_EQ("00580526-FF81-EE2A-0546-1AC593A32E2F", s3.ColumnString(0));
1247     EXPECT_EQ(ASCIIToUTF16("john@doe.com"), s3.ColumnString16(1));
1248
1249     // John P. Doe.
1250     // Gets culled during migration from 35 to 37 due to merging of John Doe and
1251     // John P. Doe addresses.
1252
1253     // 2 Main Street.
1254     ASSERT_TRUE(s3.Step());
1255     EXPECT_EQ("4C74A9D8-7EEE-423E-F9C2-E7FA70ED1396", s3.ColumnString(0));
1256     EXPECT_EQ(base::string16(), s3.ColumnString16(1));
1257
1258     // 2 Main St.
1259     ASSERT_TRUE(s3.Step());
1260     EXPECT_EQ("722DF5C4-F74A-294A-46F0-31FFDED0D635", s3.ColumnString(0));
1261     EXPECT_EQ(base::string16(), s3.ColumnString16(1));
1262
1263     // Alfred E Newman.
1264     // Gets culled during migration from 35 to 36 due to incomplete address.
1265
1266     // 3 Main St.
1267     ASSERT_TRUE(s3.Step());
1268     EXPECT_EQ("9E5FE298-62C7-83DF-6293-381BC589183F", s3.ColumnString(0));
1269     EXPECT_EQ(base::string16(), s3.ColumnString16(1));
1270
1271     // Should be all.
1272     EXPECT_FALSE(s3.Step());
1273
1274     sql::Statement s4(
1275         connection.GetUniqueStatement(
1276             "SELECT guid, number "
1277             "FROM autofill_profile_phones"));
1278
1279     // John Doe phone.
1280     ASSERT_TRUE(s4.Step());
1281     EXPECT_EQ("00580526-FF81-EE2A-0546-1AC593A32E2F", s4.ColumnString(0));
1282     EXPECT_EQ(ASCIIToUTF16("4151112222"), s4.ColumnString16(1));
1283
1284     // John Doe fax.
1285     // Gets culled after fax type removed.
1286
1287     // John P. Doe phone.
1288     // Gets culled during migration from 35 to 37 due to merging of John Doe and
1289     // John P. Doe addresses.
1290
1291     // John P. Doe fax.
1292     // Gets culled during migration from 35 to 37 due to merging of John Doe and
1293     // John P. Doe addresses.
1294
1295     // 2 Main Street phone.
1296     ASSERT_TRUE(s4.Step());
1297     EXPECT_EQ("4C74A9D8-7EEE-423E-F9C2-E7FA70ED1396", s4.ColumnString(0));
1298     EXPECT_EQ(base::string16(), s4.ColumnString16(1));
1299
1300     // 2 Main Street fax.
1301     // Gets culled after fax type removed.
1302
1303     // 2 Main St phone.
1304     ASSERT_TRUE(s4.Step());
1305     EXPECT_EQ("722DF5C4-F74A-294A-46F0-31FFDED0D635", s4.ColumnString(0));
1306     EXPECT_EQ(0, s4.ColumnInt(1));  // 0 means phone.
1307     EXPECT_EQ(base::string16(), s4.ColumnString16(2));
1308
1309     // 2 Main St fax.
1310     // Gets culled after fax type removed.
1311
1312     // Note no phone or fax for Alfred E Newman.
1313
1314     // 3 Main St phone.
1315     ASSERT_TRUE(s4.Step());
1316     EXPECT_EQ("9E5FE298-62C7-83DF-6293-381BC589183F", s4.ColumnString(0));
1317     EXPECT_EQ(base::string16(), s4.ColumnString16(1));
1318
1319     // 2 Main St fax.
1320     // Gets culled after fax type removed.
1321
1322     // Should be all.
1323     EXPECT_FALSE(s4.Step());
1324   }
1325 }
1326
1327 // Adds a column for the autofill profile's country code.
1328 TEST_F(WebDatabaseMigrationTest, MigrateVersion33ToCurrent) {
1329   // Initialize the database.
1330   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_33.sql")));
1331
1332   // Verify pre-conditions. These are expectations for version 33 of the
1333   // database.
1334   {
1335     sql::Connection connection;
1336     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1337
1338     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles",
1339                                             "country_code"));
1340
1341     // Check that the country value is the one we expect.
1342     sql::Statement s(
1343         connection.GetUniqueStatement("SELECT country FROM autofill_profiles"));
1344
1345     ASSERT_TRUE(s.Step());
1346     std::string country = s.ColumnString(0);
1347     EXPECT_EQ("United States", country);
1348   }
1349
1350   DoMigration();
1351
1352   // Verify post-conditions.  These are expectations for current version of the
1353   // database.
1354   {
1355     sql::Connection connection;
1356     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1357
1358     // Check version.
1359     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1360
1361     ASSERT_TRUE(connection.DoesColumnExist("autofill_profiles",
1362                                            "country_code"));
1363
1364     // Check that the country code is properly converted.
1365     sql::Statement s(connection.GetUniqueStatement(
1366         "SELECT country_code FROM autofill_profiles"));
1367
1368     ASSERT_TRUE(s.Step());
1369     std::string country_code = s.ColumnString(0);
1370     EXPECT_EQ("US", country_code);
1371   }
1372 }
1373
1374 // Cleans up bad country code "UK" in favor of good country code "GB".
1375 TEST_F(WebDatabaseMigrationTest, MigrateVersion34ToCurrent) {
1376   // Initialize the database.
1377   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_34.sql")));
1378
1379   // Verify pre-conditions. These are expectations for version 34 of the
1380   // database.
1381   {
1382     sql::Connection connection;
1383     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1384
1385     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles",
1386                                            "country_code"));
1387
1388     // Check that the country_code value is the one we expect.
1389     sql::Statement s(
1390         connection.GetUniqueStatement("SELECT country_code "
1391                                       "FROM autofill_profiles"));
1392
1393     ASSERT_TRUE(s.Step());
1394     std::string country_code = s.ColumnString(0);
1395     EXPECT_EQ("UK", country_code);
1396
1397     // Should have only one.
1398     ASSERT_FALSE(s.Step());
1399   }
1400
1401   DoMigration();
1402
1403   // Verify post-conditions.  These are expectations for current version of the
1404   // database.
1405   {
1406     sql::Connection connection;
1407     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1408
1409     // Check version.
1410     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1411
1412     ASSERT_TRUE(connection.DoesColumnExist("autofill_profiles",
1413                                            "country_code"));
1414
1415     // Check that the country_code code is properly converted.
1416     sql::Statement s(connection.GetUniqueStatement(
1417         "SELECT country_code FROM autofill_profiles"));
1418
1419     ASSERT_TRUE(s.Step());
1420     std::string country_code = s.ColumnString(0);
1421     EXPECT_EQ("GB", country_code);
1422
1423     // Should have only one.
1424     ASSERT_FALSE(s.Step());
1425   }
1426 }
1427
1428 // Cleans up invalid profiles based on more agressive merging.  Filters out
1429 // profiles that are subsets of other profiles, and profiles with invalid email,
1430 // state, and incomplete address.
1431 TEST_F(WebDatabaseMigrationTest, MigrateVersion35ToCurrent) {
1432   // Initialize the database.
1433   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_35.sql")));
1434
1435   // Verify pre-conditions. These are expectations for version 34 of the
1436   // database.
1437   {
1438     sql::Connection connection;
1439     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1440
1441     EXPECT_FALSE(connection.DoesTableExist("autofill_profiles_trash"));
1442     ASSERT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
1443
1444     // Check that there are 6 profiles prior to merge.
1445     sql::Statement s(
1446         connection.GetUniqueStatement("SELECT guid FROM autofill_profiles"));
1447     int i = 0;
1448     while (s.Step())
1449       ++i;
1450     EXPECT_EQ(6, i);
1451   }
1452
1453   DoMigration();
1454
1455   // Verify post-conditions.  These are expectations for current version of the
1456   // database.
1457   {
1458     sql::Connection connection;
1459     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1460
1461     // Check version.
1462     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1463
1464     ASSERT_TRUE(connection.DoesTableExist("autofill_profiles_trash"));
1465     ASSERT_TRUE(connection.DoesColumnExist("autofill_profiles_trash", "guid"));
1466     ASSERT_TRUE(connection.DoesColumnExist("autofill_profiles", "guid"));
1467
1468     // Verify data in the database after the migration.
1469     sql::Statement s1(
1470         connection.GetUniqueStatement(
1471             "SELECT guid, company_name, street_address, city, state, zipcode,"
1472             " country_code, date_modified "
1473             "FROM autofill_profiles"));
1474
1475     // John Doe.
1476     ASSERT_TRUE(s1.Step());
1477     EXPECT_EQ("00000000-0000-0000-0000-000000000001", s1.ColumnString(0));
1478     EXPECT_EQ(ASCIIToUTF16("Acme Inc."), s1.ColumnString16(1));
1479     EXPECT_EQ(ASCIIToUTF16("1 Main Street\n"
1480                            "Apt 2"),
1481               s1.ColumnString16(2));
1482     EXPECT_EQ(ASCIIToUTF16("San Francisco"), s1.ColumnString16(3));
1483     EXPECT_EQ(ASCIIToUTF16("CA"), s1.ColumnString16(4));
1484     EXPECT_EQ(ASCIIToUTF16("94102"), s1.ColumnString16(5));
1485     EXPECT_EQ(ASCIIToUTF16("US"), s1.ColumnString16(6));
1486     EXPECT_EQ(1300131704, s1.ColumnInt64(7));
1487
1488     // That should be it.
1489     ASSERT_FALSE(s1.Step());
1490
1491     // Check that there 5 trashed profile after the merge.
1492     sql::Statement s2(
1493         connection.GetUniqueStatement("SELECT guid "
1494                                       "FROM autofill_profiles_trash"));
1495     ASSERT_TRUE(s2.Step());
1496     EXPECT_EQ("00000000-0000-0000-0000-000000000002", s2.ColumnString(0));
1497
1498     ASSERT_TRUE(s2.Step());
1499     EXPECT_EQ("00000000-0000-0000-0000-000000000003", s2.ColumnString(0));
1500
1501     ASSERT_TRUE(s2.Step());
1502     EXPECT_EQ("00000000-0000-0000-0000-000000000004", s2.ColumnString(0));
1503
1504     ASSERT_TRUE(s2.Step());
1505     EXPECT_EQ("00000000-0000-0000-0000-000000000005", s2.ColumnString(0));
1506
1507     ASSERT_TRUE(s2.Step());
1508     EXPECT_EQ("00000000-0000-0000-0000-000000000006", s2.ColumnString(0));
1509
1510     // That should be it.
1511     ASSERT_FALSE(s2.Step());
1512   }
1513 }
1514
1515 // Tests that the |keywords| |last_modified| column gets added to the schema for
1516 // a version 37 database.
1517 TEST_F(WebDatabaseMigrationTest, MigrateVersion37ToCurrent) {
1518   // This schema is taken from a build prior to the addition of the |keywords|
1519   // |last_modified| column.
1520   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_37.sql")));
1521
1522   // Verify pre-conditions.  These are expectations for version 37 of the
1523   // database.
1524   {
1525     sql::Connection connection;
1526     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1527
1528     // Columns existing and not existing before current version.
1529     ASSERT_TRUE(connection.DoesColumnExist("keywords", "id"));
1530     ASSERT_FALSE(connection.DoesColumnExist("keywords", "last_modified"));
1531   }
1532
1533   DoMigration();
1534
1535   // Verify post-conditions.  These are expectations for current version of the
1536   // database.
1537   {
1538     sql::Connection connection;
1539     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1540
1541     // Check version.
1542     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1543
1544     // |keywords| |last_modified| column should have been added.
1545     EXPECT_TRUE(connection.DoesColumnExist("keywords", "id"));
1546     EXPECT_TRUE(connection.DoesColumnExist("keywords", "last_modified"));
1547   }
1548 }
1549
1550 // Tests that the |keywords| |sync_guid| column gets added to the schema for
1551 // a version 38 database.
1552 TEST_F(WebDatabaseMigrationTest, MigrateVersion38ToCurrent) {
1553   // This schema is taken from a build prior to the addition of the |keywords|
1554   // |sync_guid| column.
1555   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_38.sql")));
1556
1557   // Verify pre-conditions.  These are expectations for version 38 of the
1558   // database.
1559   {
1560     sql::Connection connection;
1561     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1562
1563     // Columns existing and not existing before current version.
1564     ASSERT_TRUE(connection.DoesColumnExist("keywords", "id"));
1565     ASSERT_FALSE(connection.DoesColumnExist("keywords", "sync_guid"));
1566   }
1567
1568   DoMigration();
1569
1570   // Verify post-conditions.  These are expectations for current version of the
1571   // database.
1572   {
1573     sql::Connection connection;
1574     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1575
1576     // Check version.
1577     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1578
1579     // |keywords| |sync_guid| column should have been added.
1580     EXPECT_TRUE(connection.DoesColumnExist("keywords", "id"));
1581     EXPECT_TRUE(connection.DoesColumnExist("keywords", "sync_guid"));
1582   }
1583 }
1584
1585 // Tests that no backup data is added to a version 39 database.
1586 TEST_F(WebDatabaseMigrationTest, MigrateVersion39ToCurrent) {
1587   // This schema is taken from a build prior to the addition of the default
1588   // search provider backup field to the meta table.
1589   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_39.sql")));
1590
1591   // Verify pre-conditions.  These are expectations for version 39 of the
1592   // database.
1593   {
1594     sql::Connection connection;
1595     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1596     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1597
1598     sql::MetaTable meta_table;
1599     ASSERT_TRUE(meta_table.Init(&connection, 39, 39));
1600
1601     int64 default_search_provider_id = 0;
1602     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1603                                     &default_search_provider_id));
1604
1605     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1606   }
1607
1608   DoMigration();
1609
1610   // Verify post-conditions.  These are expectations for current version of the
1611   // database.
1612   {
1613     sql::Connection connection;
1614     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1615     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1616
1617     // Check version.
1618     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1619
1620     sql::MetaTable meta_table;
1621     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
1622                                 kCurrentTestedVersionNumber));
1623
1624     int64 default_search_provider_id = 0;
1625     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1626                                     &default_search_provider_id));
1627     EXPECT_NE(0, default_search_provider_id);
1628
1629     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1630   }
1631 }
1632
1633 // Tests that the backup data is removed from the database.
1634 TEST_F(WebDatabaseMigrationTest, MigrateVersion40ToCurrent) {
1635   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_40.sql")));
1636
1637   // Verify pre-conditions.  These are expectations for version 40 of the
1638   // database.
1639   {
1640     sql::Connection connection;
1641     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1642     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1643
1644     sql::MetaTable meta_table;
1645     ASSERT_TRUE(meta_table.Init(&connection, 40, 40));
1646
1647     int64 default_search_provider_id = 0;
1648     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1649                                     &default_search_provider_id));
1650
1651     EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
1652   }
1653
1654   DoMigration();
1655
1656   // Verify post-conditions.  These are expectations for current version of the
1657   // database.
1658   {
1659     sql::Connection connection;
1660     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1661     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1662
1663     // Check version.
1664     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1665
1666     sql::MetaTable meta_table;
1667     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
1668                                 kCurrentTestedVersionNumber));
1669
1670     int64 default_search_provider_id = 0;
1671     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1672                                     &default_search_provider_id));
1673     EXPECT_NE(0, default_search_provider_id);
1674
1675     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1676   }
1677 }
1678
1679 // Tests that the backup data is removed from the database.
1680 TEST_F(WebDatabaseMigrationTest, MigrateVersion41ToCurrent) {
1681   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_41.sql")));
1682
1683   // Verify pre-conditions.  These are expectations for version 41 of the
1684   // database.
1685   {
1686     sql::Connection connection;
1687     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1688     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1689
1690     sql::MetaTable meta_table;
1691     ASSERT_TRUE(meta_table.Init(&connection, 41, 41));
1692
1693     int64 default_search_provider_id = 0;
1694     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1695                                     &default_search_provider_id));
1696
1697     EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
1698   }
1699
1700   DoMigration();
1701
1702   // Verify post-conditions.  These are expectations for current version of the
1703   // database.
1704   {
1705     sql::Connection connection;
1706     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1707     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1708
1709     // Check version.
1710     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1711
1712     sql::MetaTable meta_table;
1713     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
1714                                 kCurrentTestedVersionNumber));
1715
1716     int64 default_search_provider_id = 0;
1717     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1718                                     &default_search_provider_id));
1719     EXPECT_NE(0, default_search_provider_id);
1720
1721     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1722   }
1723 }
1724
1725 // Tests that the backup data is removed from the database.
1726 TEST_F(WebDatabaseMigrationTest, MigrateVersion42ToCurrent) {
1727   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_42.sql")));
1728
1729   // Verify pre-conditions.  These are expectations for version 42 of the
1730   // database.
1731   {
1732     sql::Connection connection;
1733     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1734     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1735
1736     sql::MetaTable meta_table;
1737     ASSERT_TRUE(meta_table.Init(&connection, 42, 42));
1738
1739     int64 default_search_provider_id = 0;
1740     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1741                                     &default_search_provider_id));
1742
1743     EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
1744
1745     EXPECT_FALSE(connection.DoesTableExist("keywords_backup"));
1746   }
1747
1748   DoMigration();
1749
1750   // Verify post-conditions.  These are expectations for current version of the
1751   // database.
1752   {
1753     sql::Connection connection;
1754     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1755     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1756
1757     // Check version.
1758     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1759
1760     sql::MetaTable meta_table;
1761     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
1762                                 kCurrentTestedVersionNumber));
1763
1764     int64 default_search_provider_id = 0;
1765     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1766                                     &default_search_provider_id));
1767     EXPECT_NE(0, default_search_provider_id);
1768
1769     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1770   }
1771 }
1772
1773 // Tests that the backup data is removed from the database.
1774 TEST_F(WebDatabaseMigrationTest, MigrateVersion43ToCurrent) {
1775   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_43.sql")));
1776
1777   int64 previous_default_search_provider_id;
1778
1779   // Verify pre-conditions.  These are expectations for version 43 of the
1780   // database.
1781   {
1782     sql::Connection connection;
1783     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1784     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1785
1786     sql::MetaTable meta_table;
1787     ASSERT_TRUE(meta_table.Init(&connection, 43, 43));
1788
1789     int64 default_search_provider_id = 0;
1790     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1791                                     &default_search_provider_id));
1792     EXPECT_NE(default_search_provider_id, 0);
1793     previous_default_search_provider_id = default_search_provider_id;
1794
1795     EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
1796     EXPECT_TRUE(connection.DoesTableExist("keywords_backup"));
1797   }
1798
1799   DoMigration();
1800
1801   // Verify post-conditions.  These are expectations for current version of the
1802   // database.
1803   {
1804     sql::Connection connection;
1805     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1806     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1807
1808     // Check version.
1809     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1810
1811     sql::MetaTable meta_table;
1812     ASSERT_TRUE(meta_table.Init(
1813         &connection,
1814         kCurrentTestedVersionNumber,
1815         kCurrentTestedVersionNumber));
1816
1817     int64 default_search_provider_id = 0;
1818     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
1819                                     &default_search_provider_id));
1820     // Default search provider ID should not change.
1821     EXPECT_EQ(previous_default_search_provider_id, default_search_provider_id);
1822
1823     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1824   }
1825 }
1826
1827 // Tests that the |autogenerate_keyword| and |logo_id| columns get removed from
1828 // the keyword table schema for a version 45 database.
1829 TEST_F(WebDatabaseMigrationTest, MigrateVersion44ToCurrent) {
1830   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_44.sql")));
1831
1832   // Verify pre-conditions.  These are expectations for version 44 of the
1833   // database.
1834   {
1835     sql::Connection connection;
1836     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1837     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1838
1839     sql::MetaTable meta_table;
1840     ASSERT_TRUE(meta_table.Init(&connection, 44, 44));
1841
1842     ASSERT_TRUE(connection.DoesColumnExist("keywords", "autogenerate_keyword"));
1843     ASSERT_TRUE(connection.DoesColumnExist("keywords", "logo_id"));
1844   }
1845
1846   DoMigration();
1847
1848   // Verify post-conditions.  These are expectations for current version of the
1849   // database.
1850   {
1851     sql::Connection connection;
1852     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1853     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1854
1855     // Check version.
1856     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1857
1858     sql::MetaTable meta_table;
1859     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
1860                                 kCurrentTestedVersionNumber));
1861
1862     // We should have removed this obsolete key.
1863     std::string default_search_provider_backup;
1864     EXPECT_FALSE(meta_table.GetValue("Default Search Provider Backup",
1865                                      &default_search_provider_backup));
1866
1867     // Two columns should have been removed.
1868     EXPECT_FALSE(connection.DoesColumnExist("keywords",
1869                                             "autogenerate_keyword"));
1870     EXPECT_FALSE(connection.DoesColumnExist("keywords", "logo_id"));
1871
1872     // Backup data should have been removed.
1873     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
1874   }
1875 }
1876
1877 // Previously, this tested that the web_intents and web_intents_defaults tables
1878 // were modified to include "scheme" columns. Since the web_intents and
1879 // web_intents_defaults tables are now obsolete, this test checks to ensure that
1880 // they are properly removed.
1881 TEST_F(WebDatabaseMigrationTest, MigrateVersion45ToCurrent) {
1882   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_45.sql")));
1883
1884   // Verify pre-conditions.  These are expectations for version 45 of the
1885   // database.
1886   {
1887     sql::Connection connection;
1888     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1889     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1890
1891     sql::MetaTable meta_table;
1892     ASSERT_TRUE(meta_table.Init(&connection, 45, 45));
1893
1894     ASSERT_FALSE(connection.DoesColumnExist("scheme", "web_intents"));
1895     ASSERT_FALSE(connection.DoesColumnExist(
1896         "scheme", "web_intents_defaults"));
1897   }
1898
1899   DoMigration();
1900
1901   // Verify post-conditions.  These are expectations for current version of the
1902   // database.
1903   {
1904     sql::Connection connection;
1905     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1906     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1907
1908     // Check version.
1909     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1910
1911     sql::MetaTable meta_table;
1912     ASSERT_TRUE(meta_table.Init(
1913         &connection,
1914         kCurrentTestedVersionNumber,
1915         kCurrentTestedVersionNumber));
1916
1917     // finally ensure the migration code cleaned up after itself
1918     EXPECT_FALSE(connection.DoesTableExist("web_intents"));
1919     EXPECT_FALSE(connection.DoesTableExist("web_intents_defaults"));
1920   }
1921 }
1922
1923 // Previously, this tested that the web_intents and web_intents_defaults tables
1924 // were modified to include "scheme" columns. Since the web_intents and
1925 // web_intents_defaults tables are now obsolete, this test checks to ensure that
1926 // they are properly removed.
1927 TEST_F(WebDatabaseMigrationTest, MigrateVersion45InvalidToCurrent) {
1928   ASSERT_NO_FATAL_FAILURE(
1929       LoadDatabase(FILE_PATH_LITERAL("version_45_invalid.sql")));
1930
1931   // Verify pre-conditions.  These are expectations for version 45 of the
1932   // database.
1933   {
1934     sql::Connection connection;
1935     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1936     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1937
1938     sql::MetaTable meta_table;
1939     ASSERT_TRUE(meta_table.Init(&connection, 45, 45));
1940
1941     ASSERT_FALSE(connection.DoesColumnExist("scheme", "web_intents"));
1942     ASSERT_FALSE(connection.DoesColumnExist(
1943         "scheme", "web_intents_defaults"));
1944   }
1945
1946   DoMigration();
1947
1948   // Verify post-conditions.  These are expectations for current version of the
1949   // database.
1950   {
1951     sql::Connection connection;
1952     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1953     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1954
1955     // Check version.
1956     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1957
1958     sql::MetaTable meta_table;
1959     ASSERT_TRUE(meta_table.Init(
1960         &connection,
1961         kCurrentTestedVersionNumber,
1962         kCurrentTestedVersionNumber));
1963
1964     EXPECT_FALSE(connection.DoesTableExist("web_intents"));
1965     EXPECT_FALSE(connection.DoesTableExist("web_intents_defaults"));
1966   }
1967 }
1968
1969 // Check that current version is forced to compatible version before migration,
1970 // if the former is smaller.
1971 TEST_F(WebDatabaseMigrationTest, MigrateVersion45CompatibleToCurrent) {
1972   ASSERT_NO_FATAL_FAILURE(
1973       LoadDatabase(FILE_PATH_LITERAL("version_45_compatible.sql")));
1974
1975   // Verify pre-conditions.  These are expectations for version 45 of the
1976   // database.
1977   {
1978     sql::Connection connection;
1979     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1980     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1981
1982     sql::MetaTable meta_table;
1983     // Database is actually version 45 but the version field states 40.
1984     ASSERT_TRUE(meta_table.Init(&connection, 40, 45));
1985   }
1986
1987   DoMigration();
1988
1989   // Verify post-conditions.  These are expectations for current version of the
1990   // database.
1991   {
1992     sql::Connection connection;
1993     ASSERT_TRUE(connection.Open(GetDatabasePath()));
1994     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
1995
1996     // Check version.
1997     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
1998     EXPECT_LE(45, VersionFromConnection(&connection));
1999   }
2000 }
2001
2002 // Tests that the |alternate_urls| column is added to the keyword table schema
2003 // for a version 47 database.
2004 TEST_F(WebDatabaseMigrationTest, MigrateVersion46ToCurrent) {
2005   ASSERT_NO_FATAL_FAILURE(
2006       LoadDatabase(FILE_PATH_LITERAL("version_46.sql")));
2007
2008   // Verify pre-conditions.  These are expectations for version 46 of the
2009   // database.
2010   {
2011     sql::Connection connection;
2012     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2013     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2014
2015     sql::MetaTable meta_table;
2016     ASSERT_TRUE(meta_table.Init(&connection, 46, 46));
2017
2018     ASSERT_FALSE(connection.DoesColumnExist("keywords", "alternate_urls"));
2019     ASSERT_FALSE(connection.DoesColumnExist("keywords_backup",
2020                                             "alternate_urls"));
2021   }
2022
2023   DoMigration();
2024
2025   // Verify post-conditions.  These are expectations for current version of the
2026   // database.
2027   {
2028     sql::Connection connection;
2029     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2030     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2031
2032     // Check version.
2033     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2034
2035     // A new column should have been created.
2036     EXPECT_TRUE(connection.DoesColumnExist("keywords", "alternate_urls"));
2037   }
2038 }
2039
2040 // Tests that the backup data is removed from the database.
2041 TEST_F(WebDatabaseMigrationTest, MigrateVersion47ToCurrent) {
2042   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_47.sql")));
2043
2044   // Verify pre-conditions.  These are expectations for version 47 of the
2045   // database.
2046   {
2047     sql::Connection connection;
2048     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2049     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2050
2051     sql::MetaTable meta_table;
2052     ASSERT_TRUE(meta_table.Init(&connection, 47, 47));
2053
2054     int64 default_search_provider_id = 0;
2055     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
2056                                     &default_search_provider_id));
2057     EXPECT_NE(0, default_search_provider_id);
2058
2059     EXPECT_NO_FATAL_FAILURE(CheckHasBackupData(&meta_table));
2060     EXPECT_TRUE(connection.DoesTableExist("keywords_backup"));
2061   }
2062
2063   DoMigration();
2064
2065   // Verify post-conditions.  These are expectations for current version of the
2066   // database.
2067   {
2068     sql::Connection connection;
2069     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2070     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2071
2072     // Check version.
2073     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2074
2075     sql::MetaTable meta_table;
2076     ASSERT_TRUE(meta_table.Init(&connection, kCurrentTestedVersionNumber,
2077                                 kCurrentTestedVersionNumber));
2078
2079     int64 default_search_provider_id = 0;
2080     EXPECT_TRUE(meta_table.GetValue(KeywordTable::kDefaultSearchProviderKey,
2081                                     &default_search_provider_id));
2082     EXPECT_NE(0, default_search_provider_id);
2083
2084     EXPECT_NO_FATAL_FAILURE(CheckNoBackupData(connection, &meta_table));
2085   }
2086 }
2087
2088 // Tests that the |search_terms_replacement_key| column is added to the keyword
2089 // table schema for a version 49 database.
2090 TEST_F(WebDatabaseMigrationTest, MigrateVersion48ToCurrent) {
2091   ASSERT_NO_FATAL_FAILURE(
2092       LoadDatabase(FILE_PATH_LITERAL("version_48.sql")));
2093
2094   // Verify pre-conditions.  These are expectations for version 48 of the
2095   // database.
2096   {
2097     sql::Connection connection;
2098     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2099     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2100
2101     sql::MetaTable meta_table;
2102     ASSERT_TRUE(meta_table.Init(&connection, 48, 48));
2103
2104     ASSERT_FALSE(connection.DoesColumnExist("keywords",
2105                                             "search_terms_replacement_key"));
2106   }
2107
2108   DoMigration();
2109
2110   // Verify post-conditions.  These are expectations for current version of the
2111   // database.
2112   {
2113     sql::Connection connection;
2114     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2115     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2116
2117     // Check version.
2118     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2119
2120     // A new column should have been created.
2121     EXPECT_TRUE(connection.DoesColumnExist("keywords",
2122                                            "search_terms_replacement_key"));
2123   }
2124 }
2125
2126 // Tests that the |origin| column is added to the autofill_profiles and
2127 // credit_cards table schemas for a version 50 database.
2128 TEST_F(WebDatabaseMigrationTest, MigrateVersion49ToCurrent) {
2129   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_49.sql")));
2130
2131   // Verify pre-conditions.  These are expectations for version 49 of the
2132   // database.
2133   {
2134     sql::Connection connection;
2135     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2136
2137     ASSERT_FALSE(connection.DoesColumnExist("autofill_profiles", "origin"));
2138     ASSERT_FALSE(connection.DoesColumnExist("credit_cards", "origin"));
2139   }
2140
2141   DoMigration();
2142
2143   // Verify post-conditions.  These are expectations for current version of the
2144   // database.
2145   {
2146     sql::Connection connection;
2147     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2148     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2149
2150     // Check version.
2151     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2152
2153     // A new column should have been created in both tables.
2154     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "origin"));
2155     EXPECT_TRUE(connection.DoesColumnExist("credit_cards", "origin"));
2156   }
2157 }
2158
2159 // Tests that the columns |image_url|, |search_url_post_params|,
2160 // |suggest_url_post_params|, |instant_url_post_params|, and
2161 // |image_url_post_params| are added to the keyword table schema for a version
2162 // 50 database.
2163 TEST_F(WebDatabaseMigrationTest, MigrateVersion50ToCurrent) {
2164   ASSERT_NO_FATAL_FAILURE(
2165       LoadDatabase(FILE_PATH_LITERAL("version_50.sql")));
2166
2167   // Verify pre-conditions.  These are expectations for version 50 of the
2168   // database.
2169   {
2170     sql::Connection connection;
2171     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2172     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2173
2174     sql::MetaTable meta_table;
2175     ASSERT_TRUE(meta_table.Init(&connection, 50, 50));
2176
2177     ASSERT_FALSE(connection.DoesColumnExist("keywords", "image_url"));
2178     ASSERT_FALSE(connection.DoesColumnExist("keywords",
2179                                             "search_url_post_params"));
2180     ASSERT_FALSE(connection.DoesColumnExist("keywords",
2181                                             "suggest_url_post_params"));
2182     ASSERT_FALSE(connection.DoesColumnExist("keywords",
2183                                             "instant_url_post_params"));
2184     ASSERT_FALSE(connection.DoesColumnExist("keywords",
2185                                             "image_url_post_params"));
2186   }
2187
2188   DoMigration();
2189
2190   // Verify post-conditions.  These are expectations for current version of the
2191   // database.
2192   {
2193     sql::Connection connection;
2194     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2195     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2196
2197     // Check version.
2198     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2199
2200     // New columns should have been created.
2201     EXPECT_TRUE(connection.DoesColumnExist("keywords", "image_url"));
2202     EXPECT_TRUE(connection.DoesColumnExist("keywords",
2203                                            "search_url_post_params"));
2204     EXPECT_TRUE(connection.DoesColumnExist("keywords",
2205                                            "suggest_url_post_params"));
2206     EXPECT_TRUE(connection.DoesColumnExist("keywords",
2207                                            "instant_url_post_params"));
2208     EXPECT_TRUE(connection.DoesColumnExist("keywords",
2209                                            "image_url_post_params"));
2210   }
2211 }
2212
2213 // Tests that the column |new_tab_url| is added to the keyword table schema for
2214 // a version 52 database.
2215 TEST_F(WebDatabaseMigrationTest, MigrateVersion52ToCurrent) {
2216   ASSERT_NO_FATAL_FAILURE(
2217       LoadDatabase(FILE_PATH_LITERAL("version_52.sql")));
2218
2219   // Verify pre-conditions.  These are expectations for version 52 of the
2220   // database.
2221   {
2222     sql::Connection connection;
2223     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2224     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2225
2226     sql::MetaTable meta_table;
2227     ASSERT_TRUE(meta_table.Init(&connection, 52, 52));
2228
2229     ASSERT_FALSE(connection.DoesColumnExist("keywords", "new_tab_url"));
2230   }
2231
2232   DoMigration();
2233
2234   // Verify post-conditions.  These are expectations for current version of the
2235   // database.
2236   {
2237     sql::Connection connection;
2238     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2239     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2240
2241     // Check version.
2242     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2243
2244     // New columns should have been created.
2245     EXPECT_TRUE(connection.DoesColumnExist("keywords", "new_tab_url"));
2246   }
2247 }
2248
2249 // Tests that for a version 54 database,
2250 //   (a) The street_address, dependent_locality, and sorting_code columns are
2251 //       added to the autofill_profiles table schema.
2252 //   (b) The address_line1, address_line2, and country columns are dropped from
2253 //       the autofill_profiles table schema.
2254 //   (c) The type column is dropped from the autofill_profile_phones schema.
2255 TEST_F(WebDatabaseMigrationTest, MigrateVersion53ToCurrent) {
2256   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_53.sql")));
2257
2258   // Verify pre-conditions.  These are expectations for version 53 of the
2259   // database.
2260   {
2261     sql::Connection connection;
2262     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2263
2264     EXPECT_TRUE(
2265         connection.DoesColumnExist("autofill_profiles", "address_line_1"));
2266     EXPECT_TRUE(
2267         connection.DoesColumnExist("autofill_profiles", "address_line_2"));
2268     EXPECT_TRUE(connection.DoesColumnExist("autofill_profiles", "country"));
2269     EXPECT_FALSE(
2270         connection.DoesColumnExist("autofill_profiles", "street_address"));
2271     EXPECT_FALSE(
2272         connection.DoesColumnExist("autofill_profiles", "dependent_locality"));
2273     EXPECT_FALSE(
2274         connection.DoesColumnExist("autofill_profiles", "sorting_code"));
2275     EXPECT_TRUE(connection.DoesColumnExist("autofill_profile_phones", "type"));
2276   }
2277
2278   DoMigration();
2279
2280   // Verify post-conditions.  These are expectations for current version of the
2281   // database.
2282   {
2283     sql::Connection connection;
2284     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2285     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2286
2287     // Check version.
2288     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2289
2290     // Columns should have been added and removed appropriately.
2291     EXPECT_FALSE(
2292         connection.DoesColumnExist("autofill_profiles", "address_line1"));
2293     EXPECT_FALSE(
2294         connection.DoesColumnExist("autofill_profiles", "address_line2"));
2295     EXPECT_FALSE(connection.DoesColumnExist("autofill_profiles", "country"));
2296     EXPECT_TRUE(
2297         connection.DoesColumnExist("autofill_profiles", "street_address"));
2298     EXPECT_TRUE(
2299         connection.DoesColumnExist("autofill_profiles", "dependent_locality"));
2300     EXPECT_TRUE(
2301         connection.DoesColumnExist("autofill_profiles", "sorting_code"));
2302     EXPECT_FALSE(connection.DoesColumnExist("autofill_profile_phones", "type"));
2303
2304     // Data should have been preserved.
2305     sql::Statement s_profiles(
2306         connection.GetUniqueStatement(
2307             "SELECT guid, company_name, street_address, dependent_locality,"
2308             " city, state, zipcode, sorting_code, country_code, date_modified,"
2309             " origin "
2310             "FROM autofill_profiles"));
2311
2312     // Address lines 1 and 2.
2313     ASSERT_TRUE(s_profiles.Step());
2314     EXPECT_EQ("00000000-0000-0000-0000-000000000001",
2315               s_profiles.ColumnString(0));
2316     EXPECT_EQ(ASCIIToUTF16("Google, Inc."), s_profiles.ColumnString16(1));
2317     EXPECT_EQ(ASCIIToUTF16("1950 Charleston Rd.\n"
2318                            "(2nd floor)"),
2319               s_profiles.ColumnString16(2));
2320     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(3));
2321     EXPECT_EQ(ASCIIToUTF16("Mountain View"), s_profiles.ColumnString16(4));
2322     EXPECT_EQ(ASCIIToUTF16("CA"), s_profiles.ColumnString16(5));
2323     EXPECT_EQ(ASCIIToUTF16("94043"), s_profiles.ColumnString16(6));
2324     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(7));
2325     EXPECT_EQ(ASCIIToUTF16("US"), s_profiles.ColumnString16(8));
2326     EXPECT_EQ(1386046731, s_profiles.ColumnInt(9));
2327     EXPECT_EQ(ASCIIToUTF16("Chrome settings"), s_profiles.ColumnString16(10));
2328
2329     // Only address line 1.
2330     ASSERT_TRUE(s_profiles.Step());
2331     EXPECT_EQ("00000000-0000-0000-0000-000000000002",
2332               s_profiles.ColumnString(0));
2333     EXPECT_EQ(ASCIIToUTF16("Google!"), s_profiles.ColumnString16(1));
2334     EXPECT_EQ(ASCIIToUTF16("1600 Amphitheatre Pkwy."),
2335               s_profiles.ColumnString16(2));
2336     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(3));
2337     EXPECT_EQ(ASCIIToUTF16("Mtn. View"), s_profiles.ColumnString16(4));
2338     EXPECT_EQ(ASCIIToUTF16("California"), s_profiles.ColumnString16(5));
2339     EXPECT_EQ(ASCIIToUTF16("94043-1234"), s_profiles.ColumnString16(6));
2340     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(7));
2341     EXPECT_EQ(ASCIIToUTF16("US"), s_profiles.ColumnString16(8));
2342     EXPECT_EQ(1386046800, s_profiles.ColumnInt(9));
2343     EXPECT_EQ(ASCIIToUTF16("Chrome settings"), s_profiles.ColumnString16(10));
2344
2345     // Only address line 2.
2346     ASSERT_TRUE(s_profiles.Step());
2347     EXPECT_EQ("00000000-0000-0000-0000-000000000003",
2348               s_profiles.ColumnString(0));
2349     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(1));
2350     EXPECT_EQ(ASCIIToUTF16("\nOnly line 2???"), s_profiles.ColumnString16(2));
2351     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(3));
2352     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(4));
2353     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(5));
2354     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(6));
2355     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(7));
2356     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(8));
2357     EXPECT_EQ(1386046834, s_profiles.ColumnInt(9));
2358     EXPECT_EQ(ASCIIToUTF16("Chrome settings"), s_profiles.ColumnString16(10));
2359
2360     // No address lines.
2361     ASSERT_TRUE(s_profiles.Step());
2362     EXPECT_EQ("00000000-0000-0000-0000-000000000004",
2363               s_profiles.ColumnString(0));
2364     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(1));
2365     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(2));
2366     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(3));
2367     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(4));
2368     EXPECT_EQ(ASCIIToUTF16("Texas"), s_profiles.ColumnString16(5));
2369     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(6));
2370     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(7));
2371     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(8));
2372     EXPECT_EQ(1386046847, s_profiles.ColumnInt(9));
2373     EXPECT_EQ(ASCIIToUTF16("Chrome settings"), s_profiles.ColumnString16(10));
2374
2375     // That should be it.
2376     EXPECT_FALSE(s_profiles.Step());
2377
2378     // Verify the phone number data as well.
2379     sql::Statement s_phones(
2380         connection.GetUniqueStatement(
2381             "SELECT guid, number FROM autofill_profile_phones"));
2382
2383     ASSERT_TRUE(s_phones.Step());
2384     EXPECT_EQ("00000000-0000-0000-0000-000000000001", s_phones.ColumnString(0));
2385     EXPECT_EQ(ASCIIToUTF16("1.800.555.1234"), s_phones.ColumnString16(1));
2386
2387     ASSERT_TRUE(s_phones.Step());
2388     EXPECT_EQ("00000000-0000-0000-0000-000000000001", s_phones.ColumnString(0));
2389     EXPECT_EQ(ASCIIToUTF16("+1 (800) 555-4321"), s_phones.ColumnString16(1));
2390
2391     ASSERT_TRUE(s_phones.Step());
2392     EXPECT_EQ("00000000-0000-0000-0000-000000000002", s_phones.ColumnString(0));
2393     EXPECT_EQ(base::string16(), s_phones.ColumnString16(1));
2394
2395     ASSERT_TRUE(s_phones.Step());
2396     EXPECT_EQ("00000000-0000-0000-0000-000000000003", s_phones.ColumnString(0));
2397     EXPECT_EQ(ASCIIToUTF16("6505557890"), s_phones.ColumnString16(1));
2398
2399     ASSERT_TRUE(s_phones.Step());
2400     EXPECT_EQ("00000000-0000-0000-0000-000000000004", s_phones.ColumnString(0));
2401     EXPECT_EQ(base::string16(), s_phones.ColumnString16(1));
2402
2403     EXPECT_FALSE(s_phones.Step());
2404   }
2405 }
2406
2407 // Tests that migrating from version 54 to version 55 drops the autofill_dates
2408 // table, and merges the appropriate dates into the autofill table.
2409 TEST_F(WebDatabaseMigrationTest, MigrateVersion54ToCurrent) {
2410   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_54.sql")));
2411
2412   // Verify pre-conditions.  These are expectations for version 54 of the
2413   // database.
2414   {
2415     sql::Connection connection;
2416     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2417
2418     EXPECT_TRUE(connection.DoesTableExist("autofill_dates"));
2419     EXPECT_FALSE(connection.DoesColumnExist("autofill", "date_created"));
2420     EXPECT_FALSE(connection.DoesColumnExist("autofill", "date_last_used"));
2421
2422     // Verify the incoming data.
2423     sql::Statement s_autofill(connection.GetUniqueStatement(
2424         "SELECT name, value, value_lower, pair_id, count FROM autofill"));
2425     sql::Statement s_dates(connection.GetUniqueStatement(
2426         "SELECT pair_id, date_created FROM autofill_dates"));
2427
2428     // An entry with one timestamp.
2429     ASSERT_TRUE(s_autofill.Step());
2430     EXPECT_EQ(ASCIIToUTF16("Name"), s_autofill.ColumnString16(0));
2431     EXPECT_EQ(ASCIIToUTF16("John Doe"), s_autofill.ColumnString16(1));
2432     EXPECT_EQ(ASCIIToUTF16("john doe"), s_autofill.ColumnString16(2));
2433     EXPECT_EQ(10, s_autofill.ColumnInt(3));
2434     EXPECT_EQ(1, s_autofill.ColumnInt(4));
2435     ASSERT_TRUE(s_dates.Step());
2436     EXPECT_EQ(10, s_dates.ColumnInt(0));
2437     EXPECT_EQ(1384299100, s_dates.ColumnInt64(1));
2438
2439     // Another entry with one timestamp, differing from the previous one in case
2440     // only.
2441     ASSERT_TRUE(s_autofill.Step());
2442     EXPECT_EQ(ASCIIToUTF16("Name"), s_autofill.ColumnString16(0));
2443     EXPECT_EQ(ASCIIToUTF16("john doe"), s_autofill.ColumnString16(1));
2444     EXPECT_EQ(ASCIIToUTF16("john doe"), s_autofill.ColumnString16(2));
2445     EXPECT_EQ(11, s_autofill.ColumnInt(3));
2446     EXPECT_EQ(1, s_autofill.ColumnInt(4));
2447     ASSERT_TRUE(s_dates.Step());
2448     EXPECT_EQ(11, s_dates.ColumnInt(0));
2449     EXPECT_EQ(1384299200, s_dates.ColumnInt64(1));
2450
2451     // An entry with two timestamps (with count > 2; this is realistic).
2452     ASSERT_TRUE(s_autofill.Step());
2453     EXPECT_EQ(ASCIIToUTF16("Email"), s_autofill.ColumnString16(0));
2454     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s_autofill.ColumnString16(1));
2455     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s_autofill.ColumnString16(2));
2456     EXPECT_EQ(20, s_autofill.ColumnInt(3));
2457     EXPECT_EQ(3, s_autofill.ColumnInt(4));
2458     ASSERT_TRUE(s_dates.Step());
2459     EXPECT_EQ(20, s_dates.ColumnInt(0));
2460     EXPECT_EQ(1384299300, s_dates.ColumnInt64(1));
2461     ASSERT_TRUE(s_dates.Step());
2462     EXPECT_EQ(20, s_dates.ColumnInt(0));
2463     EXPECT_EQ(1384299301, s_dates.ColumnInt64(1));
2464
2465     // An entry with more than two timestamps, which are stored out of order.
2466     ASSERT_TRUE(s_autofill.Step());
2467     EXPECT_EQ(ASCIIToUTF16("Email"), s_autofill.ColumnString16(0));
2468     EXPECT_EQ(ASCIIToUTF16("jane.doe@example.org"),
2469               s_autofill.ColumnString16(1));
2470     EXPECT_EQ(ASCIIToUTF16("jane.doe@example.org"),
2471               s_autofill.ColumnString16(2));
2472     EXPECT_EQ(21, s_autofill.ColumnInt(3));
2473     EXPECT_EQ(4, s_autofill.ColumnInt(4));
2474     ASSERT_TRUE(s_dates.Step());
2475     EXPECT_EQ(21, s_dates.ColumnInt(0));
2476     EXPECT_EQ(1384299401, s_dates.ColumnInt64(1));
2477     ASSERT_TRUE(s_dates.Step());
2478     EXPECT_EQ(21, s_dates.ColumnInt(0));
2479     EXPECT_EQ(1384299400, s_dates.ColumnInt64(1));
2480     ASSERT_TRUE(s_dates.Step());
2481     EXPECT_EQ(21, s_dates.ColumnInt(0));
2482     EXPECT_EQ(1384299403, s_dates.ColumnInt64(1));
2483     ASSERT_TRUE(s_dates.Step());
2484     EXPECT_EQ(21, s_dates.ColumnInt(0));
2485     EXPECT_EQ(1384299402, s_dates.ColumnInt64(1));
2486
2487     // No more entries expected.
2488     ASSERT_FALSE(s_autofill.Step());
2489     ASSERT_FALSE(s_dates.Step());
2490   }
2491
2492   DoMigration();
2493
2494   // Verify post-conditions.  These are expectations for current version of the
2495   // database.
2496   {
2497     sql::Connection connection;
2498     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2499     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2500
2501     // Check version.
2502     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2503
2504     // The autofill_dates table should have been dropped, and its columns should
2505     // have been migrated to the autofill table.
2506     EXPECT_FALSE(connection.DoesTableExist("autofill_dates"));
2507     EXPECT_TRUE(connection.DoesColumnExist("autofill", "date_created"));
2508     EXPECT_TRUE(connection.DoesColumnExist("autofill", "date_last_used"));
2509
2510     // Data should have been preserved.  Note that it appears out of order
2511     // relative to the previous table, as it's been alphabetized.  That's ok.
2512     sql::Statement s(
2513         connection.GetUniqueStatement(
2514             "SELECT name, value, value_lower, date_created, date_last_used,"
2515             " count "
2516             "FROM autofill "
2517             "ORDER BY name, value ASC"));
2518
2519     // "jane.doe@example.org": Timestamps should be parsed correctly, and only
2520     // the first and last should be kept.
2521     ASSERT_TRUE(s.Step());
2522     EXPECT_EQ(ASCIIToUTF16("Email"), s.ColumnString16(0));
2523     EXPECT_EQ(ASCIIToUTF16("jane.doe@example.org"), s.ColumnString16(1));
2524     EXPECT_EQ(ASCIIToUTF16("jane.doe@example.org"), s.ColumnString16(2));
2525     EXPECT_EQ(1384299400, s.ColumnInt64(3));
2526     EXPECT_EQ(1384299403, s.ColumnInt64(4));
2527     EXPECT_EQ(4, s.ColumnInt(5));
2528
2529     // "jane@example.com": Timestamps should be parsed correctly.
2530     ASSERT_TRUE(s.Step());
2531     EXPECT_EQ(ASCIIToUTF16("Email"), s.ColumnString16(0));
2532     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s.ColumnString16(1));
2533     EXPECT_EQ(ASCIIToUTF16("jane@example.com"), s.ColumnString16(2));
2534     EXPECT_EQ(1384299300, s.ColumnInt64(3));
2535     EXPECT_EQ(1384299301, s.ColumnInt64(4));
2536     EXPECT_EQ(3, s.ColumnInt(5));
2537
2538     // "John Doe": The single timestamp should be assigned as both the creation
2539     // and the last use timestamp.
2540     ASSERT_TRUE(s.Step());
2541     EXPECT_EQ(ASCIIToUTF16("Name"), s.ColumnString16(0));
2542     EXPECT_EQ(ASCIIToUTF16("John Doe"), s.ColumnString16(1));
2543     EXPECT_EQ(ASCIIToUTF16("john doe"), s.ColumnString16(2));
2544     EXPECT_EQ(1384299100, s.ColumnInt64(3));
2545     EXPECT_EQ(1384299100, s.ColumnInt64(4));
2546     EXPECT_EQ(1, s.ColumnInt(5));
2547
2548     // "john doe": Should not be merged with "John Doe" (case-sensitivity).
2549     ASSERT_TRUE(s.Step());
2550     EXPECT_EQ(ASCIIToUTF16("Name"), s.ColumnString16(0));
2551     EXPECT_EQ(ASCIIToUTF16("john doe"), s.ColumnString16(1));
2552     EXPECT_EQ(ASCIIToUTF16("john doe"), s.ColumnString16(2));
2553     EXPECT_EQ(1384299200, s.ColumnInt64(3));
2554     EXPECT_EQ(1384299200, s.ColumnInt64(4));
2555     EXPECT_EQ(1, s.ColumnInt(5));
2556
2557     // No more entries expected.
2558     ASSERT_FALSE(s.Step());
2559   }
2560 }
2561
2562 // Tests that migrating from version 55 to version 56 adds the language_code
2563 // column to autofill_profiles table.
2564 TEST_F(WebDatabaseMigrationTest, MigrateVersion55ToCurrent) {
2565   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_55.sql")));
2566
2567   // Verify pre-conditions. These are expectations for version 55 of the
2568   // database.
2569   {
2570     sql::Connection connection;
2571     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2572     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2573
2574     EXPECT_FALSE(
2575         connection.DoesColumnExist("autofill_profiles", "language_code"));
2576   }
2577
2578   DoMigration();
2579
2580   // Verify post-conditions. These are expectations for current version of the
2581   // database.
2582   {
2583     sql::Connection connection;
2584     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2585     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2586
2587     // Check version.
2588     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2589
2590     // The language_code column should have been added to autofill_profiles
2591     // table.
2592     EXPECT_TRUE(
2593         connection.DoesColumnExist("autofill_profiles", "language_code"));
2594
2595     // Data should have been preserved. Language code should have been set to
2596     // empty string.
2597     sql::Statement s_profiles(
2598         connection.GetUniqueStatement(
2599             "SELECT guid, company_name, street_address, dependent_locality,"
2600             " city, state, zipcode, sorting_code, country_code, date_modified,"
2601             " origin, language_code "
2602             "FROM autofill_profiles"));
2603
2604     ASSERT_TRUE(s_profiles.Step());
2605     EXPECT_EQ("00000000-0000-0000-0000-000000000001",
2606               s_profiles.ColumnString(0));
2607     EXPECT_EQ(ASCIIToUTF16("Google Inc"), s_profiles.ColumnString16(1));
2608     EXPECT_EQ(ASCIIToUTF16("340 Main St"),
2609               s_profiles.ColumnString16(2));
2610     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(3));
2611     EXPECT_EQ(ASCIIToUTF16("Los Angeles"), s_profiles.ColumnString16(4));
2612     EXPECT_EQ(ASCIIToUTF16("CA"), s_profiles.ColumnString16(5));
2613     EXPECT_EQ(ASCIIToUTF16("90291"), s_profiles.ColumnString16(6));
2614     EXPECT_EQ(base::string16(), s_profiles.ColumnString16(7));
2615     EXPECT_EQ(ASCIIToUTF16("US"), s_profiles.ColumnString16(8));
2616     EXPECT_EQ(1395948829, s_profiles.ColumnInt(9));
2617     EXPECT_EQ(ASCIIToUTF16("Chrome settings"), s_profiles.ColumnString16(10));
2618     EXPECT_EQ(std::string(), s_profiles.ColumnString(11));
2619
2620     // No more entries expected.
2621     ASSERT_FALSE(s_profiles.Step());
2622   }
2623 }
2624
2625 // Tests that migrating from version 56 to version 57 adds the full_name
2626 // column to autofill_profile_names table.
2627 TEST_F(WebDatabaseMigrationTest, MigrateVersion56ToCurrent) {
2628   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_56.sql")));
2629
2630   // Verify pre-conditions. These are expectations for version 56 of the
2631   // database.
2632   {
2633     sql::Connection connection;
2634     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2635     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2636
2637     EXPECT_FALSE(
2638         connection.DoesColumnExist("autofill_profile_names", "full_name"));
2639
2640     // Verify the starting data.
2641     sql::Statement s_names(
2642         connection.GetUniqueStatement(
2643             "SELECT guid, first_name, middle_name, last_name "
2644             "FROM autofill_profile_names"));
2645     ASSERT_TRUE(s_names.Step());
2646     EXPECT_EQ("B41FE6E0-B13E-2A2A-BF0B-29FCE2C3ADBD", s_names.ColumnString(0));
2647     EXPECT_EQ(ASCIIToUTF16("Jon"), s_names.ColumnString16(1));
2648     EXPECT_EQ(base::string16(), s_names.ColumnString16(2));
2649     EXPECT_EQ(ASCIIToUTF16("Smith"), s_names.ColumnString16(3));
2650   }
2651
2652   DoMigration();
2653
2654   // Verify post-conditions. These are expectations for current version of the
2655   // database.
2656   {
2657     sql::Connection connection;
2658     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2659     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2660
2661     // Check version.
2662     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2663
2664     // The full_name column should have been added to autofill_profile_names
2665     // table.
2666     EXPECT_TRUE(
2667         connection.DoesColumnExist("autofill_profile_names", "full_name"));
2668
2669     // Data should have been preserved. Full name should have been set to the
2670     // empty string.
2671     sql::Statement s_names(
2672         connection.GetUniqueStatement(
2673             "SELECT guid, first_name, middle_name, last_name, full_name "
2674             "FROM autofill_profile_names"));
2675
2676     ASSERT_TRUE(s_names.Step());
2677     EXPECT_EQ("B41FE6E0-B13E-2A2A-BF0B-29FCE2C3ADBD", s_names.ColumnString(0));
2678     EXPECT_EQ(ASCIIToUTF16("Jon"), s_names.ColumnString16(1));
2679     EXPECT_EQ(base::string16(), s_names.ColumnString16(2));
2680     EXPECT_EQ(ASCIIToUTF16("Smith"), s_names.ColumnString16(3));
2681     EXPECT_EQ(base::string16(), s_names.ColumnString16(4));
2682
2683     // No more entries expected.
2684     ASSERT_FALSE(s_names.Step());
2685   }
2686 }
2687
2688 // Tests that migrating from version 57 to version 58 drops the web_intents and
2689 // web_apps tables.
2690 TEST_F(WebDatabaseMigrationTest, MigrateVersion57ToCurrent) {
2691   ASSERT_NO_FATAL_FAILURE(LoadDatabase(FILE_PATH_LITERAL("version_57.sql")));
2692
2693   // Verify pre-conditions. These are expectations for version 57 of the
2694   // database.
2695   {
2696     sql::Connection connection;
2697     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2698     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2699
2700     EXPECT_TRUE(connection.DoesTableExist("web_apps"));
2701     EXPECT_TRUE(connection.DoesTableExist("web_app_icons"));
2702     EXPECT_TRUE(connection.DoesTableExist("web_intents"));
2703     EXPECT_TRUE(connection.DoesTableExist("web_intents_defaults"));
2704   }
2705
2706   DoMigration();
2707
2708   // Verify post-conditions. These are expectations for current version of the
2709   // database.
2710   {
2711     sql::Connection connection;
2712     ASSERT_TRUE(connection.Open(GetDatabasePath()));
2713     ASSERT_TRUE(sql::MetaTable::DoesTableExist(&connection));
2714
2715     // Check version.
2716     EXPECT_EQ(kCurrentTestedVersionNumber, VersionFromConnection(&connection));
2717
2718     EXPECT_FALSE(connection.DoesTableExist("web_apps"));
2719     EXPECT_FALSE(connection.DoesTableExist("web_app_icons"));
2720     EXPECT_FALSE(connection.DoesTableExist("web_intents"));
2721     EXPECT_FALSE(connection.DoesTableExist("web_intents_defaults"));
2722   }
2723 }