Add RemoteDeviceLoader to create RemoteDevice from CryptAuth data.

components/proximity_auth/bluetooth_connection_finder_unittest.cc

 // Copyright 2014 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/bluetooth_connection_finder.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/time/time.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_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 
 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 kUuid[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEF";
 
-RemoteDevice CreateRemoteDevice() {
-  return RemoteDevice(kDeviceName, kPublicKey, kBluetoothAddress,
-                      kPersistentSymmetricKey);
-}
-
 class MockConnection : public Connection {
  public:
-  MockConnection() : Connection(CreateRemoteDevice()), do_not_destroy_(false) {}
+  MockConnection()
+      : Connection(CreateClassicRemoteDeviceForTest()),
+        do_not_destroy_(false) {}
   ~MockConnection() override { EXPECT_FALSE(do_not_destroy_); }
 
   MOCK_METHOD0(Connect, void());
 
   void SetStatus(Connection::Status status) {
     // This object should not be destroyed after setting the status and calling
     // observers.
     do_not_destroy_ = true;
     Connection::SetStatus(status);
     do_not_destroy_ = false;
   }
 
  private:
   void Disconnect() override {}
   void SendMessageImpl(scoped_ptr<WireMessage> message) override {}
 
   // If true, we do not expect |this| object to be destroyed until this value is
   // toggled back to false.
   bool do_not_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class MockBluetoothConnectionFinder : public BluetoothConnectionFinder {
  public:
   MockBluetoothConnectionFinder()
-      : BluetoothConnectionFinder(CreateRemoteDevice(),
+      : BluetoothConnectionFinder(CreateClassicRemoteDeviceForTest(),
                                   device::BluetoothUUID(kUuid),
                                   base::TimeDelta()) {}
   ~MockBluetoothConnectionFinder() override {}
 
   MOCK_METHOD0(CreateConnectionProxy, Connection*());
 
   // Creates a mock connection and sets an expectation that the mock connection
   // finder's CreateConnection() method will be called and will return the
   // created connection. Returns a reference to the created connection.
   // NOTE: The returned connection's lifetime is managed by the connection
@@ skipping 22 matching lines @@
  protected:
   // BluetoothConnectionFinder:
   scoped_ptr<Connection> CreateConnection() override {
     return make_scoped_ptr(CreateConnectionProxy());
   }
 
   void SeekDeviceByAddress(
       const std::string& bluetooth_address,
       const base::Closure& callback,
       const bluetooth_util::ErrorCallback& error_callback) override {
-    EXPECT_EQ(kBluetoothAddress, bluetooth_address);
+    EXPECT_EQ(kTestRemoteDeviceBluetoothAddress, bluetooth_address);
     seek_callback_ = callback;
     seek_error_callback_ = error_callback;
   }
 
  private:
   base::Closure seek_callback_;
   bluetooth_util::ErrorCallback seek_error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothConnectionFinder);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothConnectionFinderTest : public testing::Test {
  protected:
   ProximityAuthBluetoothConnectionFinderTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
         bluetooth_device_(new NiceMock<device::MockBluetoothDevice>(
             adapter_.get(),
             device::BluetoothDevice::DEVICE_PHONE,
-            kDeviceName,
-            kBluetoothAddress,
+            kTestRemoteDeviceName,
+            kTestRemoteDeviceBluetoothAddress,
             true,
             false)),
         connection_callback_(base::Bind(
             &ProximityAuthBluetoothConnectionFinderTest::OnConnectionFound,
             base::Unretained(this))) {
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     // By default, configure the environment to allow polling. Individual tests
     // can override this as needed.
     ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
     ON_CALL(*adapter_, IsPowered()).WillByDefault(Return(true));
 
     // By default, the remote device is known to |adapter_| so
     // |SeekDeviceByAddress()| will not be called.
-    ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+    ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(bluetooth_device_.get()));
   }
 
   MOCK_METHOD1(OnConnectionFoundProxy, void(Connection* connection));
   void OnConnectionFound(scoped_ptr<Connection> connection) {
     OnConnectionFoundProxy(connection.get());
     last_found_connection_ = connection.Pass();
   }
 
   // Starts |connection_finder_|. If |expect_connection| is true, then we set an
@@ skipping 26 matching lines @@
   scoped_ptr<Connection> last_found_connection_;
 
   base::MessageLoop message_loop_;
 };
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
        ConstructAndDestroyDoesntCrash) {
   // Destroying a BluetoothConnectionFinder for which Find() has not been called
   // should not crash.
   BluetoothConnectionFinder connection_finder(
-      CreateRemoteDevice(), device::BluetoothUUID(kUuid),
+      CreateClassicRemoteDeviceForTest(), device::BluetoothUUID(kUuid),
       base::TimeDelta::FromMilliseconds(1));
 }
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest, Find_NoBluetoothAdapter) {
   // Some platforms do not support Bluetooth. This test is only meaningful on
   // those platforms.
   adapter_ = NULL;
   if (device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable())
     return;
 
@@ skipping 106 matching lines @@
   // Now that there is no pending task, events should once again trigger new
   // polling iterations.
   connection_finder_.ExpectCreateConnection();
   connection_finder_.AdapterPresentChanged(adapter_.get(), true);
 }
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
        Find_DeviceNotKnown_SeekDeviceSucceeds) {
   // If the BluetoothDevice is not known by the adapter, |connection_finder|
   // will call SeekDeviceByAddress() first to make it known.
-  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+  ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
       .WillByDefault(Return(nullptr));
   connection_finder_.Find(connection_callback_);
   ASSERT_FALSE(connection_finder_.seek_callback().is_null());
   EXPECT_FALSE(connection_finder_.seek_error_callback().is_null());
 
   // After seeking is successful, the normal flow should resume.
-  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+  ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
       .WillByDefault(Return(bluetooth_device_.get()));
   MockConnection* connection = connection_finder_.ExpectCreateConnection();
   connection_finder_.seek_callback().Run();
   SimulateDeviceConnection(connection);
 }
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
        Find_DeviceNotKnown_SeekDeviceFailThenSucceeds) {
   // If the BluetoothDevice is not known by the adapter, |connection_finder|
   // will call SeekDeviceByAddress() first to make it known.
-  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+  ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
       .WillByDefault(Return(nullptr));
   connection_finder_.Find(connection_callback_);
   EXPECT_FALSE(connection_finder_.seek_callback().is_null());
   ASSERT_FALSE(connection_finder_.seek_error_callback().is_null());
 
   // If the seek fails, then |connection_finder| will post a delayed poll to
   // reattempt the seek.
   connection_finder_.seek_error_callback().Run("Seek failed for test.");
   connection_finder_.ClearSeekCallbacks();
   EXPECT_TRUE(connection_finder_.seek_callback().is_null());
   EXPECT_TRUE(connection_finder_.seek_error_callback().is_null());
 
   // Check that seek is reattempted.
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
   ASSERT_FALSE(connection_finder_.seek_callback().is_null());
   EXPECT_FALSE(connection_finder_.seek_error_callback().is_null());
 
   // Successfully connect to the Bluetooth device.
-  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+  ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
       .WillByDefault(Return(bluetooth_device_.get()));
   MockConnection* connection = connection_finder_.ExpectCreateConnection();
   connection_finder_.seek_callback().Run();
   SimulateDeviceConnection(connection);
 }
 
 }  // namespace proximity_auth