// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/tether/disconnect_tethering_request_sender_impl.h"
#include <memory>
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/test/task_environment.h"
#include "chromeos/ash/components/multidevice/remote_device_ref.h"
#include "chromeos/ash/components/multidevice/remote_device_test_util.h"
#include "chromeos/ash/components/tether/disconnect_tethering_operation.h"
#include "chromeos/ash/components/tether/disconnect_tethering_request_sender.h"
#include "chromeos/ash/components/tether/fake_host_connection.h"
#include "chromeos/ash/components/tether/fake_tether_host_fetcher.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash {
namespace tether {
namespace {
class FakeDisconnectTetheringOperation : public DisconnectTetheringOperation {
public:
FakeDisconnectTetheringOperation(
const TetherHost& tether_host,
raw_ptr<HostConnection::Factory> host_connection_factory)
: DisconnectTetheringOperation(tether_host, host_connection_factory),
tether_host_(tether_host) {}
~FakeDisconnectTetheringOperation() override = default;
void NotifyFinished(bool success) {
NotifyObserversOperationFinished(success);
}
std::string GetDeviceId() { return tether_host_.GetDeviceId(); }
private:
TetherHost tether_host_;
};
class FakeDisconnectTetheringOperationFactory
: public DisconnectTetheringOperation::Factory {
public:
FakeDisconnectTetheringOperationFactory() = default;
~FakeDisconnectTetheringOperationFactory() override = default;
std::vector<raw_ptr<FakeDisconnectTetheringOperation, VectorExperimental>>&
created_operations() {
return created_operations_;
}
protected:
// DisconnectTetheringOperation::Factory:
std::unique_ptr<DisconnectTetheringOperation> CreateInstance(
const TetherHost& tether_host,
raw_ptr<HostConnection::Factory> host_connection_factory) override {
FakeDisconnectTetheringOperation* operation =
new FakeDisconnectTetheringOperation(tether_host,
host_connection_factory);
created_operations_.push_back(operation);
return base::WrapUnique(operation);
}
private:
std::vector<raw_ptr<FakeDisconnectTetheringOperation, VectorExperimental>>
created_operations_;
};
class FakeDisconnectTetheringRequestSenderObserver
: public DisconnectTetheringRequestSender::Observer {
public:
FakeDisconnectTetheringRequestSenderObserver()
: num_no_more_pending_requests_events_(0) {}
~FakeDisconnectTetheringRequestSenderObserver() override = default;
void OnPendingDisconnectRequestsComplete() override {
num_no_more_pending_requests_events_++;
}
uint32_t num_no_more_pending_requests_events() {
return num_no_more_pending_requests_events_;
}
private:
uint32_t num_no_more_pending_requests_events_;
};
} // namespace
class DisconnectTetheringRequestSenderTest : public testing::Test {
public:
DisconnectTetheringRequestSenderTest()
: test_devices_(multidevice::CreateRemoteDeviceRefListForTest(2u)) {}
DisconnectTetheringRequestSenderTest(
const DisconnectTetheringRequestSenderTest&) = delete;
DisconnectTetheringRequestSenderTest& operator=(
const DisconnectTetheringRequestSenderTest&) = delete;
~DisconnectTetheringRequestSenderTest() override = default;
void SetUp() override {
fake_tether_host_fetcher_ =
std::make_unique<FakeTetherHostFetcher>(test_devices_[0]);
fake_host_connection_factory_ =
std::make_unique<FakeHostConnection::Factory>();
fake_operation_factory_ =
std::make_unique<FakeDisconnectTetheringOperationFactory>();
DisconnectTetheringOperation::Factory::SetFactoryForTesting(
fake_operation_factory_.get());
disconnect_tethering_request_sender_ =
DisconnectTetheringRequestSenderImpl::Factory::Create(
fake_host_connection_factory_.get(),
fake_tether_host_fetcher_.get());
fake_disconnect_tethering_request_sender_observer_ =
std::make_unique<FakeDisconnectTetheringRequestSenderObserver>();
disconnect_tethering_request_sender_->AddObserver(
fake_disconnect_tethering_request_sender_observer_.get());
}
void TearDown() override {
disconnect_tethering_request_sender_->RemoveObserver(
fake_disconnect_tethering_request_sender_observer_.get());
}
void SendConcurrentRequestsToTwoDevices(bool first_operation_successful,
bool second_operation_successful) {
// Send requests to two devices concurrently.
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[1].GetDeviceId());
EXPECT_TRUE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(0u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
ASSERT_EQ(2u, fake_operation_factory_->created_operations().size());
EXPECT_EQ(test_devices_[0].GetDeviceId(),
fake_operation_factory_->created_operations()[0]->GetDeviceId());
EXPECT_EQ(test_devices_[1].GetDeviceId(),
fake_operation_factory_->created_operations()[1]->GetDeviceId());
fake_operation_factory_->created_operations()[0]->NotifyFinished(
first_operation_successful);
EXPECT_TRUE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(0u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
fake_operation_factory_->created_operations()[1]->NotifyFinished(
second_operation_successful);
EXPECT_FALSE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(1u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
}
void CallSendRequestTwiceWithOneDevice(bool operation_successful) {
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
EXPECT_TRUE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(0u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
// When multiple concurrent attempts are made to send a request to the
// same device, only one DisconnectTetheringOperation is created.
ASSERT_EQ(1u, fake_operation_factory_->created_operations().size());
EXPECT_EQ(test_devices_[0].GetDeviceId(),
fake_operation_factory_->created_operations()[0]->GetDeviceId());
fake_operation_factory_->created_operations()[0]->NotifyFinished(
operation_successful);
EXPECT_FALSE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(1u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
}
const multidevice::RemoteDeviceRefList test_devices_;
std::unique_ptr<FakeTetherHostFetcher> fake_tether_host_fetcher_;
std::unique_ptr<FakeHostConnection::Factory> fake_host_connection_factory_;
std::unique_ptr<FakeDisconnectTetheringOperationFactory>
fake_operation_factory_;
std::unique_ptr<DisconnectTetheringRequestSender>
disconnect_tethering_request_sender_;
std::unique_ptr<FakeDisconnectTetheringRequestSenderObserver>
fake_disconnect_tethering_request_sender_observer_;
};
TEST_F(DisconnectTetheringRequestSenderTest, DISABLED_SendRequest_Success) {
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
EXPECT_TRUE(disconnect_tethering_request_sender_->HasPendingRequests());
ASSERT_EQ(1u, fake_operation_factory_->created_operations().size());
EXPECT_EQ(test_devices_[0].GetDeviceId(),
fake_operation_factory_->created_operations()[0]->GetDeviceId());
fake_operation_factory_->created_operations()[0]->NotifyFinished(
true /* success */);
EXPECT_FALSE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(1u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
}
TEST_F(DisconnectTetheringRequestSenderTest,
DISABLED_SendRequest_CannotFetchHost) {
// Remove hosts from |fake_tether_host_fetcher_|; this will cause the
// fetcher to return a null RemoteDevice.
fake_tether_host_fetcher_->SetTetherHost(std::nullopt);
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
EXPECT_TRUE(fake_operation_factory_->created_operations().empty());
EXPECT_EQ(0u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
}
TEST_F(
DisconnectTetheringRequestSenderTest,
DISABLED_MultipleRequestAttempts_Concurrent_DifferentDeviceId_BothOperationsSuccessful) {
SendConcurrentRequestsToTwoDevices(true /* first_operation_successful */,
true /* second_operation_successful */);
}
TEST_F(
DisconnectTetheringRequestSenderTest,
DISABLED_MultipleRequestAttempts_Concurrent_DifferentDeviceId_BothOperationsFailed) {
SendConcurrentRequestsToTwoDevices(false /* first_operation_successful */,
false /* second_operation_successful */);
}
TEST_F(
DisconnectTetheringRequestSenderTest,
DISABLED_MultipleRequestAttempts_Concurrent_DifferentDeviceId_FirstOperationSuccessful) {
SendConcurrentRequestsToTwoDevices(true /* first_operation_successful */,
false /* second_operation_successful */);
}
TEST_F(
DisconnectTetheringRequestSenderTest,
DISABLED_MultipleRequestAttempts_Concurrent_DifferentDeviceId_SecondOperationSuccessful) {
SendConcurrentRequestsToTwoDevices(false /* first_operation_successful */,
true /* second_operation_successful */);
}
TEST_F(
DisconnectTetheringRequestSenderTest,
DISABLED_MultipleRequestAttempts_Concurrent_SameDeviceId_OperationSuccessful) {
CallSendRequestTwiceWithOneDevice(true /* operation_successful */);
}
TEST_F(
DisconnectTetheringRequestSenderTest,
DISABLED_MultipleRequestAttempts_Concurrent_SameDeviceId_OperationFailed) {
CallSendRequestTwiceWithOneDevice(false /* operation_successful */);
}
TEST_F(DisconnectTetheringRequestSenderTest,
DISABLED_SendMultipleRequests_NotifyFinished) {
// When multiple requests are sent, a new DisconnectTetheringOperation will
// be created if the previous one has finished. This is true regardless of
// the success of the previous operation.
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
EXPECT_TRUE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(0u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
ASSERT_EQ(1u, fake_operation_factory_->created_operations().size());
EXPECT_EQ(test_devices_[0].GetDeviceId(),
fake_operation_factory_->created_operations()[0]->GetDeviceId());
fake_operation_factory_->created_operations()[0]->NotifyFinished(
true /* success */);
EXPECT_FALSE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(1u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
ASSERT_EQ(2u, fake_operation_factory_->created_operations().size());
EXPECT_EQ(test_devices_[0].GetDeviceId(),
fake_operation_factory_->created_operations()[1]->GetDeviceId());
fake_operation_factory_->created_operations()[1]->NotifyFinished(
false /* success */);
EXPECT_FALSE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(2u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
disconnect_tethering_request_sender_->SendDisconnectRequestToDevice(
test_devices_[0].GetDeviceId());
ASSERT_EQ(3u, fake_operation_factory_->created_operations().size());
EXPECT_EQ(test_devices_[0].GetDeviceId(),
fake_operation_factory_->created_operations()[2]->GetDeviceId());
fake_operation_factory_->created_operations()[2]->NotifyFinished(
true /* success */);
EXPECT_FALSE(disconnect_tethering_request_sender_->HasPendingRequests());
EXPECT_EQ(3u, fake_disconnect_tethering_request_sender_observer_
->num_no_more_pending_requests_events());
}
} // namespace tether
} // namespace ash
Codebase Browser
chromium