// 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/wifi_hotspot_connector.h"
#include <memory>
#include <sstream>
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/simple_test_clock.h"
#include "base/test/task_environment.h"
#include "base/test/test_simple_task_runner.h"
#include "base/timer/mock_timer.h"
#include "base/values.h"
#include "chromeos/ash/components/login/login_state/login_state.h"
#include "chromeos/ash/components/network/network_connect.h"
#include "chromeos/ash/components/network/network_connection_handler.h"
#include "chromeos/ash/components/network/network_connection_observer.h"
#include "chromeos/ash/components/network/network_handler_test_helper.h"
#include "chromeos/ash/components/network/network_state.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/network_state_handler_observer.h"
#include "chromeos/ash/components/network/network_state_test_helper.h"
#include "chromeos/ash/components/network/network_type_pattern.h"
#include "chromeos/ash/components/network/shill_property_util.h"
#include "chromeos/ash/components/network/technology_state_controller.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
namespace ash {
namespace tether {
using ::testing::IsEmpty;
using ::testing::Not;
namespace {
const char kSsid[] = "ssid";
const char kPassword[] = "password";
const char kOtherWifiServiceGuid[] = "otherWifiServiceGuid";
const char kTetherNetworkGuid[] = "tetherNetworkGuid";
const char kTetherNetworkGuid2[] = "tetherNetworkGuid2";
constexpr base::TimeDelta kConnectionToHotspotTime = base::Seconds(20);
std::string CreateConfigurationJsonString(const std::string& guid) {
std::stringstream ss;
ss << "{" << " \"GUID\": \"" << guid << "\"," << " \"Type\": \""
<< shill::kTypeWifi << "\"," << " \"State\": \"" << shill::kStateIdle
<< "\"," << " \"Visible\":\"" << "false" << "\"" << "}";
return ss.str();
}
std::string GetSsid(const base::Value::Dict& shill_properties) {
return shill_property_util::GetSSIDFromProperties(shill_properties, false,
nullptr);
}
std::string GetSecurityClass(const base::Value::Dict& shill_properties) {
const std::string* security =
shill_properties.FindString(shill::kSecurityClassProperty);
return security ? *security : std::string();
}
std::string GetPassphrase(const base::Value::Dict& shill_properties) {
const std::string* passphrase =
shill_properties.FindString(shill::kPassphraseProperty);
return passphrase ? *passphrase : std::string();
}
std::string GetGuid(const base::Value::Dict& shill_properties) {
const std::string* guid = shill_properties.FindString(shill::kGuidProperty);
return guid ? *guid : std::string();
}
// Checks properties of the service described by shill_properties|:
// - has a SSID |expected_ssid| and
// - has a non-empty GUID.
// Returns true if all checks were successful, false otherwise.
// Fills the GUID of the service into |*out_guid|.
bool VerifyBaseConfiguration(const base::Value::Dict& shill_properties,
const std::string& expected_ssid,
std::string* out_guid) {
bool ok = true;
std::string actual_ssid = GetSsid(shill_properties);
if (actual_ssid != expected_ssid) {
ADD_FAILURE() << "Expected SSID '" << expected_ssid << "' but had '"
<< actual_ssid;
ok = false;
}
*out_guid = GetGuid(shill_properties);
if (out_guid->empty()) {
ADD_FAILURE() << "Had empty GUID";
ok = false;
}
return ok;
}
// Checks properties of the service described by shill_properties|:
// - has a SSID |expected_ssid|,
// - has a non-empty GUID,
// - has security class PSK and
// - has the passphrase |expected_passphrase|.
// Returns true if all checks were successful, false otherwise.
// Fills the GUID of the service into |*out_guid|.
bool VerifyPskConfiguration(const base::Value::Dict& shill_properties,
const std::string& expected_ssid,
const std::string& expected_passphrase,
std::string* out_guid) {
if (shill_properties.empty()) {
ADD_FAILURE() << "Received empty shill_properties";
return false;
}
bool ok = VerifyBaseConfiguration(shill_properties, expected_ssid, out_guid);
std::string actual_security_class = GetSecurityClass(shill_properties);
if (actual_security_class != shill::kSecurityClassPsk) {
ADD_FAILURE() << "Expected security class '" << shill::kSecurityClassPsk
<< "' but had '" << actual_security_class;
ok = false;
}
std::string actual_passphrase = GetPassphrase(shill_properties);
if (actual_security_class != shill::kSecurityClassPsk) {
ADD_FAILURE() << "Expected passphrase '" << expected_passphrase
<< "' but had '" << actual_passphrase;
ok = false;
}
return ok;
}
// Checks properties of the service described by shill_properties|:
// - has a SSID |expected_ssid|,
// - has a non-empty GUID and
// - has security class None.
// Returns true if all checks were successful, false otherwise.
// Fills the GUID of the service into |*out_guid|.
bool VerifyOpenConfiguration(const base::Value::Dict& shill_properties,
const std::string& expected_ssid,
std::string* out_guid) {
bool ok = VerifyBaseConfiguration(shill_properties, expected_ssid, out_guid);
std::string actual_security_class = GetSecurityClass(shill_properties);
if (actual_security_class != shill::kSecurityClassNone) {
ADD_FAILURE() << "Expected security class '" << shill::kSecurityClassNone
<< "' but had '" << actual_security_class;
ok = false;
}
return ok;
}
} // namespace
class WifiHotspotConnectorTest : public testing::Test,
public NetworkConnectionObserver {
public:
class TestNetworkConnect : public NetworkConnect {
public:
explicit TestNetworkConnect(NetworkHandlerTestHelper* helper)
: helper_(helper) {}
~TestNetworkConnect() override = default;
void set_is_running_in_test_task_runner(
bool is_running_in_test_task_runner) {
is_running_in_test_task_runner_ = is_running_in_test_task_runner;
}
// Returns a Dict object with no entries if no configuration has been passed
// to TestNetworkConnect yet.
const base::Value::Dict GetLastConfiguration() {
return last_configuration_.empty() ? base::Value::Dict()
: last_configuration_.Clone();
}
std::string last_service_path_created() {
return last_service_path_created_;
}
// Finish configuring the last specified Wi-Fi network config.
void ConfigureServiceWithLastNetworkConfig() {
ASSERT_FALSE(last_configuration_.empty());
const std::string* wifi_guid =
last_configuration_.FindString(shill::kGuidProperty);
ASSERT_TRUE(wifi_guid);
last_service_path_created_ =
helper_->ConfigureService(CreateConfigurationJsonString(*wifi_guid));
}
// NetworkConnect:
void ShowMobileSetup(const std::string& network_id) override {}
void ShowCarrierAccountDetail(const std::string& network_id) override {}
void ShowCarrierUnlockNotification() override {}
void ShowPortalSignin(const std::string& service_path,
NetworkConnect::Source source) override {}
void ConfigureNetworkIdAndConnect(const std::string& network_id,
const base::Value::Dict& shill_properties,
bool shared) override {}
void CreateConfigurationAndConnect(base::Value::Dict shill_properties,
bool shared) override {}
void CreateConfiguration(base::Value::Dict shill_properties,
bool shared) override {
EXPECT_FALSE(shared);
last_configuration_ = std::move(shill_properties);
// Prevent nested RunLoops when ConfigureServiceWithLastNetworkConfig()
// calls NetworkStateTestHelper::ConfigureService(); that causes threading
// issues. If |test_task_runner_| is causing this function to be run, the
// client which triggered this call can manually call
// ConfigureServiceWithLastNetworkConfig() once done.
if (!is_running_in_test_task_runner_) {
ConfigureServiceWithLastNetworkConfig();
}
}
void ConnectToNetworkId(const std::string& network_id) override {}
void DisconnectFromNetworkId(const std::string& network_id) override {}
private:
raw_ptr<NetworkHandlerTestHelper> helper_;
// Has type base::Value::Type::NONE if no configuration has been passed to
// TestNetworkConnect yet.
base::Value::Dict last_configuration_;
std::string last_service_path_created_;
bool is_running_in_test_task_runner_ = false;
};
class TestNetworkStateHandlerObserver : public NetworkStateHandlerObserver {
public:
bool DidTriggerScan() { return did_trigger_scan_; }
void Reset() { did_trigger_scan_ = false; }
// NetworkStateHandlerObserver:
void ScanRequested(const NetworkTypePattern& type) override {
if (type.MatchesPattern(NetworkTypePattern::WiFi())) {
did_trigger_scan_ = true;
}
}
private:
bool did_trigger_scan_ = false;
};
WifiHotspotConnectorTest() = default;
WifiHotspotConnectorTest(const WifiHotspotConnectorTest&) = delete;
WifiHotspotConnectorTest& operator=(const WifiHotspotConnectorTest&) = delete;
~WifiHotspotConnectorTest() override = default;
void SetUp() override {
if (!LoginState::IsInitialized()) {
LoginState::Initialize();
}
other_wifi_service_path_.clear();
connection_callback_responses_.clear();
network_state_handler()->SetTetherTechnologyState(
NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED);
technology_state_controller()->SetTechnologiesEnabled(
NetworkTypePattern::WiFi(), true /* enabled */,
network_handler::ErrorCallback());
base::RunLoop().RunUntilIdle();
SetUpShillState();
test_network_connect_ = base::WrapUnique(new TestNetworkConnect(&helper_));
network_state_handler()->AddTetherNetworkState(
kTetherNetworkGuid, "tetherNetworkName" /* name */,
"tetherNetworkCarrier" /* carrier */, 100 /* full battery */,
100 /* full signal strength */, false /* has_connected_to_host */);
network_state_handler()->AddTetherNetworkState(
kTetherNetworkGuid2, "tetherNetworkName2" /* name */,
"tetherNetworkCarrier2" /* carrier */, 100 /* full battery */,
100 /* full signal strength */, false /* has_connected_to_host */);
wifi_hotspot_connector_ = base::WrapUnique(new WifiHotspotConnector(
NetworkHandler::Get(), test_network_connect_.get()));
mock_timer_ = new base::MockOneShotTimer();
test_clock_.SetNow(base::Time::UnixEpoch());
test_task_runner_ = base::MakeRefCounted<base::TestSimpleTaskRunner>();
wifi_hotspot_connector_->SetTestDoubles(base::WrapUnique(mock_timer_.get()),
&test_clock_, test_task_runner_);
network_state_handler()->AddObserver(&scan_observer_);
NetworkHandler::Get()->network_connection_handler()->AddObserver(this);
}
std::string GetServicePath(std::string network_guid) {
return "service_path_for_" + network_guid;
}
void SetUpShillState() {
// Add a Wi-Fi service unrelated to the one under test. In some tests, a
// connection from another device is tested.
other_wifi_service_path_ = helper_.ConfigureService(
CreateConfigurationJsonString(std::string(kOtherWifiServiceGuid)));
}
void TearDown() override {
wifi_hotspot_connector_.reset();
network_state_handler()->RemoveObserver(&scan_observer_);
NetworkHandler::Get()->network_connection_handler()->RemoveObserver(this);
scan_observer_.Reset();
requested_connection_service_paths_.clear();
successful_connection_service_paths_.clear();
failed_connection_service_paths_.clear();
disconnect_requested_service_paths_.clear();
requested_failure_count_ = 0;
}
void VerifyTimerSet() {
EXPECT_TRUE(mock_timer_->IsRunning());
EXPECT_EQ(base::Seconds(WifiHotspotConnector::kConnectionTimeoutSeconds),
mock_timer_->GetCurrentDelay());
}
void VerifyTimerStopped() { EXPECT_FALSE(mock_timer_->IsRunning()); }
void InvokeTimerTask() {
VerifyTimerSet();
mock_timer_->Fire();
}
void RunTestTaskRunner() {
test_network_connect_->set_is_running_in_test_task_runner(true);
test_task_runner_->RunUntilIdle();
test_network_connect_->set_is_running_in_test_task_runner(false);
}
void NotifyVisible(const std::string& service_path) {
helper_.SetServiceProperty(
service_path, std::string(shill::kVisibleProperty), base::Value(true));
RunTestTaskRunner();
}
void NotifyConnected(const std::string& service_path) {
helper_.SetServiceProperty(service_path, std::string(shill::kStateProperty),
base::Value(shill::kStateReady));
RunTestTaskRunner();
}
void VerifyConnectionToHotspotDurationRecorded(bool expected) {
if (expected) {
histogram_tester_.ExpectTimeBucketCount(
"InstantTethering.Performance.ConnectToHotspotDuration",
kConnectionToHotspotTime, 1);
} else {
histogram_tester_.ExpectTotalCount(
"InstantTethering.Performance.ConnectToHotspotDuration", 0);
}
}
void VerifyTetherAndWifiNetworkAssociation(
const std::string& wifi_guid,
const std::string& tether_guid,
uint32_t expected_num_connection_attempts) {
const NetworkState* wifi_network_state =
network_state_handler()->GetNetworkStateFromGuid(wifi_guid);
ASSERT_TRUE(wifi_network_state);
EXPECT_EQ(tether_guid, wifi_network_state->tether_guid());
const NetworkState* tether_network_state =
network_state_handler()->GetNetworkStateFromGuid(tether_guid);
ASSERT_TRUE(tether_network_state);
EXPECT_EQ(wifi_guid, tether_network_state->tether_guid());
EXPECT_EQ(expected_num_connection_attempts,
requested_connection_service_paths_.size());
}
void VerifyNetworkNotAssociated(const std::string& guid) {
const NetworkState* network_state =
network_state_handler()->GetNetworkStateFromGuid(guid);
ASSERT_TRUE(network_state);
EXPECT_TRUE(network_state->tether_guid().empty());
}
void WifiConnectionCallback(
base::expected<std::string,
WifiHotspotConnector::WifiHotspotConnectionError> result) {
connection_callback_responses_.push_back(result);
}
void VerifyWifiScanRequested() {
EXPECT_TRUE(scan_observer_.DidTriggerScan());
}
// Pause any connection attempts for a service path by setting an empty custom
// connection handler on the ShillServiceClient
void PauseConnectionAttempts(const std::string& network_guid) {
helper_.service_test()->SetConnectBehavior(GetServicePath(network_guid),
base::DoNothing());
}
void HandleConnect() {}
// NetworkConnectionObserver:
void ConnectToNetworkRequested(const std::string& service_path) override {
if (requested_failure_count_ > 0) {
helper_.service_test()->SetErrorForNextConnectionAttempt("Failure");
}
requested_connection_service_paths_.push_back(service_path);
}
void ConnectSucceeded(const std::string& service_path) override {
successful_connection_service_paths_.push_back(service_path);
}
void ConnectFailed(const std::string& service_path,
const std::string& error_name) override {
if (requested_failure_count_ > 0) {
requested_failure_count_--;
}
failed_connection_service_paths_.push_back(service_path);
}
void DisconnectRequested(const std::string& service_path) override {
disconnect_requested_service_paths_.push_back(service_path);
}
void SetNumberOfUpcomingConsecutiveFailures(int count) {
requested_failure_count_ = count;
}
NetworkStateHandler* network_state_handler() {
return NetworkHandler::Get()->network_state_handler();
}
TechnologyStateController* technology_state_controller() {
return NetworkHandler::Get()->technology_state_controller();
}
base::test::SingleThreadTaskEnvironment task_environment_;
NetworkHandlerTestHelper helper_{};
std::vector<std::string> requested_connection_service_paths_;
std::vector<std::string> successful_connection_service_paths_;
std::vector<std::string> failed_connection_service_paths_;
std::vector<std::string> disconnect_requested_service_paths_;
int requested_failure_count_ = 0;
std::string other_wifi_service_path_;
std::vector<base::expected<std::string,
WifiHotspotConnector::WifiHotspotConnectionError>>
connection_callback_responses_;
TestNetworkStateHandlerObserver scan_observer_;
raw_ptr<base::MockOneShotTimer, DanglingUntriaged> mock_timer_;
base::SimpleTestClock test_clock_;
scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
std::unique_ptr<TestNetworkConnect> test_network_connect_;
std::unique_ptr<WifiHotspotConnector> wifi_hotspot_connector_;
base::HistogramTester histogram_tester_;
base::WeakPtrFactory<WifiHotspotConnectorTest> weak_ptr_factory_{this};
};
TEST_F(WifiHotspotConnectorTest, TestConnect_NetworkDoesNotBecomeVisible) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string guid_unused;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &guid_unused));
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// Network does not become connectable.
EXPECT_TRUE(requested_connection_service_paths_.empty());
// Timeout timer fires.
EXPECT_EQ(0u, connection_callback_responses_.size());
InvokeTimerTask();
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::kTimeout,
connection_callback_responses_[0].error());
VerifyConnectionToHotspotDurationRecorded(false /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest, TestConnect_AnotherNetworkBecomesVisible) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
PauseConnectionAttempts(wifi_guid);
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// Another network becomes connectable. This should not cause the connection
// to start.
NotifyVisible(other_wifi_service_path_);
VerifyNetworkNotAssociated(wifi_guid);
std::string other_wifi_guid = network_state_handler()
->GetNetworkState(other_wifi_service_path_)
->guid();
VerifyNetworkNotAssociated(other_wifi_guid);
EXPECT_TRUE(requested_connection_service_paths_.empty());
// Timeout timer fires.
EXPECT_EQ(0u, connection_callback_responses_.size());
InvokeTimerTask();
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::kTimeout,
connection_callback_responses_[0].error());
VerifyConnectionToHotspotDurationRecorded(false /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest, TestConnect_CannotConnectToNetwork) {
SetNumberOfUpcomingConsecutiveFailures(10);
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 3u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid), requested_connection_service_paths_[0]);
// Network connection failed.
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::
kNetworkConnectionHandlerFailed,
connection_callback_responses_[0].error());
EXPECT_EQ(1u, disconnect_requested_service_paths_.size());
EXPECT_EQ(GetServicePath(wifi_guid), disconnect_requested_service_paths_[0]);
VerifyConnectionToHotspotDurationRecorded(false /* expected */);
}
TEST_F(WifiHotspotConnectorTest, TestConnect_DeletedWhileConnectionPending) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
// Pause any connection attempts, allowing us to destroy WifiHotspotConnector
// mid-attempt
PauseConnectionAttempts(wifi_guid);
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 1u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid), requested_connection_service_paths_[0]);
EXPECT_EQ(0u, connection_callback_responses_.size());
// Delete the connector; this should trigger a disconnection attempt.
wifi_hotspot_connector_.reset();
EXPECT_EQ(1u, disconnect_requested_service_paths_.size());
EXPECT_EQ(GetServicePath(wifi_guid), disconnect_requested_service_paths_[0]);
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::
kWifiHotspotConnectorClassDestroyed,
connection_callback_responses_[0].error());
VerifyConnectionToHotspotDurationRecorded(false /* expected */);
}
TEST_F(WifiHotspotConnectorTest, TestConnect_Success) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
test_clock_.Advance(kConnectionToHotspotTime);
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 1u /* expected_num_connection_attempts */);
// Connection was successful
EXPECT_EQ("service_path_for_" + wifi_guid,
requested_connection_service_paths_[0]);
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid, connection_callback_responses_[0]);
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest, TestConnect_Success_RetryNeeded) {
SetNumberOfUpcomingConsecutiveFailures(1);
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
test_clock_.Advance(kConnectionToHotspotTime);
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
RunTestTaskRunner();
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 3u /* expected_num_connection_attempts */);
// Connection was successful.
EXPECT_EQ("service_path_for_" + wifi_guid,
requested_connection_service_paths_[0]);
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid, connection_callback_responses_[0]);
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_EQ(2u, failed_connection_service_paths_.size());
EXPECT_EQ(0u, disconnect_requested_service_paths_.size());
}
TEST_F(WifiHotspotConnectorTest, TestConnect_Success_EmptyPassword) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string() /* password */, kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid;
EXPECT_TRUE(VerifyOpenConfiguration(
test_network_connect_->GetLastConfiguration(), kSsid, &wifi_guid));
test_clock_.Advance(kConnectionToHotspotTime);
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 1u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid), requested_connection_service_paths_[0]);
// Connection to network successful.
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid, connection_callback_responses_[0].value());
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_EQ(GetServicePath(wifi_guid), requested_connection_service_paths_[0]);
EXPECT_EQ(GetServicePath(wifi_guid), successful_connection_service_paths_[0]);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest,
TestConnect_SecondConnectionWhileWaitingForFirstToBecomeVisible) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
"ssid1", "password1", "tetherNetworkGuid1",
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid_1;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
"ssid1", "password1", &wifi_guid_1));
std::string service_path_1 =
test_network_connect_->last_service_path_created();
EXPECT_FALSE(service_path_1.empty());
// Pass some arbitrary time -- this should not affect the
// recorded duration because the start time should be reset
// for a new network attempt.
test_clock_.Advance(base::Seconds(13));
// Before network becomes connectable, start the new connection.
EXPECT_EQ(0u, connection_callback_responses_.size());
wifi_hotspot_connector_->ConnectToWifiHotspot(
"ssid2", "password2", kTetherNetworkGuid2,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
std::string wifi_guid_2;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
"ssid2", "password2", &wifi_guid_2));
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
std::string service_path_2 =
test_network_connect_->last_service_path_created();
EXPECT_FALSE(service_path_2.empty());
VerifyNetworkNotAssociated(wifi_guid_1);
EXPECT_NE(service_path_1, service_path_2);
// The original connection attempt should have gotten an empty response.
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::
kCancelledForNewerConnectionAttempt,
connection_callback_responses_[0].error());
// First network becomes connectable.
NotifyVisible(service_path_1);
// A connection should not have started to that GUID.
EXPECT_TRUE(requested_connection_service_paths_.empty());
EXPECT_EQ(1u, connection_callback_responses_.size());
test_clock_.Advance(kConnectionToHotspotTime);
// Second network becomes connectable.
NotifyVisible(service_path_2);
VerifyTetherAndWifiNetworkAssociation(
wifi_guid_2, kTetherNetworkGuid2,
1u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid_2),
requested_connection_service_paths_[0]);
// Connection to network successful.
NotifyConnected(service_path_2);
EXPECT_EQ(2u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid_2, connection_callback_responses_[1]);
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest,
TestConnect_SecondConnectionWhileWaitingForFirstToConnect) {
wifi_hotspot_connector_->ConnectToWifiHotspot(
"ssid1", "password1", kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Pass some arbitrary time -- this should not affect the
// recorded duration because the start time should be reset
// for a new network attempt.
test_clock_.Advance(base::Seconds(13));
std::string wifi_guid_1;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
"ssid1", "password1", &wifi_guid_1));
std::string service_path_1 =
test_network_connect_->last_service_path_created();
EXPECT_FALSE(service_path_1.empty());
// Pause any connection attempts for the first network, allowing the second
// connection attempt to occur mid-connection
PauseConnectionAttempts(wifi_guid_1);
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// First network becomes connectable.
NotifyVisible(service_path_1);
VerifyTetherAndWifiNetworkAssociation(
wifi_guid_1, kTetherNetworkGuid,
1u /* expected_num_connection_attempts */);
// After network becomes connectable, request a connection to second network.
wifi_hotspot_connector_->ConnectToWifiHotspot(
"ssid2", "password2", kTetherNetworkGuid2,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// The first Tether and Wi-Fi networks should no longer be associated.
VerifyNetworkNotAssociated(kTetherNetworkGuid);
VerifyNetworkNotAssociated(wifi_guid_1);
// The original connection attempt should have gotten an empty response.
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::
kCancelledForNewerConnectionAttempt,
connection_callback_responses_[0].error());
// A disconnection attempt should have been initiated to the other network.
EXPECT_EQ(1u, disconnect_requested_service_paths_.size());
EXPECT_EQ(GetServicePath(wifi_guid_1),
disconnect_requested_service_paths_[0]);
std::string wifi_guid_2;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
"ssid2", "password2", &wifi_guid_2));
std::string service_path_2 =
test_network_connect_->last_service_path_created();
EXPECT_FALSE(service_path_2.empty());
EXPECT_NE(service_path_1, service_path_2);
test_clock_.Advance(kConnectionToHotspotTime);
// Second network becomes connectable.
NotifyVisible(service_path_2);
VerifyTetherAndWifiNetworkAssociation(
wifi_guid_2, kTetherNetworkGuid2,
2u /* expected_num_connection_attempts */);
// Connection to network successful.
EXPECT_EQ(GetServicePath(wifi_guid_2),
requested_connection_service_paths_[1]);
EXPECT_EQ(2u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid_2, connection_callback_responses_[1].value());
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
}
TEST_F(WifiHotspotConnectorTest, TestConnect_WifiDisabled_Success) {
technology_state_controller()->SetTechnologiesEnabled(
NetworkTypePattern::WiFi(), false /* enabled */,
network_handler::ErrorCallback());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Allow the asynchronous call to
// TechnologyStateHandler::SetTechnologiesEnabled() within
// WifiHotspotConnector::ConnectToWifiHotspot() to synchronously run. After
// this call, Wi-Fi should be enabled and WifiHotspotConnector will have
// called TestNetworkConnect::CreateConfiguration().
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
// Run the task and manually invoke ConfigureServiceWithLastNetworkConfig() to
// prevent nested RunLoop errors.
RunTestTaskRunner();
test_network_connect_->ConfigureServiceWithLastNetworkConfig();
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
test_clock_.Advance(kConnectionToHotspotTime);
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
RunTestTaskRunner();
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 1u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid), requested_connection_service_paths_[0]);
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid, connection_callback_responses_[0].value());
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest,
TestConnect_WifiDisabled_FailsIfWifiDoesNotTurnOn) {
technology_state_controller()->SetTechnologiesEnabled(
NetworkTypePattern::WiFi(), false /* enabled */,
network_handler::ErrorCallback());
std::vector<std::string> prohibited_technologies;
prohibited_technologies.push_back(shill::kTypeWifi);
network_state_handler()->SetProhibitedTechnologies(prohibited_technologies);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Allow the asynchronous call to
// TechnologyStateHandler::SetTechnologiesEnabled() within
// WifiHotspotConnector::ConnectToWifiHotspot() to synchronously run. After
// this call, Wi-Fi should be enabled and WifiHotspotConnector will have
// called TestNetworkConnect::CreateConfiguration().
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(
WifiHotspotConnector::WifiHotspotConnectionError::kWifiFailedToEnabled,
connection_callback_responses_[0].error());
}
TEST_F(WifiHotspotConnectorTest,
TestConnect_WifiDisabled_Success_OtherDeviceStatesChange) {
technology_state_controller()->SetTechnologiesEnabled(
NetworkTypePattern::WiFi(), false /* enabled */,
network_handler::ErrorCallback());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Ensure that WifiHotspotConnector only begins configuring the Wi-Fi network
// once Wi-Fi is enabled.
wifi_hotspot_connector_->DeviceListChanged();
wifi_hotspot_connector_->DeviceListChanged();
EXPECT_TRUE(test_network_connect_->GetLastConfiguration().empty());
// Allow the asynchronous call to
// TechnologyStateController::SetTechnologiesEnabled() within
// WifiHotspotConnector::ConnectToWifiHotspot() to synchronously run. After
// this call, Wi-Fi should be enabled and WifiHotspotConnector will have
// called TestNetworkConnect::CreateConfiguration().
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
// Run the task and manually invoke ConfigureServiceWithLastNetworkConfig() to
// prevent nested RunLoop errors.
RunTestTaskRunner();
test_network_connect_->ConfigureServiceWithLastNetworkConfig();
std::string wifi_guid;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
kSsid, kPassword, &wifi_guid));
PauseConnectionAttempts(wifi_guid);
// A Wi-Fi scan occurs after the network is configured.
VerifyWifiScanRequested();
// Network becomes connectable.
NotifyVisible(test_network_connect_->last_service_path_created());
VerifyTetherAndWifiNetworkAssociation(
wifi_guid, kTetherNetworkGuid, 1u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid), requested_connection_service_paths_[0]);
EXPECT_EQ(0u, connection_callback_responses_.size());
test_clock_.Advance(kConnectionToHotspotTime);
// Connection to network successful.
NotifyConnected(test_network_connect_->last_service_path_created());
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid, connection_callback_responses_[0].value());
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
TEST_F(WifiHotspotConnectorTest, TestConnect_WifiDisabled_AttemptTimesOut) {
technology_state_controller()->SetTechnologiesEnabled(
NetworkTypePattern::WiFi(), false /* enabled */,
network_handler::ErrorCallback());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
wifi_hotspot_connector_->ConnectToWifiHotspot(
std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Timeout timer fires.
InvokeTimerTask();
EXPECT_EQ(1u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::kTimeout,
connection_callback_responses_[0].error());
// Allow the asynchronous call to
// TechnologyStateController::SetTechnologiesEnabled() within
// WifiHotspotConnector::ConnectToWifiHotspot() to synchronously run. After
// this call, Wi-Fi should be enabled, but the connection attempt has timed
// out and therefore a new Wi-Fi configuration should not exist.
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
// No configuration should have been created since the connection attempt
// timed out before Wi-Fi was successfully enabled.
EXPECT_TRUE(test_network_connect_->GetLastConfiguration().empty());
// No Wi-Fi scan should have occurred either.
EXPECT_FALSE(scan_observer_.DidTriggerScan());
VerifyConnectionToHotspotDurationRecorded(false /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::kTimeout,
connection_callback_responses_[0].error());
}
TEST_F(WifiHotspotConnectorTest,
TestConnect_WifiDisabled_SecondConnectionWhileWaitingForWifiEnabled) {
technology_state_controller()->SetTechnologiesEnabled(
NetworkTypePattern::WiFi(), false /* enabled */,
network_handler::ErrorCallback());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
wifi_hotspot_connector_->ConnectToWifiHotspot(
"ssid1", "password1", kTetherNetworkGuid,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Pass some arbitrary time -- this should not affect the
// recorded duration because the start time should be reset
// for a new network attempt.
test_clock_.Advance(base::Seconds(13));
EXPECT_TRUE(test_network_connect_->GetLastConfiguration().empty());
wifi_hotspot_connector_->ConnectToWifiHotspot(
"ssid2", "password2", kTetherNetworkGuid2,
base::BindOnce(&WifiHotspotConnectorTest::WifiConnectionCallback,
base::Unretained(this)));
// Allow the asynchronous call to
// TechnologyStateController::SetTechnologiesEnabled() within
// WifiHotspotConnector::ConnectToWifiHotspot() to synchronously run. After
// this call, Wi-Fi should be enabled and WifiHotspotConnector will have
// called TestNetworkConnect::CreateConfiguration().
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(
network_state_handler()->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
// Run the task and manually invoke ConfigureServiceWithLastNetworkConfig() to
// prevent nested RunLoop errors.
RunTestTaskRunner();
test_network_connect_->ConfigureServiceWithLastNetworkConfig();
std::string wifi_guid_2;
EXPECT_TRUE(
VerifyPskConfiguration(test_network_connect_->GetLastConfiguration(),
"ssid2", "password2", &wifi_guid_2));
std::string service_path_2 =
test_network_connect_->last_service_path_created();
EXPECT_FALSE(service_path_2.empty());
// Second network becomes connectable.
test_clock_.Advance(kConnectionToHotspotTime);
NotifyVisible(service_path_2);
VerifyTetherAndWifiNetworkAssociation(
wifi_guid_2, kTetherNetworkGuid2,
1u /* expected_num_connection_attempts */);
EXPECT_EQ(GetServicePath(wifi_guid_2),
requested_connection_service_paths_[0]);
// Connection to network successful.
EXPECT_EQ(2u, connection_callback_responses_.size());
EXPECT_EQ(wifi_guid_2, connection_callback_responses_[1]);
EXPECT_EQ(2u, connection_callback_responses_.size());
EXPECT_EQ(WifiHotspotConnector::WifiHotspotConnectionError::
kCancelledForNewerConnectionAttempt,
connection_callback_responses_[0].error());
EXPECT_EQ(wifi_guid_2, connection_callback_responses_[1].value());
VerifyTimerStopped();
VerifyConnectionToHotspotDurationRecorded(true /* expected */);
EXPECT_TRUE(disconnect_requested_service_paths_.empty());
}
} // namespace tether
} // namespace ash
Codebase Browser
chromium