//
// Copyright (C) 2013 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "shill/wifi/wifi_provider.h"
#include <map>
#include <set>
#include <string>
#include <vector>
#include <base/format_macros.h>
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_util.h>
#include <base/strings/stringprintf.h>
#if defined(__ANDROID__)
#include <dbus/service_constants.h>
#else
#include <chromeos/dbus/service_constants.h>
#endif // __ANDROID__
#include <gtest/gtest.h>
#include "shill/mock_event_dispatcher.h"
#include "shill/mock_manager.h"
#include "shill/mock_metrics.h"
#include "shill/mock_profile.h"
#include "shill/mock_store.h"
#include "shill/net/ieee80211.h"
#include "shill/net/mock_time.h"
#include "shill/nice_mock_control.h"
#include "shill/supplicant/wpa_supplicant.h"
#include "shill/technology.h"
#include "shill/wifi/mock_wifi_service.h"
#include "shill/wifi/wifi_endpoint.h"
using base::StringPrintf;
using std::map;
using std::set;
using std::string;
using std::vector;
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::ContainerEq;
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::SetArgumentPointee;
using ::testing::StartsWith;
using ::testing::StrictMock;
namespace shill {
namespace {
const time_t kFirstWeek = 50;
const char kIllegalDayProfile[] = "IllegalDay";
const time_t kSecondsPerWeek = 60 * 60 * 24 * 7;
const time_t kTestDays = 20;
} // namespace
class WiFiProviderTest : public testing::Test {
public:
WiFiProviderTest()
: metrics_(nullptr),
manager_(&control_, &dispatcher_, &metrics_),
provider_(&control_, &dispatcher_, &metrics_, &manager_),
default_profile_(
new NiceMock<MockProfile>(
&control_, &metrics_, &manager_, "default")),
user_profile_(
new NiceMock<MockProfile>(&control_, &metrics_, &manager_, "user")),
storage_entry_index_(0) {
provider_.time_ = &time_;
string freq_string = StringPrintf("%s%d", WiFiProvider::kStorageFrequencies,
0);
profile_frequency_data_[freq_string].push_back(
base::StringPrintf("@%" PRIu64, static_cast<uint64_t>(kFirstWeek)));
profile_frequency_data_[freq_string].push_back("5001:1");
profile_frequency_data_[freq_string].push_back("5002:2");
freq_string = StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 1);
profile_frequency_data_[freq_string].push_back(
base::StringPrintf("@%" PRIu64, static_cast<uint64_t>(kFirstWeek) + 1));
// Overlap one entry with previous block.
profile_frequency_data_[freq_string].push_back("5001:1");
profile_frequency_data_[freq_string].push_back("6001:1");
profile_frequency_data_[freq_string].push_back("6002:2");
freq_string = StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 2);
profile_frequency_data_[freq_string].push_back(
base::StringPrintf("@%" PRIu64, static_cast<uint64_t>(kFirstWeek) + 2));
profile_frequency_data_[freq_string].push_back("7001:1");
profile_frequency_data_[freq_string].push_back("7002:2");
profile_frequency_data_[kIllegalDayProfile].push_back("7001:1");
profile_frequency_data_[kIllegalDayProfile].push_back("7002:2");
}
virtual ~WiFiProviderTest() {}
virtual void SetUp() {
EXPECT_CALL(*default_profile_, IsDefault()).WillRepeatedly(Return(true));
EXPECT_CALL(*default_profile_, GetStorage())
.WillRepeatedly(Return(&default_profile_storage_));
EXPECT_CALL(*default_profile_, GetConstStorage())
.WillRepeatedly(Return(&default_profile_storage_));
EXPECT_CALL(*user_profile_, IsDefault()).WillRepeatedly(Return(false));
EXPECT_CALL(*user_profile_, GetStorage())
.WillRepeatedly(Return(&user_profile_storage_));
EXPECT_CALL(*user_profile_, GetConstStorage())
.WillRepeatedly(Return(&user_profile_storage_));
// Default expectations for UMA metrics. Individual test cases
// will override these, by adding later expectations.
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
_,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets))
.Times(AnyNumber());
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedPrivateNetworkCount."),
_,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets))
.Times(AnyNumber());
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedSharedNetworkCount."),
_,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets))
.Times(AnyNumber());
}
bool GetStringList(const std::string& /*group*/,
const std::string& key,
std::vector<std::string>* value) {
if (!value) {
return false;
}
if (ContainsKey(profile_frequency_data_, key)) {
*value = profile_frequency_data_[key];
return true;
}
return false;
}
bool GetIllegalDayStringList(const std::string& /*group*/,
const std::string& key,
std::vector<std::string>* value) {
if (!value) {
return false;
}
if (ContainsKey(profile_frequency_data_, key)) {
*value = profile_frequency_data_[kIllegalDayProfile];
return true;
}
return false;
}
// Used by mock invocations of RegisterService() to maintain the side-effect
// of assigning a profile to |service|.
void BindServiceToDefaultProfile(const ServiceRefPtr& service) {
service->set_profile(default_profile_);
}
void BindServiceToUserProfile(const ServiceRefPtr& service) {
service->set_profile(user_profile_);
}
protected:
typedef scoped_refptr<MockWiFiService> MockWiFiServiceRefPtr;
void CreateServicesFromProfile(Profile* profile) {
provider_.CreateServicesFromProfile(profile);
}
void LoadAndFixupServiceEntries(Profile* profile) {
provider_.LoadAndFixupServiceEntries(profile);
}
void Save() {
provider_.Save(&default_profile_storage_);
}
const vector<WiFiServiceRefPtr> GetServices() {
return provider_.services_;
}
const WiFiProvider::EndpointServiceMap& GetServiceByEndpoint() {
return provider_.service_by_endpoint_;
}
bool GetRunning() {
return provider_.running_;
}
void AddStringParameterToStorage(MockStore* storage,
const string& id,
const string& key,
const string& value) {
EXPECT_CALL(*storage, GetString(id, key, _))
.WillRepeatedly(DoAll(SetArgumentPointee<2>(value),
Return(true)));
}
// Adds service to profile's storage. But does not set profile on the Service.
string AddServiceToProfileStorage(Profile* profile,
const char* ssid,
const char* mode,
const char* security,
bool is_hidden,
bool provide_hidden) {
string id = base::StringPrintf("entry_%d", storage_entry_index_);
auto profile_storage = static_cast<MockStore*>(profile->GetStorage());
EXPECT_CALL(*profile_storage, GetString(id, _, _))
.WillRepeatedly(Return(false));
AddStringParameterToStorage(
profile_storage, id, WiFiService::kStorageType, kTypeWifi);
if (ssid) {
const string ssid_string(ssid);
const string hex_ssid(
base::HexEncode(ssid_string.data(), ssid_string.size()));
AddStringParameterToStorage(
profile_storage, id, WiFiService::kStorageSSID, hex_ssid);
}
if (mode) {
AddStringParameterToStorage(
profile_storage, id, WiFiService::kStorageMode, mode);
}
if (security) {
AddStringParameterToStorage(
profile_storage, id, WiFiService::kStorageSecurity, security);
}
if (provide_hidden) {
EXPECT_CALL(*profile_storage, GetBool(id, kWifiHiddenSsid, _))
.WillRepeatedly(
DoAll(SetArgumentPointee<2>(is_hidden), Return(true)));
} else {
EXPECT_CALL(*profile_storage, GetBool(id, kWifiHiddenSsid, _))
.WillRepeatedly(Return(false));
}
storage_entry_index_++;
return id;
}
void SetServiceParameters(const char* ssid,
const char* mode,
const char* security_class,
bool is_hidden,
bool provide_hidden,
KeyValueStore* args) {
args->SetString(kTypeProperty, kTypeWifi);
if (ssid) {
// TODO(pstew): When Chrome switches to using kWifiHexSsid primarily for
// GetService and friends, we should switch to doing so here ourselves.
args->SetString(kSSIDProperty, ssid);
}
if (mode) {
args->SetString(kModeProperty, mode);
}
if (security_class) {
args->SetString(kSecurityClassProperty, security_class);
}
if (provide_hidden) {
args->SetBool(kWifiHiddenSsid, is_hidden);
}
}
ServiceRefPtr CreateTemporaryService(const char* ssid,
const char* mode,
const char* security,
bool is_hidden,
bool provide_hidden,
Error* error) {
KeyValueStore args;
SetServiceParameters(
ssid, mode, security, is_hidden, provide_hidden, &args);
return provider_.CreateTemporaryService(args, error);
}
WiFiServiceRefPtr GetService(const char* ssid,
const char* mode,
const char* security_class,
bool is_hidden,
bool provide_hidden,
Error* error) {
KeyValueStore args;
SetServiceParameters(
ssid, mode, security_class, is_hidden, provide_hidden, &args);
return provider_.GetWiFiService(args, error);
}
WiFiServiceRefPtr GetWiFiService(const KeyValueStore& args, Error* error) {
return provider_.GetWiFiService(args, error);
}
WiFiServiceRefPtr FindService(const vector<uint8_t>& ssid,
const string& mode,
const string& security) {
return provider_.FindService(ssid, mode, security);
}
WiFiEndpointRefPtr MakeEndpoint(const string& ssid, const string& bssid,
uint16_t frequency, int16_t signal_dbm) {
return WiFiEndpoint::MakeOpenEndpoint(
nullptr, nullptr, ssid, bssid,
WPASupplicant::kNetworkModeInfrastructure, frequency, signal_dbm);
}
MockWiFiServiceRefPtr AddMockService(const vector<uint8_t>& ssid,
const string& mode,
const string& security,
bool hidden_ssid) {
MockWiFiServiceRefPtr service = new MockWiFiService(
&control_,
&dispatcher_,
&metrics_,
&manager_,
&provider_,
ssid,
mode,
security,
hidden_ssid);
provider_.services_.push_back(service);
return service;
}
void AddEndpointToService(WiFiServiceRefPtr service,
const WiFiEndpointConstRefPtr& endpoint) {
provider_.service_by_endpoint_[endpoint.get()] = service;
}
void BuildFreqCountStrings(vector<string>* strings) {
// NOTE: These strings match the frequencies in |BuildFreqCountMap|. They
// are also provided, here, in sorted order to match the frequency map
// (iterators for which will provide them in frequency-sorted order).
static const char* kStrings[] = {
"@20", "5180:14", "5240:16", "5745:7", "5765:4", "5785:14", "5805:5"
};
if (!strings) {
LOG(ERROR) << "NULL |strings|.";
return;
}
for (size_t i = 0; i < arraysize(kStrings); ++i) {
(*strings).push_back(kStrings[i]);
}
}
void BuildFreqCountMap(WiFiProvider::ConnectFrequencyMap* frequencies) {
// NOTE: These structures match the strings in |BuildFreqCountStrings|.
static const struct FreqCount {
uint16_t freq;
int64_t count;
} kConnectFreq[] = {
{5180, 14},
{5240, 16},
{5745, 7},
{5765, 4},
{5785, 14},
{5805, 5}
};
if (!frequencies) {
LOG(ERROR) << "NULL |frequencies|.";
return;
}
for (size_t i = 0; i < arraysize(kConnectFreq); ++i) {
(*frequencies)[kConnectFreq[i].freq] = kConnectFreq[i].count;
}
}
void LoadConnectCountByFrequency(time_t today_seconds) {
provider_.time_ = &time_;
EXPECT_CALL(time_, GetSecondsSinceEpoch()).WillOnce(Return(today_seconds));
const string kGroupId =
StringPrintf("%s_0_0_%s_%s", kTypeWifi, kModeManaged, kSecurityNone);
EXPECT_CALL(default_profile_storage_,
GetString(kGroupId, _, _)).WillRepeatedly(Return(true));
set<string> groups;
groups.insert(kGroupId);
EXPECT_CALL(default_profile_storage_, GetGroups()).WillOnce(Return(groups));
// Provide data for block[0] through block[2] (block[3] is empty).
EXPECT_CALL(
default_profile_storage_,
GetStringList(
WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 0), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
EXPECT_CALL(
default_profile_storage_,
GetStringList(
WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 1), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
EXPECT_CALL(
default_profile_storage_,
GetStringList(
WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 2), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
EXPECT_CALL(
default_profile_storage_,
GetStringList(
WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 3), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
LoadAndFixupServiceEntries(default_profile_.get());
}
map<string, vector<string>> profile_frequency_data_;
NiceMockControl control_;
MockEventDispatcher dispatcher_;
MockMetrics metrics_;
MockTime time_;
StrictMock<MockManager> manager_;
WiFiProvider provider_;
scoped_refptr<MockProfile> default_profile_;
scoped_refptr<MockProfile> user_profile_;
StrictMock<MockStore> default_profile_storage_;
StrictMock<MockStore> user_profile_storage_;
int storage_entry_index_; // shared across profiles
};
MATCHER(TypeWiFiPropertyMatch, "") {
return arg.properties().size() == 1 &&
arg.LookupString(kTypeProperty, "") == kTypeWifi;
}
MATCHER_P(RefPtrMatch, ref, "") {
return ref.get() == arg.get();
}
TEST_F(WiFiProviderTest, Start) {
// Doesn't do anything really. Just testing for no crash.
EXPECT_TRUE(GetServices().empty());
EXPECT_FALSE(GetRunning());
provider_.Start();
EXPECT_TRUE(GetServices().empty());
EXPECT_TRUE(GetRunning());
EXPECT_TRUE(GetServiceByEndpoint().empty());
EXPECT_FALSE(provider_.disable_vht());
}
TEST_F(WiFiProviderTest, Stop) {
MockWiFiServiceRefPtr service0 = AddMockService(vector<uint8_t>(1, '0'),
kModeManaged,
kSecurityNone,
false);
MockWiFiServiceRefPtr service1 = AddMockService(vector<uint8_t>(1, '1'),
kModeManaged,
kSecurityNone,
false);
WiFiEndpointRefPtr endpoint = MakeEndpoint("", "00:00:00:00:00:00", 0, 0);
AddEndpointToService(service0, endpoint);
EXPECT_EQ(2, GetServices().size());
EXPECT_FALSE(GetServiceByEndpoint().empty());
EXPECT_CALL(*service0, ResetWiFi()).Times(1);
EXPECT_CALL(*service1, ResetWiFi()).Times(1);
EXPECT_CALL(manager_, DeregisterService(RefPtrMatch(service0))).Times(1);
EXPECT_CALL(manager_, DeregisterService(RefPtrMatch(service1))).Times(1);
provider_.Stop();
// Verify now, so it's clear that this happened as a result of the call
// above, and not anything in the destructor(s).
Mock::VerifyAndClearExpectations(service0.get());
Mock::VerifyAndClearExpectations(service1.get());
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_TRUE(GetServices().empty());
EXPECT_TRUE(GetServiceByEndpoint().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileWithNoGroups) {
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillOnce(Return(set<string>()));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileMissingSSID) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), nullptr, kModeManaged, kSecurityNone, false,
true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileEmptySSID) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "", kModeManaged, kSecurityNone, false,
true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileMissingMode) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", nullptr, kSecurityNone, false, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileEmptyMode) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", "", kSecurityNone, false, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileMissingSecurity) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, nullptr, false, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileEmptySecurity) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, "", false, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileMissingHidden) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, kSecurityNone, false,
false));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileSingle) {
set<string> groups;
string kSSID("foo");
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(),
kSSID.c_str(), kModeManaged, kSecurityNone, false, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(manager_, RegisterService(_))
.WillOnce(Invoke(this, &WiFiProviderTest::BindServiceToDefaultProfile));
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
1,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets)).Times(2);
CreateServicesFromProfile(default_profile_.get());
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(1, GetServices().size());
const WiFiServiceRefPtr service = GetServices().front();
const string service_ssid(service->ssid().begin(), service->ssid().end());
EXPECT_EQ(kSSID, service_ssid);
EXPECT_EQ(kModeManaged, service->mode());
EXPECT_TRUE(service->IsSecurityMatch(kSecurityNone));
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
CreateServicesFromProfile(default_profile_.get());
EXPECT_EQ(1, GetServices().size());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileHiddenButConnected) {
set<string> groups;
string kSSID("foo");
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(),
kSSID.c_str(), kModeManaged, kSecurityNone, true, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(manager_, RegisterService(_))
.WillOnce(Invoke(this, &WiFiProviderTest::BindServiceToDefaultProfile));
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
EXPECT_CALL(manager_, IsTechnologyConnected(Technology::kWifi))
.WillOnce(Return(true));
EXPECT_CALL(manager_, RequestScan(_, _, _)).Times(0);
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
1,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets)).Times(2);
CreateServicesFromProfile(default_profile_.get());
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, IsTechnologyConnected(_)).Times(0);
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
CreateServicesFromProfile(default_profile_.get());
}
TEST_F(WiFiProviderTest, CreateServicesFromProfileHiddenNotConnected) {
set<string> groups;
string kSSID("foo");
groups.insert(AddServiceToProfileStorage(default_profile_.get(),
kSSID.c_str(), kModeManaged, kSecurityNone, true, true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(manager_, RegisterService(_))
.WillOnce(Invoke(this, &WiFiProviderTest::BindServiceToDefaultProfile));
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
EXPECT_CALL(manager_, IsTechnologyConnected(Technology::kWifi))
.WillOnce(Return(false));
EXPECT_CALL(manager_, RequestScan(Device::kProgressiveScan,
kTypeWifi, _)).Times(1);
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
1,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets)).Times(2);
CreateServicesFromProfile(default_profile_.get());
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, IsTechnologyConnected(_)).Times(0);
EXPECT_CALL(manager_, RequestScan(_, _, _)).Times(0);
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
CreateServicesFromProfile(default_profile_.get());
}
TEST_F(WiFiProviderTest, CreateTemporaryServiceFromProfileNonWiFi) {
const string kEntryName("name");
auto profile_storage =
static_cast<MockStore*>(default_profile_->GetStorage());
EXPECT_CALL(*profile_storage,
GetString(kEntryName, WiFiService::kStorageType, _))
.WillOnce(Return(false));
Error error;
EXPECT_EQ(nullptr,
provider_.CreateTemporaryServiceFromProfile(
default_profile_, kEntryName, &error));
EXPECT_FALSE(error.IsSuccess());
EXPECT_THAT(error.message(),
StartsWith("Unspecified or invalid network type"));
}
TEST_F(WiFiProviderTest, CreateTemporaryServiceFromProfileMissingSSID) {
string entry_name = AddServiceToProfileStorage(
default_profile_.get(), nullptr, kModeManaged, kSecurityNone, false,
true);
Error error;
EXPECT_EQ(nullptr,
provider_.CreateTemporaryServiceFromProfile(
default_profile_, entry_name, &error));
EXPECT_FALSE(error.IsSuccess());
EXPECT_THAT(error.message(), StartsWith("Unspecified or invalid SSID"));
}
TEST_F(WiFiProviderTest, CreateTemporaryServiceFromProfileMissingMode) {
string entry_name = AddServiceToProfileStorage(
default_profile_.get(), "foo", "", kSecurityNone, false, true);
Error error;
EXPECT_EQ(nullptr,
provider_.CreateTemporaryServiceFromProfile(
default_profile_, entry_name, &error));
EXPECT_FALSE(error.IsSuccess());
EXPECT_THAT(error.message(), StartsWith("Network mode not specified"));
}
TEST_F(WiFiProviderTest, CreateTemporaryServiceFromProfileMissingSecurity) {
string entry_name = AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, "", false, true);
Error error;
EXPECT_EQ(nullptr,
provider_.CreateTemporaryServiceFromProfile(
default_profile_, entry_name, &error));
EXPECT_FALSE(error.IsSuccess());
EXPECT_THAT(error.message(),
StartsWith("Unspecified or invalid security mode"));
}
TEST_F(WiFiProviderTest, CreateTemporaryServiceFromProfileMissingHidden) {
string entry_name = AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, kSecurityNone, false, false);
Error error;
EXPECT_EQ(nullptr,
provider_.CreateTemporaryServiceFromProfile(
default_profile_, entry_name, &error));
EXPECT_FALSE(error.IsSuccess());
EXPECT_THAT(error.message(),
StartsWith("Hidden SSID not specified"));
}
TEST_F(WiFiProviderTest, CreateTemporaryServiceFromProfile) {
string entry_name = AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, kSecurityNone, false, true);
Error error;
EXPECT_NE(nullptr,
provider_.CreateTemporaryServiceFromProfile(
default_profile_, entry_name, &error));
EXPECT_TRUE(error.IsSuccess());
}
TEST_F(WiFiProviderTest, CreateTwoServices) {
set<string> groups;
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, kSecurityNone, false,
true));
groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "bar", kModeManaged, kSecurityNone, true,
true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(groups));
EXPECT_CALL(manager_, RegisterService(_))
.Times(2)
.WillRepeatedly(
Invoke(this, &WiFiProviderTest::BindServiceToDefaultProfile));
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
EXPECT_CALL(manager_, IsTechnologyConnected(Technology::kWifi))
.WillOnce(Return(true));
EXPECT_CALL(manager_, RequestScan(_, kTypeWifi, _)).Times(0);
EXPECT_CALL(metrics_, SendToUMA(
Metrics::kMetricRememberedWiFiNetworkCount,
2,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(default_profile_.get());
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(2, GetServices().size());
}
TEST_F(WiFiProviderTest, ServiceSourceStats) {
set<string> default_profile_groups;
default_profile_groups.insert(
AddServiceToProfileStorage(
default_profile_.get(), "foo", kModeManaged, kSecurityWpa, false,
true));
EXPECT_CALL(default_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(default_profile_groups));
EXPECT_CALL(manager_, RegisterService(_))
.WillOnce(Invoke(this, &WiFiProviderTest::BindServiceToDefaultProfile));
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
// Processing default profile does not generate UMA metrics.
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedSystemNetworkCount."),
_, _, _, _))
.Times(0);
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedUserNetworkCount."),
_, _, _, _))
.Times(0);
CreateServicesFromProfile(default_profile_.get());
Mock::VerifyAndClearExpectations(&manager_);
set<string> user_profile_groups;
user_profile_groups.insert(
AddServiceToProfileStorage(
user_profile_.get(), "bar", kModeManaged, kSecurityRsn, false, true));
EXPECT_CALL(user_profile_storage_,
GetGroupsWithProperties(TypeWiFiPropertyMatch()))
.WillRepeatedly(Return(user_profile_groups));
EXPECT_CALL(manager_, RegisterService(_))
.WillOnce(Invoke(this, &WiFiProviderTest::BindServiceToUserProfile));
EXPECT_CALL(manager_, IsServiceEphemeral(_)).WillRepeatedly(Return(false));
// Processing user profile generates metrics for both, default profile,
// and user profile.
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedSystemNetworkCount."),
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets))
.Times(3); // none, wep, 802.1x
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedUserNetworkCount."),
0,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets))
.Times(3); // none, wep, 802.1x
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedSystemNetworkCount.psk"),
1,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
EXPECT_CALL(metrics_, SendToUMA(
StartsWith("Network.Shill.WiFi.RememberedUserNetworkCount.psk"),
1,
Metrics::kMetricRememberedWiFiNetworkCountMin,
Metrics::kMetricRememberedWiFiNetworkCountMax,
Metrics::kMetricRememberedWiFiNetworkCountNumBuckets));
CreateServicesFromProfile(user_profile_.get());
}
TEST_F(WiFiProviderTest, GetServiceEmptyMode) {
Error error;
EXPECT_FALSE(GetService("foo", "", kSecurityNone,
false, false, &error).get());
EXPECT_EQ(Error::kNotSupported, error.type());
}
TEST_F(WiFiProviderTest, GetServiceNoMode) {
Error error;
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
EXPECT_TRUE(GetService("foo", nullptr, kSecurityNone,
false, false, &error).get());
EXPECT_TRUE(error.IsSuccess());
}
TEST_F(WiFiProviderTest, GetServiceBadMode) {
Error error;
EXPECT_FALSE(GetService("foo", "BogoMesh",
kSecurityNone,
false, false, &error).get());
EXPECT_EQ(Error::kNotSupported, error.type());
EXPECT_EQ("service mode is unsupported", error.message());
}
TEST_F(WiFiProviderTest, GetServiceNoSSID) {
Error error;
EXPECT_FALSE(GetService(nullptr, kModeManaged,
kSecurityNone, false, false,
&error).get());
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("must specify SSID", error.message());
}
TEST_F(WiFiProviderTest, GetServiceEmptySSID) {
Error error;
EXPECT_FALSE(GetService("", kModeManaged,
kSecurityNone, false, false,
&error).get());
EXPECT_EQ(Error::kInvalidNetworkName, error.type());
EXPECT_EQ("SSID is too short", error.message());
}
TEST_F(WiFiProviderTest, GetServiceLongSSID) {
Error error;
string ssid(IEEE_80211::kMaxSSIDLen + 1, '0');
EXPECT_FALSE(GetService(ssid.c_str(), kModeManaged,
kSecurityNone, false, false,
&error).get());
EXPECT_EQ(Error::kInvalidNetworkName, error.type());
EXPECT_EQ("SSID is too long", error.message());
}
TEST_F(WiFiProviderTest, GetServiceJustLongEnoughSSID) {
Error error;
string ssid(IEEE_80211::kMaxSSIDLen, '0');
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
EXPECT_TRUE(GetService(ssid.c_str(), kModeManaged,
kSecurityNone, false, false,
&error));
EXPECT_TRUE(error.IsSuccess());
}
TEST_F(WiFiProviderTest, GetServiceBadSecurityClass) {
Error error;
EXPECT_FALSE(GetService("foo", kModeManaged,
kSecurityRsn, false, false,
&error));
EXPECT_EQ(Error::kNotSupported, error.type());
EXPECT_EQ("security class is unsupported", error.message());
}
TEST_F(WiFiProviderTest, GetServiceMinimal) {
Error error;
const string kSSID("foo");
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
WiFiServiceRefPtr service = GetService(kSSID.c_str(), kModeManaged,
nullptr, false, false, &error);
EXPECT_TRUE(service.get());
EXPECT_TRUE(error.IsSuccess());
const string service_ssid(service->ssid().begin(), service->ssid().end());
EXPECT_EQ(kSSID, service_ssid);
EXPECT_EQ(kModeManaged, service->mode());
// These two should be set to their default values if not specified.
EXPECT_TRUE(service->IsSecurityMatch(kSecurityNone));
EXPECT_TRUE(service->hidden_ssid());
}
TEST_F(WiFiProviderTest, GetServiceFullySpecified) {
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
const string kSSID("bar");
Error error;
WiFiServiceRefPtr service0 = GetService(
kSSID.c_str(), kModeManaged, kSecurityPsk, false, true, &error);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_TRUE(error.IsSuccess());
const string service_ssid(service0->ssid().begin(), service0->ssid().end());
EXPECT_EQ(kSSID, service_ssid);
EXPECT_EQ(kModeManaged, service0->mode());
EXPECT_TRUE(service0->IsSecurityMatch(kSecurityPsk));
EXPECT_FALSE(service0->hidden_ssid());
// Getting the same service parameters (even with a different hidden
// parameter) should return the same service.
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
WiFiServiceRefPtr service1 =
GetService(kSSID.c_str(), kModeManaged, kSecurityPsk, true, true, &error);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(service0.get(), service1.get());
EXPECT_EQ(1, GetServices().size());
// Getting the same ssid with different other parameters should return
// a different service.
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
WiFiServiceRefPtr service2 = GetService(
kSSID.c_str(), kModeManaged, kSecurityNone, true, true, &error);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_NE(service0.get(), service2.get());
EXPECT_EQ(2, GetServices().size());
}
TEST_F(WiFiProviderTest, GetServiceByHexSsid) {
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
const string kSSID("bar");
const string kHexSsid(base::HexEncode(kSSID.c_str(), kSSID.length()));
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kWifiHexSsid, kHexSsid);
args.SetString(kSecurityProperty, kSecurityPsk);
args.SetBool(kWifiHiddenSsid, false);
Error error;
WiFiServiceRefPtr service = GetWiFiService(args, &error);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_TRUE(error.IsSuccess());
const string service_ssid(service->ssid().begin(), service->ssid().end());
EXPECT_EQ(kSSID, service_ssid);
EXPECT_EQ(kModeManaged, service->mode());
EXPECT_TRUE(service->IsSecurityMatch(kSecurityPsk));
EXPECT_FALSE(service->hidden_ssid());
// While here, make sure FindSimilarService also supports kWifiHexSsid.
Error find_error;
ServiceRefPtr find_service = provider_.FindSimilarService(args, &find_error);
EXPECT_TRUE(find_error.IsSuccess());
EXPECT_EQ(service.get(), find_service.get());
}
TEST_F(WiFiProviderTest, GetServiceWithSecurityAndSecurityClassMismatched) {
const string kSSID("bar");
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kSSIDProperty, kSSID);
args.SetString(kSecurityProperty, kSecurityRsn);
args.SetString(kSecurityClassProperty, kSecurityPsk);
args.SetBool(kWifiHiddenSsid, false);
Error error;
WiFiServiceRefPtr service;
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
service = GetWiFiService(args, &error);
EXPECT_FALSE(error.IsSuccess());
}
TEST_F(WiFiProviderTest, GetServiceWithSecurityAndSecurityClassMatching) {
const string kSSID("bar");
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kSSIDProperty, kSSID);
args.SetString(kSecurityProperty, kSecurityPsk);
args.SetString(kSecurityClassProperty, kSecurityPsk);
args.SetBool(kWifiHiddenSsid, false);
Error error;
WiFiServiceRefPtr service;
EXPECT_CALL(manager_, RegisterService(_));
service = GetWiFiService(args, &error);
EXPECT_TRUE(error.IsSuccess());
}
TEST_F(WiFiProviderTest,
GetServiceWithSecurityAndSecurityClassMatchingButInvalidClass) {
const string kSSID("bar");
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kSSIDProperty, kSSID);
args.SetString(kSecurityProperty, kSecurityRsn);
args.SetString(kSecurityClassProperty, kSecurityRsn);
args.SetBool(kWifiHiddenSsid, false);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
Error error;
WiFiServiceRefPtr service = GetWiFiService(args, &error);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_FALSE(error.IsSuccess());
}
TEST_F(WiFiProviderTest, GetServiceBadSecurity) {
const string kSSID("bar");
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kSSIDProperty, kSSID);
args.SetString(kSecurityProperty, "pig-80211");
args.SetBool(kWifiHiddenSsid, false);
Error error;
WiFiServiceRefPtr service;
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
service = GetWiFiService(args, &error);
EXPECT_FALSE(error.IsSuccess());
EXPECT_EQ(Error::kNotSupported, error.type());
EXPECT_EQ("security mode is unsupported", error.message());
}
TEST_F(WiFiProviderTest, FindSimilarService) {
// Since CreateTemporyService uses exactly the same validation as
// GetService, don't bother with testing invalid parameters.
const string kSSID("foo");
KeyValueStore args;
SetServiceParameters(
kSSID.c_str(), kModeManaged, kSecurityNone,
true, true, &args);
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
Error get_service_error;
WiFiServiceRefPtr service = GetWiFiService(args, &get_service_error);
EXPECT_EQ(1, GetServices().size());
{
Error error;
ServiceRefPtr find_service = provider_.FindSimilarService(args, &error);
EXPECT_EQ(service.get(), find_service.get());
EXPECT_TRUE(error.IsSuccess());
}
args.SetBool(kWifiHiddenSsid, false);
{
Error error;
ServiceRefPtr find_service = provider_.FindSimilarService(args, &error);
EXPECT_EQ(service.get(), find_service.get());
EXPECT_TRUE(error.IsSuccess());
}
args.SetString(kSecurityClassProperty, kSecurityPsk);
{
Error error;
ServiceRefPtr find_service = provider_.FindSimilarService(args, &error);
EXPECT_EQ(nullptr, find_service.get());
EXPECT_EQ(Error::kNotFound, error.type());
}
}
TEST_F(WiFiProviderTest, CreateTemporaryService) {
// Since CreateTemporyService uses exactly the same validation as
// GetService, don't bother with testing invalid parameters.
const string kSSID("foo");
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
Error error;
WiFiServiceRefPtr service0 = GetService(
kSSID.c_str(), kModeManaged, kSecurityNone, true, true, &error);
EXPECT_EQ(1, GetServices().size());
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
ServiceRefPtr service1 =
CreateTemporaryService(kSSID.c_str(), kModeManaged,
kSecurityNone, true, true, &error);
// Test that a new service was created, but not registered with the
// manager or added to the provider's service list.
EXPECT_EQ(1, GetServices().size());
EXPECT_TRUE(service0 != service1);
EXPECT_TRUE(service1->HasOneRef());
}
TEST_F(WiFiProviderTest, FindServiceWPA) {
const string kSSID("an_ssid");
Error error;
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
KeyValueStore args;
SetServiceParameters(
kSSID.c_str(), kModeManaged, nullptr, false, false, &args);
args.SetString(kSecurityProperty, kSecurityRsn);
WiFiServiceRefPtr service = GetWiFiService(args, &error);
ASSERT_TRUE(service);
const vector<uint8_t> ssid_bytes(kSSID.begin(), kSSID.end());
WiFiServiceRefPtr wpa_service(FindService(ssid_bytes, kModeManaged,
kSecurityWpa));
EXPECT_TRUE(wpa_service);
EXPECT_EQ(service.get(), wpa_service.get());
WiFiServiceRefPtr rsn_service(FindService(ssid_bytes, kModeManaged,
kSecurityRsn));
EXPECT_TRUE(rsn_service.get());
EXPECT_EQ(service.get(), rsn_service.get());
WiFiServiceRefPtr psk_service(FindService(ssid_bytes, kModeManaged,
kSecurityPsk));
EXPECT_EQ(service.get(), psk_service.get());
WiFiServiceRefPtr wep_service(FindService(ssid_bytes, kModeManaged,
kSecurityWep));
EXPECT_TRUE(service.get() != wep_service.get());
EXPECT_EQ(nullptr, wep_service.get());
}
TEST_F(WiFiProviderTest, FindServiceForEndpoint) {
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
Error error;
const string kSSID("an_ssid");
WiFiServiceRefPtr service = GetService(
kSSID.c_str(), kModeManaged, kSecurityNone, false, true, &error);
ASSERT_TRUE(service);
WiFiEndpointRefPtr endpoint = MakeEndpoint(kSSID, "00:00:00:00:00:00", 0, 0);
WiFiServiceRefPtr endpoint_service =
provider_.FindServiceForEndpoint(endpoint);
// Just because a matching service exists, we shouldn't necessarily have
// it returned. We will test that this function returns the correct
// service if the endpoint is added below.
EXPECT_EQ(nullptr, endpoint_service.get());
}
TEST_F(WiFiProviderTest, OnEndpointAdded) {
provider_.Start();
const string ssid0("an_ssid");
const vector<uint8_t> ssid0_bytes(ssid0.begin(), ssid0.end());
EXPECT_FALSE(FindService(ssid0_bytes, kModeManaged,
kSecurityNone));
WiFiEndpointRefPtr endpoint0 = MakeEndpoint(ssid0, "00:00:00:00:00:00", 0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
EXPECT_CALL(manager_, UpdateService(_)).Times(1);
provider_.OnEndpointAdded(endpoint0);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(1, GetServices().size());
WiFiServiceRefPtr service0(FindService(ssid0_bytes, kModeManaged,
kSecurityNone));
EXPECT_TRUE(service0);
EXPECT_TRUE(service0->HasEndpoints());
EXPECT_EQ(1, GetServiceByEndpoint().size());
WiFiServiceRefPtr endpoint_service =
provider_.FindServiceForEndpoint(endpoint0);
EXPECT_EQ(service0.get(), endpoint_service.get());
WiFiEndpointRefPtr endpoint1 = MakeEndpoint(ssid0, "00:00:00:00:00:01", 0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(1);
provider_.OnEndpointAdded(endpoint1);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(1, GetServices().size());
const string ssid1("another_ssid");
const vector<uint8_t> ssid1_bytes(ssid1.begin(), ssid1.end());
EXPECT_FALSE(FindService(ssid1_bytes, kModeManaged,
kSecurityNone));
WiFiEndpointRefPtr endpoint2 = MakeEndpoint(ssid1, "00:00:00:00:00:02",
0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
EXPECT_CALL(manager_, UpdateService(_)).Times(1);
provider_.OnEndpointAdded(endpoint2);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(2, GetServices().size());
WiFiServiceRefPtr service1(FindService(ssid1_bytes, kModeManaged,
kSecurityNone));
EXPECT_TRUE(service1);
EXPECT_TRUE(service1->HasEndpoints());
EXPECT_TRUE(service1 != service0);
}
TEST_F(WiFiProviderTest, OnEndpointAddedWithSecurity) {
provider_.Start();
const string ssid0("an_ssid");
const vector<uint8_t> ssid0_bytes(ssid0.begin(), ssid0.end());
EXPECT_FALSE(FindService(ssid0_bytes, kModeManaged,
kSecurityNone));
WiFiEndpointRefPtr endpoint0 = MakeEndpoint(ssid0, "00:00:00:00:00:00", 0, 0);
endpoint0->set_security_mode(kSecurityRsn);
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
EXPECT_CALL(manager_, UpdateService(_)).Times(1);
provider_.OnEndpointAdded(endpoint0);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(1, GetServices().size());
WiFiServiceRefPtr service0(FindService(ssid0_bytes, kModeManaged,
kSecurityWpa));
EXPECT_TRUE(service0);
EXPECT_TRUE(service0->HasEndpoints());
EXPECT_EQ(kSecurityPsk, service0->security_);
WiFiEndpointRefPtr endpoint1 = MakeEndpoint(ssid0, "00:00:00:00:00:01", 0, 0);
endpoint1->set_security_mode(kSecurityWpa);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(1);
provider_.OnEndpointAdded(endpoint1);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(1, GetServices().size());
const string ssid1("another_ssid");
const vector<uint8_t> ssid1_bytes(ssid1.begin(), ssid1.end());
EXPECT_FALSE(FindService(ssid1_bytes, kModeManaged,
kSecurityNone));
WiFiEndpointRefPtr endpoint2 = MakeEndpoint(ssid1, "00:00:00:00:00:02", 0, 0);
endpoint2->set_security_mode(kSecurityWpa);
EXPECT_CALL(manager_, RegisterService(_)).Times(1);
EXPECT_CALL(manager_, UpdateService(_)).Times(1);
provider_.OnEndpointAdded(endpoint2);
Mock::VerifyAndClearExpectations(&manager_);
EXPECT_EQ(2, GetServices().size());
WiFiServiceRefPtr service1(FindService(ssid1_bytes, kModeManaged,
kSecurityRsn));
EXPECT_TRUE(service1);
EXPECT_TRUE(service1->HasEndpoints());
EXPECT_EQ(kSecurityPsk, service1->security_);
EXPECT_TRUE(service1 != service0);
}
TEST_F(WiFiProviderTest, OnEndpointAddedWhileStopped) {
// If we don't call provider_.Start(), OnEndpointAdded should have no effect.
const string ssid("an_ssid");
WiFiEndpointRefPtr endpoint = MakeEndpoint(ssid, "00:00:00:00:00:00", 0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, UpdateService(_)).Times(0);
provider_.OnEndpointAdded(endpoint);
EXPECT_TRUE(GetServices().empty());
}
TEST_F(WiFiProviderTest, OnEndpointAddedToMockService) {
// The previous test allowed the provider to create its own "real"
// WiFiServices, which hides some of what we can test with mock
// services. Re-do an add-endpoint operation by seeding the provider
// with a mock service.
provider_.Start();
const string ssid0("an_ssid");
const vector<uint8_t> ssid0_bytes(ssid0.begin(), ssid0.end());
MockWiFiServiceRefPtr service0 = AddMockService(ssid0_bytes,
kModeManaged,
kSecurityNone,
false);
const string ssid1("another_ssid");
const vector<uint8_t> ssid1_bytes(ssid1.begin(), ssid1.end());
MockWiFiServiceRefPtr service1 = AddMockService(ssid1_bytes,
kModeManaged,
kSecurityNone,
false);
EXPECT_EQ(service0.get(), FindService(ssid0_bytes,
kModeManaged,
kSecurityNone).get());
WiFiEndpointRefPtr endpoint0 = MakeEndpoint(ssid0, "00:00:00:00:00:00", 0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(1);
EXPECT_CALL(*service0, AddEndpoint(RefPtrMatch(endpoint0))).Times(1);
EXPECT_CALL(*service1, AddEndpoint(_)).Times(0);
provider_.OnEndpointAdded(endpoint0);
Mock::VerifyAndClearExpectations(&manager_);
Mock::VerifyAndClearExpectations(service0.get());
Mock::VerifyAndClearExpectations(service1.get());
WiFiEndpointRefPtr endpoint1 = MakeEndpoint(ssid0, "00:00:00:00:00:01", 0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(1);
EXPECT_CALL(*service0, AddEndpoint(RefPtrMatch(endpoint1))).Times(1);
EXPECT_CALL(*service1, AddEndpoint(_)).Times(0);
provider_.OnEndpointAdded(endpoint1);
Mock::VerifyAndClearExpectations(&manager_);
Mock::VerifyAndClearExpectations(service0.get());
Mock::VerifyAndClearExpectations(service1.get());
WiFiEndpointRefPtr endpoint2 = MakeEndpoint(ssid1, "00:00:00:00:00:02", 0, 0);
EXPECT_CALL(manager_, RegisterService(_)).Times(0);
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service1))).Times(1);
EXPECT_CALL(*service0, AddEndpoint(_)).Times(0);
EXPECT_CALL(*service1, AddEndpoint(RefPtrMatch(endpoint2))).Times(1);
provider_.OnEndpointAdded(endpoint2);
}
TEST_F(WiFiProviderTest, OnEndpointRemoved) {
provider_.Start();
const string ssid0("an_ssid");
const vector<uint8_t> ssid0_bytes(ssid0.begin(), ssid0.end());
MockWiFiServiceRefPtr service0 = AddMockService(ssid0_bytes,
kModeManaged,
kSecurityNone,
false);
const string ssid1("another_ssid");
const vector<uint8_t> ssid1_bytes(ssid1.begin(), ssid1.end());
MockWiFiServiceRefPtr service1 = AddMockService(ssid1_bytes,
kModeManaged,
kSecurityNone,
false);
EXPECT_EQ(2, GetServices().size());
// Remove the last endpoint of a non-remembered service.
WiFiEndpointRefPtr endpoint0 = MakeEndpoint(ssid0, "00:00:00:00:00:00", 0, 0);
AddEndpointToService(service0, endpoint0);
EXPECT_EQ(1, GetServiceByEndpoint().size());
EXPECT_CALL(*service0, RemoveEndpoint(RefPtrMatch(endpoint0))).Times(1);
EXPECT_CALL(*service1, RemoveEndpoint(_)).Times(0);
EXPECT_CALL(*service0, HasEndpoints()).WillOnce(Return(false));
EXPECT_CALL(*service0, IsRemembered()).WillOnce(Return(false));
EXPECT_CALL(*service0, ResetWiFi()).Times(1);
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(0);
EXPECT_CALL(manager_, DeregisterService(RefPtrMatch(service0))).Times(1);
provider_.OnEndpointRemoved(endpoint0);
// Verify now, so it's clear that this happened as a result of the call
// above, and not anything in the destructor(s).
Mock::VerifyAndClearExpectations(&manager_);
Mock::VerifyAndClearExpectations(service0.get());
Mock::VerifyAndClearExpectations(service1.get());
EXPECT_EQ(1, GetServices().size());
EXPECT_EQ(service1.get(), GetServices().front().get());
EXPECT_TRUE(GetServiceByEndpoint().empty());
}
TEST_F(WiFiProviderTest, OnEndpointRemovedButHasEndpoints) {
provider_.Start();
const string ssid0("an_ssid");
const vector<uint8_t> ssid0_bytes(ssid0.begin(), ssid0.end());
MockWiFiServiceRefPtr service0 = AddMockService(ssid0_bytes,
kModeManaged,
kSecurityNone,
false);
EXPECT_EQ(1, GetServices().size());
// Remove an endpoint of a non-remembered service.
WiFiEndpointRefPtr endpoint0 = MakeEndpoint(ssid0, "00:00:00:00:00:00", 0, 0);
AddEndpointToService(service0, endpoint0);
EXPECT_EQ(1, GetServiceByEndpoint().size());
EXPECT_CALL(*service0, RemoveEndpoint(RefPtrMatch(endpoint0))).Times(1);
EXPECT_CALL(*service0, HasEndpoints()).WillOnce(Return(true));
EXPECT_CALL(*service0, IsRemembered()).WillRepeatedly(Return(false));
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(1);
EXPECT_CALL(*service0, ResetWiFi()).Times(0);
EXPECT_CALL(manager_, DeregisterService(_)).Times(0);
provider_.OnEndpointRemoved(endpoint0);
// Verify now, so it's clear that this happened as a result of the call
// above, and not anything in the destructor(s).
Mock::VerifyAndClearExpectations(&manager_);
Mock::VerifyAndClearExpectations(service0.get());
EXPECT_EQ(1, GetServices().size());
EXPECT_TRUE(GetServiceByEndpoint().empty());
}
TEST_F(WiFiProviderTest, OnEndpointRemovedButIsRemembered) {
provider_.Start();
const string ssid0("an_ssid");
const vector<uint8_t> ssid0_bytes(ssid0.begin(), ssid0.end());
MockWiFiServiceRefPtr service0 = AddMockService(ssid0_bytes,
kModeManaged,
kSecurityNone,
false);
EXPECT_EQ(1, GetServices().size());
// Remove the last endpoint of a remembered service.
WiFiEndpointRefPtr endpoint0 = MakeEndpoint(ssid0, "00:00:00:00:00:00", 0, 0);
AddEndpointToService(service0, endpoint0);
EXPECT_EQ(1, GetServiceByEndpoint().size());
EXPECT_CALL(*service0, RemoveEndpoint(RefPtrMatch(endpoint0))).Times(1);
EXPECT_CALL(*service0, HasEndpoints()).WillRepeatedly(Return(false));
EXPECT_CALL(*service0, IsRemembered()).WillOnce(Return(true));
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(service0))).Times(1);
EXPECT_CALL(*service0, ResetWiFi()).Times(0);
EXPECT_CALL(manager_, DeregisterService(_)).Times(0);
provider_.OnEndpointRemoved(endpoint0);
// Verify now, so it's clear that this happened as a result of the call
// above, and not anything in the destructor(s).
Mock::VerifyAndClearExpectations(&manager_);
Mock::VerifyAndClearExpectations(service0.get());
EXPECT_EQ(1, GetServices().size());
EXPECT_TRUE(GetServiceByEndpoint().empty());
}
TEST_F(WiFiProviderTest, OnEndpointRemovedWhileStopped) {
// If we don't call provider_.Start(), OnEndpointRemoved should not
// cause a crash even if a service matching the endpoint does not exist.
const string ssid("an_ssid");
WiFiEndpointRefPtr endpoint = MakeEndpoint(ssid, "00:00:00:00:00:00", 0, 0);
provider_.OnEndpointRemoved(endpoint);
}
TEST_F(WiFiProviderTest, OnEndpointUpdated) {
provider_.Start();
// Create an endpoint and associate it with a mock service.
const string ssid("an_ssid");
WiFiEndpointRefPtr endpoint = MakeEndpoint(ssid, "00:00:00:00:00:00", 0, 0);
const vector<uint8_t> ssid_bytes(ssid.begin(), ssid.end());
MockWiFiServiceRefPtr open_service = AddMockService(ssid_bytes,
kModeManaged,
kSecurityNone,
false);
EXPECT_CALL(*open_service, AddEndpoint(RefPtrMatch(endpoint)));
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(open_service)));
provider_.OnEndpointAdded(endpoint);
Mock::VerifyAndClearExpectations(open_service.get());
// WiFiProvider is running and endpoint matches this service.
EXPECT_CALL(*open_service, NotifyEndpointUpdated(RefPtrMatch(endpoint)));
EXPECT_CALL(*open_service, AddEndpoint(_)).Times(0);
provider_.OnEndpointUpdated(endpoint);
Mock::VerifyAndClearExpectations(open_service.get());
// If the endpoint is changed in a way that causes it to match a different
// service, the provider should transfer the endpoint from one service to
// the other.
MockWiFiServiceRefPtr rsn_service = AddMockService(ssid_bytes,
kModeManaged,
kSecurityRsn,
false);
EXPECT_CALL(*open_service, RemoveEndpoint(RefPtrMatch(endpoint)));
// We are playing out a scenario where the open service is not removed
// since it still claims to have more endpoints remaining.
EXPECT_CALL(*open_service, HasEndpoints()).WillOnce(Return(true));
EXPECT_CALL(*rsn_service, AddEndpoint(RefPtrMatch(endpoint)));
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(open_service)));
EXPECT_CALL(manager_, UpdateService(RefPtrMatch(rsn_service)));
endpoint->set_security_mode(kSecurityRsn);
provider_.OnEndpointUpdated(endpoint);
}
TEST_F(WiFiProviderTest, OnEndpointUpdatedWhileStopped) {
// If we don't call provider_.Start(), OnEndpointUpdated should not
// cause a crash even if a service matching the endpoint does not exist.
const string ssid("an_ssid");
WiFiEndpointRefPtr endpoint = MakeEndpoint(ssid, "00:00:00:00:00:00", 0, 0);
provider_.OnEndpointUpdated(endpoint);
}
TEST_F(WiFiProviderTest, OnServiceUnloaded) {
// This function should never unregister services itself -- the Manager
// will automatically deregister the service if OnServiceUnloaded()
// returns true (via WiFiService::Unload()).
EXPECT_CALL(manager_, DeregisterService(_)).Times(0);
MockWiFiServiceRefPtr service = AddMockService(vector<uint8_t>(1, '0'),
kModeManaged,
kSecurityNone,
false);
EXPECT_EQ(1, GetServices().size());
EXPECT_CALL(*service, HasEndpoints()).WillOnce(Return(true));
EXPECT_CALL(*service, ResetWiFi()).Times(0);
EXPECT_FALSE(provider_.OnServiceUnloaded(service));
EXPECT_EQ(1, GetServices().size());
Mock::VerifyAndClearExpectations(service.get());
EXPECT_CALL(*service, HasEndpoints()).WillOnce(Return(false));
EXPECT_CALL(*service, ResetWiFi()).Times(1);
EXPECT_TRUE(provider_.OnServiceUnloaded(service));
// Verify now, so it's clear that this happened as a result of the call
// above, and not anything in the destructor(s).
Mock::VerifyAndClearExpectations(service.get());
EXPECT_TRUE(GetServices().empty());
Mock::VerifyAndClearExpectations(&manager_);
}
TEST_F(WiFiProviderTest, LoadAndFixupServiceEntriesDefaultProfile) {
// We test LoadAndFixupServiceEntries indirectly since it calls a static
// method in WiFiService.
EXPECT_CALL(metrics_, SendEnumToUMA(
"Network.Shill.Wifi.ServiceFixupEntries",
Metrics::kMetricServiceFixupDefaultProfile,
Metrics::kMetricServiceFixupMax)).Times(1);
EXPECT_CALL(default_profile_storage_, Flush()).Times(1);
const string kGroupId =
StringPrintf("%s_0_0_%s_%s", kTypeWifi, kModeManaged, kSecurityNone);
EXPECT_CALL(default_profile_storage_,
GetString(kGroupId, _, _)).WillRepeatedly(Return(false));
EXPECT_CALL(default_profile_storage_,
SetString(kGroupId, _, _)).WillRepeatedly(Return(true));
set<string> groups;
groups.insert(kGroupId);
EXPECT_CALL(default_profile_storage_, GetGroups())
.WillRepeatedly(Return(groups));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 0), _)).
WillOnce(Return(true));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 1), _)).
WillOnce(Return(true));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 2), _)).
WillOnce(Return(true));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 3), _)).
WillOnce(Return(false));
LoadAndFixupServiceEntries(default_profile_.get());
}
TEST_F(WiFiProviderTest, LoadAndFixupServiceEntriesUserProfile) {
EXPECT_CALL(metrics_, SendEnumToUMA(
"Network.Shill.Wifi.ServiceFixupEntries",
Metrics::kMetricServiceFixupUserProfile,
Metrics::kMetricServiceFixupMax)).Times(1);
EXPECT_CALL(user_profile_storage_, Flush()).Times(1);
const string kGroupId =
StringPrintf("%s_0_0_%s_%s", kTypeWifi, kModeManaged, kSecurityNone);
EXPECT_CALL(user_profile_storage_,
GetString(kGroupId, _, _)).WillRepeatedly(Return(false));
EXPECT_CALL(user_profile_storage_,
SetString(kGroupId, _, _)).WillRepeatedly(Return(true));
set<string> groups;
groups.insert(kGroupId);
EXPECT_CALL(user_profile_storage_, GetGroups())
.WillRepeatedly(Return(groups));
EXPECT_CALL(user_profile_storage_, GetStringList(_, _, _)).Times(0);
LoadAndFixupServiceEntries(user_profile_.get());
}
TEST_F(WiFiProviderTest, LoadAndFixupServiceEntriesNothingToDo) {
EXPECT_CALL(metrics_, SendEnumToUMA(_, _, _)).Times(0);
EXPECT_CALL(default_profile_storage_, Flush()).Times(0);
const string kGroupId =
StringPrintf("%s_0_0_%s_%s", kTypeWifi, kModeManaged, kSecurityNone);
EXPECT_CALL(default_profile_storage_,
GetString(kGroupId, _, _)).WillRepeatedly(Return(true));
set<string> groups;
groups.insert(kGroupId);
EXPECT_CALL(default_profile_storage_, GetGroups()).WillOnce(Return(groups));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 0), _)).
WillOnce(Return(true));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 1), _)).
WillOnce(Return(true));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 2), _)).
WillOnce(Return(true));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 3), _)).
WillOnce(Return(false));
LoadAndFixupServiceEntries(default_profile_.get());
}
TEST_F(WiFiProviderTest, GetHiddenSSIDList) {
EXPECT_TRUE(provider_.GetHiddenSSIDList().empty());
const vector<uint8_t> ssid0(1, '0');
AddMockService(ssid0, kModeManaged, kSecurityNone, false);
EXPECT_TRUE(provider_.GetHiddenSSIDList().empty());
const vector<uint8_t> ssid1(1, '1');
MockWiFiServiceRefPtr service1 = AddMockService(ssid1,
kModeManaged,
kSecurityNone,
true);
EXPECT_CALL(*service1, IsRemembered()).WillRepeatedly(Return(false));
EXPECT_TRUE(provider_.GetHiddenSSIDList().empty());
const vector<uint8_t> ssid2(1, '2');
MockWiFiServiceRefPtr service2 = AddMockService(ssid2,
kModeManaged,
kSecurityNone,
true);
EXPECT_CALL(*service2, IsRemembered()).WillRepeatedly(Return(true));
ByteArrays ssid_list = provider_.GetHiddenSSIDList();
EXPECT_EQ(1, ssid_list.size());
EXPECT_TRUE(ssid_list[0] == ssid2);
const vector<uint8_t> ssid3(1, '3');
MockWiFiServiceRefPtr service3 = AddMockService(ssid3,
kModeManaged,
kSecurityNone,
false);
EXPECT_CALL(*service2, IsRemembered()).WillRepeatedly(Return(true));
ssid_list = provider_.GetHiddenSSIDList();
EXPECT_EQ(1, ssid_list.size());
EXPECT_TRUE(ssid_list[0] == ssid2);
const vector<uint8_t> ssid4(1, '4');
MockWiFiServiceRefPtr service4 = AddMockService(ssid4,
kModeManaged,
kSecurityNone,
true);
EXPECT_CALL(*service4, IsRemembered()).WillRepeatedly(Return(true));
ssid_list = provider_.GetHiddenSSIDList();
EXPECT_EQ(2, ssid_list.size());
EXPECT_TRUE(ssid_list[0] == ssid2);
EXPECT_TRUE(ssid_list[1] == ssid4);
}
TEST_F(WiFiProviderTest, StringListToFrequencyMap) {
vector<string> strings;
BuildFreqCountStrings(&strings);
WiFiProvider::ConnectFrequencyMap frequencies_result;
time_t days = WiFiProvider::StringListToFrequencyMap(strings,
&frequencies_result);
WiFiProvider::ConnectFrequencyMap frequencies_expect;
BuildFreqCountMap(&frequencies_expect);
EXPECT_THAT(frequencies_result, ContainerEq(frequencies_expect));
EXPECT_EQ(days, kTestDays);
}
TEST_F(WiFiProviderTest, StringListToFrequencyMapEmpty) {
vector<string> strings;
strings.push_back("@50");
WiFiProvider::ConnectFrequencyMap frequencies_result;
time_t days = WiFiProvider::StringListToFrequencyMap(strings,
&frequencies_result);
EXPECT_TRUE(frequencies_result.empty());
EXPECT_EQ(days, 50);
}
TEST_F(WiFiProviderTest, FrequencyMapToStringList) {
WiFiProvider::ConnectFrequencyMap frequencies;
BuildFreqCountMap(&frequencies);
vector<string> strings_result;
WiFiProvider::FrequencyMapToStringList(kTestDays, frequencies,
&strings_result);
vector<string> strings_expect;
BuildFreqCountStrings(&strings_expect);
EXPECT_THAT(strings_result, ContainerEq(strings_expect));
}
TEST_F(WiFiProviderTest, FrequencyMapToStringListEmpty) {
WiFiProvider::ConnectFrequencyMap frequencies;
vector<string> strings_result;
WiFiProvider::FrequencyMapToStringList(kTestDays, frequencies,
&strings_result);
EXPECT_EQ(1, strings_result.size());
EXPECT_EQ(*strings_result.begin(), "@20");
}
TEST_F(WiFiProviderTest, FrequencyMapBasicAging) {
const time_t kThisWeek = kFirstWeek +
WiFiProvider::kWeeksToKeepFrequencyCounts - 1;
LoadConnectCountByFrequency(kThisWeek * kSecondsPerWeek);
// Make sure we have data for all 3 blocks.
WiFiProvider::ConnectFrequencyMap expected;
expected[5001] = 2;
expected[5002] = 2;
expected[6001] = 1;
expected[6002] = 2;
expected[7001] = 1;
expected[7002] = 2;
EXPECT_THAT(provider_.connect_count_by_frequency_, ContainerEq(expected));
// And, then, make sure we output the expected blocks of data.
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _,
Eq(profile_frequency_data_[
StringPrintf(
"%s%d", WiFiProvider::kStorageFrequencies, 0)])));
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _,
Eq(profile_frequency_data_[
StringPrintf(
"%s%d", WiFiProvider::kStorageFrequencies, 1)])));
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _,
Eq(profile_frequency_data_[
StringPrintf(
"%s%d", WiFiProvider::kStorageFrequencies, 2)])));
vector<string> frequencies;
frequencies.push_back(base::StringPrintf("@%" PRIu64,
static_cast<uint64_t>(kThisWeek)));
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _, Eq(frequencies))).Times(0);
Save();
}
TEST_F(WiFiProviderTest, FrequencyMapAgingIllegalDay) {
provider_.time_ = &time_;
const time_t kThisWeek = kFirstWeek +
WiFiProvider::kWeeksToKeepFrequencyCounts - 1;
const time_t kThisWeekSeconds = kThisWeek * kSecondsPerWeek;
EXPECT_CALL(time_, GetSecondsSinceEpoch()).WillOnce(Return(kThisWeekSeconds));
const string kGroupId =
StringPrintf("%s_0_0_%s_%s", kTypeWifi, kModeManaged, kSecurityNone);
EXPECT_CALL(default_profile_storage_,
GetString(kGroupId, _, _)).WillRepeatedly(Return(true));
set<string> groups;
groups.insert(kGroupId);
// Instead of block[1], return a block without the date.
EXPECT_CALL(default_profile_storage_, GetGroups()).WillOnce(Return(groups));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 0), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 1), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetIllegalDayStringList));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 2), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
EXPECT_CALL(default_profile_storage_, GetStringList(WiFiProvider::kStorageId,
StringPrintf("%s%d", WiFiProvider::kStorageFrequencies, 3), _)).
WillOnce(Invoke(this, &WiFiProviderTest::GetStringList));
LoadAndFixupServiceEntries(default_profile_.get());
// Verify that the received information only includes block[0] and block[2].
WiFiProvider::ConnectFrequencyMap expected;
expected[5001] = 1;
expected[5002] = 2;
expected[7001] = 1;
expected[7002] = 2;
EXPECT_THAT(provider_.connect_count_by_frequency_, ContainerEq(expected));
// And, then, make sure we output the expected blocks of data.
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _,
Eq(profile_frequency_data_[
StringPrintf(
"%s%d", WiFiProvider::kStorageFrequencies, 0)])));
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _,
Eq(profile_frequency_data_[
StringPrintf(
"%s%d", WiFiProvider::kStorageFrequencies, 1)]))).
Times(0);
EXPECT_CALL(
default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _,
Eq(profile_frequency_data_[
StringPrintf(
"%s%d", WiFiProvider::kStorageFrequencies, 2)])));
vector<string> frequencies;
frequencies.push_back(base::StringPrintf("@%" PRIu64,
static_cast<uint64_t>(kThisWeek)));
EXPECT_CALL(default_profile_storage_,
SetStringList(WiFiProvider::kStorageId, _, Eq(frequencies)))
.Times(0);
Save();
}
TEST_F(WiFiProviderTest, IncrementConnectCount) {
const time_t kThisWeek = kFirstWeek +
WiFiProvider::kWeeksToKeepFrequencyCounts - 1;
const time_t kThisWeekSeconds = kThisWeek * kSecondsPerWeek;
LoadConnectCountByFrequency(kThisWeekSeconds);
EXPECT_CALL(time_, GetSecondsSinceEpoch()).WillOnce(Return(kThisWeekSeconds));
EXPECT_CALL(manager_, UpdateWiFiProvider());
EXPECT_CALL(metrics_, SendToUMA(Metrics::kMetricFrequenciesConnectedEver,
_, _, _, _));
time_t newest_week_at_start =
provider_.connect_count_by_frequency_dated_.crbegin()->first;
provider_.IncrementConnectCount(6002);
// Make sure we have data for all 3 blocks.
WiFiProvider::ConnectFrequencyMap expected;
expected[5001] = 2;
expected[5002] = 2;
expected[6001] = 1;
expected[6002] = 3;
expected[7001] = 1;
expected[7002] = 2;
EXPECT_THAT(provider_.connect_count_by_frequency_, ContainerEq(expected));
// Make sure we didn't delete the oldest block.
EXPECT_TRUE(ContainsKey(provider_.connect_count_by_frequency_dated_,
kFirstWeek));
// Make sure we didn't create a new block.
time_t newest_week_at_end =
provider_.connect_count_by_frequency_dated_.crbegin()->first;
EXPECT_EQ(newest_week_at_start, newest_week_at_end);
}
TEST_F(WiFiProviderTest, IncrementConnectCountCreateNew) {
time_t this_week = kFirstWeek + WiFiProvider::kWeeksToKeepFrequencyCounts - 1;
LoadConnectCountByFrequency(this_week * kSecondsPerWeek);
this_week += 2;
EXPECT_CALL(time_, GetSecondsSinceEpoch()).
WillOnce(Return(this_week * kSecondsPerWeek));
EXPECT_CALL(manager_, UpdateWiFiProvider());
EXPECT_CALL(metrics_, SendToUMA(Metrics::kMetricFrequenciesConnectedEver,
_, _, _, _));
time_t newest_week_at_start =
provider_.connect_count_by_frequency_dated_.crbegin()->first;
provider_.IncrementConnectCount(6001);
// Make sure we have data for newest 2 blocks (only).
WiFiProvider::ConnectFrequencyMap expected;
expected[5001] = 1;
expected[6001] = 2;
expected[6002] = 2;
expected[7001] = 1;
expected[7002] = 2;
EXPECT_THAT(provider_.connect_count_by_frequency_, ContainerEq(expected));
// Verify that the oldest block is gone.
EXPECT_FALSE(ContainsKey(provider_.connect_count_by_frequency_dated_,
kFirstWeek));
// Make sure we created a new block and that it is for the current week.
time_t newest_week_at_end =
provider_.connect_count_by_frequency_dated_.crbegin()->first;
EXPECT_NE(newest_week_at_start, newest_week_at_end);
EXPECT_TRUE(ContainsKey(provider_.connect_count_by_frequency_dated_,
this_week));
}
TEST_F(WiFiProviderTest, ReportAutoConnectableServices) {
MockWiFiServiceRefPtr service0 = AddMockService(vector<uint8_t>(1, '0'),
kModeManaged,
kSecurityNone,
false);
MockWiFiServiceRefPtr service1 = AddMockService(vector<uint8_t>(1, '1'),
kModeManaged,
kSecurityNone,
false);
service0->EnableAndRetainAutoConnect();
service0->SetConnectable(true);
service1->EnableAndRetainAutoConnect();
service1->SetConnectable(true);
EXPECT_CALL(*service0, IsAutoConnectable(_))
.WillOnce(Return(true))
.WillOnce(Return(false));
EXPECT_CALL(*service1, IsAutoConnectable(_))
.WillRepeatedly(Return(false));
// With 1 auto connectable service.
EXPECT_CALL(metrics_, NotifyWifiAutoConnectableServices(1));
provider_.ReportAutoConnectableServices();
// With no auto connectable service.
EXPECT_CALL(metrics_, NotifyWifiAutoConnectableServices(_)).Times(0);
provider_.ReportAutoConnectableServices();
}
TEST_F(WiFiProviderTest, NumAutoConnectableServices) {
MockWiFiServiceRefPtr service0 = AddMockService(
vector<uint8_t>(1, '0'), kModeManaged, kSecurityNone, false);
MockWiFiServiceRefPtr service1 = AddMockService(
vector<uint8_t>(1, '1'), kModeManaged, kSecurityNone, false);
service0->EnableAndRetainAutoConnect();
service0->SetConnectable(true);
service1->EnableAndRetainAutoConnect();
service1->SetConnectable(true);
EXPECT_CALL(*service0, IsAutoConnectable(_))
.WillOnce(Return(true))
.WillOnce(Return(false));
EXPECT_CALL(*service1, IsAutoConnectable(_)).WillRepeatedly(Return(true));
// 2 auto-connectable services.
EXPECT_EQ(2, provider_.NumAutoConnectableServices());
// 1 auto-connectable service.
EXPECT_EQ(1, provider_.NumAutoConnectableServices());
}
TEST_F(WiFiProviderTest, GetSsidsConfiguredForAutoConnect) {
vector<uint8_t> ssid0(3, '0');
vector<uint8_t> ssid1(5, '1');
ByteString ssid0_bytes(ssid0);
ByteString ssid1_bytes(ssid1);
MockWiFiServiceRefPtr service0 =
AddMockService(ssid0, kModeManaged, kSecurityNone, false);
MockWiFiServiceRefPtr service1 =
AddMockService(ssid1, kModeManaged, kSecurityNone, false);
// 2 services configured for auto-connect.
service0->SetAutoConnect(true);
service1->SetAutoConnect(true);
vector<ByteString> service_list_0 =
provider_.GetSsidsConfiguredForAutoConnect();
EXPECT_EQ(2, service_list_0.size());
EXPECT_TRUE(ssid0_bytes.Equals(service_list_0[0]));
EXPECT_TRUE(ssid1_bytes.Equals(service_list_0[1]));
// 1 service configured for auto-connect.
service0->SetAutoConnect(false);
service1->SetAutoConnect(true);
vector<ByteString> service_list_1 =
provider_.GetSsidsConfiguredForAutoConnect();
EXPECT_EQ(1, service_list_1.size());
EXPECT_TRUE(ssid1_bytes.Equals(service_list_1[0]));
}
} // namespace shill