chromeos/components/tether/connect_tethering_operation_unittest.cc - chromium/src - Git at Google

 // Copyright 2016 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 "chromeos/components/tether/connect_tethering_operation.h"

 #include <memory>
 #include <vector>

 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
 #include "chromeos/components/multidevice/remote_device_test_util.h"
 #include "chromeos/components/tether/message_wrapper.h"
 #include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/components/tether/proto/tether.pb.h"
 #include "chromeos/components/tether/proto_test_util.h"
 #include "chromeos/components/tether/test_timer_factory.h"
 #include "chromeos/services/device_sync/public/cpp/fake_device_sync_client.h"
 #include "chromeos/services/secure_channel/public/cpp/client/fake_client_channel.h"
 #include "chromeos/services/secure_channel/public/cpp/client/fake_connection_attempt.h"
 #include "chromeos/services/secure_channel/public/cpp/client/fake_secure_channel_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 using testing::_;
 using testing::StrictMock;

 namespace chromeos {

 namespace tether {

 namespace {

 constexpr base::TimeDelta kConnectTetheringResponseTimeSeconds =
     base::TimeDelta::FromSeconds(15);

 // Used to verify the ConnectTetheringOperation notifies the observer
 // when appropriate.
 class MockOperationObserver : public ConnectTetheringOperation::Observer {
  public:
   MockOperationObserver() = default;
   ~MockOperationObserver() = default;

   MOCK_METHOD1(OnConnectTetheringRequestSent,
                void(multidevice::RemoteDeviceRef));
   MOCK_METHOD3(OnSuccessfulConnectTetheringResponse,
                void(multidevice::RemoteDeviceRef,
                     const std::string&,
                     const std::string&));
   MOCK_METHOD2(OnConnectTetheringFailure,
                void(multidevice::RemoteDeviceRef,
                     ConnectTetheringOperation::HostResponseErrorCode));

  private:
   DISALLOW_COPY_AND_ASSIGN(MockOperationObserver);
 };

 }  // namespace

 class ConnectTetheringOperationTest : public testing::Test {
  protected:
   ConnectTetheringOperationTest()
       : test_local_device_(multidevice::RemoteDeviceRefBuilder()
                                .SetPublicKey("local device")
                                .Build()),
         remote_device_(multidevice::CreateRemoteDeviceRefForTest()) {}

   void SetUp() override {
     mock_tether_host_response_recorder_ =
         std::make_unique<StrictMock<MockTetherHostResponseRecorder>>();
     fake_device_sync_client_ =
         std::make_unique<device_sync::FakeDeviceSyncClient>();
     fake_device_sync_client_->set_local_device_metadata(test_local_device_);
     fake_secure_channel_client_ =
         std::make_unique<secure_channel::FakeSecureChannelClient>();

     operation_ = ConstructOperation();
     operation_->Initialize();

     ConnectAuthenticatedChannelForDevice(remote_device_);
   }

   std::unique_ptr<ConnectTetheringOperation> ConstructOperation() {
     std::unique_ptr<ConnectTetheringOperation> operation;
     test_timer_factory_ = new TestTimerFactory();

     // Prepare the connection timeout timer to be made for the remote device.
     test_timer_factory_->set_device_id_for_next_timer(
         remote_device_.GetDeviceId());

     auto fake_connection_attempt =
         std::make_unique<secure_channel::FakeConnectionAttempt>();
     remote_device_to_fake_connection_attempt_map_[remote_device_] =
         fake_connection_attempt.get();
     fake_secure_channel_client_->set_next_listen_connection_attempt(
         remote_device_, test_local_device_, std::move(fake_connection_attempt));

     operation = base::WrapUnique(new ConnectTetheringOperation(
         remote_device_, fake_device_sync_client_.get(),
         fake_secure_channel_client_.get(),
         mock_tether_host_response_recorder_.get(), false /* setup_required */));
     operation->SetTimerFactoryForTest(base::WrapUnique(test_timer_factory_));
     operation->AddObserver(&mock_observer_);

     test_clock_.SetNow(base::Time::UnixEpoch());
     operation->SetClockForTest(&test_clock_);

     return operation;
   }

   void ConnectAuthenticatedChannelForDevice(
       multidevice::RemoteDeviceRef remote_device) {
     auto fake_client_channel =
         std::make_unique<secure_channel::FakeClientChannel>();
     remote_device_to_fake_client_channel_map_[remote_device] =
         fake_client_channel.get();
     remote_device_to_fake_connection_attempt_map_[remote_device]
         ->NotifyConnection(std::move(fake_client_channel));
   }

   const multidevice::RemoteDeviceRef test_local_device_;
   const multidevice::RemoteDeviceRef remote_device_;

   base::flat_map<multidevice::RemoteDeviceRef,
                  secure_channel::FakeConnectionAttempt*>
       remote_device_to_fake_connection_attempt_map_;
   base::flat_map<multidevice::RemoteDeviceRef,
                  secure_channel::FakeClientChannel*>
       remote_device_to_fake_client_channel_map_;

   std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
   std::unique_ptr<secure_channel::FakeSecureChannelClient>
       fake_secure_channel_client_;
   std::unique_ptr<StrictMock<MockTetherHostResponseRecorder>>
       mock_tether_host_response_recorder_;
   base::SimpleTestClock test_clock_;
   TestTimerFactory* test_timer_factory_;
   MockOperationObserver mock_observer_;
   base::HistogramTester histogram_tester_;
   std::unique_ptr<ConnectTetheringOperation> operation_;
 };

 TEST_F(ConnectTetheringOperationTest, SuccessWithValidResponse) {
   static const std::string kTestSsid = "testSsid";
   static const std::string kTestPassword = "testPassword";

   EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(remote_device_));

   // Verify that the Observer is called with success and the correct parameters.
   EXPECT_CALL(mock_observer_, OnSuccessfulConnectTetheringResponse(
                                   remote_device_, kTestSsid, kTestPassword));

   // Advance the clock in order to verify a non-zero response duration is
   // recorded and verified (below).
   test_clock_.Advance(kConnectTetheringResponseTimeSeconds);

   // The ConnectTetheringResponse message contains the success response code and
   // the required SSID and password parameters.
   ConnectTetheringResponse response;
   response.set_response_code(ConnectTetheringResponse_ResponseCode::
                                  ConnectTetheringResponse_ResponseCode_SUCCESS);
   response.set_ssid(kTestSsid);
   response.set_password(kTestPassword);
   std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

   operation_->OnMessageReceived(std::move(message), remote_device_);

   // Verify the response duration metric is recorded.
   histogram_tester_.ExpectTimeBucketCount(
       "InstantTethering.Performance.ConnectTetheringResponseDuration",
       kConnectTetheringResponseTimeSeconds, 1);
 }

 // Tests that the SSID and password parameters are a required parameters of the
 // success response code; failure to provide these parameters results in a
 // failed tethering connection.
 TEST_F(ConnectTetheringOperationTest, SuccessButInvalidResponse) {
   EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);

   // Verify that the observer is called with failure and the appropriate error
   // code.
   EXPECT_CALL(
       mock_observer_,
       OnConnectTetheringFailure(
           remote_device_, ConnectTetheringOperation::HostResponseErrorCode::
                               INVALID_HOTSPOT_CREDENTIALS));

   // The ConnectTetheringResponse message does not contain the required SSID and
   // password fields.
   ConnectTetheringResponse response;
   response.set_response_code(ConnectTetheringResponse_ResponseCode::
                                  ConnectTetheringResponse_ResponseCode_SUCCESS);
   std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

   operation_->OnMessageReceived(std::move(message), remote_device_);
 }

 TEST_F(ConnectTetheringOperationTest, UnknownError) {
   EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);

   // Verify that the observer is called with failure and the appropriate error
   // code.
   EXPECT_CALL(
       mock_observer_,
       OnConnectTetheringFailure(
           remote_device_,
           ConnectTetheringOperation::HostResponseErrorCode::UNKNOWN_ERROR));

   ConnectTetheringResponse response;
   response.set_response_code(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR);
   std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

   operation_->OnMessageReceived(std::move(message), remote_device_);
 }

 TEST_F(ConnectTetheringOperationTest, ProvisioningFailed) {
   EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);

   // Verify that the observer is called with failure and the appropriate error
   // code.
   EXPECT_CALL(
       mock_observer_,
       OnConnectTetheringFailure(
           remote_device_, ConnectTetheringOperation::HostResponseErrorCode::
                               PROVISIONING_FAILED));

   ConnectTetheringResponse response;
   response.set_response_code(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_PROVISIONING_FAILED);
   std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

   operation_->OnMessageReceived(std::move(message), remote_device_);
 }

 // Tests that observers are notified when the connection request is sent.
 TEST_F(ConnectTetheringOperationTest, NotifyConnectTetheringRequest) {
   EXPECT_CALL(mock_observer_, OnConnectTetheringRequestSent(remote_device_));

   operation_->OnMessageSent(0 /* sequence_number */);
 }

 // Tests that the message timeout value varies based on whether setup is
 // required or not.
 TEST_F(ConnectTetheringOperationTest, GetMessageTimeoutSeconds) {
   // Setup required case.
   std::unique_ptr<ConnectTetheringOperation> operation(
       new ConnectTetheringOperation(remote_device_,
                                     fake_device_sync_client_.get(),
                                     fake_secure_channel_client_.get(),
                                     mock_tether_host_response_recorder_.get(),
                                     true /* setup_required */));

   EXPECT_EQ(ConnectTetheringOperation::kSetupRequiredResponseTimeoutSeconds,
             operation->GetMessageTimeoutSeconds());

   // Setup not required case.
   operation.reset(new ConnectTetheringOperation(
       remote_device_, fake_device_sync_client_.get(),
       fake_secure_channel_client_.get(),
       mock_tether_host_response_recorder_.get(), false /* setup_required */));

   EXPECT_EQ(ConnectTetheringOperation::kSetupNotRequiredResponseTimeoutSeconds,
             operation->GetMessageTimeoutSeconds());
 }

 // Tests that the ConnectTetheringRequest message is sent to the remote device
 // once the communication channel is connected and authenticated.
 TEST_F(ConnectTetheringOperationTest, ConnectRequestSentOnceAuthenticated) {
   std::unique_ptr<ConnectTetheringOperation> operation = ConstructOperation();
   operation->Initialize();

   // Create the client channel to the remote device.
   auto fake_client_channel =
       std::make_unique<secure_channel::FakeClientChannel>();
   remote_device_to_fake_client_channel_map_[remote_device_] =
       fake_client_channel.get();

   // No requests as a result of creating the client channel.
   auto& sent_messages = fake_client_channel->sent_messages();
   EXPECT_EQ(0u, sent_messages.size());

   // Connect and authenticate the client channel.
   remote_device_to_fake_connection_attempt_map_[remote_device_]
       ->NotifyConnection(std::move(fake_client_channel));

   // Verify the ConnectTetheringRequest message is sent.
   auto message_wrapper =
       std::make_unique<MessageWrapper>(ConnectTetheringRequest());
   std::string expected_payload = message_wrapper->ToRawMessage();
   EXPECT_EQ(1u, sent_messages.size());
   EXPECT_EQ(expected_payload, sent_messages[0].first);
 }

 }  // namespace tether

 }  // namespace chromeos
	// Copyright 2016 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 "chromeos/components/tether/connect_tethering_operation.h"

	#include <memory>
	#include <vector>

	#include "base/logging.h"
	#include "base/memory/ptr_util.h"
	#include "base/optional.h"
	#include "base/test/metrics/histogram_tester.h"
	#include "base/test/scoped_task_environment.h"
	#include "base/test/simple_test_clock.h"
	#include "base/time/time.h"
	#include "base/timer/mock_timer.h"
	#include "chromeos/components/multidevice/remote_device_test_util.h"
	#include "chromeos/components/tether/message_wrapper.h"
	#include "chromeos/components/tether/mock_tether_host_response_recorder.h"
	#include "chromeos/components/tether/proto/tether.pb.h"
	#include "chromeos/components/tether/proto_test_util.h"
	#include "chromeos/components/tether/test_timer_factory.h"
	#include "chromeos/services/device_sync/public/cpp/fake_device_sync_client.h"
	#include "chromeos/services/secure_channel/public/cpp/client/fake_client_channel.h"
	#include "chromeos/services/secure_channel/public/cpp/client/fake_connection_attempt.h"
	#include "chromeos/services/secure_channel/public/cpp/client/fake_secure_channel_client.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	using testing::_;
	using testing::StrictMock;

	namespace chromeos {

	namespace tether {

	namespace {

	constexpr base::TimeDelta kConnectTetheringResponseTimeSeconds =
	base::TimeDelta::FromSeconds(15);

	// Used to verify the ConnectTetheringOperation notifies the observer
	// when appropriate.
	class MockOperationObserver : public ConnectTetheringOperation::Observer {
	public:
	MockOperationObserver() = default;
	~MockOperationObserver() = default;

	MOCK_METHOD1(OnConnectTetheringRequestSent,
	void(multidevice::RemoteDeviceRef));
	MOCK_METHOD3(OnSuccessfulConnectTetheringResponse,
	void(multidevice::RemoteDeviceRef,
	const std::string&,
	const std::string&));
	MOCK_METHOD2(OnConnectTetheringFailure,
	void(multidevice::RemoteDeviceRef,
	ConnectTetheringOperation::HostResponseErrorCode));

	private:
	DISALLOW_COPY_AND_ASSIGN(MockOperationObserver);
	};

	} // namespace

	class ConnectTetheringOperationTest : public testing::Test {
	protected:
	ConnectTetheringOperationTest()
	: test_local_device_(multidevice::RemoteDeviceRefBuilder()
	.SetPublicKey("local device")
	.Build()),
	remote_device_(multidevice::CreateRemoteDeviceRefForTest()) {}

	void SetUp() override {
	mock_tether_host_response_recorder_ =
	std::make_unique<StrictMock<MockTetherHostResponseRecorder>>();
	fake_device_sync_client_ =
	std::make_unique<device_sync::FakeDeviceSyncClient>();
	fake_device_sync_client_->set_local_device_metadata(test_local_device_);
	fake_secure_channel_client_ =
	std::make_unique<secure_channel::FakeSecureChannelClient>();

	operation_ = ConstructOperation();
	operation_->Initialize();

	ConnectAuthenticatedChannelForDevice(remote_device_);
	}

	std::unique_ptr<ConnectTetheringOperation> ConstructOperation() {
	std::unique_ptr<ConnectTetheringOperation> operation;
	test_timer_factory_ = new TestTimerFactory();

	// Prepare the connection timeout timer to be made for the remote device.
	test_timer_factory_->set_device_id_for_next_timer(
	remote_device_.GetDeviceId());

	auto fake_connection_attempt =
	std::make_unique<secure_channel::FakeConnectionAttempt>();
	remote_device_to_fake_connection_attempt_map_[remote_device_] =
	fake_connection_attempt.get();
	fake_secure_channel_client_->set_next_listen_connection_attempt(
	remote_device_, test_local_device_, std::move(fake_connection_attempt));

	operation = base::WrapUnique(new ConnectTetheringOperation(
	remote_device_, fake_device_sync_client_.get(),
	fake_secure_channel_client_.get(),
	mock_tether_host_response_recorder_.get(), false /* setup_required */));
	operation->SetTimerFactoryForTest(base::WrapUnique(test_timer_factory_));
	operation->AddObserver(&mock_observer_);

	test_clock_.SetNow(base::Time::UnixEpoch());
	operation->SetClockForTest(&test_clock_);

	return operation;
	}

	void ConnectAuthenticatedChannelForDevice(
	multidevice::RemoteDeviceRef remote_device) {
	auto fake_client_channel =
	std::make_unique<secure_channel::FakeClientChannel>();
	remote_device_to_fake_client_channel_map_[remote_device] =
	fake_client_channel.get();
	remote_device_to_fake_connection_attempt_map_[remote_device]
	->NotifyConnection(std::move(fake_client_channel));
	}

	const multidevice::RemoteDeviceRef test_local_device_;
	const multidevice::RemoteDeviceRef remote_device_;

	base::flat_map<multidevice::RemoteDeviceRef,
	secure_channel::FakeConnectionAttempt*>
	remote_device_to_fake_connection_attempt_map_;
	base::flat_map<multidevice::RemoteDeviceRef,
	secure_channel::FakeClientChannel*>
	remote_device_to_fake_client_channel_map_;

	std::unique_ptr<device_sync::FakeDeviceSyncClient> fake_device_sync_client_;
	std::unique_ptr<secure_channel::FakeSecureChannelClient>
	fake_secure_channel_client_;
	std::unique_ptr<StrictMock<MockTetherHostResponseRecorder>>
	mock_tether_host_response_recorder_;
	base::SimpleTestClock test_clock_;
	TestTimerFactory* test_timer_factory_;
	MockOperationObserver mock_observer_;
	base::HistogramTester histogram_tester_;
	std::unique_ptr<ConnectTetheringOperation> operation_;
	};

	TEST_F(ConnectTetheringOperationTest, SuccessWithValidResponse) {
	static const std::string kTestSsid = "testSsid";
	static const std::string kTestPassword = "testPassword";

	EXPECT_CALL(*mock_tether_host_response_recorder_,
	RecordSuccessfulConnectTetheringResponse(remote_device_));

	// Verify that the Observer is called with success and the correct parameters.
	EXPECT_CALL(mock_observer_, OnSuccessfulConnectTetheringResponse(
	remote_device_, kTestSsid, kTestPassword));

	// Advance the clock in order to verify a non-zero response duration is
	// recorded and verified (below).
	test_clock_.Advance(kConnectTetheringResponseTimeSeconds);

	// The ConnectTetheringResponse message contains the success response code and
	// the required SSID and password parameters.
	ConnectTetheringResponse response;
	response.set_response_code(ConnectTetheringResponse_ResponseCode::
	ConnectTetheringResponse_ResponseCode_SUCCESS);
	response.set_ssid(kTestSsid);
	response.set_password(kTestPassword);
	std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

	operation_->OnMessageReceived(std::move(message), remote_device_);

	// Verify the response duration metric is recorded.
	histogram_tester_.ExpectTimeBucketCount(
	"InstantTethering.Performance.ConnectTetheringResponseDuration",
	kConnectTetheringResponseTimeSeconds, 1);
	}

	// Tests that the SSID and password parameters are a required parameters of the
	// success response code; failure to provide these parameters results in a
	// failed tethering connection.
	TEST_F(ConnectTetheringOperationTest, SuccessButInvalidResponse) {
	EXPECT_CALL(*mock_tether_host_response_recorder_,
	RecordSuccessfulConnectTetheringResponse(_))
	.Times(0);

	// Verify that the observer is called with failure and the appropriate error
	// code.
	EXPECT_CALL(
	mock_observer_,
	OnConnectTetheringFailure(
	remote_device_, ConnectTetheringOperation::HostResponseErrorCode::
	INVALID_HOTSPOT_CREDENTIALS));

	// The ConnectTetheringResponse message does not contain the required SSID and
	// password fields.
	ConnectTetheringResponse response;
	response.set_response_code(ConnectTetheringResponse_ResponseCode::
	ConnectTetheringResponse_ResponseCode_SUCCESS);
	std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

	operation_->OnMessageReceived(std::move(message), remote_device_);
	}

	TEST_F(ConnectTetheringOperationTest, UnknownError) {
	EXPECT_CALL(*mock_tether_host_response_recorder_,
	RecordSuccessfulConnectTetheringResponse(_))
	.Times(0);

	// Verify that the observer is called with failure and the appropriate error
	// code.
	EXPECT_CALL(
	mock_observer_,
	OnConnectTetheringFailure(
	remote_device_,
	ConnectTetheringOperation::HostResponseErrorCode::UNKNOWN_ERROR));

	ConnectTetheringResponse response;
	response.set_response_code(
	ConnectTetheringResponse_ResponseCode::
	ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR);
	std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

	operation_->OnMessageReceived(std::move(message), remote_device_);
	}

	TEST_F(ConnectTetheringOperationTest, ProvisioningFailed) {
	EXPECT_CALL(*mock_tether_host_response_recorder_,
	RecordSuccessfulConnectTetheringResponse(_))
	.Times(0);

	// Verify that the observer is called with failure and the appropriate error
	// code.
	EXPECT_CALL(
	mock_observer_,
	OnConnectTetheringFailure(
	remote_device_, ConnectTetheringOperation::HostResponseErrorCode::
	PROVISIONING_FAILED));

	ConnectTetheringResponse response;
	response.set_response_code(
	ConnectTetheringResponse_ResponseCode::
	ConnectTetheringResponse_ResponseCode_PROVISIONING_FAILED);
	std::unique_ptr<MessageWrapper> message(new MessageWrapper(response));

	operation_->OnMessageReceived(std::move(message), remote_device_);
	}

	// Tests that observers are notified when the connection request is sent.
	TEST_F(ConnectTetheringOperationTest, NotifyConnectTetheringRequest) {
	EXPECT_CALL(mock_observer_, OnConnectTetheringRequestSent(remote_device_));

	operation_->OnMessageSent(0 /* sequence_number */);
	}

	// Tests that the message timeout value varies based on whether setup is
	// required or not.
	TEST_F(ConnectTetheringOperationTest, GetMessageTimeoutSeconds) {
	// Setup required case.
	std::unique_ptr<ConnectTetheringOperation> operation(
	new ConnectTetheringOperation(remote_device_,
	fake_device_sync_client_.get(),
	fake_secure_channel_client_.get(),
	mock_tether_host_response_recorder_.get(),
	true /* setup_required */));

	EXPECT_EQ(ConnectTetheringOperation::kSetupRequiredResponseTimeoutSeconds,
	operation->GetMessageTimeoutSeconds());

	// Setup not required case.
	operation.reset(new ConnectTetheringOperation(
	remote_device_, fake_device_sync_client_.get(),
	fake_secure_channel_client_.get(),
	mock_tether_host_response_recorder_.get(), false /* setup_required */));

	EXPECT_EQ(ConnectTetheringOperation::kSetupNotRequiredResponseTimeoutSeconds,
	operation->GetMessageTimeoutSeconds());
	}

	// Tests that the ConnectTetheringRequest message is sent to the remote device
	// once the communication channel is connected and authenticated.
	TEST_F(ConnectTetheringOperationTest, ConnectRequestSentOnceAuthenticated) {
	std::unique_ptr<ConnectTetheringOperation> operation = ConstructOperation();
	operation->Initialize();

	// Create the client channel to the remote device.
	auto fake_client_channel =
	std::make_unique<secure_channel::FakeClientChannel>();
	remote_device_to_fake_client_channel_map_[remote_device_] =
	fake_client_channel.get();

	// No requests as a result of creating the client channel.
	auto& sent_messages = fake_client_channel->sent_messages();
	EXPECT_EQ(0u, sent_messages.size());

	// Connect and authenticate the client channel.
	remote_device_to_fake_connection_attempt_map_[remote_device_]
	->NotifyConnection(std::move(fake_client_channel));

	// Verify the ConnectTetheringRequest message is sent.
	auto message_wrapper =
	std::make_unique<MessageWrapper>(ConnectTetheringRequest());
	std::string expected_payload = message_wrapper->ToRawMessage();
	EXPECT_EQ(1u, sent_messages.size());
	EXPECT_EQ(expected_payload, sent_messages[0].first);
	}

	} // namespace tether

	} // namespace chromeos