Refactor fake Connection subclasses in proximity_auth/ tests to a single file.

components/proximity_auth/remote_device_life_cycle_impl_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/remote_device_life_cycle_impl.h"
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/proximity_auth/authenticator.h"
-#include "components/proximity_auth/connection.h"
 #include "components/proximity_auth/connection_finder.h"
+#include "components/proximity_auth/fake_connection.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/secure_context.h"
 #include "components/proximity_auth/wire_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Mock;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 
 namespace proximity_auth {
 
 namespace {
 
 // Attributes of the remote device under test.
 const char kRemoteDeviceName[] = "remote device";
 const char kRemoteDevicePublicKey[] = "public key";
 const char kRemoteDeviceBluetoothAddress[] = "AA:BB:CC:DD:EE:FF";
 const char kRemoteDevicePSK[] = "remote device psk";
 
-class StubConnection : public Connection {
- public:
-  StubConnection() : Connection(RemoteDevice()) {
-    SetStatus(Connection::Status::CONNECTED);
-  }
-
-  ~StubConnection() override {}
-
-  // Connection:
-  void Connect() override { NOTREACHED(); }
-
-  void Disconnect() override { SetStatus(Connection::Status::DISCONNECTED); }
-
-  void SendMessageImpl(scoped_ptr<WireMessage> message) override {
-    NOTREACHED();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(StubConnection);
-};
-
 class StubSecureContext : public SecureContext {
  public:
   StubSecureContext() {}
   ~StubSecureContext() override {}
 
   void Decode(const std::string& encoded_message,
               const MessageCallback& callback) override {
     NOTREACHED();
   }
 
   void Encode(const std::string& message,
               const MessageCallback& callback) override {
     NOTREACHED();
   }
 
   ProtocolVersion GetProtocolVersion() const override {
     NOTREACHED();
     return SecureContext::PROTOCOL_VERSION_THREE_ONE;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StubSecureContext);
 };
 
 class FakeConnectionFinder : public ConnectionFinder {
  public:
-  FakeConnectionFinder() : connection_(nullptr) {}
+  FakeConnectionFinder(const RemoteDevice& remote_device)
+      : remote_device_(remote_device), connection_(nullptr) {}
   ~FakeConnectionFinder() override {}
 
   void OnConnectionFound() {
     ASSERT_FALSE(connection_callback_.is_null());
-    scoped_ptr<StubConnection> scoped_connection_(new StubConnection());
+    scoped_ptr<FakeConnection> scoped_connection_(
+        new FakeConnection(remote_device_));
     connection_ = scoped_connection_.get();
     connection_callback_.Run(scoped_connection_.Pass());
   }
 
-  StubConnection* connection() { return connection_; }
+  FakeConnection* connection() { return connection_; }
 
  private:
   // ConnectionFinder:
   void Find(const ConnectionCallback& connection_callback) override {
     ASSERT_TRUE(connection_callback_.is_null());
     connection_callback_ = connection_callback;
   }
 
-  StubConnection* connection_;
+  const RemoteDevice remote_device_;
+
+  FakeConnection* connection_;
 
   ConnectionCallback connection_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnectionFinder);
 };
 
 class FakeAuthenticator : public Authenticator {
  public:
   FakeAuthenticator() {}
   ~FakeAuthenticator() override {}
@@ skipping 14 matching lines @@
   }
 
   AuthenticationCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAuthenticator);
 };
 
 // Subclass of RemoteDeviceLifeCycleImpl to make it testable.
 class TestableRemoteDeviceLifeCycleImpl : public RemoteDeviceLifeCycleImpl {
  public:
-  TestableRemoteDeviceLifeCycleImpl()
-      : RemoteDeviceLifeCycleImpl(RemoteDevice(kRemoteDeviceName,
-                                               kRemoteDevicePublicKey,
-                                               kRemoteDeviceBluetoothAddress,
-                                               kRemoteDevicePSK),
-                                  nullptr) {}
+  TestableRemoteDeviceLifeCycleImpl(const RemoteDevice& remote_device)
+      : RemoteDeviceLifeCycleImpl(remote_device, nullptr),
+        remote_device_(remote_device) {}
 
   ~TestableRemoteDeviceLifeCycleImpl() override {}
 
   FakeConnectionFinder* connection_finder() { return connection_finder_; }
   FakeAuthenticator* authenticator() { return authenticator_; }
 
  private:
   scoped_ptr<ConnectionFinder> CreateConnectionFinder() override {
     scoped_ptr<FakeConnectionFinder> scoped_connection_finder(
-        new FakeConnectionFinder());
+        new FakeConnectionFinder(remote_device_));
     connection_finder_ = scoped_connection_finder.get();
     return scoped_connection_finder.Pass();
   }
 
   scoped_ptr<Authenticator> CreateAuthenticator() override {
     scoped_ptr<FakeAuthenticator> scoped_authenticator(new FakeAuthenticator());
     authenticator_ = scoped_authenticator.get();
     return scoped_authenticator.Pass();
   }
 
+  const RemoteDevice remote_device_;
   FakeConnectionFinder* connection_finder_;
   FakeAuthenticator* authenticator_;
 
   DISALLOW_COPY_AND_ASSIGN(TestableRemoteDeviceLifeCycleImpl);
 };
 
 }  // namespace
 
 class ProximityAuthRemoteDeviceLifeCycleImplTest
     : public testing::Test,
       public RemoteDeviceLifeCycle::Observer {
  protected:
   ProximityAuthRemoteDeviceLifeCycleImplTest()
-      : task_runner_(new base::TestSimpleTaskRunner()),
+      : life_cycle_(RemoteDevice(kRemoteDeviceName,
+                                 kRemoteDevicePublicKey,
+                                 kRemoteDeviceBluetoothAddress,
+                                 kRemoteDevicePSK)),
+        task_runner_(new base::TestSimpleTaskRunner()),
         thread_task_runner_handle_(task_runner_) {}
 
   ~ProximityAuthRemoteDeviceLifeCycleImplTest() override {
     life_cycle_.RemoveObserver(this);
   }
 
   void StartLifeCycle() {
     EXPECT_EQ(RemoteDeviceLifeCycle::State::STOPPED, life_cycle_.GetState());
     life_cycle_.AddObserver(this);
 
     EXPECT_CALL(*this, OnLifeCycleStateChanged(
                            RemoteDeviceLifeCycle::State::STOPPED,
                            RemoteDeviceLifeCycle::State::FINDING_CONNECTION));
     life_cycle_.Start();
     task_runner_->RunUntilIdle();
     Mock::VerifyAndClearExpectations(this);
 
     EXPECT_EQ(RemoteDeviceLifeCycle::State::FINDING_CONNECTION,
               life_cycle_.GetState());
   }
 
-  StubConnection* OnConnectionFound() {
+  FakeConnection* OnConnectionFound() {
     EXPECT_EQ(RemoteDeviceLifeCycle::State::FINDING_CONNECTION,
               life_cycle_.GetState());
 
     EXPECT_CALL(*this, OnLifeCycleStateChanged(
                            RemoteDeviceLifeCycle::State::FINDING_CONNECTION,
                            RemoteDeviceLifeCycle::State::AUTHENTICATING));
     life_cycle_.connection_finder()->OnConnectionFound();
     task_runner_->RunUntilIdle();
     Mock::VerifyAndClearExpectations(this);
 
@@ skipping 92 matching lines @@
 
   // Authentication succeeds on second pass.
   Connection* connection = OnConnectionFound();
   Authenticate(Authenticator::Result::SUCCESS);
   EXPECT_TRUE(life_cycle_.GetMessenger());
   EXPECT_CALL(*this, OnLifeCycleStateChanged(_, _));
   connection->Disconnect();
 }
 
 }  // namespace proximity_auth