Add RemoteDeviceLoader to create RemoteDevice from CryptAuth data.

components/proximity_auth/ble/bluetooth_low_energy_connection_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 #include "components/proximity_auth/bluetooth_throttler.h"
 #include "components/proximity_auth/connection_finder.h"
+#include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 using testing::SaveArg;
 
 namespace proximity_auth {
 namespace {
 
-const char kDeviceName[] = "Device name";
-const char kPublicKey[] = "Public key";
-const char kBluetoothAddress[] = "11:22:33:44:55:66";
-const char kPersistentSymmetricKey[] = "PSK";
-
 const char kServiceUUID[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEEF";
 const char kToPeripheralCharUUID[] = "977c6674-1239-4e72-993b-502369b8bb5a";
 const char kFromPeripheralCharUUID[] = "f4b904a2-a030-43b3-98a8-221c536c03cb";
 
 const char kServiceID[] = "service id";
 const char kToPeripheralCharID[] = "to peripheral char id";
 const char kFromPeripheralCharID[] = "from peripheral char id";
 
 const device::BluetoothGattCharacteristic::Properties
     kCharacteristicProperties =
@@ skipping 64 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyConnection);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothLowEnergyConnectionTest : public testing::Test {
  public:
   ProximityAuthBluetoothLowEnergyConnectionTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
-        remote_device_(kDeviceName,
-                       kPublicKey,
-                       kBluetoothAddress,
-                       kPersistentSymmetricKey),
+        remote_device_(CreateLERemoteDeviceForTest()),
         service_uuid_(device::BluetoothUUID(kServiceUUID)),
         to_peripheral_char_uuid_(device::BluetoothUUID(kToPeripheralCharUUID)),
         from_peripheral_char_uuid_(
             device::BluetoothUUID(kFromPeripheralCharUUID)),
         notify_session_alias_(NULL),
         bluetooth_throttler_(new NiceMock<MockBluetoothThrottler>),
         task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
     device_ = make_scoped_ptr(new NiceMock<device::MockBluetoothDevice>(
-        adapter_.get(), 0, kDeviceName, kBluetoothAddress, false, false));
+        adapter_.get(), 0, kTestRemoteDeviceName,
+        kTestRemoteDeviceBluetoothAddress, false, false));
 
     service_ = make_scoped_ptr(new NiceMock<device::MockBluetoothGattService>(
         device_.get(), kServiceID, service_uuid_, true, false));
     to_peripheral_char_ =
         make_scoped_ptr(new NiceMock<device::MockBluetoothGattCharacteristic>(
             service_.get(), kToPeripheralCharID, to_peripheral_char_uuid_,
             false, kCharacteristicProperties,
             device::BluetoothGattCharacteristic::PERMISSION_NONE));
 
     from_peripheral_char_ =
         make_scoped_ptr(new NiceMock<device::MockBluetoothGattCharacteristic>(
             service_.get(), kFromPeripheralCharID, from_peripheral_char_uuid_,
             false, kCharacteristicProperties,
             device::BluetoothGattCharacteristic::PERMISSION_NONE));
 
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     std::vector<const device::BluetoothDevice*> devices;
     devices.push_back(device_.get());
     ON_CALL(*adapter_, GetDevices()).WillByDefault(Return(devices));
-    ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+    ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(device_.get()));
     ON_CALL(*device_, GetGattService(kServiceID))
         .WillByDefault(Return(service_.get()));
     ON_CALL(*service_, GetCharacteristic(kFromPeripheralCharID))
         .WillByDefault(Return(from_peripheral_char_.get()));
     ON_CALL(*service_, GetCharacteristic(kToPeripheralCharID))
         .WillByDefault(Return(to_peripheral_char_.get()));
   }
 
   // Creates a BluetoothLowEnergyConnection and verifies it's in DISCONNECTED
@@ skipping 38 matching lines @@
     EXPECT_FALSE(create_gatt_connection_error_callback_.is_null());
     ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
     EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
         .WillOnce(DoAll(
             SaveArg<0>(&characteristics_finder_success_callback_),
             SaveArg<1>(&characteristics_finder_error_callback_),
             Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
     create_gatt_connection_success_callback_.Run(
         make_scoped_ptr(new NiceMock<device::MockBluetoothGattConnection>(
-            adapter_, kBluetoothAddress)));
+            adapter_, kTestRemoteDeviceBluetoothAddress)));
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_CHARACTERISTICS);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_CHARACTERISTICS to
   // WAITING_NOTIFY_SESSION state.
   void CharacteristicsFound(MockBluetoothLowEnergyConnection* connection) {
     EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _))
@@ skipping 434 matching lines @@
 
   // Preparing |connection| to run |create_gatt_connection_success_callback_|.
   EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
       .WillOnce(DoAll(
           SaveArg<0>(&characteristics_finder_success_callback_),
           SaveArg<1>(&characteristics_finder_error_callback_),
           Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
   create_gatt_connection_success_callback_.Run(
       make_scoped_ptr(new NiceMock<device::MockBluetoothGattConnection>(
-          adapter_, kBluetoothAddress)));
+          adapter_, kTestRemoteDeviceBluetoothAddress)));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   ResponseSignalReceived(connection.get());
 }
 
 }  // namespace proximity_auth