content/browser/indexed_db/instance/database_unittest.cc

// Copyright 2013 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/indexed_db/instance/database.h"

#include <stdint.h>

#include <array>
#include <optional>
#include <set>
#include <string>
#include <utility>

#include "base/auto_reset.h"
#include "base/containers/span.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/run_loop.h"
#include "base/sequence_checker.h"
#include "base/strings/stringprintf.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/updateable_sequenced_task_runner.h"
#include "base/test/bind.h"
#include "base/test/gmock_callback_support.h"
#include "base/test/mock_callback.h"
#include "base/test/task_environment.h"
#include "components/services/storage/indexed_db/locks/partitioned_lock_manager.h"
#include "components/services/storage/privileged/mojom/indexed_db_client_state_checker.mojom.h"
#include "components/services/storage/public/cpp/buckets/bucket_locator.h"
#include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
#include "content/browser/indexed_db/indexed_db_value.h"
#include "content/browser/indexed_db/instance/backing_store.h"
#include "content/browser/indexed_db/instance/bucket_context.h"
#include "content/browser/indexed_db/instance/connection.h"
#include "content/browser/indexed_db/instance/cursor.h"
#include "content/browser/indexed_db/instance/database_callbacks.h"
#include "content/browser/indexed_db/instance/factory_client.h"
#include "content/browser/indexed_db/instance/fake_transaction.h"
#include "content/browser/indexed_db/instance/mock_factory_client.h"
#include "content/browser/indexed_db/instance/mock_file_system_access_context.h"
#include "content/browser/indexed_db/instance/transaction.h"
#include "content/browser/indexed_db/mock_mojo_indexed_db_database_callbacks.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "storage/browser/test/mock_quota_manager.h"
#include "storage/browser/test/mock_quota_manager_proxy.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"

using blink::IndexedDBDatabaseMetadata;
using blink::IndexedDBIndexKeys;
using blink::IndexedDBKey;
using blink::IndexedDBKeyPath;

namespace content::indexed_db {

namespace {
constexpr int64_t kTestObjectStoreId = 1001;
constexpr int64_t kTestIndexId = 2002;
constexpr char kTestForceCloseMessage[] =
    "The database's connection is force-closed.";

// Contains a record's keys and value that tests use to populate the database.
struct TestIDBRecord {
  TestIDBRecord(IndexedDBKey primary_key,
                const IndexedDBValue& value,
                std::optional<IndexedDBKey> index_key)
      : primary_key(std::move(primary_key)),
        value(value.Clone()),
        index_key(std::move(index_key)) {}

  TestIDBRecord(const TestIDBRecord& other) {
    primary_key = other.primary_key.Clone();
    value = other.value.Clone();
    if (other.index_key) {
      index_key = other.index_key->Clone();
    }
  }

  IndexedDBKey primary_key;
  IndexedDBValue value;
  // Optional. Tests may skip index creation.
  std::optional<IndexedDBKey> index_key;
};

// Contains the options used to create an object store.  Initializes members
// to reasonable defaults that tests may override.
struct TestObjectStoreParameters {
  int64_t object_store_id = 0;
  std::u16string name{u"store"};
  IndexedDBKeyPath key_path;
  bool auto_increment = false;
};

// Contains the options used to create an index.  Optional.  Test setup skips
// index creation when `index_id` is `kInvalidId`. Initializes members to
// reasonable defaults that tests may override.
struct TestIndexParameters {
  int64_t index_id = blink::IndexedDBIndexMetadata::kInvalidId;
  std::u16string name{u"index"};
  bool unique = false;
  bool multi_entry = false;
  IndexedDBKeyPath key_path;
  bool auto_increment = false;
};

// Describes how test setup should create and populate an object store and
// optionally an index.
struct TestDatabaseParameters {
  TestObjectStoreParameters object_store_parameters;
  TestIndexParameters index_parameters;
  std::vector<TestIDBRecord> records;
};

// Contains the arguments needed to call `Database::GetAllOperation`.
// Initializes members to reasonable defaults that tests may override.
struct TestGetAllParameters {
  blink::mojom::IDBGetAllResultType result_type =
      blink::mojom::IDBGetAllResultType::Keys;

  blink::IndexedDBKeyRange key_range;

  int64_t max_count = std::numeric_limits<int64_t>::max();

  blink::mojom::IDBCursorDirection direction =
      blink::mojom::IDBCursorDirection::Next;
};

// `Database::GetAllOperation` streams record results to a sink.  This fake
// implementation enables test to wait for all the results and inspect them.
class FakeGetAllResultSink final
    : public blink::mojom::IDBDatabaseGetAllResultSink {
 public:
  FakeGetAllResultSink() = default;

  ~FakeGetAllResultSink() final {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  }

  FakeGetAllResultSink(const FakeGetAllResultSink&) = delete;
  FakeGetAllResultSink& operator=(const FakeGetAllResultSink&) = delete;

  blink::mojom::IDBError* GetError() const {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    CHECK(is_done_);
    return error_.get();
  }

  const std::vector<blink::mojom::IDBRecordPtr>& GetResults() const {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    CHECK(is_done_);
    return records_;
  }

  void BindReceiver(
      mojo::PendingAssociatedReceiver<blink::mojom::IDBDatabaseGetAllResultSink>
          receiver) {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    CHECK(!is_done_);
    receiver_.Bind(std::move(receiver));
  }

  void WaitForResults() {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    run_loop_.Run();
    CHECK(is_done_);
  }

 private:
  void ReceiveResults(std::vector<blink::mojom::IDBRecordPtr> records,
                      bool done) final {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    CHECK(!is_done_);

    if (records_.empty()) {
      records_ = std::move(records);
    } else {
      records_.reserve(records_.size() + records.size());
      for (auto& record : records) {
        records_.emplace_back(std::move(record));
      }
    }

    if (done) {
      is_done_ = true;
      run_loop_.Quit();
    }
  }

  void OnError(blink::mojom::IDBErrorPtr error) final {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    CHECK(!is_done_);

    error_ = std::move(error);
    is_done_ = true;
    run_loop_.Quit();
  }

  SEQUENCE_CHECKER(sequence_checker_);

  mojo::AssociatedReceiver<blink::mojom::IDBDatabaseGetAllResultSink> receiver_{
      this};

  // Used to wait until all results have been received.
  base::RunLoop run_loop_;
  bool is_done_ = false;

  // Store results and error for later inspection.  Must not be accessed until
  // `is_done_` is true.
  std::vector<blink::mojom::IDBRecordPtr> records_;
  blink::mojom::IDBErrorPtr error_;
};

void ExpectEqualsIndexedDBKey(const IndexedDBKey& expected_primary_key,
                              const IndexedDBKey& actual_primary_key) {
  ASSERT_EQ(actual_primary_key.IsValid(), expected_primary_key.IsValid());

  if (expected_primary_key.IsValid()) {
    EXPECT_TRUE(actual_primary_key.Equals(expected_primary_key))
        << "Expected " << expected_primary_key.DebugString() << " but got "
        << actual_primary_key.DebugString();
  }
}

void ExpectEqualsOptionalIndexedDBKey(
    const std::optional<IndexedDBKey>& expected_primary_key,
    const std::optional<IndexedDBKey>& actual_primary_key) {
  ASSERT_EQ(actual_primary_key.has_value(), expected_primary_key.has_value());

  if (expected_primary_key.has_value()) {
    ASSERT_NO_FATAL_FAILURE(
        ExpectEqualsIndexedDBKey(*expected_primary_key, *actual_primary_key));
  }
}

void ExpectEqualsIDBReturnValuePtr(
    const blink::mojom::IDBReturnValuePtr& expected_return_value,
    const blink::mojom::IDBReturnValuePtr& actual_return_value) {
  ASSERT_EQ(actual_return_value.is_null(), expected_return_value.is_null());

  if (!expected_return_value.is_null()) {
    // Verify the value bits.
    ASSERT_EQ(actual_return_value->value.is_null(),
              expected_return_value->value.is_null());

    if (!expected_return_value->value.is_null()) {
      EXPECT_EQ(actual_return_value->value->bits,
                expected_return_value->value->bits);

      // Verify the external objects.
      EXPECT_EQ(actual_return_value->value->external_objects.size(),
                expected_return_value->value->external_objects.size());
    }

    // Verify the return value primary key and key path.
    ASSERT_NO_FATAL_FAILURE(ExpectEqualsIndexedDBKey(
        actual_return_value->primary_key, expected_return_value->primary_key));

    EXPECT_EQ(expected_return_value->key_path, actual_return_value->key_path);
  }
}

// Creates a `IDBReturnValuePtr` with the given bits. `primary_key`,
// `key_path` are optional, required only for object stores that generate keys.
// `external_objects` is not set and remains empty.
blink::mojom::IDBReturnValuePtr CreateIDBReturnValuePtr(
    const std::string& bits,
    const IndexedDBKey* primary_key = nullptr,
    IndexedDBKeyPath key_path = {}) {
  blink::mojom::IDBReturnValuePtr result = blink::mojom::IDBReturnValue::New();
  result->value = blink::mojom::IDBValue::New();
  result->value->bits.assign(bits.begin(), bits.end());
  if (primary_key) {
    result->primary_key = primary_key->Clone();
  }
  result->key_path = std::move(key_path);
  return result;
}

}  // namespace

class DatabaseTest : public ::testing::Test {
 public:
  DatabaseTest() = default;

  void SetUp() override {
    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    quota_manager_ = base::MakeRefCounted<storage::MockQuotaManager>(
        /*is_incognito=*/false, temp_dir_.GetPath(),
        base::SingleThreadTaskRunner::GetCurrentDefault(),
        /*special_storage_policy=*/nullptr);

    quota_manager_proxy_ = base::MakeRefCounted<storage::MockQuotaManagerProxy>(
        quota_manager_.get(),
        base::SingleThreadTaskRunner::GetCurrentDefault().get());

    BucketContext::Delegate delegate;
    delegate.on_ready_for_destruction =
        base::BindOnce(&DatabaseTest::OnBucketContextReadyForDestruction,
                       weak_factory_.GetWeakPtr());

    mojo::PendingRemote<storage::mojom::FileSystemAccessContext> fsa_context;
    file_system_access_context_ =
        std::make_unique<test::MockFileSystemAccessContext>();
    file_system_access_context_->Clone(
        fsa_context.InitWithNewPipeAndPassReceiver());

    bucket_context_ = std::make_unique<BucketContext>(
        storage::BucketInfo(), temp_dir_.GetPath(), std::move(delegate),
        scoped_refptr<base::UpdateableSequencedTaskRunner>(),
        quota_manager_proxy_,
        /*blob_storage_context=*/mojo::NullRemote(),
        /*file_system_access_context=*/std::move(fsa_context));

    bucket_context_->InitBackingStoreIfNeeded(true);
    db_ = bucket_context_->CreateAndAddDatabase(u"db");
  }

  void TearDown() override { db_ = nullptr; }

  void OnBucketContextReadyForDestruction() { bucket_context_.reset(); }

  void RunPostedTasks() {
    base::RunLoop run_loop;
    base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, run_loop.QuitClosure());
    run_loop.Run();
  }

 protected:
  base::test::TaskEnvironment task_environment_;

  base::ScopedTempDir temp_dir_;
  std::unique_ptr<BucketContext> bucket_context_;
  std::unique_ptr<test::MockFileSystemAccessContext>
      file_system_access_context_;
  scoped_refptr<storage::MockQuotaManager> quota_manager_;
  scoped_refptr<storage::MockQuotaManagerProxy> quota_manager_proxy_;

  // As this is owned by `bucket_context_`, tests that cause the database to
  // be destroyed must manually reset this to null to avoid triggering dangling
  // pointer warnings.
  raw_ptr<Database> db_ = nullptr;

  base::WeakPtrFactory<DatabaseTest> weak_factory_{this};
};

TEST_F(DatabaseTest, ConnectionLifecycle) {
  MockMojoDatabaseCallbacks database_callbacks;
  MockFactoryClient request1;
  const int64_t transaction_id1 = 1;
  auto connection1 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request1),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id1, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection1));
  RunPostedTasks();

  MockMojoDatabaseCallbacks database_callbacks2;
  MockFactoryClient request2;
  const int64_t transaction_id2 = 2;
  auto connection2 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request2),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks2.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id2, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection2));
  RunPostedTasks();
  db_ = nullptr;

  EXPECT_TRUE(request1.connection());
  request1.connection()->CloseAndReportForceClose(kTestForceCloseMessage);
  EXPECT_FALSE(request1.connection()->IsConnected());

  EXPECT_TRUE(request2.connection());
  request2.connection()->CloseAndReportForceClose(kTestForceCloseMessage);
  EXPECT_FALSE(request2.connection()->IsConnected());

  RunPostedTasks();

  EXPECT_TRUE(bucket_context_->GetDatabasesForTesting().empty());
}

TEST_F(DatabaseTest, ForcedClose) {
  MockMojoDatabaseCallbacks database_callbacks;
  MockFactoryClient request;
  const int64_t upgrade_transaction_id = 3;
  auto connection = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks.BindNewEndpointAndPassDedicatedRemote()),
      upgrade_transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection));
  RunPostedTasks();

  EXPECT_EQ(db_, request.connection()->database().get());

  request.connection()->CreateTransaction(
      mojo::NullAssociatedReceiver(), /*transaction_id=*/123,
      /*object_store_ids=*/{}, blink::mojom::IDBTransactionMode::ReadOnly,
      blink::mojom::IDBTransactionDurability::Relaxed);
  db_ = nullptr;

  base::RunLoop run_loop;
  EXPECT_CALL(database_callbacks, ForcedClose)
      .WillOnce(base::test::RunClosure(run_loop.QuitClosure()));
  request.connection()->CloseAndReportForceClose(kTestForceCloseMessage);
  run_loop.Run();
}

namespace {

class FakeFactoryClient : public FactoryClient {
 public:
  FakeFactoryClient() : FactoryClient(mojo::NullAssociatedRemote()) {}
  ~FakeFactoryClient() override = default;

  FakeFactoryClient(const FakeFactoryClient&) = delete;
  FakeFactoryClient& operator=(const FakeFactoryClient&) = delete;

  void OnBlocked(int64_t existing_version) override { blocked_called_ = true; }
  void OnDeleteSuccess(int64_t old_version) override { success_called_ = true; }
  void OnError(const DatabaseError& error) override { error_called_ = true; }

  bool blocked_called() const { return blocked_called_; }
  bool success_called() const { return success_called_; }
  bool error_called() const { return error_called_; }

 private:
  bool blocked_called_ = false;
  bool success_called_ = false;
  bool error_called_ = false;
};

}  // namespace

TEST_F(DatabaseTest, PendingDelete) {
  MockFactoryClient request1;
  const int64_t transaction_id1 = 1;
  MockMojoDatabaseCallbacks database_callbacks1;
  auto connection = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request1),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks1.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id1, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 0UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  base::RunLoop run_loop;
  FakeFactoryClient request2;
  db_->ScheduleDeleteDatabase(std::make_unique<ThunkFactoryClient>(request2),
                              run_loop.QuitClosure());
  RunPostedTasks();
  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  EXPECT_FALSE(request2.blocked_called());
  request1.connection()->VersionChangeIgnored();
  EXPECT_TRUE(request2.blocked_called());
  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  db_->ForceCloseAndRunTasks(kTestForceCloseMessage);
  db_ = nullptr;

  run_loop.Run();
  EXPECT_FALSE(db_);

  EXPECT_TRUE(request2.success_called());
}

TEST_F(DatabaseTest, OpenDeleteClear) {
  const int64_t kDatabaseVersion = 1;

  MockFactoryClient request1(
      /*expect_connection=*/true);
  MockMojoDatabaseCallbacks database_callbacks1;
  const int64_t transaction_id1 = 1;
  auto connection1 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request1),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks1.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id1, kDatabaseVersion, mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection1));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  MockFactoryClient request2(
      /*expect_connection=*/false);
  MockMojoDatabaseCallbacks database_callbacks2;
  const int64_t transaction_id2 = 2;
  auto connection2 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request2),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks2.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id2, kDatabaseVersion, mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection2));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 1UL);

  MockFactoryClient request3(
      /*expect_connection=*/false);
  MockMojoDatabaseCallbacks database_callbacks3;
  const int64_t transaction_id3 = 3;
  auto connection3 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request3),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks3.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id3, kDatabaseVersion, mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection3));
  RunPostedTasks();

  EXPECT_TRUE(request1.upgrade_called());

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 2UL);

  EXPECT_CALL(database_callbacks1, ForcedClose);
  EXPECT_CALL(database_callbacks2, ForcedClose);
  EXPECT_CALL(database_callbacks3, ForcedClose);

  db_->ForceCloseAndRunTasks(kTestForceCloseMessage);
  db_ = nullptr;
  database_callbacks1.FlushForTesting();

  EXPECT_TRUE(request1.error_called());
  EXPECT_TRUE(request2.error_called());
  EXPECT_TRUE(request3.error_called());
}

TEST_F(DatabaseTest, ForceDelete) {
  MockFactoryClient request1;
  MockMojoDatabaseCallbacks database_callbacks;
  const int64_t transaction_id1 = 1;
  auto connection = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request1),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id1, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 0UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  base::RunLoop run_loop;
  FakeFactoryClient request2;
  db_->ScheduleDeleteDatabase(std::make_unique<ThunkFactoryClient>(request2),
                              run_loop.QuitClosure());
  RunPostedTasks();
  EXPECT_FALSE(run_loop.AnyQuitCalled());
  db_->ForceCloseAndRunTasks(kTestForceCloseMessage);
  db_ = nullptr;
  run_loop.Run();
  EXPECT_FALSE(db_);
  EXPECT_FALSE(request2.blocked_called());
  EXPECT_TRUE(request2.success_called());
}

TEST_F(DatabaseTest, ForceCloseWhileOpenPending) {
  // Verify that pending connection requests are handled correctly during a
  // ForceClose.
  MockFactoryClient request1;
  MockMojoDatabaseCallbacks database_callbacks1;
  const int64_t transaction_id1 = 1;
  auto connection1 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request1),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks1.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id1, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection1));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 0UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  MockFactoryClient request2(/*expect_connection=*/false);
  MockMojoDatabaseCallbacks database_callbacks2;

  const int64_t transaction_id2 = 2;
  auto connection2 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request2),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks2.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id2, 3, mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection2));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  db_->ForceCloseAndRunTasks(kTestForceCloseMessage);
  db_ = nullptr;
  RunPostedTasks();
  EXPECT_FALSE(db_);
}

TEST_F(DatabaseTest, ForceCloseWhileOpenAndDeletePending) {
  // Verify that pending connection requests are handled correctly during a
  // ForceClose.
  MockFactoryClient request1;
  MockMojoDatabaseCallbacks database_callbacks1;
  const int64_t transaction_id1 = 1;
  auto connection1 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request1),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks1.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id1, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
      mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection1));
  RunPostedTasks();

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 0UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 0UL);

  MockFactoryClient request2(false);
  MockMojoDatabaseCallbacks database_callbacks2;
  const int64_t transaction_id2 = 2;
  auto connection2 = std::make_unique<PendingConnection>(
      std::make_unique<ThunkFactoryClient>(request2),
      std::make_unique<DatabaseCallbacks>(
          database_callbacks2.BindNewEndpointAndPassDedicatedRemote()),
      transaction_id2, 3, mojo::NullAssociatedReceiver());
  db_->ScheduleOpenConnection(std::move(connection2));
  RunPostedTasks();

  base::RunLoop run_loop;
  auto request3 = std::make_unique<FakeFactoryClient>();
  db_->ScheduleDeleteDatabase(std::move(request3), run_loop.QuitClosure());
  RunPostedTasks();
  EXPECT_FALSE(run_loop.AnyQuitCalled());

  EXPECT_EQ(db_->ConnectionCount(), 1UL);
  EXPECT_EQ(db_->ActiveOpenDeleteCount(), 1UL);
  EXPECT_EQ(db_->PendingOpenDeleteCount(), 1UL);

  db_->ForceCloseAndRunTasks(kTestForceCloseMessage);
  db_ = nullptr;
  run_loop.Run();
}

Status DummyOperation(Transaction* transaction) {
  return Status::OK();
}

class DatabaseOperationTest : public DatabaseTest {
 public:
  DatabaseOperationTest() = default;
  DatabaseOperationTest(const DatabaseOperationTest&) = delete;
  DatabaseOperationTest& operator=(const DatabaseOperationTest&) = delete;

  void SetUp() override {
    DatabaseTest::SetUp();

    const int64_t transaction_id = 1;
    auto connection = std::make_unique<PendingConnection>(
        std::make_unique<ThunkFactoryClient>(request_),
        std::make_unique<DatabaseCallbacks>(mojo::NullAssociatedRemote()),
        transaction_id, IndexedDBDatabaseMetadata::DEFAULT_VERSION,
        mojo::NullAssociatedReceiver());
    db_->ScheduleOpenConnection(std::move(connection));
    RunPostedTasks();
    EXPECT_EQ(IndexedDBDatabaseMetadata::NO_VERSION, db_->metadata().version);

    EXPECT_TRUE(request_.connection());
    transaction_ = request_.connection()->CreateVersionChangeTransaction(
        transaction_id, /*scope=*/std::set<int64_t>(),
        std::make_unique<FakeTransaction>(
            commit_success_,
            db_->backing_store_db()->CreateTransaction(
                blink::mojom::IDBTransactionDurability::Relaxed,
                blink::mojom::IDBTransactionMode::VersionChange)));

    std::vector<PartitionedLockManager::PartitionedLockRequest> lock_requests =
        db_->BuildLockRequestsForTransaction(
            blink::mojom::IDBTransactionMode::VersionChange, /*scope=*/{});
    db_->lock_manager().AcquireLocks(
        std::move(lock_requests), *transaction_->mutable_locks_receiver(),
        base::BindOnce(&Transaction::Start, transaction_->AsWeakPtr()));

    // Add a dummy task which takes the place of the VersionChangeOperation
    // which kicks off the upgrade. This ensures that the transaction has
    // processed at least one task before the CreateObjectStore call.
    transaction_->ScheduleTask(base::BindOnce(&DummyOperation));
    // Run posted tasks to execute the dummy operation and ensure that it is
    // stored in the connection.
    RunPostedTasks();
  }

  // Populates an object store and optionally an index with `database_records`.
  // After setup, calls `Database::GetAllOperation` with `get_all_parameters`.
  // Verifies that the results match `expected_results`.
  void TestGetAll(
      TestDatabaseParameters database_parameters,
      TestGetAllParameters get_all_parameters,
      base::span<const blink::mojom::IDBRecordPtr> expected_results) {
    // Create the object store.
    ASSERT_EQ(0u, db_->metadata().object_stores.size());
    const auto& object_store_parameters =
        database_parameters.object_store_parameters;
    const int64_t store_id = object_store_parameters.object_store_id;
    Status status = transaction_->BackingStoreTransaction()->CreateObjectStore(
        store_id, object_store_parameters.name,
        object_store_parameters.key_path,
        object_store_parameters.auto_increment);
    EXPECT_TRUE(status.ok()) << status.ToString();
    EXPECT_EQ(1u, db_->metadata().object_stores.size());

    // Optionally, create an index when the test provides a valid index id.
    const blink::IndexedDBIndexMetadata index(
        database_parameters.index_parameters.name,
        database_parameters.index_parameters.index_id,
        database_parameters.index_parameters.key_path,
        database_parameters.index_parameters.unique,
        database_parameters.index_parameters.multi_entry);
    const int64_t index_id = index.id;
    const bool has_index =
        index_id != blink::IndexedDBIndexMetadata::kInvalidId;
    if (has_index) {
      status =
          transaction_->BackingStoreTransaction()->CreateIndex(store_id, index);
    }
    EXPECT_TRUE(status.ok()) << status.ToString();

    // Populate the object store and optionally the index with the provided
    // records.
    for (TestIDBRecord& record : database_parameters.records) {
      std::vector<IndexedDBIndexKeys> index_keys;
      ASSERT_EQ(record.index_key.has_value(), has_index);
      if (has_index) {
        IndexedDBIndexKeys index_key{index_id, {}};
        index_key.keys.emplace_back(std::move(*record.index_key));
        index_keys.emplace_back(std::move(index_key));
      }

      testing::NiceMock<
          base::MockCallback<blink::mojom::IDBTransaction::PutCallback>>
          callback;

      // Set in-flight memory to a reasonably large number to prevent underflow
      // in `PutOperation`
      transaction_->in_flight_memory_ += 1000;

      status = transaction_->DoPut(
          store_id, record.value.Clone(), std::move(record.primary_key),
          blink::mojom::IDBPutMode::AddOnly, std::move(index_keys),
          callback.Get(), transaction_);
      EXPECT_TRUE(status.ok()) << status.ToString();
    }

    // Call `Database::GetAllOperation` with the provided parameters.
    FakeGetAllResultSink result_sink;
    blink::mojom::IDBDatabase::GetAllCallback get_all_callback = base::BindOnce(
        &FakeGetAllResultSink::BindReceiver, base::Unretained(&result_sink));

    std::unique_ptr<Database::GetAllResultSinkWrapper> result_sink_wrapper =
        std::make_unique<Database::GetAllResultSinkWrapper>(
            transaction_->AsWeakPtr(), std::move(get_all_callback));
    result_sink_wrapper->UseDedicatedReceiverForTesting();

    status = db_->GetAllOperation(
        store_id, index_id, std::move(get_all_parameters.key_range),
        get_all_parameters.result_type, get_all_parameters.max_count,
        get_all_parameters.direction, std::move(result_sink_wrapper),
        transaction_);
    EXPECT_TRUE(status.ok()) << status.ToString();

    result_sink.WaitForResults();
    EXPECT_EQ(result_sink.GetError(), nullptr);

    // Verify that the actual results match the expected results.
    const std::vector<blink::mojom::IDBRecordPtr>& actual_results =
        result_sink.GetResults();
    ASSERT_EQ(actual_results.size(), expected_results.size());

    for (size_t i = 0u; i < expected_results.size(); ++i) {
      ASSERT_FALSE(actual_results[i].is_null());

      // Verify the primary key.
      ASSERT_NO_FATAL_FAILURE(ExpectEqualsOptionalIndexedDBKey(
          expected_results[i]->primary_key, actual_results[i]->primary_key));

      // Verify the record value.
      ASSERT_NO_FATAL_FAILURE(ExpectEqualsIDBReturnValuePtr(
          expected_results[i]->return_value, actual_results[i]->return_value));

      // Verify the index key.
      ASSERT_NO_FATAL_FAILURE(ExpectEqualsOptionalIndexedDBKey(
          expected_results[i]->index_key, actual_results[i]->index_key));
    }

    // Perform cleanup.
    transaction_->SetCommitFlag();
    transaction_ = nullptr;
    RunPostedTasks();

    // A transaction error would have resulted in a deleted db.
    EXPECT_FALSE(bucket_context_->GetDatabasesForTesting().empty());
  }

 protected:
  MockFactoryClient request_;

  // As this is owned by `Connection`, tests that cause the transaction
  // to be committed must manually reset this to null to avoid triggering
  // dangling pointer warnings.
  raw_ptr<Transaction> transaction_ = nullptr;
  Status commit_success_;
};

TEST_F(DatabaseOperationTest, CreateObjectStore) {
  EXPECT_EQ(0ULL, db_->metadata().object_stores.size());
  const int64_t store_id = 1001;
  Status s = transaction_->BackingStoreTransaction()->CreateObjectStore(
      store_id, u"store", IndexedDBKeyPath(),
      /*auto_increment=*/false);
  EXPECT_TRUE(s.ok());
  transaction_->SetCommitFlag();
  transaction_ = nullptr;
  RunPostedTasks();
  EXPECT_TRUE(bucket_context_);
  EXPECT_EQ(1ULL, db_->metadata().object_stores.size());
}

TEST_F(DatabaseOperationTest, CreateIndex) {
  EXPECT_EQ(0ULL, db_->metadata().object_stores.size());
  const int64_t store_id = 1001;
  Status s = transaction_->BackingStoreTransaction()->CreateObjectStore(
      store_id, u"store", IndexedDBKeyPath(),
      /*auto_increment=*/false);
  EXPECT_TRUE(s.ok());
  EXPECT_EQ(1ULL, db_->metadata().object_stores.size());
  const int64_t index_id = 2002;
  s = transaction_->BackingStoreTransaction()->CreateIndex(
      store_id, blink::IndexedDBIndexMetadata(
                    u"index", index_id, IndexedDBKeyPath(), /*unique=*/false,
                    /*multi_entry=*/false));
  EXPECT_TRUE(s.ok());
  EXPECT_EQ(
      1ULL,
      db_->metadata().object_stores.find(store_id)->second.indexes.size());
  transaction_->SetCommitFlag();
  transaction_ = nullptr;
  RunPostedTasks();
  EXPECT_TRUE(bucket_context_);
  EXPECT_EQ(1ULL, db_->metadata().object_stores.size());
  EXPECT_EQ(
      1ULL,
      db_->metadata().object_stores.find(store_id)->second.indexes.size());
}

class DatabaseOperationAbortTest : public DatabaseOperationTest {
 public:
  DatabaseOperationAbortTest() {
    commit_success_ = Status::NotFound("Bummer.");
  }

  DatabaseOperationAbortTest(const DatabaseOperationAbortTest&) = delete;
  DatabaseOperationAbortTest& operator=(const DatabaseOperationAbortTest&) =
      delete;
};

TEST_F(DatabaseOperationAbortTest, CreateObjectStore) {
  EXPECT_EQ(0ULL, db_->metadata().object_stores.size());
  const int64_t store_id = 1001;
  Status s = transaction_->BackingStoreTransaction()->CreateObjectStore(
      store_id, u"store", IndexedDBKeyPath(),
      /*auto_increment=*/false);
  EXPECT_TRUE(s.ok());
  EXPECT_EQ(1ULL, db_->metadata().object_stores.size());
  db_ = nullptr;
  transaction_->SetCommitFlag();
  RunPostedTasks();
  // A transaction error results in a deleted db.
  EXPECT_TRUE(bucket_context_->GetDatabasesForTesting().empty());
}

TEST_F(DatabaseOperationAbortTest, CreateIndex) {
  EXPECT_EQ(0ULL, db_->metadata().object_stores.size());
  const int64_t store_id = 1001;
  Status s = transaction_->BackingStoreTransaction()->CreateObjectStore(
      store_id, u"store", IndexedDBKeyPath(),
      /*auto_increment=*/false);
  EXPECT_TRUE(s.ok());
  EXPECT_EQ(1ULL, db_->metadata().object_stores.size());
  const int64_t index_id = 2002;
  s = transaction_->BackingStoreTransaction()->CreateIndex(
      store_id, blink::IndexedDBIndexMetadata(
                    u"index", index_id, IndexedDBKeyPath(), /*unique=*/false,
                    /*multi_entry=*/false));
  EXPECT_TRUE(s.ok());
  EXPECT_EQ(
      1ULL,
      db_->metadata().object_stores.find(store_id)->second.indexes.size());
  db_ = nullptr;
  transaction_->SetCommitFlag();
  RunPostedTasks();
  // A transaction error results in a deleted db.
  EXPECT_TRUE(bucket_context_->GetDatabasesForTesting().empty());
}

TEST_F(DatabaseOperationTest, CreatePutDelete) {
  EXPECT_EQ(0ULL, db_->metadata().object_stores.size());
  const int64_t store_id = 1001;

  Status s = transaction_->BackingStoreTransaction()->CreateObjectStore(
      store_id, u"store", IndexedDBKeyPath(),
      /*auto_increment=*/false);
  EXPECT_TRUE(s.ok());
  EXPECT_EQ(1ULL, db_->metadata().object_stores.size());

  base::MockCallback<blink::mojom::IDBTransaction::PutCallback> callback;

  // Set in-flight memory to a reasonably large number to prevent underflow in
  // `PutOperation`
  transaction_->in_flight_memory_ += 1000;

  s = transaction_->DoPut(
      store_id, IndexedDBValue("value1", {}), IndexedDBKey("key"),
      blink::mojom::IDBPutMode::AddOnly, std::vector<IndexedDBIndexKeys>(),
      callback.Get(), transaction_);
  EXPECT_TRUE(s.ok());

  s = transaction_->BackingStoreTransaction()->DeleteObjectStore(store_id);
  EXPECT_TRUE(s.ok());

  EXPECT_EQ(0ULL, db_->metadata().object_stores.size());

  transaction_->SetCommitFlag();
  transaction_ = nullptr;
  RunPostedTasks();
  // A transaction error would have resulted in a deleted db.
  EXPECT_FALSE(bucket_context_->GetDatabasesForTesting().empty());
  EXPECT_TRUE(s.ok());
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeysWhenEmpty) {
  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/{},
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
      },
      /*expected_results=*/{}));
}

TEST_F(DatabaseOperationTest, IndexGetAllValuesWhenEmpty) {
  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/{},
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Values,
      },
      /*expected_results=*/{}));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeys) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key3"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllValues) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(
          /*primary_key=*/std::nullopt,
          /*value=*/CreateIDBReturnValuePtr("value1"),
          /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(
          /*primary_key=*/std::nullopt,
          /*value=*/CreateIDBReturnValuePtr("value2"),
          /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(
          /*primary_key=*/std::nullopt,
          /*value=*/CreateIDBReturnValuePtr("value3"),
          /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Values,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllRecords) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/CreateIDBReturnValuePtr("value1"),
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/CreateIDBReturnValuePtr("value2"),
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key3"},
                                   /*value=*/CreateIDBReturnValuePtr("value3"),
                                   /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, IndexGetAllKeys) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key3"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  IndexedDBKey("index_key1"),
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, IndexGetAllValues) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(
          /*primary_key=*/std::nullopt,
          /*value=*/CreateIDBReturnValuePtr("value3"),
          /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(
          /*primary_key=*/std::nullopt,
          /*value=*/CreateIDBReturnValuePtr("value2"),
          /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(
          /*primary_key=*/std::nullopt,
          /*value=*/CreateIDBReturnValuePtr("value1"),
          /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  IndexedDBKey("index_key1"),
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Values,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, IndexGetAllRecords) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key3"},
                                   /*value=*/CreateIDBReturnValuePtr("value3"),
                                   IndexedDBKey{"index_key1"}),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/CreateIDBReturnValuePtr("value2"),
                                   IndexedDBKey{"index_key2"}),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/CreateIDBReturnValuePtr("value1"),
                                   IndexedDBKey{"index_key3"}),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  IndexedDBKey("index_key1"),
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeysWithRange) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key3"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
          .key_range =
              {
                  IndexedDBKey("key2"),
                  IndexedDBKey("key9"),
                  /*lower_open=*/false,
                  /*upper_open=*/false,
              },
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeysWithRangeThatDoesNotExist) {
  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
          .key_range =
              {
                  IndexedDBKey("key7"),
                  IndexedDBKey("key9"),
                  /*lower_open=*/false,
                  /*upper_open=*/false,
              },
      },
      /*expected_results=*/{}));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeysWithInvalidRange) {
  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
          .key_range =
              {
                  IndexedDBKey("key9"),
                  IndexedDBKey("key7"),
                  /*lower_open=*/false,
                  /*upper_open=*/false,
              },
      },
      /*expected_results=*/{}));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeysWithMaxCount) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/nullptr,
                                   /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Keys,
          .max_count = 2,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllRecordsWithPrevDirection) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key3"},
                                   /*value=*/CreateIDBReturnValuePtr("value3"),
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/CreateIDBReturnValuePtr("value2"),
                                   /*index_key=*/std::nullopt),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/CreateIDBReturnValuePtr("value1"),
                                   /*index_key=*/std::nullopt),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  /*index_key=*/std::nullopt,
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
          .direction = blink::mojom::IDBCursorDirection::Prev,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, IndexGetAllRecordsWithNextNoDuplicateDirection) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/CreateIDBReturnValuePtr("value1"),
                                   IndexedDBKey{"index_key1"}),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/CreateIDBReturnValuePtr("value2"),
                                   IndexedDBKey{"index_key2"}),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key4"},
                                   /*value=*/CreateIDBReturnValuePtr("value4"),
                                   IndexedDBKey{"index_key3"}),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  IndexedDBKey("index_key1"),
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key4"},
                  {"value4", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key5"},
                  {"value5", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key6"},
                  {"value6", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
          .direction = blink::mojom::IDBCursorDirection::NextNoDuplicate,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, IndexGetAllRecordsWithPrevNoDuplicateDirection) {
  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(IndexedDBKey{"key4"},
                                   /*value=*/CreateIDBReturnValuePtr("value4"),
                                   IndexedDBKey{"index_key3"}),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key2"},
                                   /*value=*/CreateIDBReturnValuePtr("value2"),
                                   IndexedDBKey{"index_key2"}),
      blink::mojom::IDBRecord::New(IndexedDBKey{"key1"},
                                   /*value=*/CreateIDBReturnValuePtr("value1"),
                                   IndexedDBKey{"index_key1"}),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/
          {
              {
                  IndexedDBKey{"key1"},
                  {"value1", /*external_objects=*/{}},
                  IndexedDBKey("index_key1"),
              },
              {
                  IndexedDBKey{"key2"},
                  {"value2", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key3"},
                  {"value3", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  IndexedDBKey{"key4"},
                  {"value4", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key5"},
                  {"value5", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  IndexedDBKey{"key6"},
                  {"value6", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
          .direction = blink::mojom::IDBCursorDirection::PrevNoDuplicate,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, ObjectStoreGetAllKeysWithInvalidObjectStoreId) {
  ASSERT_EQ(0u, db_->metadata().object_stores.size());

  // Call `Database::GetAllOperation` with an invalid object store id, which
  // must fail with an invalid argument status.
  FakeGetAllResultSink result_sink;
  blink::mojom::IDBDatabase::GetAllCallback get_all_callback = base::BindOnce(
      &FakeGetAllResultSink::BindReceiver, base::Unretained(&result_sink));

  std::unique_ptr<Database::GetAllResultSinkWrapper> result_sink_wrapper =
      std::make_unique<Database::GetAllResultSinkWrapper>(
          transaction_->AsWeakPtr(), std::move(get_all_callback));
  result_sink_wrapper->UseDedicatedReceiverForTesting();

  TestGetAllParameters get_all_parameters;

  Status status = db_->GetAllOperation(
      kTestObjectStoreId,
      /*index_id=*/blink::IndexedDBIndexMetadata::kInvalidId,
      std::move(get_all_parameters.key_range), get_all_parameters.result_type,
      get_all_parameters.max_count, get_all_parameters.direction,
      std::move(result_sink_wrapper), transaction_);
  ASSERT_TRUE(status.IsInvalidArgument()) << status.ToString();

  // Verify that the result sink received an error.
  result_sink.WaitForResults();
  ASSERT_NE(result_sink.GetError(), nullptr);
  EXPECT_EQ(result_sink.GetError()->error_code,
            blink::mojom::IDBException::kUnknownError);

  // Perform cleanup.
  transaction_->SetCommitFlag();
  transaction_ = nullptr;
  RunPostedTasks();
}

TEST_F(DatabaseOperationTest, IndexGetAllKeysWithInvalidIndexId) {
  // Create an object store.
  ASSERT_EQ(0u, db_->metadata().object_stores.size());
  Status status = transaction_->BackingStoreTransaction()->CreateObjectStore(
      kTestObjectStoreId, u"store", IndexedDBKeyPath(),
      /*auto_increment=*/false);
  ASSERT_TRUE(status.ok()) << status.ToString();
  ASSERT_EQ(1u, db_->metadata().object_stores.size());

  // Call `Database::GetAllOperation` with an invalid index id, which must fail
  // with an invalid argument status.
  FakeGetAllResultSink result_sink;
  blink::mojom::IDBDatabase::GetAllCallback get_all_callback = base::BindOnce(
      &FakeGetAllResultSink::BindReceiver, base::Unretained(&result_sink));

  std::unique_ptr<Database::GetAllResultSinkWrapper> result_sink_wrapper =
      std::make_unique<Database::GetAllResultSinkWrapper>(
          transaction_->AsWeakPtr(), std::move(get_all_callback));
  result_sink_wrapper->UseDedicatedReceiverForTesting();

  TestGetAllParameters get_all_parameters;

  status = db_->GetAllOperation(
      kTestObjectStoreId, kTestIndexId, std::move(get_all_parameters.key_range),
      get_all_parameters.result_type, get_all_parameters.max_count,
      get_all_parameters.direction, std::move(result_sink_wrapper),
      transaction_);
  ASSERT_TRUE(status.IsInvalidArgument()) << status.ToString();

  // Verify that the result sink received an error.
  result_sink.WaitForResults();
  ASSERT_NE(result_sink.GetError(), nullptr);
  EXPECT_EQ(result_sink.GetError()->error_code,
            blink::mojom::IDBException::kUnknownError);

  // Perform cleanup.
  transaction_->SetCommitFlag();
  transaction_ = nullptr;
  RunPostedTasks();
}

TEST_F(DatabaseOperationTest,
       ObjectStoreGetAllRecordsWithMultipleResultChunks) {
  // Generate 2.5 chunks of results.
  const size_t record_count = (blink::mojom::kIDBGetAllChunkSize * 2) +
                              (blink::mojom::kIDBGetAllChunkSize / 2);

  std::vector<TestIDBRecord> database_records;
  std::vector<blink::mojom::IDBRecordPtr> expected_results;

  for (size_t i = 0u; i < record_count; ++i) {
    const std::string primary_key = base::StringPrintf("key%zu", i);
    const std::string value = base::StringPrintf("value%zu", i);

    database_records.emplace_back(IndexedDBKey{primary_key},
                                  IndexedDBValue{value, {}},
                                  /*index_key=*/std::nullopt);

    expected_results.emplace_back(
        blink::mojom::IDBRecord::New(IndexedDBKey{primary_key},
                                     /*value=*/CreateIDBReturnValuePtr(value),
                                     /*index_key=*/std::nullopt));
  }

  // Sort the expected results by primary key.
  std::sort(expected_results.begin(), expected_results.end(),
            [](const blink::mojom::IDBRecordPtr& left,
               const blink::mojom::IDBRecordPtr& right) {
              return left->primary_key->IsLessThan(*right->primary_key);
            });

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
          },
          /*index_parameters=*/{},
          std::move(database_records),
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
      },
      expected_results));
}

TEST_F(DatabaseOperationTest, IndexGetAllRecordsWithAutoIncrementingKeys) {
  const IndexedDBKeyPath object_store_key_path{u"id"};

  const auto expected_generated_keys = std::to_array<IndexedDBKey>({
      IndexedDBKey(1.0, blink::mojom::IDBKeyType::Number),
      IndexedDBKey(2.0, blink::mojom::IDBKeyType::Number),
      IndexedDBKey(3.0, blink::mojom::IDBKeyType::Number),
  });

  const blink::mojom::IDBRecordPtr expected_results[] = {
      blink::mojom::IDBRecord::New(
          /*primary_key=*/expected_generated_keys[2].Clone(),
          /*value=*/
          CreateIDBReturnValuePtr("value3", &expected_generated_keys[2],
                                  object_store_key_path),
          /*index_key=*/IndexedDBKey{"index_key1"}),
      blink::mojom::IDBRecord::New(
          /*primary_key=*/expected_generated_keys[1].Clone(),
          /*value=*/
          CreateIDBReturnValuePtr("value2", &expected_generated_keys[1],
                                  object_store_key_path),
          /*index_key=*/IndexedDBKey{"index_key2"}),
      blink::mojom::IDBRecord::New(
          /*primary_key=*/expected_generated_keys[0].Clone(),
          /*value=*/
          CreateIDBReturnValuePtr("value1", &expected_generated_keys[0],
                                  object_store_key_path),
          /*index_key=*/IndexedDBKey{"index_key3"}),
  };

  ASSERT_NO_FATAL_FAILURE(TestGetAll(
      /*database_parameters=*/
      {
          /*object_store_parameters=*/
          {
              .object_store_id = kTestObjectStoreId,
              .key_path = object_store_key_path,
              .auto_increment = true,
          },
          /*index_parameters=*/
          {
              .index_id = kTestIndexId,
          },
          /*database_records=*/
          {
              {
                  /*primary_key (generated)=*/IndexedDBKey(),
                  {"value1", /*external_objects=*/{}},
                  IndexedDBKey("index_key3"),
              },
              {
                  /*primary_key (generated)=*/IndexedDBKey(),
                  {"value2", /*external_objects=*/{}},
                  IndexedDBKey("index_key2"),
              },
              {
                  /*primary_key (generated)=*/IndexedDBKey(),
                  {"value3", /*external_objects=*/{}},
                  IndexedDBKey("index_key1"),
              },
          },
      },
      /*get_all_parameters=*/
      {
          .result_type = blink::mojom::IDBGetAllResultType::Records,
      },
      expected_results));
}

}  // namespace content::indexed_db