components/proximity_auth/proximity_monitor_impl_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/proximity_auth/proximity_monitor_impl.h"
   6
   7 #include "base/macros.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/test/histogram_tester.h"
  11 #include "base/test/simple_test_tick_clock.h"
  12 #include "base/test/test_simple_task_runner.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/time/time.h"
  15 #include "components/proximity_auth/logging/logging.h"
  16 #include "components/proximity_auth/proximity_monitor_observer.h"
  17 #include "components/proximity_auth/remote_device.h"
  18 #include "device/bluetooth/bluetooth_adapter_factory.h"
  19 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 using device::BluetoothDevice;
  24 using testing::_;
  25 using testing::NiceMock;
  26 using testing::Return;
  27 using testing::SaveArg;
  28
  29 namespace proximity_auth {
  30 namespace {
  31
  32 const char kBluetoothAddress[] = "AA:BB:CC:DD:EE:FF";
  33 const char kRemoteDevicePublicKey[] = "Remote Public Key";
  34 const char kRemoteDeviceName[] = "LGE Nexus 5";
  35 const char kPersistentSymmetricKey[] = "PSK";
  36
  37 class TestProximityMonitorImpl : public ProximityMonitorImpl {
  38  public:
  39   explicit TestProximityMonitorImpl(const RemoteDevice& remote_device,
  40                                     scoped_ptr<base::TickClock> clock,
  41                                     ProximityMonitorObserver* observer)
  42       : ProximityMonitorImpl(remote_device, clock.Pass(), observer) {}
  43   ~TestProximityMonitorImpl() override {}
  44
  45   using ProximityMonitorImpl::SetStrategy;
  46
  47  private:
  48   DISALLOW_COPY_AND_ASSIGN(TestProximityMonitorImpl);
  49 };
  50
  51 class MockProximityMonitorObserver : public ProximityMonitorObserver {
  52  public:
  53   MockProximityMonitorObserver() {}
  54   ~MockProximityMonitorObserver() override {}
  55
  56   MOCK_METHOD0(OnProximityStateChanged, void());
  57
  58  private:
  59   DISALLOW_COPY_AND_ASSIGN(MockProximityMonitorObserver);
  60 };
  61
  62 // Creates a mock Bluetooth adapter and sets it as the global adapter for
  63 // testing.
  64 scoped_refptr<device::MockBluetoothAdapter>
  65 CreateAndRegisterMockBluetoothAdapter() {
  66   scoped_refptr<device::MockBluetoothAdapter> adapter =
  67       new NiceMock<device::MockBluetoothAdapter>();
  68   device::BluetoothAdapterFactory::SetAdapterForTesting(adapter);
  69   return adapter;
  70 }
  71
  72 }  // namespace
  73
  74 class ProximityAuthProximityMonitorImplTest : public testing::Test {
  75  public:
  76   ProximityAuthProximityMonitorImplTest()
  77       : clock_(new base::SimpleTestTickClock()),
  78         bluetooth_adapter_(CreateAndRegisterMockBluetoothAdapter()),
  79         remote_bluetooth_device_(&*bluetooth_adapter_,
  80                                  0,
  81                                  kRemoteDeviceName,
  82                                  kBluetoothAddress,
  83                                  false /* paired */,
  84                                  true /* connected */),
  85         monitor_(RemoteDevice(kRemoteDeviceName,
  86                               kRemoteDevicePublicKey,
  87                               kBluetoothAddress,
  88                               kPersistentSymmetricKey),
  89                  make_scoped_ptr(clock_),
  90                  &observer_),
  91         task_runner_(new base::TestSimpleTaskRunner()),
  92         thread_task_runner_handle_(task_runner_) {
  93     ON_CALL(*bluetooth_adapter_, GetDevice(kBluetoothAddress))
  94         .WillByDefault(Return(&remote_bluetooth_device_));
  95     ON_CALL(remote_bluetooth_device_, GetConnectionInfo(_))
  96         .WillByDefault(SaveArg<0>(&connection_info_callback_));
  97   }
  98   ~ProximityAuthProximityMonitorImplTest() override {}
  99
 100   void RunPendingTasks() { task_runner_->RunPendingTasks(); }
 101
 102   void ProvideConnectionInfo(
 103       const BluetoothDevice::ConnectionInfo& connection_info) {
 104     RunPendingTasks();
 105     connection_info_callback_.Run(connection_info);
 106
 107     // Reset the callback to ensure that tests correctly only respond at most
 108     // once per call to GetConnectionInfo().
 109     connection_info_callback_ = BluetoothDevice::ConnectionInfoCallback();
 110   }
 111
 112  protected:
 113   // Mock for verifying interactions with the proximity monitor's observer.
 114   NiceMock<MockProximityMonitorObserver> observer_;
 115
 116   // Clock used for verifying time calculations. Owned by the monitor_.
 117   base::SimpleTestTickClock* clock_;
 118
 119   // Mocks used for verifying interactions with the Bluetooth subsystem.
 120   scoped_refptr<device::MockBluetoothAdapter> bluetooth_adapter_;
 121   NiceMock<device::MockBluetoothDevice> remote_bluetooth_device_;
 122
 123   // The proximity monitor under test.
 124   TestProximityMonitorImpl monitor_;
 125
 126  private:
 127   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 128   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
 129   BluetoothDevice::ConnectionInfoCallback connection_info_callback_;
 130   ScopedDisableLoggingForTesting disable_logging_;
 131 };
 132
 133 TEST_F(ProximityAuthProximityMonitorImplTest, GetStrategy) {
 134   EXPECT_EQ(ProximityMonitor::Strategy::NONE, monitor_.GetStrategy());
 135
 136   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 137   EXPECT_EQ(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER,
 138             monitor_.GetStrategy());
 139 }
 140
 141 TEST_F(ProximityAuthProximityMonitorImplTest, ProximityState_StrategyIsNone) {
 142   monitor_.SetStrategy(ProximityMonitor::Strategy::NONE);
 143
 144   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 145   EXPECT_FALSE(monitor_.IsInRssiRange());
 146 }
 147
 148 TEST_F(ProximityAuthProximityMonitorImplTest, ProximityState_NeverStarted) {
 149   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 150
 151   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 152   EXPECT_FALSE(monitor_.IsInRssiRange());
 153 }
 154
 155 TEST_F(ProximityAuthProximityMonitorImplTest,
 156        ProximityState_Started_NoConnectionInfoReceivedYet) {
 157   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 158   monitor_.Start();
 159
 160   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 161   EXPECT_FALSE(monitor_.IsInRssiRange());
 162 }
 163
 164 TEST_F(ProximityAuthProximityMonitorImplTest,
 165        ProximityState_InformsObserverOfChanges) {
 166   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 167
 168   // Initially, the device is not in proximity.
 169   monitor_.Start();
 170   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 171
 172   // Simulate a reading indicating proximity.
 173   EXPECT_CALL(observer_, OnProximityStateChanged()).Times(1);
 174   ProvideConnectionInfo({0, 0, 4});
 175   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 176
 177   // Simulate a reading indicating non-proximity.
 178   EXPECT_CALL(observer_, OnProximityStateChanged()).Times(1);
 179   ProvideConnectionInfo({0, 4, 4});
 180   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 181 }
 182
 183 TEST_F(ProximityAuthProximityMonitorImplTest,
 184        ProximityState_CheckRssi_RssiIndicatesProximity_TxPowerDoesNot) {
 185   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 186   monitor_.Start();
 187
 188   ProvideConnectionInfo({0, 4, 4});
 189
 190   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 191   EXPECT_TRUE(monitor_.IsInRssiRange());
 192 }
 193
 194 TEST_F(ProximityAuthProximityMonitorImplTest,
 195        ProximityState_CheckRssi_TxPowerIndicatesProximity_RssiDoesNot) {
 196   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 197   monitor_.Start();
 198
 199   ProvideConnectionInfo({-10, 0, 4});
 200
 201   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 202   EXPECT_FALSE(monitor_.IsInRssiRange());
 203 }
 204
 205 TEST_F(ProximityAuthProximityMonitorImplTest,
 206        ProximityState_CheckRssi_NeitherRssiNorTxPowerIndicatesProximity) {
 207   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 208   monitor_.Start();
 209
 210   ProvideConnectionInfo({-10, 4, 4});
 211
 212   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 213   EXPECT_FALSE(monitor_.IsInRssiRange());
 214 }
 215
 216 TEST_F(ProximityAuthProximityMonitorImplTest,
 217        ProximityState_CheckRssi_BothRssiAndTxPowerIndicateProximity) {
 218   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 219   monitor_.Start();
 220
 221   ProvideConnectionInfo({0, 0, 4});
 222
 223   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 224   EXPECT_TRUE(monitor_.IsInRssiRange());
 225 }
 226
 227 TEST_F(ProximityAuthProximityMonitorImplTest,
 228        ProximityState_CheckRssi_UnknownRssi) {
 229   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 230   monitor_.Start();
 231
 232   ProvideConnectionInfo({0, 0, 4});
 233   ProvideConnectionInfo({BluetoothDevice::kUnknownPower, 0, 4});
 234
 235   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 236   EXPECT_FALSE(monitor_.IsInRssiRange());
 237 }
 238
 239 TEST_F(ProximityAuthProximityMonitorImplTest,
 240        ProximityState_CheckRssi_UnknownTxPower) {
 241   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 242   monitor_.Start();
 243
 244   ProvideConnectionInfo({0, 0, 4});
 245   ProvideConnectionInfo({0, BluetoothDevice::kUnknownPower, 4});
 246
 247   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 248   EXPECT_FALSE(monitor_.IsInRssiRange());
 249 }
 250
 251 TEST_F(ProximityAuthProximityMonitorImplTest,
 252        ProximityState_CheckRssi_UnknownMaxTxPower) {
 253   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 254   monitor_.Start();
 255
 256   ProvideConnectionInfo({0, 0, 4});
 257   ProvideConnectionInfo({0, 0, BluetoothDevice::kUnknownPower});
 258
 259   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 260   EXPECT_FALSE(monitor_.IsInRssiRange());
 261 }
 262
 263 TEST_F(ProximityAuthProximityMonitorImplTest,
 264        ProximityState_CheckTxPower_RssiIndicatesProximity_TxPowerDoesNot) {
 265   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 266   monitor_.Start();
 267
 268   ProvideConnectionInfo({0, 4, 4});
 269
 270   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 271   EXPECT_TRUE(monitor_.IsInRssiRange());
 272 }
 273
 274 TEST_F(ProximityAuthProximityMonitorImplTest,
 275        ProximityState_CheckTxPower_TxPowerIndicatesProximity_RssiDoesNot) {
 276   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 277   monitor_.Start();
 278
 279   ProvideConnectionInfo({-10, 0, 4});
 280
 281   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 282   EXPECT_FALSE(monitor_.IsInRssiRange());
 283 }
 284
 285 TEST_F(ProximityAuthProximityMonitorImplTest,
 286        ProximityState_CheckTxPower_NeitherRssiNorTxPowerIndicatesProximity) {
 287   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 288   monitor_.Start();
 289
 290   ProvideConnectionInfo({-10, 4, 4});
 291
 292   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 293   EXPECT_FALSE(monitor_.IsInRssiRange());
 294 }
 295
 296 TEST_F(ProximityAuthProximityMonitorImplTest,
 297        ProximityState_CheckTxPower_BothRssiAndTxPowerIndicateProximity) {
 298   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 299   monitor_.Start();
 300
 301   ProvideConnectionInfo({0, 0, 4});
 302
 303   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 304   EXPECT_TRUE(monitor_.IsInRssiRange());
 305 }
 306
 307 TEST_F(ProximityAuthProximityMonitorImplTest,
 308        ProximityState_CheckTxPower_UnknownRssi) {
 309   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 310   monitor_.Start();
 311
 312   ProvideConnectionInfo({0, 0, 4});
 313   ProvideConnectionInfo({BluetoothDevice::kUnknownPower, 0, 4});
 314
 315   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 316   EXPECT_FALSE(monitor_.IsInRssiRange());
 317 }
 318
 319 TEST_F(ProximityAuthProximityMonitorImplTest,
 320        ProximityState_CheckTxPower_UnknownTxPower) {
 321   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 322   monitor_.Start();
 323
 324   ProvideConnectionInfo({0, 0, 4});
 325   ProvideConnectionInfo({0, BluetoothDevice::kUnknownPower, 4});
 326
 327   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 328   EXPECT_FALSE(monitor_.IsInRssiRange());
 329 }
 330
 331 TEST_F(ProximityAuthProximityMonitorImplTest,
 332        ProximityState_CheckTxPower_UnknownMaxTxPower) {
 333   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_TRANSMIT_POWER);
 334   monitor_.Start();
 335
 336   ProvideConnectionInfo({0, 0, 4});
 337   ProvideConnectionInfo({0, 0, BluetoothDevice::kUnknownPower});
 338
 339   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 340   EXPECT_FALSE(monitor_.IsInRssiRange());
 341 }
 342
 343 TEST_F(ProximityAuthProximityMonitorImplTest, ProximityState_StartThenStop) {
 344   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 345
 346   monitor_.Start();
 347   ProvideConnectionInfo({0, 0, 4});
 348   monitor_.Stop();
 349
 350   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 351   EXPECT_FALSE(monitor_.IsInRssiRange());
 352 }
 353
 354 TEST_F(ProximityAuthProximityMonitorImplTest,
 355        ProximityState_StartThenStopThenStartAgain) {
 356   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 357
 358   monitor_.Start();
 359   ProvideConnectionInfo({-10, 4, 4});
 360   ProvideConnectionInfo({-10, 4, 4});
 361   ProvideConnectionInfo({-10, 4, 4});
 362   ProvideConnectionInfo({-10, 4, 4});
 363   ProvideConnectionInfo({-10, 4, 4});
 364   monitor_.Stop();
 365
 366   // Restarting the monitor should immediately reset the proximity state, rather
 367   // than building on the previous rolling average.
 368   monitor_.Start();
 369   ProvideConnectionInfo({0, 4, 4});
 370
 371   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 372   EXPECT_TRUE(monitor_.IsInRssiRange());
 373 }
 374
 375 TEST_F(ProximityAuthProximityMonitorImplTest,
 376        ProximityState_RemoteDeviceRemainsInProximity) {
 377   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 378
 379   monitor_.Start();
 380   ProvideConnectionInfo({0, 4, 4});
 381   ProvideConnectionInfo({-1, 4, 4});
 382   ProvideConnectionInfo({0, 4, 4});
 383   ProvideConnectionInfo({-2, 4, 4});
 384   ProvideConnectionInfo({-1, 4, 4});
 385
 386   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 387   EXPECT_TRUE(monitor_.IsInRssiRange());
 388
 389   // Brief drops in RSSI should be handled by weighted averaging.
 390   ProvideConnectionInfo({-10, 4, 4});
 391
 392   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 393   EXPECT_TRUE(monitor_.IsInRssiRange());
 394 }
 395
 396 TEST_F(ProximityAuthProximityMonitorImplTest,
 397        ProximityState_RemoteDeviceLeavesProximity) {
 398   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 399   monitor_.Start();
 400
 401   // Start with a device in proximity.
 402   ProvideConnectionInfo({0, 4, 4});
 403   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 404   EXPECT_TRUE(monitor_.IsInRssiRange());
 405
 406   // Simulate readings for the remote device leaving proximity.
 407   ProvideConnectionInfo({-1, 4, 4});
 408   ProvideConnectionInfo({-4, 4, 4});
 409   ProvideConnectionInfo({0, 4, 4});
 410   ProvideConnectionInfo({-10, 4, 4});
 411   ProvideConnectionInfo({-8, 4, 4});
 412   ProvideConnectionInfo({-15, 4, 4});
 413   ProvideConnectionInfo({-10, 4, 4});
 414   ProvideConnectionInfo({-10, 4, 4});
 415   ProvideConnectionInfo({-10, 4, 4});
 416   ProvideConnectionInfo({-10, 4, 4});
 417
 418   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 419   EXPECT_FALSE(monitor_.IsInRssiRange());
 420 }
 421
 422 TEST_F(ProximityAuthProximityMonitorImplTest,
 423        ProximityState_RemoteDeviceEntersProximity) {
 424   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 425   monitor_.Start();
 426
 427   // Start with a device in proximity.
 428   ProvideConnectionInfo({-20, 4, 4});
 429   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 430   EXPECT_FALSE(monitor_.IsInRssiRange());
 431
 432   // Simulate readings for the remote device entering proximity.
 433   ProvideConnectionInfo({-15, 4, 4});
 434   ProvideConnectionInfo({-8, 4, 4});
 435   ProvideConnectionInfo({-12, 4, 4});
 436   ProvideConnectionInfo({-18, 4, 4});
 437   ProvideConnectionInfo({-7, 4, 4});
 438   ProvideConnectionInfo({-3, 4, 4});
 439   ProvideConnectionInfo({-2, 4, 4});
 440   ProvideConnectionInfo({0, 4, 4});
 441   ProvideConnectionInfo({0, 4, 4});
 442
 443   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 444   EXPECT_TRUE(monitor_.IsInRssiRange());
 445 }
 446
 447 TEST_F(ProximityAuthProximityMonitorImplTest,
 448        ProximityState_DeviceNotKnownToAdapter) {
 449   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 450   monitor_.Start();
 451
 452   // Start with the device known to the adapter and in proximity.
 453   ProvideConnectionInfo({0, 4, 4});
 454   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 455   EXPECT_TRUE(monitor_.IsInRssiRange());
 456
 457   // Simulate it being forgotten.
 458   ON_CALL(*bluetooth_adapter_, GetDevice(kBluetoothAddress))
 459       .WillByDefault(Return(nullptr));
 460   EXPECT_CALL(observer_, OnProximityStateChanged());
 461   RunPendingTasks();
 462
 463   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 464   EXPECT_FALSE(monitor_.IsInRssiRange());
 465 }
 466
 467 TEST_F(ProximityAuthProximityMonitorImplTest,
 468        ProximityState_DeviceNotConnected) {
 469   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 470   monitor_.Start();
 471
 472   // Start with the device connected and in proximity.
 473   ProvideConnectionInfo({0, 4, 4});
 474   EXPECT_TRUE(monitor_.IsUnlockAllowed());
 475   EXPECT_TRUE(monitor_.IsInRssiRange());
 476
 477   // Simulate it disconnecting.
 478   ON_CALL(remote_bluetooth_device_, IsConnected()).WillByDefault(Return(false));
 479   EXPECT_CALL(observer_, OnProximityStateChanged());
 480   RunPendingTasks();
 481
 482   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 483   EXPECT_FALSE(monitor_.IsInRssiRange());
 484 }
 485
 486 TEST_F(ProximityAuthProximityMonitorImplTest,
 487        ProximityState_ConnectionInfoReceivedAfterStopping) {
 488   monitor_.SetStrategy(ProximityMonitor::Strategy::CHECK_RSSI);
 489
 490   monitor_.Start();
 491   monitor_.Stop();
 492   ProvideConnectionInfo({0, 4, 4});
 493
 494   EXPECT_FALSE(monitor_.IsUnlockAllowed());
 495   EXPECT_FALSE(monitor_.IsInRssiRange());
 496 }
 497
 498 TEST_F(ProximityAuthProximityMonitorImplTest,
 499        RecordProximityMetricsOnAuthSuccess_NormalValues) {
 500   monitor_.Start();
 501   ProvideConnectionInfo({0, 0, 4});
 502
 503   clock_->Advance(base::TimeDelta::FromMilliseconds(101));
 504   ProvideConnectionInfo({-20, 3, 4});
 505
 506   clock_->Advance(base::TimeDelta::FromMilliseconds(203));
 507   base::HistogramTester histogram_tester;
 508   monitor_.RecordProximityMetricsOnAuthSuccess();
 509   histogram_tester.ExpectUniqueSample("EasyUnlock.AuthProximity.RollingRssi",
 510                                       -6, 1);
 511   histogram_tester.ExpectUniqueSample(
 512       "EasyUnlock.AuthProximity.TransmitPowerDelta", -1, 1);
 513   histogram_tester.ExpectUniqueSample(
 514       "EasyUnlock.AuthProximity.TimeSinceLastZeroRssi", 304, 1);
 515   histogram_tester.ExpectUniqueSample(
 516       "EasyUnlock.AuthProximity.RemoteDeviceModelHash",
 517       1881443083 /* hash of "LGE Nexus 5" */, 1);
 518 }
 519
 520 TEST_F(ProximityAuthProximityMonitorImplTest,
 521        RecordProximityMetricsOnAuthSuccess_ClampedValues) {
 522   monitor_.Start();
 523   ProvideConnectionInfo({-99999, 99999, 12345});
 524
 525   base::HistogramTester histogram_tester;
 526   monitor_.RecordProximityMetricsOnAuthSuccess();
 527   histogram_tester.ExpectUniqueSample("EasyUnlock.AuthProximity.RollingRssi",
 528                                       -100, 1);
 529   histogram_tester.ExpectUniqueSample(
 530       "EasyUnlock.AuthProximity.TransmitPowerDelta", 50, 1);
 531 }
 532
 533 TEST_F(ProximityAuthProximityMonitorImplTest,
 534        RecordProximityMetricsOnAuthSuccess_UnknownValues) {
 535   // Note: A device without a recorded name will have its Bluetooth address as
 536   // its name.
 537   RemoteDevice unnamed_remote_device(kBluetoothAddress, kRemoteDevicePublicKey,
 538                                      kBluetoothAddress,
 539                                      kPersistentSymmetricKey);
 540
 541   scoped_ptr<base::TickClock> clock(new base::SimpleTestTickClock());
 542   ProximityMonitorImpl monitor(unnamed_remote_device, clock.Pass(), &observer_);
 543   monitor.Start();
 544   ProvideConnectionInfo({127, 127, 127});
 545
 546   base::HistogramTester histogram_tester;
 547   monitor.RecordProximityMetricsOnAuthSuccess();
 548   histogram_tester.ExpectUniqueSample("EasyUnlock.AuthProximity.RollingRssi",
 549                                       127, 1);
 550   histogram_tester.ExpectUniqueSample(
 551       "EasyUnlock.AuthProximity.TransmitPowerDelta", 127, 1);
 552   histogram_tester.ExpectUniqueSample(
 553       "EasyUnlock.AuthProximity.TimeSinceLastZeroRssi",
 554       base::TimeDelta::FromSeconds(10).InMilliseconds(), 1);
 555   histogram_tester.ExpectUniqueSample(
 556       "EasyUnlock.AuthProximity.RemoteDeviceModelHash",
 557       -1808066424 /* hash of "Unknown" */, 1);
 558 }
 559
 560 }  // namespace proximity_auth