device/bluetooth/server_socket_unittest.cc

// Copyright 2020 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 "device/bluetooth/server_socket.h"

#include <memory>
#include <tuple>
#include <vector>

#include "base/callback_helpers.h"
#include "base/location.h"
#include "base/run_loop.h"
#include "base/test/task_environment.h"
#include "device/bluetooth/bluetooth_socket.h"
#include "device/bluetooth/socket.h"
#include "device/bluetooth/test/fake_bluetooth_socket.h"
#include "device/bluetooth/test/mock_bluetooth_adapter.h"
#include "device/bluetooth/test/mock_bluetooth_device.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "net/base/io_buffer.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/types/optional.h"

namespace bluetooth {

class ServerSocketTest : public testing::Test {
 public:
  ServerSocketTest() = default;
  ~ServerSocketTest() override = default;
  ServerSocketTest(const ServerSocketTest&) = delete;
  ServerSocketTest& operator=(const ServerSocketTest&) = delete;

  void SetUp() override {
    mock_bluetooth_adapter_ =
        base::MakeRefCounted<testing::NiceMock<device::MockBluetoothAdapter>>();
    mock_bluetooth_device_ =
        std::make_unique<testing::NiceMock<device::MockBluetoothDevice>>(
            mock_bluetooth_adapter_.get(),
            /*class=*/0, "DeviceName", "DeviceAddress",
            /*paired=*/false,
            /*connected=*/false);

    fake_bluetooth_server_socket_ =
        base::MakeRefCounted<device::FakeBluetoothSocket>();
    server_socket_ =
        std::make_unique<ServerSocket>(fake_bluetooth_server_socket_);
  }

 protected:
  void Accept() {
    server_socket_->Accept(
        base::BindOnce(&ServerSocketTest::OnAccept, base::Unretained(this)));

    EXPECT_TRUE(fake_bluetooth_server_socket_->HasAcceptArgs());
  }

  std::unique_ptr<ServerSocket> server_socket_;
  scoped_refptr<device::FakeBluetoothSocket> fake_bluetooth_server_socket_;

  scoped_refptr<testing::NiceMock<device::MockBluetoothAdapter>>
      mock_bluetooth_adapter_;
  std::unique_ptr<testing::NiceMock<device::MockBluetoothDevice>>
      mock_bluetooth_device_;
  mojom::AcceptConnectionResultPtr accept_connection_result_;

 private:
  void OnAccept(mojom::AcceptConnectionResultPtr result) {
    accept_connection_result_ = std::move(result);
  }

  base::test::SingleThreadTaskEnvironment task_environment;
};

TEST_F(ServerSocketTest, TestOnDestroyCallsClose) {
  // When destroyed, |server_socket_| is expected to tear down its
  // BluetoothSocket.
  server_socket_.reset();
  EXPECT_TRUE(fake_bluetooth_server_socket_->called_disconnect());
}

TEST_F(ServerSocketTest, TestAccept_Success) {
  Accept();
  auto accept_args = fake_bluetooth_server_socket_->TakeAcceptArgs();

  auto success_callback = std::move(std::get<0>(*accept_args));
  auto fake_bluetooth_client_socket =
      base::MakeRefCounted<device::FakeBluetoothSocket>();
  std::move(success_callback)
      .Run(/*device=*/mock_bluetooth_device_.get(),
           /*bluetooth_socket=*/fake_bluetooth_client_socket);

  EXPECT_TRUE(accept_connection_result_);
  EXPECT_EQ(mock_bluetooth_device_->GetName(),
            accept_connection_result_->device->name);
  auto pending_socket = std::move(accept_connection_result_->socket);
  EXPECT_TRUE(pending_socket.is_valid());
  EXPECT_TRUE(accept_connection_result_->receive_stream.is_valid());
  EXPECT_TRUE(accept_connection_result_->send_stream.is_valid());

  // Ensure that the underlying BluetoothSocket is
  // |fake_bluetooth_client_socket|.
  mojo::Remote<mojom::Socket> socket(std::move(pending_socket));
  base::RunLoop run_loop;
  socket->Disconnect(run_loop.QuitClosure());
  run_loop.Run();
  EXPECT_TRUE(fake_bluetooth_client_socket->called_disconnect());

  EXPECT_FALSE(fake_bluetooth_server_socket_->HasAcceptArgs());
}

TEST_F(ServerSocketTest, TestAccept_Error) {
  Accept();
  auto accept_args = fake_bluetooth_server_socket_->TakeAcceptArgs();

  auto error_callback = std::move(std::get<1>(*accept_args));
  std::move(error_callback).Run("ErrorMessage");

  EXPECT_FALSE(accept_connection_result_);

  EXPECT_FALSE(fake_bluetooth_server_socket_->HasAcceptArgs());
}

TEST_F(ServerSocketTest, TestDisconnect) {
  server_socket_->Disconnect(base::DoNothing());
  EXPECT_TRUE(fake_bluetooth_server_socket_->called_disconnect());
}

}  // namespace bluetooth