File: pairer_broker_impl_unittest.cc

package info (click to toggle)
chromium 139.0.7258.127-1
links: PTS, VCS
area: main
in suites:
size: 6,122,068 kB
sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (909 lines) | stat: -rw-r--r-- 35,728 bytes
parent folder | download | duplicates (6)
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/quick_pair/pairing/pairer_broker_impl.h"
#include "ash/constants/ash_features.h"
#include "ash/quick_pair/common/account_key_failure.h"
#include "ash/quick_pair/common/device.h"
#include "ash/quick_pair/common/fake_bluetooth_adapter.h"
#include "ash/quick_pair/common/fast_pair/fast_pair_metrics.h"
#include "ash/quick_pair/common/pair_failure.h"
#include "ash/quick_pair/common/protocol.h"
#include "ash/quick_pair/fast_pair_handshake/fake_fast_pair_data_encryptor.h"
#include "ash/quick_pair/fast_pair_handshake/fake_fast_pair_gatt_service_client.h"
#include "ash/quick_pair/fast_pair_handshake/fake_fast_pair_handshake.h"
#include "ash/quick_pair/fast_pair_handshake/fake_fast_pair_handshake_lookup.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_data_encryptor.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_data_encryptor_impl.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_gatt_service_client.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_gatt_service_client_impl.h"
#include "ash/quick_pair/fast_pair_handshake/fast_pair_handshake_lookup.h"
#include "ash/quick_pair/pairing/fast_pair/fast_pair_pairer.h"
#include "ash/quick_pair/pairing/fast_pair/fast_pair_pairer_impl.h"
#include "ash/test/ash_test_base.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/mock_callback.h"
#include "base/test/scoped_feature_list.h"
#include "device/bluetooth/bluetooth_adapter.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/test/mock_bluetooth_adapter.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {

constexpr char kValidModelId[] = "718c17";
constexpr char kTestDeviceAddress[] = "test_address";
constexpr char kTestDeviceAddress2[] = "test_address_2";
constexpr char kDeviceName[] = "test_device_name";
constexpr char kBluetoothCanonicalizedAddress[] = "0C:0E:4C:C8:05:08";
const uint8_t kValidPasskey = 13;
constexpr base::TimeDelta kCancelPairingRetryDelay = base::Seconds(1);

const char kFastPairRetryCountMetricName[] =
    "Bluetooth.ChromeOS.FastPair.PairRetry.Count";
constexpr char kInitializePairingProcessInitial[] =
    "FastPair.InitialPairing.Initialization";
constexpr char kInitializePairingProcessSubsequent[] =
    "FastPair.SubsequentPairing.Initialization";
constexpr char kInitializePairingProcessRetroactive[] =
    "FastPair.RetroactivePairing.Initialization";
constexpr char kInitializePairingProcessFailureReasonInitial[] =
    "FastPair.InitialPairing.Initialization.FailureReason";
constexpr char kInitializePairingProcessFailureReasonSubsequent[] =
    "FastPair.SubsequentPairing.Initialization.FailureReason";
constexpr char kInitializePairingProcessFailureReasonRetroactive[] =
    "FastPair.RetroactivePairing.Initialization.FailureReason";

constexpr char kProtocolPairingStepInitial[] =
    "FastPair.InitialPairing.Pairing";
constexpr char kProtocolPairingStepSubsequent[] =
    "FastPair.SubsequentPairing.Pairing";
const char kHandshakeEffectiveSuccessRate[] =
    "FastPair.Handshake.EffectiveSuccessRate";
const char kHandshakeAttemptCount[] = "FastPair.Handshake.AttemptCount";

class FakeFastPairPairer : public ash::quick_pair::FastPairPairer {
 public:
  FakeFastPairPairer(
      scoped_refptr<device::BluetoothAdapter> adapter,
      scoped_refptr<ash::quick_pair::Device> device,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>)>
          paired_callback,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>,
                              ash::quick_pair::PairFailure)>
          pair_failed_callback,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>,
                              ash::quick_pair::AccountKeyFailure)>
          account_key_failure_callback,
      base::OnceCallback<void(std::u16string, uint32_t)> display_passkey,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>)>
          pairing_procedure_complete)
      : adapter_(adapter),
        device_(device),
        paired_callback_(std::move(paired_callback)),
        pair_failed_callback_(std::move(pair_failed_callback)),
        account_key_failure_callback_(std::move(account_key_failure_callback)),
        display_passkey_(std::move(display_passkey)),
        pairing_procedure_complete_(std::move(pairing_procedure_complete)) {}

  ~FakeFastPairPairer() override = default;

  void TriggerPairedCallback() {
    EXPECT_TRUE(paired_callback_);
    std::move(paired_callback_).Run(device_);
  }

  void TriggerPairingProcedureCompleteCallback() {
    EXPECT_TRUE(pairing_procedure_complete_);
    std::move(pairing_procedure_complete_).Run(device_);
  }

  void TriggerAccountKeyFailureCallback(
      ash::quick_pair::AccountKeyFailure failure) {
    EXPECT_TRUE(account_key_failure_callback_);
    std::move(account_key_failure_callback_).Run(device_, failure);
  }

  void TriggerPairFailureCallback(ash::quick_pair::PairFailure failure) {
    EXPECT_TRUE(pair_failed_callback_);
    std::move(pair_failed_callback_).Run(device_, failure);
  }

  void TriggerDisplayPasskeyCallback() {
    EXPECT_TRUE(display_passkey_);
    std::move(display_passkey_).Run(std::u16string(), kValidPasskey);
  }

 private:
  scoped_refptr<device::BluetoothAdapter> adapter_;
  scoped_refptr<ash::quick_pair::Device> device_;
  base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>)>
      paired_callback_;
  base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>,
                          ash::quick_pair::PairFailure)>
      pair_failed_callback_;
  base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>,
                          ash::quick_pair::AccountKeyFailure)>
      account_key_failure_callback_;
  base::OnceCallback<void(std::u16string, uint32_t)> display_passkey_;
  base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>)>
      pairing_procedure_complete_;
};

class FakeFastPairPairerFactory
    : public ash::quick_pair::FastPairPairerImpl::Factory {
 public:
  std::unique_ptr<ash::quick_pair::FastPairPairer> CreateInstance(
      scoped_refptr<device::BluetoothAdapter> adapter,
      scoped_refptr<ash::quick_pair::Device> device,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>)>
          paired_callback,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>,
                              ash::quick_pair::PairFailure)>
          pair_failed_callback,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>,
                              ash::quick_pair::AccountKeyFailure)>
          account_key_failure_callback,
      base::OnceCallback<void(std::u16string, uint32_t)> display_passkey,
      base::OnceCallback<void(scoped_refptr<ash::quick_pair::Device>)>
          pairing_procedure_complete) override {
    auto fake_fast_pair_pairer = std::make_unique<FakeFastPairPairer>(
        std::move(adapter), std::move(device), std::move(paired_callback),
        std::move(pair_failed_callback),
        std::move(account_key_failure_callback), std::move(display_passkey),
        std::move(pairing_procedure_complete));
    fake_fast_pair_pairer_ = fake_fast_pair_pairer.get();
    return fake_fast_pair_pairer;
  }

  ~FakeFastPairPairerFactory() override = default;

  FakeFastPairPairer* fake_fast_pair_pairer() { return fake_fast_pair_pairer_; }

 protected:
  raw_ptr<FakeFastPairPairer, DanglingUntriaged> fake_fast_pair_pairer_ =
      nullptr;
};

class FakeFastPairGattServiceClientImplFactory
    : public ash::quick_pair::FastPairGattServiceClientImpl::Factory {
 public:
  ~FakeFastPairGattServiceClientImplFactory() override = default;

  ash::quick_pair::FakeFastPairGattServiceClient*
  fake_fast_pair_gatt_service_client() {
    return fake_fast_pair_gatt_service_client_;
  }

 private:
  // FastPairGattServiceClientImpl::Factory:
  std::unique_ptr<ash::quick_pair::FastPairGattServiceClient> CreateInstance(
      device::BluetoothDevice* device,
      scoped_refptr<device::BluetoothAdapter> adapter,
      base::OnceCallback<void(std::optional<ash::quick_pair::PairFailure>)>
          on_initialized_callback) override {
    auto fake_fast_pair_gatt_service_client =
        std::make_unique<ash::quick_pair::FakeFastPairGattServiceClient>(
            device, adapter, std::move(on_initialized_callback));
    fake_fast_pair_gatt_service_client_ =
        fake_fast_pair_gatt_service_client.get();
    return fake_fast_pair_gatt_service_client;
  }

  raw_ptr<ash::quick_pair::FakeFastPairGattServiceClient, DanglingUntriaged>
      fake_fast_pair_gatt_service_client_ = nullptr;
};

}  // namespace

namespace ash {
namespace quick_pair {

class PairerBrokerImplTest : public AshTestBase, public PairerBroker::Observer {
 public:
  PairerBrokerImplTest()
      : AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}

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

    adapter_ = base::MakeRefCounted<FakeBluetoothAdapter>();

    device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);

    fast_pair_pairer_factory_ = std::make_unique<FakeFastPairPairerFactory>();
    FastPairPairerImpl::Factory::SetFactoryForTesting(
        fast_pair_pairer_factory_.get());

    FastPairGattServiceClientImpl::Factory::SetFactoryForTesting(
        &fast_pair_gatt_service_factory_);
    FastPairHandshakeLookup::UseFakeInstance();
    pairer_broker_ = std::make_unique<PairerBrokerImpl>();
    pairer_broker_->AddObserver(this);

    gatt_service_client_ = FastPairGattServiceClientImpl::Factory::Create(
        mock_bluetooth_device_ptr_, adapter_.get(), base::DoNothing());

    // We have to pass in a unique_ptr when we create a Handshake, however
    // we also want to be able to set fake responses on the encryptor. Thus
    // we maintain 2 pointers. We won't touch fake_fast_pair_data_encryptor_
    // aside from CreateHandshake.
    fake_fast_pair_data_encryptor_ =
        std::make_unique<FakeFastPairDataEncryptor>();
  }

  void CreateMockDevice(DeviceFastPairVersion version, Protocol protocol) {
    device_ = base::MakeRefCounted<Device>(kValidModelId, kTestDeviceAddress,
                                           protocol);
    device_->set_classic_address(kBluetoothCanonicalizedAddress);

    device_->set_version(version);

    // Add a matching mock device to the bluetooth adapter with the
    // same address to mock the relationship between Device and
    // device::BluetoothDevice.
    mock_bluetooth_device_ =
        std::make_unique<testing::NiceMock<device::MockBluetoothDevice>>(
            adapter_.get(), /*bluetooth_class=*/0, kDeviceName,
            kBluetoothCanonicalizedAddress,
            /*initially_paired=*/true, /*connected=*/false);
    mock_bluetooth_device_ptr_ = mock_bluetooth_device_.get();
    adapter_->AddMockDevice(std::move(mock_bluetooth_device_));
  }

  void EraseHandshake() {
    FastPairHandshakeLookup::GetInstance()->Erase(device_);
  }

  void InvokeHandshakeLookupCallbackSuccess() {
    FakeFastPairHandshakeLookup::GetFakeInstance()->InvokeCallbackForTesting(
        device_, std::nullopt);
  }

  void InvokeHandshakeLookupCallbackFailure(PairFailure failure) {
    FakeFastPairHandshakeLookup::GetFakeInstance()->InvokeCallbackForTesting(
        device_, failure);
  }

  void ExpectHandshakeExistsForDevice(scoped_refptr<Device> device) {
    auto* handshake = FastPairHandshakeLookup::GetInstance()->Get(device);
    EXPECT_TRUE(handshake);
  }

  void ExpectBleRotatedForDevice(scoped_refptr<Device> device) {
    auto* handshake = FastPairHandshakeLookup::GetInstance()->Get(device);
    EXPECT_TRUE(handshake->DidBleAddressRotate());
  }

  void TearDown() override {
    pairer_broker_->RemoveObserver(this);
    pairer_broker_.reset();
    AshTestBase::TearDown();
  }

  void OnDevicePaired(scoped_refptr<Device> device) override {
    ++device_paired_count_;
  }

  void OnPairFailure(scoped_refptr<Device> device,
                     PairFailure failure) override {
    ++pair_failure_count_;
  }

  void OnAccountKeyWrite(scoped_refptr<Device> device,
                         std::optional<AccountKeyFailure> error) override {
    ++account_key_write_count_;
  }

  void OnPairingStart(scoped_refptr<Device> device) override {
    pairing_started_ = true;
  }

  void OnHandshakeComplete(scoped_refptr<Device> device) override {
    handshake_complete_ = true;
  }

  void OnDisplayPasskey(std::u16string device_name, uint32_t passkey) override {
    display_passkey_ = passkey;
  }

  void OnPairingComplete(scoped_refptr<Device> device) override {
    device_pair_complete_ = true;
  }

  void PairerSetCurrentBleAddress(std::string ble_address) {
    pairer_broker_
        ->model_id_to_current_ble_address_map_[device_->metadata_id()] =
        ble_address;
  }

  void PairerCreateHandshake(scoped_refptr<Device> device) {
    pairer_broker_->CreateHandshake(device);
  }

  void PairerOnBleAddressRotation(scoped_refptr<Device> device) {
    pairer_broker_->OnBleAddressRotation(device);
  }

 protected:
  int device_paired_count_ = 0;
  int pair_failure_count_ = 0;
  int account_key_write_count_ = 0;
  uint32_t display_passkey_ = 0;
  bool pairing_started_ = false;
  bool handshake_complete_ = false;
  bool device_pair_complete_ = false;

  base::HistogramTester histogram_tester_;
  scoped_refptr<FakeBluetoothAdapter> adapter_;
  raw_ptr<device::MockBluetoothDevice> mock_bluetooth_device_ptr_ = nullptr;
  std::unique_ptr<FakeFastPairPairerFactory> fast_pair_pairer_factory_;

  std::unique_ptr<PairerBrokerImpl> pairer_broker_;
  raw_ptr<FakeFastPairHandshake, DanglingUntriaged> fake_fast_pair_handshake_ =
      nullptr;
  std::unique_ptr<FastPairGattServiceClient> gatt_service_client_;
  FakeFastPairGattServiceClientImplFactory fast_pair_gatt_service_factory_;
  std::unique_ptr<FakeFastPairDataEncryptor> fake_fast_pair_data_encryptor_;
  std::unique_ptr<testing::NiceMock<device::MockBluetoothDevice>>
      mock_bluetooth_device_ = nullptr;
  scoped_refptr<Device> device_;
};

TEST_F(PairerBrokerImplTest, PairV1Device_Initial) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);

  CreateMockDevice(DeviceFastPairVersion::kV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();

  EXPECT_EQ(account_key_write_count_, 0);
}

TEST_F(PairerBrokerImplTest, PairV2Device_Initial) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);

  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(account_key_write_count_, 1);
}

TEST_F(PairerBrokerImplTest, PairDevice_Subsequent) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairSubsequent);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairing_started_);
  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();
  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_TRUE(device_pair_complete_);
}

TEST_F(PairerBrokerImplTest, Ble_Address_Matches_Create_Handshake) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({ash::features::kFastPairBleRotation}, {});

  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);

  // Populate the ble_address map with the correct address.
  PairerSetCurrentBleAddress(device_->ble_address());
  PairerCreateHandshake(device_);
  ExpectHandshakeExistsForDevice(device_);
}

TEST_F(PairerBrokerImplTest, Ble_Address_Mismatch_No_Handshake) {
  base::test::ScopedFeatureList feature_list{
      ash::features::kFastPairBleRotation};
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);

  // Populate the ble_address map with a different address than the current BLE
  // address.
  PairerSetCurrentBleAddress(kTestDeviceAddress2);
  PairerCreateHandshake(device_);
  EXPECT_EQ(fake_fast_pair_handshake_, nullptr);
}

TEST_F(PairerBrokerImplTest, Ble_Address_Mismatch_Set_Callback) {
  base::test::ScopedFeatureList feature_list{
      ash::features::kFastPairBleRotation};
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);
  // Populate the ble_address map with a different address than the current BLE
  // address.
  PairerSetCurrentBleAddress(device_->ble_address());
  PairerCreateHandshake(device_);

  scoped_refptr<Device> device_after_ble_rotation_ =
      base::MakeRefCounted<Device>(kValidModelId, kTestDeviceAddress2,
                                   Protocol::kFastPairRetroactive);
  device_after_ble_rotation_->set_classic_address(
      kBluetoothCanonicalizedAddress);
  device_after_ble_rotation_->set_version(DeviceFastPairVersion::kHigherThanV1);

  pairer_broker_->PairDevice(device_after_ble_rotation_);

  ExpectBleRotatedForDevice(device_);
}

TEST_F(PairerBrokerImplTest, OnBleAddressRotation_Pairs_Successfully) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({ash::features::kFastPairBleRotation}, {});

  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);

  // Populate the ble_address map with the correct address.
  PairerSetCurrentBleAddress(device_->ble_address());

  // Call PairerOnBleAddressRotation, this is analogous to the function being
  // called as a callback from the pairer.
  PairerOnBleAddressRotation(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();
  EXPECT_FALSE(pairer_broker_->IsPairing());
}

TEST_F(PairerBrokerImplTest, PairDevice_Retroactive) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();
  EXPECT_FALSE(pairer_broker_->IsPairing());
}

TEST_F(PairerBrokerImplTest, AlreadyPairingDevice_Initial) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();
  pairer_broker_->PairDevice(device_);
  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessInitial,
                FastPairInitializePairingProcessEvent::kAlreadyPairingFailure),
            1);
}

TEST_F(PairerBrokerImplTest, AlreadyPairingDevice_Subsequent) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairSubsequent);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  pairer_broker_->PairDevice(device_);

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessSubsequent,
                FastPairInitializePairingProcessEvent::kAlreadyPairingFailure),
            1);
}

TEST_F(PairerBrokerImplTest, AlreadyPairingDevice_Retroactive) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  pairer_broker_->PairDevice(device_);

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessRetroactive,
                FastPairInitializePairingProcessEvent::kAlreadyPairingFailure),
            1);
}

TEST_F(PairerBrokerImplTest, PairAfterCancelPairing) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);

  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();
  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_CALL(*mock_bluetooth_device_ptr_, IsPaired())
      .WillOnce(testing::Return(false));

  // Attempt to pair with a failure.
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);

  // Fast forward |kCancelPairingDelay| seconds to allow the retry callback to
  // be called.
  task_environment()->FastForwardBy(kCancelPairingRetryDelay);

  // Now allow the pairing to succeed.
  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);
}

TEST_F(PairerBrokerImplTest, PairDeviceFailureMax_Initial) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(pair_failure_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  histogram_tester_.ExpectTotalCount(kProtocolPairingStepInitial, 1);
}

TEST_F(PairerBrokerImplTest, PairDeviceFailureMax_Subsequent) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairSubsequent);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(pair_failure_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  histogram_tester_.ExpectTotalCount(kProtocolPairingStepSubsequent, 1);
}

TEST_F(PairerBrokerImplTest, PairDeviceFailureMax_Retroactive) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);
  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairFailureCallback(
          PairFailure::kPasskeyCharacteristicNotifySession);

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(pair_failure_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
}

TEST_F(PairerBrokerImplTest, AccountKeyFailure_Initial) {
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerAccountKeyFailureCallback(
          AccountKeyFailure::kAccountKeyCharacteristicDiscovery);

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(account_key_write_count_, 1);
}

TEST_F(PairerBrokerImplTest, AccountKeyFailure_Subsequent) {
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairSubsequent);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();
  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerAccountKeyFailureCallback(
          AccountKeyFailure::kAccountKeyCharacteristicDiscovery);

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(account_key_write_count_, 1);
}

TEST_F(PairerBrokerImplTest, AccountKeyFailure_Retroactive) {
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerAccountKeyFailureCallback(
          AccountKeyFailure::kAccountKeyCharacteristicDiscovery);

  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(account_key_write_count_, 1);
}

TEST_F(PairerBrokerImplTest, StopPairing) {
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  // Stop Pairing mid pair.
  pairer_broker_->StopPairing();
  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(pair_failure_count_, 0);

  // Stop Pairing when we are not pairing should cause no issues.
  pairer_broker_->StopPairing();
  EXPECT_FALSE(pairer_broker_->IsPairing());
}

TEST_F(PairerBrokerImplTest, ReuseHandshake_Initial) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);

  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);

  FakeFastPairHandshakeLookup::GetFakeInstance()->CreateForTesting(
      adapter_, device_, base::DoNothing(), nullptr, nullptr);

  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();
  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessInitial,
                FastPairInitializePairingProcessEvent::kHandshakeReused),
            1);
}

TEST_F(PairerBrokerImplTest, ReuseHandshake_Subsequent) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairSubsequent);

  FakeFastPairHandshakeLookup::GetFakeInstance()->CreateForTesting(
      adapter_, device_, base::DoNothing(), nullptr, nullptr);

  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairing_started_);
  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();
  EXPECT_FALSE(pairer_broker_->IsPairing());
  EXPECT_TRUE(device_pair_complete_);

  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessSubsequent,
                FastPairInitializePairingProcessEvent::kHandshakeReused),
            1);
}

TEST_F(PairerBrokerImplTest, ReuseHandshake_Retroactive) {
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 0);
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);

  FakeFastPairHandshakeLookup::GetFakeInstance()->CreateForTesting(
      adapter_, device_, base::DoNothing(), nullptr, nullptr);

  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()->TriggerPairedCallback();

  EXPECT_TRUE(pairer_broker_->IsPairing());
  EXPECT_EQ(device_paired_count_, 1);
  histogram_tester_.ExpectTotalCount(kFastPairRetryCountMetricName, 1);

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerPairingProcedureCompleteCallback();
  EXPECT_FALSE(pairer_broker_->IsPairing());

  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessRetroactive,
                FastPairInitializePairingProcessEvent::kHandshakeReused),
            1);
}

TEST_F(PairerBrokerImplTest, NoPairingIfHandshakeFailed_Initial) {
  base::test::ScopedFeatureList feature_list{
      ash::features::kFastPairHandshakeLongTermRefactor};
  histogram_tester_.ExpectTotalCount(kHandshakeEffectiveSuccessRate, 0);
  histogram_tester_.ExpectTotalCount(kHandshakeAttemptCount, 0);

  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackFailure(PairFailure::kCreateGattConnection);

  EXPECT_EQ(device_paired_count_, 0);
  EXPECT_EQ(pair_failure_count_, 1);
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessFailureReasonInitial,
                PairFailure::kCreateGattConnection),
            1);
}

TEST_F(PairerBrokerImplTest, NoPairingIfHandshakeFailed_Subsequent) {
  base::test::ScopedFeatureList feature_list{
      ash::features::kFastPairHandshakeLongTermRefactor};
  histogram_tester_.ExpectTotalCount(kHandshakeEffectiveSuccessRate, 0);
  histogram_tester_.ExpectTotalCount(kHandshakeAttemptCount, 0);

  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairSubsequent);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackFailure(PairFailure::kCreateGattConnection);

  EXPECT_EQ(device_paired_count_, 0);
  EXPECT_EQ(pair_failure_count_, 1);
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessFailureReasonSubsequent,
                PairFailure::kCreateGattConnection),
            1);
}

TEST_F(PairerBrokerImplTest, NoPairingIfHandshakeFailed_Retroactive) {
  base::test::ScopedFeatureList feature_list{
      ash::features::kFastPairHandshakeLongTermRefactor};
  histogram_tester_.ExpectTotalCount(kHandshakeEffectiveSuccessRate, 0);
  histogram_tester_.ExpectTotalCount(kHandshakeAttemptCount, 0);

  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairRetroactive);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackFailure(PairFailure::kCreateGattConnection);

  EXPECT_EQ(device_paired_count_, 0);
  EXPECT_EQ(pair_failure_count_, 1);
  EXPECT_EQ(histogram_tester_.GetBucketCount(
                kInitializePairingProcessFailureReasonRetroactive,
                PairFailure::kCreateGattConnection),
            1);
}

TEST_F(PairerBrokerImplTest, DisplayPasskeySuccess) {
  CreateMockDevice(DeviceFastPairVersion::kHigherThanV1,
                   /*protocol=*/Protocol::kFastPairInitial);
  pairer_broker_->PairDevice(device_);
  InvokeHandshakeLookupCallbackSuccess();

  EXPECT_TRUE(pairer_broker_->IsPairing());

  fast_pair_pairer_factory_->fake_fast_pair_pairer()
      ->TriggerDisplayPasskeyCallback();

  EXPECT_EQ(display_passkey_, kValidPasskey);
}

}  // namespace quick_pair
}  // namespace ash