// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/btm/btm_database_migrator.h"

#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/path_service.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "content/browser/btm/btm_test_utils.h"
#include "sql/database.h"
#include "sql/test/test_helpers.h"
#include "sql/transaction.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gtest/include/gtest/gtest.h"

using testing::AssertionFailure;
using testing::AssertionResult;
using testing::AssertionSuccess;

namespace content {

using internal::BtmDatabaseMigrator;

class BtmDatabaseMigrationTest : public testing::Test {
 protected:
  base::FilePath db_path() { return db_path_; }

  [[nodiscard]] AssertionResult LoadDatabase(const char* file_name) {
    base::FilePath root;
    if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &root)) {
      return AssertionFailure() << "Could not get test data directory root";
    }
    base::FilePath file_path = root.AppendASCII("content")
                                   .AppendASCII("test")
                                   .AppendASCII("data")
                                   .AppendASCII("btm")
                                   .AppendASCII(file_name);
    if (!base::PathExists(file_path)) {
      return AssertionFailure() << file_path << " does not exist";
    }
    if (!sql::test::CreateDatabaseFromSQL(db_path(), file_path)) {
      return AssertionFailure() << "Could not create database at " << db_path();
    }
    return AssertionSuccess();
  }

  int GetDatabaseVersion(sql::Database* db) {
    sql::Statement kGetVersionSql(
        db->GetUniqueStatement("SELECT value FROM meta WHERE key='version'"));
    if (!kGetVersionSql.Step()) {
      return 0;
    }
    return kGetVersionSql.ColumnInt(0);
  }

  int GetDatabaseLastCompatibleVersion(sql::Database* db) {
    sql::Statement kGetLastCompatibleVersionSql(db->GetUniqueStatement(
        "SELECT value FROM meta WHERE key='last_compatible_version'"));
    if (!kGetLastCompatibleVersionSql.Step()) {
      return 0;
    }
    return kGetLastCompatibleVersionSql.ColumnInt(0);
  }

  std::optional<int> GetPrepopulatedFromMetaTable(sql::Database* db) {
    sql::Statement kGetPrepopulatedSql(db->GetUniqueStatement(
        "SELECT value FROM meta WHERE key='prepopulated'"));
    if (!kGetPrepopulatedSql.Step()) {
      return std::nullopt;
    }
    return kGetPrepopulatedSql.ColumnInt(0);
  }

  std::optional<int64_t> GetPrepopulatedFromConfigTable(sql::Database* db) {
    sql::Statement kGetPrepopulatedSql(db->GetUniqueStatement(
        "SELECT int_value FROM config WHERE key='prepopulated'"));
    if (!kGetPrepopulatedSql.Step()) {
      return std::nullopt;
    }
    return kGetPrepopulatedSql.ColumnInt64(0);
  }

  std::string DbBouncesToString(sql::Database* db) {
    return sql::test::ExecuteWithResults(
        db, "SELECT * FROM bounces ORDER BY site", "|", "\n");
  }

  std::string DbPopupsToString(sql::Database* db) {
    return sql::test::ExecuteWithResults(
        db, "SELECT * FROM popups ORDER BY opener_site", "|", "\n");
  }

  std::string DbConfigToString(sql::Database* db) {
    return sql::test::ExecuteWithResults(
        db, "SELECT * FROM config ORDER BY key", "|", "\n");
  }

  std::vector<std::string> GetFirstAndLastColumnForSite(sql::Database* db,
                                                        const char* column,
                                                        const char* site) {
    std::string both_times = sql::test::ExecuteWithResults(
        db,
        base::StringPrintf("SELECT first_%s_time,last_%s_time FROM bounces "
                           "WHERE site='%s'",
                           column, column, site),
        "|", ",");

    return base::SplitString(both_times, "|", base::KEEP_WHITESPACE,
                             base::SPLIT_WANT_ALL);
  }

  void ExpectAllEntriesInColumnToBeNull(sql::Database* db,
                                        const char* table,
                                        const char* column) {
    const std::string num_rows_with_non_null_column_value =
        sql::test::ExecuteWithResult(
            db,
            base::StringPrintf("SELECT COUNT(*) FROM %s WHERE %s IS NOT NULL",
                               table, column));
    EXPECT_EQ(num_rows_with_non_null_column_value, "0");
  }

 private:
  base::ScopedTempDir temp_dir_;
  base::FilePath db_path_;
  // Test setup.
  void SetUp() override {
    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    db_path_ = temp_dir_.GetPath().AppendASCII("BTM.db");
  }

  void TearDown() override { ASSERT_TRUE(temp_dir_.Delete()); }
};

TEST_F(BtmDatabaseMigrationTest, MigrateV1ToLatestVersion) {
  ASSERT_TRUE(LoadDatabase("v1.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 1);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 1);

    EXPECT_TRUE(db.DoesTableExist("bounces"));
    EXPECT_FALSE(db.DoesTableExist("popups"));
    EXPECT_FALSE(db.DoesTableExist("config"));

    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|0|0|4|4|1|4|2|6\n"
              "site-storage-stateful-bounce-drop.test|1|1|0|0|0|0|0|0\n"
              "stateful-bounce.test|0|0|4|4|1|1|0|0\n"
              "stateless-bounce.test|0|0|4|4|0|0|1|1\n"
              "storage.test|1|1|4|4|0|0|0|0");

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 1, 1));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    MigrateBtmSchemaToLatestVersion(db, meta_table);
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), BtmDatabase::kLatestSchemaVersion);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db),
              BtmDatabase::kMinCompatibleSchemaVersion);

    ASSERT_TRUE(db.DoesTableExist("bounces"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "site"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "first_bounce_time"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "last_bounce_time"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "first_user_activation_time"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "last_user_activation_time"));
    EXPECT_TRUE(
        db.DoesColumnExist("bounces", "first_web_authn_assertion_time"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "last_web_authn_assertion_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_stateless_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_stateless_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_stateful_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_stateful_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_site_storage_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_site_storage_time"));

    ASSERT_TRUE(db.DoesTableExist("popups"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "opener_site"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "popup_site"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "access_id"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "last_popup_time"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "is_current_interaction"));

    ASSERT_TRUE(db.DoesTableExist("config"));
    EXPECT_TRUE(db.DoesColumnExist("config", "key"));
    EXPECT_TRUE(db.DoesColumnExist("config", "int_value"));

    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|4|4|1|6||\n"
              "stateful-bounce.test|4|4|1|1||\n"
              "stateless-bounce.test|4|4|1|1||\n"
              "storage.test|4|4||||");
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV1ToV2) {
  ASSERT_TRUE(LoadDatabase("v1.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 1);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 1);

    EXPECT_FALSE(db.DoesTableExist("popups"));
    EXPECT_FALSE(db.DoesTableExist("config"));

    EXPECT_TRUE(db.DoesColumnExist("bounces", "first_stateless_bounce_time"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "last_stateless_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_bounce_time"));
    EXPECT_FALSE(
        db.DoesColumnExist("bounces", "first_web_authn_assertion_time"));
    EXPECT_FALSE(
        db.DoesColumnExist("bounces", "last_web_authn_assertion_time"));

    // These values are all set in v1.sql.
    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|0|0|4|4|1|4|2|6\n"
              "site-storage-stateful-bounce-drop.test|1|1|0|0|0|0|0|0\n"
              "stateful-bounce.test|0|0|4|4|1|1|0|0\n"
              "stateless-bounce.test|0|0|4|4|0|0|1|1\n"
              "storage.test|1|1|4|4|0|0|0|0");

    // Note: that the stateful bounce happens earlier than the stateless bounce
    // this should be reflected in the first/last bounce times for this in v2.
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "stateful_bounce",
                                             "both-bounce-kinds.test"),
                testing::ElementsAre("1", "4"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "stateless_bounce",
                                             "both-bounce-kinds.test"),
                testing::ElementsAre("2", "6"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "user_interaction",
                                             "both-bounce-kinds.test"),
                testing::ElementsAre("4", "4"));

    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "stateful_bounce",
                                             "stateful-bounce.test"),
                testing::ElementsAre("1", "1"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "user_interaction",
                                             "stateful-bounce.test"),
                testing::ElementsAre("4", "4"));

    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "stateless_bounce",
                                             "stateless-bounce.test"),
                testing::ElementsAre("1", "1"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "user_interaction",
                                             "stateless-bounce.test"),
                testing::ElementsAre("4", "4"));

    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "site_storage", "storage.test"),
        testing::ElementsAre("1", "1"));
    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "user_interaction", "storage.test"),
        testing::ElementsAre("4", "4"));

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 1, 1));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    migrator.MigrateSchemaVersionFrom1To2();
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 2);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 2);

    // Verify that all 0s were transformed to NULLs.
    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|||4|4|1|4|1|6\n"
              "site-storage-stateful-bounce-drop.test|1|1||||||\n"
              "stateful-bounce.test|||4|4|1|1|1|1\n"
              "stateless-bounce.test|||4|4|||1|1\n"
              "storage.test|1|1|4|4||||");

    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "stateful_bounce",
                                             "both-bounce-kinds.test"),
                testing::ElementsAre("1", "4"));
    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "bounce", "both-bounce-kinds.test"),
        testing::ElementsAre(
            // first_bounce_time should be the minimum of
            // first_stateful_bounce_time and first_stateless_bounce_time.
            "1",
            // last_bounce_time should be the maximum of
            // last_stateful_bounce_time and last_stateless_bounce_time.
            "6"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "user_interaction",
                                             "both-bounce-kinds.test"),
                testing::ElementsAre("4", "4"));

    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "stateful_bounce",
                                             "stateful-bounce.test"),
                testing::ElementsAre("1", "1"));
    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "bounce", "stateful-bounce.test"),
        // first_ and last_bounce_time should populate even if the old
        // *_stateless_bounce_time columns were null.
        testing::ElementsAre("1", "1"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "user_interaction",
                                             "stateful-bounce.test"),
                testing::ElementsAre("4", "4"));

    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "bounce", "stateless-bounce.test"),
        // first_ and last_bounce_time should populate even if the
        // *_stateful_bounce_times columns were null.
        testing::ElementsAre("1", "1"));
    EXPECT_THAT(GetFirstAndLastColumnForSite(&db, "user_interaction",
                                             "stateful-bounce.test"),
                testing::ElementsAre("4", "4"));

    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "site_storage", "storage.test"),
        testing::ElementsAre("1", "1"));
    EXPECT_THAT(
        GetFirstAndLastColumnForSite(&db, "user_interaction", "storage.test"),
        testing::ElementsAre("4", "4"));
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV2ToV3) {
  ASSERT_TRUE(LoadDatabase("v2.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 2);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 2);
    EXPECT_EQ(GetPrepopulatedFromMetaTable(&db), 1);

    EXPECT_FALSE(db.DoesTableExist("popups"));
    EXPECT_FALSE(db.DoesTableExist("config"));

    EXPECT_FALSE(
        db.DoesColumnExist("bounces", "first_web_authn_assertion_time"));
    EXPECT_FALSE(
        db.DoesColumnExist("bounces", "last_web_authn_assertion_time"));

    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|||4|4|1|4|2|6\n"
              "stateful-bounce.test|||4|4|1|1||\n"
              "stateless-bounce.test|||4|4|||1|1\n"
              "storage.test|1|1|4|4||||");

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 2, 2));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    migrator.MigrateSchemaVersionFrom2To3();
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 3);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 3);

    ASSERT_TRUE(
        db.DoesColumnExist("bounces", "first_web_authn_assertion_time"));
    ASSERT_TRUE(db.DoesColumnExist("bounces", "last_web_authn_assertion_time"));

    ExpectAllEntriesInColumnToBeNull(&db, "bounces",
                                     "first_web_authn_assertion_time");
    ExpectAllEntriesInColumnToBeNull(&db, "bounces",
                                     "last_web_authn_assertion_time");
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV3ToV4) {
  ASSERT_TRUE(LoadDatabase("v3.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 3);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 3);
    EXPECT_EQ(GetPrepopulatedFromMetaTable(&db), 1);

    EXPECT_FALSE(db.DoesTableExist("popups"));
    EXPECT_FALSE(db.DoesTableExist("config"));

    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|||4|4|1|4|2|6||\n"
              "stateful-bounce.test|||4|4|1|1||||\n"
              "stateless-bounce.test|||4|4|||1|1||\n"
              "storage.test|1|1|4|4||||||");

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 3, 3));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    migrator.MigrateSchemaVersionFrom3To4();
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 4);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 4);

    EXPECT_TRUE(db.DoesTableExist("popups"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "opener_site"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "popup_site"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "access_id"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "last_popup_time"));
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV4ToV5) {
  ASSERT_TRUE(LoadDatabase("v4.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 4);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 4);
    EXPECT_EQ(GetPrepopulatedFromMetaTable(&db), 1);

    EXPECT_FALSE(db.DoesTableExist("config"));

    EXPECT_TRUE(db.DoesColumnExist("popups", "opener_site"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "popup_site"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "access_id"));
    EXPECT_TRUE(db.DoesColumnExist("popups", "last_popup_time"));

    EXPECT_EQ(DbPopupsToString(&db),
              "site1.com|3p-site.com|123|2023-10-01 12:00:00\n"
              "site2.com|3p-site.com|456|2023-10-02 12:00:00");

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 4, 4));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    migrator.MigrateSchemaVersionFrom4To5();
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 5);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 5);

    ASSERT_TRUE(db.DoesColumnExist("popups", "is_current_interaction"));
    ExpectAllEntriesInColumnToBeNull(&db, "popups", "is_current_interaction");
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV5ToV6) {
  ASSERT_TRUE(LoadDatabase("v5.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    ASSERT_EQ(GetDatabaseVersion(&db), 5);
    ASSERT_EQ(GetDatabaseLastCompatibleVersion(&db), 5);
    ASSERT_EQ(GetPrepopulatedFromMetaTable(&db), 1);

    ASSERT_TRUE(db.DoesTableExist("bounces"));
    ASSERT_TRUE(db.DoesTableExist("popups"));
    ASSERT_FALSE(db.DoesTableExist("config"));

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 5, 5));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    migrator.MigrateSchemaVersionFrom5To6();
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 6);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 6);

    EXPECT_TRUE(db.DoesTableExist("config"));
    EXPECT_TRUE(db.DoesColumnExist("config", "key"));
    EXPECT_TRUE(db.DoesColumnExist("config", "int_value"));

    EXPECT_EQ(GetPrepopulatedFromMetaTable(&db), std::nullopt);
    EXPECT_EQ(GetPrepopulatedFromConfigTable(&db), 1);
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV6ToV7) {
  ASSERT_TRUE(LoadDatabase("v6.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    ASSERT_EQ(GetDatabaseVersion(&db), 6);
    ASSERT_EQ(GetDatabaseLastCompatibleVersion(&db), 6);

    ASSERT_TRUE(db.DoesTableExist("config"));
    ASSERT_TRUE(db.DoesColumnExist("config", "key"));
    ASSERT_TRUE(db.DoesColumnExist("config", "int_value"));

    ASSERT_EQ(GetPrepopulatedFromConfigTable(&db), 1);

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 6, 6));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    ASSERT_TRUE(migrator.MigrateSchemaVersionFrom6To7());
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 7);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 6);

    EXPECT_TRUE(db.DoesTableExist("config"));
    EXPECT_TRUE(db.DoesColumnExist("config", "key"));
    EXPECT_TRUE(db.DoesColumnExist("config", "int_value"));

    EXPECT_EQ(GetPrepopulatedFromConfigTable(&db), std::nullopt);
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV7ToV8) {
  ASSERT_TRUE(LoadDatabase("v7.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    ASSERT_EQ(GetDatabaseVersion(&db), 7);
    ASSERT_EQ(GetDatabaseLastCompatibleVersion(&db), 6);

    ASSERT_TRUE(db.DoesTableExist("config"));
    ASSERT_TRUE(db.DoesColumnExist("config", "key"));
    ASSERT_TRUE(db.DoesColumnExist("config", "int_value"));

    ASSERT_EQ(GetPrepopulatedFromConfigTable(&db), std::nullopt);

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 7, 6));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    ASSERT_TRUE(migrator.MigrateSchemaVersionFrom7To8());
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_EQ(GetDatabaseVersion(&db), 8);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 8);

    ASSERT_TRUE(db.DoesColumnExist("popups", "is_authentication_interaction"));
    ExpectAllEntriesInColumnToBeNull(&db, "popups",
                                     "is_authentication_interaction");
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV8ToV9) {
  ASSERT_TRUE(LoadDatabase("v8.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    ASSERT_EQ(GetDatabaseVersion(&db), 8);
    ASSERT_EQ(GetDatabaseLastCompatibleVersion(&db), 8);

    ASSERT_TRUE(db.DoesColumnExist("bounces", "first_user_interaction_time"));
    ASSERT_TRUE(db.DoesColumnExist("bounces", "last_user_interaction_time"));
    ASSERT_FALSE(db.DoesColumnExist("bounces", "first_user_activation_time"));
    ASSERT_FALSE(db.DoesColumnExist("bounces", "last_user_activation_time"));

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 8, 8));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    ASSERT_TRUE(migrator.MigrateSchemaVersionFrom8To9());
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_TRUE(db.DoesColumnExist("bounces", "first_user_activation_time"));
    EXPECT_TRUE(db.DoesColumnExist("bounces", "last_user_activation_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_user_interaction_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_user_interaction_time"));

    EXPECT_EQ(GetDatabaseVersion(&db), 9);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 9);
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV9ToV10) {
  ASSERT_TRUE(LoadDatabase("v9.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    ASSERT_EQ(GetDatabaseVersion(&db), 9);
    ASSERT_EQ(GetDatabaseLastCompatibleVersion(&db), 9);

    ASSERT_TRUE(db.DoesColumnExist("bounces", "first_site_storage_time"));
    ASSERT_TRUE(db.DoesColumnExist("bounces", "last_site_storage_time"));
    ASSERT_TRUE(db.DoesColumnExist("bounces", "first_stateful_bounce_time"));
    ASSERT_TRUE(db.DoesColumnExist("bounces", "last_stateful_bounce_time"));

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 9, 9));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    ASSERT_TRUE(migrator.MigrateSchemaVersionFrom9To10());
    ASSERT_TRUE(transaction.Commit());

    // Verify post-migration conditions.

    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_site_storage_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_site_storage_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "first_stateful_bounce_time"));
    EXPECT_FALSE(db.DoesColumnExist("bounces", "last_stateful_bounce_time"));

    EXPECT_EQ(GetDatabaseVersion(&db), 10);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 10);
  }
}

TEST_F(BtmDatabaseMigrationTest, MigrateV10ToV11) {
  ASSERT_TRUE(LoadDatabase("v10.sql"));

  {
    sql::Database db(sql::test::kTestTag);
    ASSERT_TRUE(db.Open(db_path()));

    // Verify pre-migration conditions.

    ASSERT_EQ(GetDatabaseVersion(&db), 10);
    ASSERT_EQ(GetDatabaseLastCompatibleVersion(&db), 10);
    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|4|4|2|6||\n"
              "site-storage-stateful-bounce-drop.test||||||\n"
              "stateful-bounce.test|4|4||||\n"
              "stateless-bounce.test|4|4|1|1||\n"
              "storage.test|4|4||||");

    // Migrate.

    sql::MetaTable meta_table;
    ASSERT_TRUE(meta_table.Init(&db, 10, 10));

    sql::Transaction transaction(&db);
    ASSERT_TRUE(transaction.Begin());
    BtmDatabaseMigrator migrator(&db, &meta_table);
    ASSERT_TRUE(migrator.MigrateSchemaVersionFrom10To11());
    ASSERT_TRUE(transaction.Commit());

    // Verify empty row is removed.

    EXPECT_EQ(DbBouncesToString(&db),
              "both-bounce-kinds.test|4|4|2|6||\n"
              "stateful-bounce.test|4|4||||\n"
              "stateless-bounce.test|4|4|1|1||\n"
              "storage.test|4|4||||");

    EXPECT_EQ(GetDatabaseVersion(&db), 11);
    EXPECT_EQ(GetDatabaseLastCompatibleVersion(&db), 11);
  }
}

}  // namespace content