blob: c878867154a64b3026c9df277ad64fe697af57e4 [file] [log] [blame]
//
// Copyright (C) 2012 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/manager.h"
#include <map>
#include <memory>
#include <set>
#include <base/files/file_util.h>
#include <base/files/scoped_temp_dir.h>
#include <base/stl_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 <gmock/gmock.h>
#include <gtest/gtest.h>
#include "shill/adaptor_interfaces.h"
#include "shill/ephemeral_profile.h"
#include "shill/error.h"
#include "shill/fake_store.h"
#include "shill/geolocation_info.h"
#include "shill/key_value_store.h"
#include "shill/link_monitor.h"
#include "shill/logging.h"
#include "shill/mock_adaptors.h"
#include "shill/mock_connection.h"
#include "shill/mock_control.h"
#include "shill/mock_crypto_util_proxy.h"
#include "shill/mock_device.h"
#include "shill/mock_device_claimer.h"
#include "shill/mock_device_info.h"
#include "shill/mock_log.h"
#include "shill/mock_metrics.h"
#include "shill/mock_power_manager.h"
#include "shill/mock_profile.h"
#include "shill/mock_resolver.h"
#include "shill/mock_service.h"
#include "shill/mock_store.h"
#include "shill/portal_detector.h"
#include "shill/property_store_unittest.h"
#include "shill/resolver.h"
#include "shill/service_under_test.h"
#include "shill/store_factory.h"
#include "shill/testing.h"
#include "shill/upstart/mock_upstart.h"
#include "shill/wimax/wimax_service.h"
#if !defined(DISABLE_WIFI)
#include "shill/wifi/mock_wifi_provider.h"
#include "shill/wifi/mock_wifi_service.h"
#include "shill/wifi/wifi_service.h"
#if defined(__BRILLO__)
#include "shill/wifi/mock_wifi_driver_hal.h"
#endif // __BRILLO__
#endif // DISABLE_WIFI
#if !defined(DISABLE_WIRED_8021X)
#include "shill/ethernet/mock_ethernet_eap_provider.h"
#endif // DISABLE_WIRED_8021X
using base::Bind;
using base::FilePath;
using base::ScopedTempDir;
using base::Unretained;
using std::map;
using std::set;
using std::string;
using std::vector;
namespace shill {
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::AtLeast;
using ::testing::ContainerEq;
using ::testing::DoAll;
using ::testing::ElementsAre;
using ::testing::HasSubstr;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::Mock;
using ::testing::Ne;
using ::testing::NiceMock;
using ::testing::Ref;
using ::testing::Return;
using ::testing::ReturnNull;
using ::testing::ReturnRef;
using ::testing::SaveArg;
using ::testing::SetArgumentPointee;
using ::testing::StrEq;
using ::testing::StrictMock;
using ::testing::Test;
using ::testing::WithArg;
class ManagerTest : public PropertyStoreTest {
public:
ManagerTest()
: power_manager_(new MockPowerManager(nullptr, control_interface())),
device_info_(new NiceMock<MockDeviceInfo>(control_interface(),
nullptr,
nullptr,
nullptr)),
manager_adaptor_(new NiceMock<ManagerMockAdaptor>()),
#if !defined(DISABLE_WIRED_8021X)
ethernet_eap_provider_(new NiceMock<MockEthernetEapProvider>()),
#endif // DISABLE_WIRED_8021X
#if !defined(DISABLE_WIFI)
wifi_provider_(new NiceMock<MockWiFiProvider>()),
#endif // DISABLE_WIFI
crypto_util_proxy_(
new NiceMock<MockCryptoUtilProxy>(dispatcher())),
upstart_(new NiceMock<MockUpstart>(control_interface())) {
ON_CALL(*control_interface(), CreatePowerManagerProxy(_, _, _))
.WillByDefault(ReturnNull());
mock_devices_.push_back(new NiceMock<MockDevice>(control_interface(),
dispatcher(),
metrics(),
manager(),
"null0",
"addr0",
0));
mock_devices_.push_back(new NiceMock<MockDevice>(control_interface(),
dispatcher(),
metrics(),
manager(),
"null1",
"addr1",
1));
mock_devices_.push_back(new NiceMock<MockDevice>(control_interface(),
dispatcher(),
metrics(),
manager(),
"null2",
"addr2",
2));
mock_devices_.push_back(new NiceMock<MockDevice>(control_interface(),
dispatcher(),
metrics(),
manager(),
"null3",
"addr3",
3));
manager()->connect_profiles_to_rpc_ = false;
SetRunning(true);
// Replace the manager's adaptor with a quieter one, and one
// we can do EXPECT*() against. Passes ownership.
manager()->adaptor_.reset(manager_adaptor_);
#if !defined(DISABLE_WIRED_8021X)
// Replace the manager's Ethernet EAP provider with our mock.
// Passes ownership.
manager()->ethernet_eap_provider_.reset(ethernet_eap_provider_);
#endif // DISABLE_WIRED_8021X
#if !defined(DISABLE_WIFI)
// Replace the manager's WiFi provider with our mock. Passes
// ownership.
manager()->wifi_provider_.reset(wifi_provider_);
#if defined(__BRILLO__)
manager()->wifi_driver_hal_ = &wifi_driver_hal_;
#endif // __BRILLO__
#endif // DISABLE_WIFI
// Update the manager's map from technology to provider.
manager()->UpdateProviderMapping();
// Replace the manager's crypto util proxy with our mock. Passes
// ownership.
manager()->crypto_util_proxy_.reset(crypto_util_proxy_);
// Replace the manager's upstart instance with our mock. Passes
// ownership.
manager()->upstart_.reset(upstart_);
}
virtual ~ManagerTest() {}
void SetMetrics(Metrics* metrics) {
manager()->set_metrics(metrics);
}
bool IsDeviceRegistered(const DeviceRefPtr& device,
Technology::Identifier tech) {
auto devices = manager()->FilterByTechnology(tech);
return (devices.size() == 1 && devices[0].get() == device.get());
}
bool ServiceOrderIs(ServiceRefPtr svc1, ServiceRefPtr svc2);
void AdoptProfile(Manager* manager, ProfileRefPtr profile) {
manager->profiles_.push_back(profile);
}
void SetRunning(bool running) {
manager()->running_ = running;
}
ProfileRefPtr GetEphemeralProfile(Manager* manager) {
return manager->ephemeral_profile_;
}
vector<ProfileRefPtr>& GetProfiles(Manager* manager) {
return manager->profiles_;
}
Profile* CreateProfileForManager(Manager* manager) {
Profile::Identifier id("rather", "irrelevant");
std::unique_ptr<FakeStore> storage(new FakeStore());
if (!storage->Open())
return nullptr;
Profile* profile(new Profile(
control_interface(), metrics(), manager, id, FilePath(), false));
profile->set_storage(storage.release()); // Passes ownership of "storage".
return profile; // Passes ownership of "profile".
}
bool CreateBackingStoreForService(ScopedTempDir* temp_dir,
const string& user_identifier,
const string& profile_identifier,
const string& service_name) {
std::unique_ptr<StoreInterface> store(
StoreFactory::GetInstance()->CreateStore(
Profile::GetFinalStoragePath(
temp_dir->path(),
Profile::Identifier(user_identifier,
profile_identifier))));
return store->Open() &&
store->SetString(service_name, "rather", "irrelevant") &&
store->Close();
}
Error::Type TestCreateProfile(Manager* manager, const string& name) {
Error error;
string path;
manager->CreateProfile(name, &path, &error);
return error.type();
}
Error::Type TestPopAnyProfile(Manager* manager) {
Error error;
manager->PopAnyProfile(&error);
return error.type();
}
Error::Type TestPopAllUserProfiles(Manager* manager) {
Error error;
manager->PopAllUserProfiles(&error);
return error.type();
}
Error::Type TestPopProfile(Manager* manager, const string& name) {
Error error;
manager->PopProfile(name, &error);
return error.type();
}
Error::Type TestPushProfile(Manager* manager, const string& name) {
Error error;
string path;
manager->PushProfile(name, &path, &error);
return error.type();
}
Error::Type TestInsertUserProfile(Manager* manager,
const string& name,
const string& user_hash) {
Error error;
string path;
manager->InsertUserProfile(name, user_hash, &path, &error);
return error.type();
}
scoped_refptr<MockProfile> AddNamedMockProfileToManager(
Manager* manager, const string& name) {
scoped_refptr<MockProfile> profile(
new MockProfile(control_interface(), metrics(), manager, ""));
EXPECT_CALL(*profile, GetRpcIdentifier()).WillRepeatedly(Return(name));
EXPECT_CALL(*profile, UpdateDevice(_)).WillRepeatedly(Return(false));
AdoptProfile(manager, profile);
return profile;
}
void AddMockProfileToManager(Manager* manager) {
AddNamedMockProfileToManager(manager, "/");
}
void CompleteServiceSort() {
EXPECT_TRUE(IsSortServicesTaskPending());
dispatcher()->DispatchPendingEvents();
EXPECT_FALSE(IsSortServicesTaskPending());
}
bool IsSortServicesTaskPending() {
return !manager()->sort_services_task_.IsCancelled();
}
void RefreshConnectionState() {
manager()->RefreshConnectionState();
}
RpcIdentifier GetDefaultServiceRpcIdentifier() {
return manager()->GetDefaultServiceRpcIdentifier(nullptr);
}
void SetResolver(Resolver* resolver) {
manager()->resolver_ = resolver;
}
bool SetIgnoredDNSSearchPaths(const string& search_paths, Error* error) {
return manager()->SetIgnoredDNSSearchPaths(search_paths, error);
}
bool SetCheckPortalList(const string& check_portal_list, Error* error) {
return manager()->SetCheckPortalList(check_portal_list, error);
}
const string& GetIgnoredDNSSearchPaths() {
return manager()->props_.ignored_dns_search_paths;
}
#if !defined(DISABLE_WIFI)
WiFiServiceRefPtr ReleaseTempMockService() {
// Take a reference to hold during this function.
WiFiServiceRefPtr temp_service = temp_mock_service_;
temp_mock_service_ = nullptr;
return temp_service;
}
#endif // DISABLE_WIFI
void SetDeviceClaimer(DeviceClaimer* device_claimer) {
manager()->device_claimer_.reset(device_claimer);
}
void VerifyPassiveMode() {
EXPECT_NE(nullptr, manager()->device_claimer_.get());
EXPECT_TRUE(manager()->device_claimer_->default_claimer());
}
protected:
typedef scoped_refptr<MockService> MockServiceRefPtr;
class ServiceWatcher : public base::SupportsWeakPtr<ServiceWatcher> {
public:
ServiceWatcher() {}
virtual ~ServiceWatcher() {}
MOCK_METHOD1(OnDefaultServiceChanged, void(const ServiceRefPtr& service));
private:
DISALLOW_COPY_AND_ASSIGN(ServiceWatcher);
};
class TerminationActionTest :
public base::SupportsWeakPtr<TerminationActionTest> {
public:
static const char kActionName[];
TerminationActionTest() : manager_(nullptr) {}
virtual ~TerminationActionTest() {}
MOCK_METHOD1(Done, void(const Error& error));
void Action() {
manager_->TerminationActionComplete("action");
}
void set_manager(Manager* manager) { manager_ = manager; }
private:
Manager* manager_;
DISALLOW_COPY_AND_ASSIGN(TerminationActionTest);
};
class DestinationVerificationTest :
public base::SupportsWeakPtr<DestinationVerificationTest> {
public:
DestinationVerificationTest() {}
virtual ~DestinationVerificationTest() {}
MOCK_METHOD2(ResultBoolCallbackStub, void(const Error& result, bool flag));
MOCK_METHOD2(ResultStringCallbackStub, void(const Error& result,
const string& value));
private:
DISALLOW_COPY_AND_ASSIGN(DestinationVerificationTest);
};
class DisableTechnologyReplyHandler :
public base::SupportsWeakPtr<DisableTechnologyReplyHandler> {
public:
DisableTechnologyReplyHandler() {}
virtual ~DisableTechnologyReplyHandler() {}
MOCK_METHOD1(ReportResult, void(const Error&));
private:
DISALLOW_COPY_AND_ASSIGN(DisableTechnologyReplyHandler);
};
class ResultCallbackObserver {
public:
ResultCallbackObserver()
: result_callback_(
Bind(&ResultCallbackObserver::OnResultCallback,
Unretained(this))) {}
virtual ~ResultCallbackObserver() {}
MOCK_METHOD1(OnResultCallback, void(const Error& error));
const ResultCallback& result_callback() const {
return result_callback_;
}
private:
ResultCallback result_callback_;
DISALLOW_COPY_AND_ASSIGN(ResultCallbackObserver);
};
void SetSuspending(bool suspending) {
power_manager_->suspending_ = suspending;
}
void SetPowerManager() {
manager()->set_power_manager(power_manager_.release());
}
HookTable* GetTerminationActions() {
return &manager()->termination_actions_;
}
void OnSuspendImminent() {
manager()->OnSuspendImminent();
}
void OnDarkSuspendImminent() {
manager()->OnDarkSuspendImminent();
}
void OnSuspendDone() {
manager()->OnSuspendDone();
}
void OnSuspendActionsComplete(const Error& error) {
manager()->OnSuspendActionsComplete(error);
}
vector<string> EnumerateAvailableServices() {
return manager()->EnumerateAvailableServices(nullptr);
}
vector<string> EnumerateWatchedServices() {
return manager()->EnumerateWatchedServices(nullptr);
}
MockServiceRefPtr MakeAutoConnectableService() {
MockServiceRefPtr service = new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager());
service->SetAutoConnect(true);
service->SetConnectable(true);
return service;
}
#if !defined(DISABLE_WIRED_8021X)
void SetEapProviderService(const ServiceRefPtr& service) {
ethernet_eap_provider_->set_service(service);
}
#endif // DISABLE_WIRED_8021X
const std::vector<Technology::Identifier>& GetTechnologyOrder() {
return manager()->technology_order_;
}
std::unique_ptr<MockPowerManager> power_manager_;
vector<scoped_refptr<MockDevice>> mock_devices_;
std::unique_ptr<MockDeviceInfo> device_info_;
#if !defined(DISABLE_WIFI)
// This service is held for the manager, and given ownership in a mock
// function. This ensures that when the Manager takes ownership, there
// is only one reference left.
scoped_refptr<MockWiFiService> temp_mock_service_;
#endif // DISABLE_WIFI
// These pointers are owned by the manager, and only tracked here for
// EXPECT*()
ManagerMockAdaptor* manager_adaptor_;
#if !defined(DISABLE_WIRED_8021X)
MockEthernetEapProvider* ethernet_eap_provider_;
#endif // DISABLE_WIRED_8021X
#if !defined(DISABLE_WIFI)
MockWiFiProvider* wifi_provider_;
#if defined(__BRILLO__)
MockWiFiDriverHal wifi_driver_hal_;
#endif // __BRILLO__
#endif // DISABLE_WIFI
MockCryptoUtilProxy* crypto_util_proxy_;
MockUpstart* upstart_;
};
const char ManagerTest::TerminationActionTest::kActionName[] = "action";
bool ManagerTest::ServiceOrderIs(ServiceRefPtr svc0, ServiceRefPtr svc1) {
if (!manager()->sort_services_task_.IsCancelled()) {
manager()->SortServicesTask();
}
return (svc0.get() == manager()->services_[0].get() &&
svc1.get() == manager()->services_[1].get());
}
void SetErrorPermissionDenied(Error* error) {
error->Populate(Error::kPermissionDenied);
}
void SetErrorSuccess(Error* error) {
error->Reset();
}
MATCHER_P(IsError, error, "") {
return arg.type() == error->type() &&
arg.message() == error->message();
}
TEST_F(ManagerTest, Contains) {
EXPECT_TRUE(manager()->store().Contains(kStateProperty));
EXPECT_FALSE(manager()->store().Contains(""));
}
TEST_F(ManagerTest, PassiveModeDeviceRegistration) {
manager()->SetPassiveMode();
VerifyPassiveMode();
// Setup mock device claimer.
MockDeviceClaimer* device_claimer = new MockDeviceClaimer("");
SetDeviceClaimer(device_claimer);
EXPECT_CALL(*device_claimer, default_claimer()).WillRepeatedly(Return(true));
ON_CALL(*mock_devices_[0].get(), technology())
.WillByDefault(Return(Technology::kEthernet));
ON_CALL(*mock_devices_[1].get(), technology())
.WillByDefault(Return(Technology::kWifi));
// Device not released, should not be registered.
EXPECT_CALL(*device_claimer, IsDeviceReleased(mock_devices_[0]->link_name()))
.WillOnce(Return(false));
EXPECT_CALL(*device_claimer, Claim(mock_devices_[0]->link_name(), _))
.Times(1);
manager()->RegisterDevice(mock_devices_[0]);
EXPECT_FALSE(IsDeviceRegistered(mock_devices_[0], Technology::kEthernet));
// Device is released, should be registered.
EXPECT_CALL(*device_claimer, IsDeviceReleased(mock_devices_[1]->link_name()))
.WillOnce(Return(true));
EXPECT_CALL(*device_claimer, Claim(mock_devices_[1]->link_name(), _))
.Times(0);
manager()->RegisterDevice(mock_devices_[1]);
EXPECT_TRUE(IsDeviceRegistered(mock_devices_[1], Technology::kWifi));
}
TEST_F(ManagerTest, DeviceRegistration) {
ON_CALL(*mock_devices_[0].get(), technology())
.WillByDefault(Return(Technology::kEthernet));
ON_CALL(*mock_devices_[1].get(), technology())
.WillByDefault(Return(Technology::kWifi));
ON_CALL(*mock_devices_[2].get(), technology())
.WillByDefault(Return(Technology::kCellular));
manager()->RegisterDevice(mock_devices_[0]);
manager()->RegisterDevice(mock_devices_[1]);
manager()->RegisterDevice(mock_devices_[2]);
EXPECT_TRUE(IsDeviceRegistered(mock_devices_[0], Technology::kEthernet));
EXPECT_TRUE(IsDeviceRegistered(mock_devices_[1], Technology::kWifi));
EXPECT_TRUE(IsDeviceRegistered(mock_devices_[2], Technology::kCellular));
}
TEST_F(ManagerTest, DeviceRegistrationAndStart) {
manager()->running_ = true;
mock_devices_[0]->enabled_persistent_ = true;
mock_devices_[1]->enabled_persistent_ = false;
EXPECT_CALL(*mock_devices_[0].get(), SetEnabled(true))
.Times(1);
EXPECT_CALL(*mock_devices_[1].get(), SetEnabled(_))
.Times(0);
manager()->RegisterDevice(mock_devices_[0]);
manager()->RegisterDevice(mock_devices_[1]);
}
TEST_F(ManagerTest, DeviceRegistrationWithProfile) {
MockProfile* profile =
new MockProfile(control_interface(), metrics(), manager(), "");
DeviceRefPtr device_ref(mock_devices_[0].get());
AdoptProfile(manager(), profile); // Passes ownership.
EXPECT_CALL(*profile, ConfigureDevice(device_ref));
EXPECT_CALL(*profile, UpdateDevice(device_ref));
manager()->RegisterDevice(mock_devices_[0]);
}
TEST_F(ManagerTest, DeviceDeregistration) {
ON_CALL(*mock_devices_[0].get(), technology())
.WillByDefault(Return(Technology::kEthernet));
ON_CALL(*mock_devices_[1].get(), technology())
.WillByDefault(Return(Technology::kWifi));
manager()->RegisterDevice(mock_devices_[0]);
manager()->RegisterDevice(mock_devices_[1]);
ASSERT_TRUE(IsDeviceRegistered(mock_devices_[0], Technology::kEthernet));
ASSERT_TRUE(IsDeviceRegistered(mock_devices_[1], Technology::kWifi));
MockProfile* profile =
new MockProfile(control_interface(), metrics(), manager(), "");
AdoptProfile(manager(), profile); // Passes ownership.
EXPECT_CALL(*mock_devices_[0].get(), SetEnabled(false));
EXPECT_CALL(*profile, UpdateDevice(DeviceRefPtr(mock_devices_[0])));
manager()->DeregisterDevice(mock_devices_[0]);
EXPECT_FALSE(IsDeviceRegistered(mock_devices_[0], Technology::kEthernet));
EXPECT_CALL(*mock_devices_[1].get(), SetEnabled(false));
EXPECT_CALL(*profile, UpdateDevice(DeviceRefPtr(mock_devices_[1])));
manager()->DeregisterDevice(mock_devices_[1]);
EXPECT_FALSE(IsDeviceRegistered(mock_devices_[1], Technology::kWifi));
}
TEST_F(ManagerTest, ServiceRegistration) {
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
string());
ProfileRefPtr profile(CreateProfileForManager(&manager));
ASSERT_TRUE(profile.get());
AdoptProfile(&manager, profile);
scoped_refptr<MockService> mock_service(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
&manager));
scoped_refptr<MockService> mock_service2(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
&manager));
string service1_name(mock_service->unique_name());
string service2_name(mock_service2->unique_name());
EXPECT_CALL(*mock_service.get(), GetRpcIdentifier())
.WillRepeatedly(Return(service1_name));
EXPECT_CALL(*mock_service2.get(), GetRpcIdentifier())
.WillRepeatedly(Return(service2_name));
// TODO(quiche): make this EXPECT_CALL work (crbug.com/203247)
// EXPECT_CALL(*static_cast<ManagerMockAdaptor*>(manager.adaptor_.get()),
// EmitRpcIdentifierArrayChanged(kServicesProperty, _));
manager.RegisterService(mock_service);
manager.RegisterService(mock_service2);
Error error;
vector<string> rpc_ids = manager.EnumerateAvailableServices(&error);
set<string> ids(rpc_ids.begin(), rpc_ids.end());
EXPECT_EQ(2, ids.size());
EXPECT_TRUE(ContainsKey(ids, mock_service->GetRpcIdentifier()));
EXPECT_TRUE(ContainsKey(ids, mock_service2->GetRpcIdentifier()));
EXPECT_NE(nullptr, manager.FindService(service1_name).get());
EXPECT_NE(nullptr, manager.FindService(service2_name).get());
manager.set_power_manager(power_manager_.release());
manager.Stop();
}
TEST_F(ManagerTest, RegisterKnownService) {
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
string());
ProfileRefPtr profile(CreateProfileForManager(&manager));
ASSERT_TRUE(profile.get());
AdoptProfile(&manager, profile);
{
ServiceRefPtr service1(new ServiceUnderTest(control_interface(),
dispatcher(),
metrics(),
&manager));
ASSERT_TRUE(profile->AdoptService(service1));
ASSERT_TRUE(profile->ContainsService(service1));
} // Force destruction of service1.
ServiceRefPtr service2(new ServiceUnderTest(control_interface(),
dispatcher(),
metrics(),
&manager));
manager.RegisterService(service2);
EXPECT_EQ(service2->profile().get(), profile.get());
manager.set_power_manager(power_manager_.release());
manager.Stop();
}
TEST_F(ManagerTest, RegisterUnknownService) {
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
string());
ProfileRefPtr profile(CreateProfileForManager(&manager));
ASSERT_TRUE(profile.get());
AdoptProfile(&manager, profile);
{
ServiceRefPtr service1(new ServiceUnderTest(control_interface(),
dispatcher(),
metrics(),
&manager));
ASSERT_TRUE(profile->AdoptService(service1));
ASSERT_TRUE(profile->ContainsService(service1));
} // Force destruction of service1.
scoped_refptr<MockService> mock_service2(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
&manager));
EXPECT_CALL(*mock_service2.get(), GetStorageIdentifier())
.WillRepeatedly(Return(mock_service2->unique_name()));
manager.RegisterService(mock_service2);
EXPECT_NE(mock_service2->profile().get(), profile.get());
manager.set_power_manager(power_manager_.release());
manager.Stop();
}
TEST_F(ManagerTest, DeregisterUnregisteredService) {
// WiFi assumes that it can deregister a service that is not
// registered. (E.g. a hidden service can be deregistered when it
// loses its last endpoint, and again when WiFi is Stop()-ed.)
//
// So test that doing so doesn't cause a crash.
MockServiceRefPtr service = new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager());
manager()->DeregisterService(service);
}
TEST_F(ManagerTest, GetProperties) {
AddMockProfileToManager(manager());
{
brillo::VariantDictionary props;
Error error;
string expected("portal_list");
manager()->mutable_store()->SetStringProperty(
kCheckPortalListProperty,
expected,
&error);
manager()->store().GetProperties(&props, &error);
ASSERT_FALSE(props.find(kCheckPortalListProperty) == props.end());
EXPECT_TRUE(props[kCheckPortalListProperty].IsTypeCompatible<string>());
EXPECT_EQ(props[kCheckPortalListProperty].Get<string>(), expected);
}
{
brillo::VariantDictionary props;
Error error;
bool expected = true;
manager()->mutable_store()->SetBoolProperty(kOfflineModeProperty,
expected,
&error);
manager()->store().GetProperties(&props, &error);
ASSERT_FALSE(props.find(kOfflineModeProperty) == props.end());
EXPECT_TRUE(props[kOfflineModeProperty].IsTypeCompatible<bool>());
EXPECT_EQ(props[kOfflineModeProperty].Get<bool>(), expected);
}
}
TEST_F(ManagerTest, GetDevicesProperty) {
AddMockProfileToManager(manager());
manager()->RegisterDevice(mock_devices_[0]);
manager()->RegisterDevice(mock_devices_[1]);
{
brillo::VariantDictionary props;
Error error;
manager()->store().GetProperties(&props, &error);
ASSERT_FALSE(props.find(kDevicesProperty) == props.end());
EXPECT_TRUE(
props[kDevicesProperty].IsTypeCompatible<vector<dbus::ObjectPath>>());
vector <dbus::ObjectPath> devices =
props[kDevicesProperty].Get<vector<dbus::ObjectPath>>();
EXPECT_EQ(2, devices.size());
}
}
TEST_F(ManagerTest, GetServicesProperty) {
AddMockProfileToManager(manager());
brillo::VariantDictionary props;
Error error;
manager()->store().GetProperties(&props, &error);
ASSERT_FALSE(props.find(kServicesProperty) == props.end());
EXPECT_TRUE(
props[kServicesProperty].IsTypeCompatible<vector<dbus::ObjectPath>>());
}
TEST_F(ManagerTest, MoveService) {
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
string());
scoped_refptr<MockService> s2(new MockService(control_interface(),
dispatcher(),
metrics(),
&manager));
// Inject an actual profile, backed by a fake StoreInterface
{
Profile::Identifier id("irrelevant");
ProfileRefPtr profile(new Profile(
control_interface(), metrics(), &manager, id, FilePath(), false));
MockStore* storage = new MockStore;
EXPECT_CALL(*storage, ContainsGroup(s2->GetStorageIdentifier()))
.WillRepeatedly(Return(true));
EXPECT_CALL(*storage, Flush())
.Times(AnyNumber())
.WillRepeatedly(Return(true));
profile->set_storage(storage);
AdoptProfile(&manager, profile);
}
// Create a profile that already has |s2| in it.
ProfileRefPtr profile(
new EphemeralProfile(control_interface(), metrics(), &manager));
EXPECT_TRUE(profile->AdoptService(s2));
// Now, move the Service |s2| to another profile.
EXPECT_CALL(*s2.get(), Save(_)).WillOnce(Return(true));
ASSERT_TRUE(manager.MoveServiceToProfile(s2, manager.ActiveProfile()));
// Force destruction of the original Profile, to ensure that the Service
// is kept alive and populated with data.
profile = nullptr;
ASSERT_TRUE(manager.ActiveProfile()->ContainsService(s2));
manager.set_power_manager(power_manager_.release());
manager.Stop();
}
TEST_F(ManagerTest, LookupProfileByRpcIdentifier) {
scoped_refptr<MockProfile> mock_profile(
new MockProfile(control_interface(), metrics(), manager(), ""));
const string kProfileName("profile0");
EXPECT_CALL(*mock_profile, GetRpcIdentifier())
.WillRepeatedly(Return(kProfileName));
AdoptProfile(manager(), mock_profile);
EXPECT_FALSE(manager()->LookupProfileByRpcIdentifier("foo"));
ProfileRefPtr profile = manager()->LookupProfileByRpcIdentifier(kProfileName);
EXPECT_EQ(mock_profile.get(), profile.get());
}
TEST_F(ManagerTest, SetProfileForService) {
scoped_refptr<MockProfile> profile0(
new MockProfile(control_interface(), metrics(), manager(), ""));
string profile_name0("profile0");
EXPECT_CALL(*profile0, GetRpcIdentifier())
.WillRepeatedly(Return(profile_name0));
AdoptProfile(manager(), profile0);
scoped_refptr<MockService> service(new MockService(control_interface(),
dispatcher(),
metrics(),
manager()));
EXPECT_FALSE(manager()->HasService(service));
{
Error error;
EXPECT_CALL(*profile0, AdoptService(_))
.WillOnce(Return(true));
// Expect that setting the profile of a service that does not already
// have one assigned does not cause a crash.
manager()->SetProfileForService(service, "profile0", &error);
EXPECT_TRUE(error.IsSuccess());
}
// The service should be registered as a side-effect of the profile being
// set for this service.
EXPECT_TRUE(manager()->HasService(service));
// Since we have mocked Profile::AdoptServie() above, the service's
// profile was not actually changed. Do so explicitly now.
service->set_profile(profile0);
{
Error error;
manager()->SetProfileForService(service, "foo", &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("Unknown Profile foo requested for Service", error.message());
}
{
Error error;
manager()->SetProfileForService(service, profile_name0, &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("Service is already connected to this profile", error.message());
}
scoped_refptr<MockProfile> profile1(
new MockProfile(control_interface(), metrics(), manager(), ""));
string profile_name1("profile1");
EXPECT_CALL(*profile1, GetRpcIdentifier())
.WillRepeatedly(Return(profile_name1));
AdoptProfile(manager(), profile1);
{
Error error;
EXPECT_CALL(*profile1, AdoptService(_))
.WillOnce(Return(true));
EXPECT_CALL(*profile0, AbandonService(_))
.WillOnce(Return(true));
manager()->SetProfileForService(service, profile_name1, &error);
EXPECT_TRUE(error.IsSuccess());
}
}
TEST_F(ManagerTest, CreateProfile) {
ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
temp_dir.path().value());
// Invalid name should be rejected.
EXPECT_EQ(Error::kInvalidArguments, TestCreateProfile(&manager, ""));
// A profile with invalid characters in it should similarly be rejected.
EXPECT_EQ(Error::kInvalidArguments,
TestCreateProfile(&manager, "valid_profile"));
// We should be able to create a machine profile.
EXPECT_EQ(Error::kSuccess, TestCreateProfile(&manager, "valid"));
// We should succeed in creating a valid user profile. Verify the returned
// path.
const char kProfile[] = "~user/profile";
{
Error error;
string path;
ASSERT_TRUE(base::CreateDirectory(temp_dir.path().Append("user")));
manager.CreateProfile(kProfile, &path, &error);
EXPECT_EQ(Error::kSuccess, error.type());
EXPECT_EQ("/profile_rpc", path);
}
// We should fail in creating it a second time (already exists).
EXPECT_EQ(Error::kAlreadyExists, TestCreateProfile(&manager, kProfile));
}
TEST_F(ManagerTest, PushPopProfile) {
ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
temp_dir.path().value());
vector<ProfileRefPtr>& profiles = GetProfiles(&manager);
// Pushing an invalid profile should fail.
EXPECT_EQ(Error::kInvalidArguments, TestPushProfile(&manager, ""));
// Create and push a default profile. Should succeed.
const char kDefaultProfile0[] = "default";
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kDefaultProfile0));
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kDefaultProfile0));
EXPECT_EQ(Error::kSuccess, TestPopProfile(&manager, kDefaultProfile0));
// Pushing a default profile that does not exist on disk will _not_
// fail, because we'll use temporary storage for it.
const char kMissingDefaultProfile[] = "missingdefault";
EXPECT_EQ(Error::kSuccess,
TestPushProfile(&manager, kMissingDefaultProfile));
EXPECT_EQ(1, profiles.size());
EXPECT_EQ(Error::kSuccess,
TestPopProfile(&manager, kMissingDefaultProfile));
EXPECT_EQ(0, profiles.size());
const char kProfile0[] = "~user/profile0";
const char kProfile1[] = "~user/profile1";
ASSERT_TRUE(base::CreateDirectory(temp_dir.path().Append("user")));
// Create a couple of profiles.
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kProfile0));
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kProfile1));
// Push these profiles on the stack.
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile0));
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile1));
// Pushing a profile a second time should fail.
EXPECT_EQ(Error::kAlreadyExists, TestPushProfile(&manager, kProfile0));
EXPECT_EQ(Error::kAlreadyExists, TestPushProfile(&manager, kProfile1));
Error error;
// Active profile should be the last one we pushed.
EXPECT_EQ(kProfile1, "~" + manager.ActiveProfile()->GetFriendlyName());
// Make sure a profile name that doesn't exist fails.
const char kProfile2Id[] = "profile2";
const string kProfile2 = base::StringPrintf("~user/%s", kProfile2Id);
EXPECT_EQ(Error::kNotFound, TestPushProfile(&manager, kProfile2));
// Create a new service, with a specific storage name.
scoped_refptr<MockService> service(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
&manager));
const char kServiceName[] = "service_storage_name";
EXPECT_CALL(*service.get(), GetStorageIdentifier())
.WillRepeatedly(Return(kServiceName));
EXPECT_CALL(*service.get(), Load(_))
.WillRepeatedly(Return(true));
// Add this service to the manager -- it should end up in the ephemeral
// profile.
manager.RegisterService(service);
ASSERT_EQ(GetEphemeralProfile(&manager), service->profile());
// Create storage for a profile that contains the service storage name.
ASSERT_TRUE(CreateBackingStoreForService(&temp_dir, "user", kProfile2Id,
kServiceName));
// When we push the profile, the service should move away from the
// ephemeral profile to this new profile since it has an entry for
// this service.
EXPECT_CALL(*service, ClearExplicitlyDisconnected());
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile2));
EXPECT_NE(GetEphemeralProfile(&manager), service->profile());
EXPECT_EQ(kProfile2, "~" + service->profile()->GetFriendlyName());
// Insert another profile that should supersede ownership of the service.
const char kProfile3Id[] = "profile3";
const string kProfile3 = base::StringPrintf("~user/%s", kProfile3Id);
ASSERT_TRUE(CreateBackingStoreForService(&temp_dir, "user", kProfile3Id,
kServiceName));
// We don't verify this expectation inline, since this would clear other
// recurring expectations on the service.
EXPECT_CALL(*service, ClearExplicitlyDisconnected());
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile3));
EXPECT_EQ(kProfile3, "~" + service->profile()->GetFriendlyName());
// Popping an invalid profile name should fail.
EXPECT_EQ(Error::kInvalidArguments, TestPopProfile(&manager, "~"));
// Popping an profile that is not at the top of the stack should fail.
EXPECT_EQ(Error::kNotSupported, TestPopProfile(&manager, kProfile0));
// Popping the top profile should succeed.
EXPECT_CALL(*service, ClearExplicitlyDisconnected());
EXPECT_EQ(Error::kSuccess, TestPopProfile(&manager, kProfile3));
// Moreover the service should have switched profiles to profile 2.
EXPECT_EQ(kProfile2, "~" + service->profile()->GetFriendlyName());
// Popping the top profile should succeed.
EXPECT_CALL(*service, ClearExplicitlyDisconnected());
EXPECT_EQ(Error::kSuccess, TestPopAnyProfile(&manager));
// The service should now revert to the ephemeral profile.
EXPECT_EQ(GetEphemeralProfile(&manager), service->profile());
// Pop the remaining two profiles off the stack.
EXPECT_CALL(*service, ClearExplicitlyDisconnected()).Times(2);
EXPECT_EQ(Error::kSuccess, TestPopAnyProfile(&manager));
EXPECT_EQ(Error::kSuccess, TestPopAnyProfile(&manager));
Mock::VerifyAndClearExpectations(service.get());
// Next pop should fail with "stack is empty".
EXPECT_EQ(Error::kNotFound, TestPopAnyProfile(&manager));
const char kMachineProfile0[] = "machineprofile0";
const char kMachineProfile1[] = "machineprofile1";
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kMachineProfile0));
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kMachineProfile1));
// Should be able to push a machine profile.
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kMachineProfile0));
// Should be able to push a user profile atop a machine profile.
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile0));
// Pushing a system-wide profile on top of a user profile should fail.
EXPECT_EQ(Error::kInvalidArguments,
TestPushProfile(&manager, kMachineProfile1));
// However if we pop the user profile, we should be able stack another
// machine profile on.
EXPECT_EQ(Error::kSuccess, TestPopAnyProfile(&manager));
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kMachineProfile1));
// Add two user profiles to the top of the stack.
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile0));
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile1));
EXPECT_EQ(4, profiles.size());
// PopAllUserProfiles should remove both user profiles, leaving the two
// machine profiles.
EXPECT_EQ(Error::kSuccess, TestPopAllUserProfiles(&manager));
EXPECT_EQ(2, profiles.size());
EXPECT_TRUE(profiles[0]->GetUser().empty());
EXPECT_TRUE(profiles[1]->GetUser().empty());
// Use InsertUserProfile() instead. Although a machine profile is valid
// in this state, it cannot be added via InsertUserProfile.
EXPECT_EQ(Error::kSuccess, TestPopProfile(&manager, kMachineProfile1));
EXPECT_EQ(Error::kInvalidArguments,
TestInsertUserProfile(&manager, kMachineProfile1, "machinehash1"));
const char kUserHash0[] = "userhash0";
const char kUserHash1[] = "userhash1";
EXPECT_EQ(Error::kSuccess,
TestInsertUserProfile(&manager, kProfile0, kUserHash0));
EXPECT_EQ(Error::kSuccess,
TestInsertUserProfile(&manager, kProfile1, kUserHash1));
EXPECT_EQ(3, profiles.size());
EXPECT_EQ(kUserHash0, profiles[1]->GetUserHash());
EXPECT_EQ(kUserHash1, profiles[2]->GetUserHash());
}
TEST_F(ManagerTest, RemoveProfile) {
ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
temp_dir.path().value());
const char kProfile0[] = "profile0";
FilePath profile_path(
Profile::GetFinalStoragePath(
FilePath(storage_path()), Profile::Identifier(kProfile0)));
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kProfile0));
ASSERT_TRUE(base::PathExists(profile_path));
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile0));
// Remove should fail since the profile is still on the stack.
{
Error error;
manager.RemoveProfile(kProfile0, &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
}
// Profile path should still exist.
EXPECT_TRUE(base::PathExists(profile_path));
EXPECT_EQ(Error::kSuccess, TestPopAnyProfile(&manager));
// This should succeed now that the profile is off the stack.
{
Error error;
manager.RemoveProfile(kProfile0, &error);
EXPECT_EQ(Error::kSuccess, error.type());
}
// Profile path should no longer exist.
EXPECT_FALSE(base::PathExists(profile_path));
// Another remove succeeds, due to a foible in base::DeleteFile --
// it is not an error to delete a file that does not exist.
{
Error error;
manager.RemoveProfile(kProfile0, &error);
EXPECT_EQ(Error::kSuccess, error.type());
}
// Let's create an error case that will "work". Create a non-empty
// directory in the place of the profile pathname.
ASSERT_TRUE(base::CreateDirectory(profile_path.Append("foo")));
{
Error error;
manager.RemoveProfile(kProfile0, &error);
EXPECT_EQ(Error::kOperationFailed, error.type());
}
}
TEST_F(ManagerTest, RemoveService) {
MockServiceRefPtr mock_service(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
// Used in expectations which cannot accept a mock refptr.
const ServiceRefPtr& service = mock_service;
manager()->RegisterService(service);
EXPECT_EQ(GetEphemeralProfile(manager()), service->profile().get());
scoped_refptr<MockProfile> profile(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
AdoptProfile(manager(), profile);
// If service is ephemeral, it should be unloaded and left ephemeral.
EXPECT_CALL(*profile, AbandonService(service)).Times(0);
EXPECT_CALL(*profile, ConfigureService(service)).Times(0);
EXPECT_CALL(*mock_service, Unload()).WillOnce(Return(false));
manager()->RemoveService(service);
Mock::VerifyAndClearExpectations(mock_service.get());
Mock::VerifyAndClearExpectations(profile.get());
EXPECT_EQ(GetEphemeralProfile(manager()), service->profile().get());
EXPECT_TRUE(manager()->HasService(service)); // Since Unload() was false.
// If service is not ephemeral and the Manager finds a profile to assign
// the service to, the service should be re-parented. Note that since we
// are using a MockProfile, ConfigureService() never actually changes the
// Service's profile.
service->set_profile(profile);
EXPECT_CALL(*profile, AbandonService(service));
EXPECT_CALL(*profile, ConfigureService(service)).WillOnce(Return(true));
EXPECT_CALL(*mock_service, Unload()).Times(0);
manager()->RemoveService(service);
Mock::VerifyAndClearExpectations(mock_service.get());
Mock::VerifyAndClearExpectations(profile.get());
EXPECT_TRUE(manager()->HasService(service));
EXPECT_EQ(profile.get(), service->profile().get());
// If service becomes ephemeral since there is no profile to support it,
// it should be unloaded.
EXPECT_CALL(*profile, AbandonService(service));
EXPECT_CALL(*profile, ConfigureService(service)).WillOnce(Return(false));
EXPECT_CALL(*mock_service, Unload()).WillOnce(Return(true));
manager()->RemoveService(service);
EXPECT_FALSE(manager()->HasService(service));
}
TEST_F(ManagerTest, CreateDuplicateProfileWithMissingKeyfile) {
ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
Manager manager(control_interface(),
dispatcher(),
metrics(),
run_path(),
storage_path(),
temp_dir.path().value());
const char kProfile0[] = "profile0";
FilePath profile_path(
Profile::GetFinalStoragePath(
FilePath(storage_path()), Profile::Identifier(kProfile0)));
ASSERT_EQ(Error::kSuccess, TestCreateProfile(&manager, kProfile0));
ASSERT_TRUE(base::PathExists(profile_path));
EXPECT_EQ(Error::kSuccess, TestPushProfile(&manager, kProfile0));
// Ensure that even if the backing filestore is removed, we still can't
// create a profile twice.
ASSERT_TRUE(base::DeleteFile(profile_path, false));
EXPECT_EQ(Error::kAlreadyExists, TestCreateProfile(&manager, kProfile0));
}
TEST_F(ManagerTest, HandleProfileEntryDeletion) {
MockServiceRefPtr s_not_in_profile(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_not_in_group(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_configure_fail(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_configure_succeed(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
string entry_name("entry_name");
EXPECT_CALL(*s_not_in_profile.get(), GetStorageIdentifier()).Times(0);
EXPECT_CALL(*s_not_in_group.get(), GetStorageIdentifier())
.WillRepeatedly(Return("not_entry_name"));
EXPECT_CALL(*s_configure_fail.get(), GetStorageIdentifier())
.WillRepeatedly(Return(entry_name));
EXPECT_CALL(*s_configure_succeed.get(), GetStorageIdentifier())
.WillRepeatedly(Return(entry_name));
manager()->RegisterService(s_not_in_profile);
manager()->RegisterService(s_not_in_group);
manager()->RegisterService(s_configure_fail);
manager()->RegisterService(s_configure_succeed);
scoped_refptr<MockProfile> profile0(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
scoped_refptr<MockProfile> profile1(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
s_not_in_group->set_profile(profile1);
s_configure_fail->set_profile(profile1);
s_configure_succeed->set_profile(profile1);
AdoptProfile(manager(), profile0);
AdoptProfile(manager(), profile1);
CompleteServiceSort();
// No services are a member of this profile.
EXPECT_FALSE(manager()->HandleProfileEntryDeletion(profile0, entry_name));
EXPECT_FALSE(IsSortServicesTaskPending());
// No services that are members of this profile have this entry name.
EXPECT_FALSE(manager()->HandleProfileEntryDeletion(profile1, ""));
EXPECT_FALSE(IsSortServicesTaskPending());
// Only services that are members of the profile and group will be abandoned.
EXPECT_CALL(*profile1.get(),
AbandonService(IsRefPtrTo(s_not_in_profile.get()))).Times(0);
EXPECT_CALL(*profile1.get(),
AbandonService(IsRefPtrTo(s_not_in_group.get()))).Times(0);
EXPECT_CALL(*profile1.get(),
AbandonService(IsRefPtrTo(s_configure_fail.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile1.get(),
AbandonService(IsRefPtrTo(s_configure_succeed.get())))
.WillOnce(Return(true));
// Never allow services to re-join profile1.
EXPECT_CALL(*profile1.get(), ConfigureService(_))
.WillRepeatedly(Return(false));
// Only allow one of the members of the profile and group to successfully
// join profile0.
EXPECT_CALL(*profile0.get(),
ConfigureService(IsRefPtrTo(s_not_in_profile.get()))).Times(0);
EXPECT_CALL(*profile0.get(),
ConfigureService(IsRefPtrTo(s_not_in_group.get()))).Times(0);
EXPECT_CALL(*profile0.get(),
ConfigureService(IsRefPtrTo(s_configure_fail.get())))
.WillOnce(Return(false));
EXPECT_CALL(*profile0.get(),
ConfigureService(IsRefPtrTo(s_configure_succeed.get())))
.WillOnce(Return(true));
// Expect the failed-to-configure service to have Unload() called on it.
EXPECT_CALL(*s_not_in_profile.get(), Unload()).Times(0);
EXPECT_CALL(*s_not_in_group.get(), Unload()).Times(0);
EXPECT_CALL(*s_configure_fail.get(), Unload()).Times(1);
EXPECT_CALL(*s_configure_succeed.get(), Unload()).Times(0);
EXPECT_TRUE(manager()->HandleProfileEntryDeletion(profile1, entry_name));
EXPECT_TRUE(IsSortServicesTaskPending());
EXPECT_EQ(GetEphemeralProfile(manager()), s_not_in_profile->profile().get());
EXPECT_EQ(profile1, s_not_in_group->profile());
EXPECT_EQ(GetEphemeralProfile(manager()), s_configure_fail->profile());
// Since we are using a MockProfile, the profile does not actually change,
// since ConfigureService was not actually called on the service.
EXPECT_EQ(profile1, s_configure_succeed->profile());
}
TEST_F(ManagerTest, HandleProfileEntryDeletionWithUnload) {
MockServiceRefPtr s_will_remove0(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_will_remove1(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_will_not_remove0(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_will_not_remove1(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
EXPECT_CALL(*metrics(), NotifyDefaultServiceChanged(nullptr))
.Times(4); // Once for each registration.
string entry_name("entry_name");
EXPECT_CALL(*s_will_remove0.get(), GetStorageIdentifier())
.WillRepeatedly(Return(entry_name));
EXPECT_CALL(*s_will_remove1.get(), GetStorageIdentifier())
.WillRepeatedly(Return(entry_name));
EXPECT_CALL(*s_will_not_remove0.get(), GetStorageIdentifier())
.WillRepeatedly(Return(entry_name));
EXPECT_CALL(*s_will_not_remove1.get(), GetStorageIdentifier())
.WillRepeatedly(Return(entry_name));
manager()->RegisterService(s_will_remove0);
CompleteServiceSort();
manager()->RegisterService(s_will_not_remove0);
CompleteServiceSort();
manager()->RegisterService(s_will_remove1);
CompleteServiceSort();
manager()->RegisterService(s_will_not_remove1);
CompleteServiceSort();
// One for each service added above.
ASSERT_EQ(4, manager()->services_.size());
scoped_refptr<MockProfile> profile(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
s_will_remove0->set_profile(profile);
s_will_remove1->set_profile(profile);
s_will_not_remove0->set_profile(profile);
s_will_not_remove1->set_profile(profile);
AdoptProfile(manager(), profile);
// Deny any of the services re-entry to the profile.
EXPECT_CALL(*profile, ConfigureService(_))
.WillRepeatedly(Return(false));
EXPECT_CALL(*profile, AbandonService(ServiceRefPtr(s_will_remove0)))
.WillOnce(Return(true));
EXPECT_CALL(*profile, AbandonService(ServiceRefPtr(s_will_remove1)))
.WillOnce(Return(true));
EXPECT_CALL(*profile, AbandonService(ServiceRefPtr(s_will_not_remove0)))
.WillOnce(Return(true));
EXPECT_CALL(*profile, AbandonService(ServiceRefPtr(s_will_not_remove1)))
.WillOnce(Return(true));
EXPECT_CALL(*s_will_remove0, Unload())
.WillOnce(Return(true));
EXPECT_CALL(*s_will_remove1, Unload())
.WillOnce(Return(true));
EXPECT_CALL(*s_will_not_remove0, Unload())
.WillOnce(Return(false));
EXPECT_CALL(*s_will_not_remove1, Unload())
.WillOnce(Return(false));
// This will cause all the profiles to be unloaded.
EXPECT_FALSE(IsSortServicesTaskPending());
EXPECT_TRUE(manager()->HandleProfileEntryDeletion(profile, entry_name));
EXPECT_TRUE(IsSortServicesTaskPending());
// 2 of the 4 services added above should have been unregistered and
// removed, leaving 2.
EXPECT_EQ(2, manager()->services_.size());
EXPECT_EQ(s_will_not_remove0.get(), manager()->services_[0].get());
EXPECT_EQ(s_will_not_remove1.get(), manager()->services_[1].get());
}
TEST_F(ManagerTest, PopProfileWithUnload) {
MockServiceRefPtr s_will_remove0(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_will_remove1(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_will_not_remove0(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
MockServiceRefPtr s_will_not_remove1(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
EXPECT_CALL(*metrics(), NotifyDefaultServiceChanged(nullptr))
.Times(5); // Once for each registration, and one after profile pop.
manager()->RegisterService(s_will_remove0);
CompleteServiceSort();
manager()->RegisterService(s_will_not_remove0);
CompleteServiceSort();
manager()->RegisterService(s_will_remove1);
CompleteServiceSort();
manager()->RegisterService(s_will_not_remove1);
CompleteServiceSort();
// One for each service added above.
ASSERT_EQ(4, manager()->services_.size());
scoped_refptr<MockProfile> profile0(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
scoped_refptr<MockProfile> profile1(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
s_will_remove0->set_profile(profile1);
s_will_remove1->set_profile(profile1);
s_will_not_remove0->set_profile(profile1);
s_will_not_remove1->set_profile(profile1);
AdoptProfile(manager(), profile0);
AdoptProfile(manager(), profile1);
// Deny any of the services entry to profile0, so they will all be unloaded.
EXPECT_CALL(*profile0, ConfigureService(_))
.WillRepeatedly(Return(false));
EXPECT_CALL(*s_will_remove0, Unload())
.WillOnce(Return(true));
EXPECT_CALL(*s_will_remove1, Unload())
.WillOnce(Return(true));
EXPECT_CALL(*s_will_not_remove0, Unload())
.WillRepeatedly(Return(false));
EXPECT_CALL(*s_will_not_remove1, Unload())
.WillOnce(Return(false));
// Ignore calls to Profile::GetRpcIdentifier because of emitted changes of the
// profile list.
EXPECT_CALL(*profile0, GetRpcIdentifier()).Times(AnyNumber());
EXPECT_CALL(*profile1, GetRpcIdentifier()).Times(AnyNumber());
// This will pop profile1, which should cause all our profiles to unload.
manager()->PopProfileInternal();
CompleteServiceSort();
// 2 of the 4 services added above should have been unregistered and
// removed, leaving 2.
EXPECT_EQ(2, manager()->services_.size());
EXPECT_EQ(s_will_not_remove0.get(), manager()->services_[0].get());
EXPECT_EQ(s_will_not_remove1.get(), manager()->services_[1].get());
// Expect the unloaded services to lose their profile reference.
EXPECT_FALSE(s_will_remove0->profile());
EXPECT_FALSE(s_will_remove1->profile());
// If we explicitly deregister a service, the effect should be the same
// with respect to the profile reference.
ASSERT_TRUE(s_will_not_remove0->profile().get());
manager()->DeregisterService(s_will_not_remove0);
EXPECT_FALSE(s_will_not_remove0->profile());
}
TEST_F(ManagerTest, SetProperty) {
{
Error error;
const bool offline_mode = true;
EXPECT_TRUE(manager()->mutable_store()->SetAnyProperty(
kOfflineModeProperty, brillo::Any(offline_mode), &error));
}
{
Error error;
const string country("a_country");
EXPECT_TRUE(manager()->mutable_store()->SetAnyProperty(
kCountryProperty, brillo::Any(country), &error));
}
// Attempt to write with value of wrong type should return InvalidArgs.
{
Error error;
EXPECT_FALSE(manager()->mutable_store()->SetAnyProperty(
kCountryProperty, PropertyStoreTest::kBoolV, &error));
EXPECT_EQ(Error::kInvalidArguments, error.type());
}
{
Error error;
EXPECT_FALSE(manager()->mutable_store()->SetAnyProperty(
kOfflineModeProperty, PropertyStoreTest::kStringV, &error));
EXPECT_EQ(Error::kInvalidArguments, error.type());
}
// Attempt to write R/O property should return InvalidArgs.
{
Error error;
EXPECT_FALSE(manager()->mutable_store()->SetAnyProperty(
kEnabledTechnologiesProperty, PropertyStoreTest::kStringsV, &error));
EXPECT_EQ(Error::kInvalidArguments, error.type());
}
}
TEST_F(ManagerTest, RequestScan) {
{
Error error;
manager()->RegisterDevice(mock_devices_[0].get());
manager()->RegisterDevice(mock_devices_[1].get());
EXPECT_CALL(*mock_devices_[0], technology())
.WillRepeatedly(Return(Technology::kWifi));
EXPECT_CALL(*mock_devices_[0], Scan(_, _));
EXPECT_CALL(*mock_devices_[1], technology())
.WillRepeatedly(Return(Technology::kUnknown));
EXPECT_CALL(*mock_devices_[1], Scan(_, _)).Times(0);
EXPECT_CALL(*metrics(), NotifyUserInitiatedEvent(
Metrics::kUserInitiatedEventWifiScan)).Times(1);
manager()->RequestScan(kTypeWifi, &error);
manager()->DeregisterDevice(mock_devices_[0].get());
manager()->DeregisterDevice(mock_devices_[1].get());
Mock::VerifyAndClearExpectations(mock_devices_[0].get());
Mock::VerifyAndClearExpectations(mock_devices_[1].get());
manager()->RegisterDevice(mock_devices_[0].get());
EXPECT_CALL(*mock_devices_[0], technology())
.WillRepeatedly(Return(Technology::kWifi));
EXPECT_CALL(*metrics(), NotifyUserInitiatedEvent(
Metrics::kUserInitiatedEventWifiScan)).Times(1);
EXPECT_CALL(*mock_devices_[0], Scan(_, _));
manager()->RequestScan(kTypeWifi, &error);
manager()->DeregisterDevice(mock_devices_[0].get());
Mock::VerifyAndClearExpectations(mock_devices_[0].get());
manager()->RegisterDevice(mock_devices_[0].get());
EXPECT_CALL(*mock_devices_[0], technology())
.WillRepeatedly(Return(Technology::kUnknown));
EXPECT_CALL(*metrics(), NotifyUserInitiatedEvent(
Metrics::kUserInitiatedEventWifiScan)).Times(0);
EXPECT_CALL(*mock_devices_[0], Scan(_, _)).Times(0);
manager()->RequestScan(kTypeWifi, &error);
manager()->DeregisterDevice(mock_devices_[0].get());
Mock::VerifyAndClearExpectations(mock_devices_[0].get());
}
{
Error error;
manager()->RequestScan("bogus_device_type", &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
}
}
TEST_F(ManagerTest, GetServiceNoType) {
KeyValueStore args;
Error e;
manager()->GetService(args, &e);
EXPECT_EQ(Error::kInvalidArguments, e.type());
EXPECT_EQ("must specify service type", e.message());
}
TEST_F(ManagerTest, GetServiceUnknownType) {
KeyValueStore args;
Error e;
args.SetString(kTypeProperty, kTypeEthernet);
manager()->GetService(args, &e);
EXPECT_EQ(Error::kNotSupported, e.type());
EXPECT_EQ("service type is unsupported", e.message());
}
#if !defined(DISABLE_WIRED_8021X)
TEST_F(ManagerTest, GetServiceEthernetEap) {
KeyValueStore args;
Error e;
ServiceRefPtr service = new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager());
args.SetString(kTypeProperty, kTypeEthernetEap);
SetEapProviderService(service);
EXPECT_EQ(service, manager()->GetService(args, &e));
EXPECT_TRUE(e.IsSuccess());
}
#endif // DISABLE_WIRED_8021X
#if !defined(DISABLE_WIFI)
TEST_F(ManagerTest, GetServiceWifi) {
KeyValueStore args;
Error e;
WiFiServiceRefPtr wifi_service;
args.SetString(kTypeProperty, kTypeWifi);
EXPECT_CALL(*wifi_provider_, GetService(_, _))
.WillRepeatedly(Return(wifi_service));
manager()->GetService(args, &e);
EXPECT_TRUE(e.IsSuccess());
}
#endif // DISABLE_WIFI
TEST_F(ManagerTest, GetServiceVPNUnknownType) {
KeyValueStore args;
Error e;
args.SetString(kTypeProperty, kTypeVPN);
scoped_refptr<MockProfile> profile(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
AdoptProfile(manager(), profile);
ServiceRefPtr service = manager()->GetService(args, &e);
EXPECT_EQ(Error::kNotSupported, e.type());
EXPECT_FALSE(service);
}
TEST_F(ManagerTest, GetServiceVPN) {
KeyValueStore args;
Error e;
args.SetString(kTypeProperty, kTypeVPN);
args.SetString(kProviderTypeProperty, kProviderOpenVpn);
args.SetString(kProviderHostProperty, "10.8.0.1");
args.SetString(kNameProperty, "vpn-name");
scoped_refptr<MockProfile> profile(
new StrictMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
AdoptProfile(manager(), profile);
#if defined(DISABLE_VPN)
ServiceRefPtr service = manager()->GetService(args, &e);
EXPECT_EQ(Error::kNotSupported, e.type());
EXPECT_FALSE(service);
#else
ServiceRefPtr updated_service;
EXPECT_CALL(*profile, UpdateService(_))
.WillOnce(DoAll(SaveArg<0>(&updated_service), Return(true)));
ServiceRefPtr configured_service;
EXPECT_CALL(*profile, LoadService(_))
.WillOnce(Return(false));
EXPECT_CALL(*profile, ConfigureService(_))
.WillOnce(DoAll(SaveArg<0>(&configured_service), Return(true)));
ServiceRefPtr service = manager()->GetService(args, &e);
EXPECT_TRUE(e.IsSuccess());
EXPECT_TRUE(service.get());
EXPECT_EQ(service, updated_service);
EXPECT_EQ(service, configured_service);
#endif // DISABLE_VPN
}
#if !defined(DISABLE_WIMAX)
TEST_F(ManagerTest, GetServiceWiMaxNoNetworkId) {
KeyValueStore args;
Error e;
args.SetString(kTypeProperty, kTypeWimax);
ServiceRefPtr service = manager()->GetService(args, &e);
EXPECT_EQ(Error::kInvalidArguments, e.type());
EXPECT_EQ("Missing WiMAX network id.", e.message());
EXPECT_FALSE(service);
}
TEST_F(ManagerTest, GetServiceWiMax) {
KeyValueStore args;
Error e;
args.SetString(kTypeProperty, kTypeWimax);
args.SetString(WiMaxService::kNetworkIdProperty, "01234567");
args.SetString(kNameProperty, "WiMAX Network");
ServiceRefPtr service = manager()->GetService(args, &e);
EXPECT_TRUE(e.IsSuccess());
EXPECT_TRUE(service.get());
}
#endif // DISABLE_WIMAX
TEST_F(ManagerTest, ConfigureServiceWithInvalidProfile) {
// Manager calls ActiveProfile() so we need at least one profile installed.
scoped_refptr<MockProfile> profile(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
AdoptProfile(manager(), profile);
KeyValueStore args;
args.SetString(kProfileProperty, "xxx");
Error error;
manager()->ConfigureService(args, &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("Invalid profile name xxx", error.message());
}
TEST_F(ManagerTest, ConfigureServiceWithGetServiceFailure) {
// Manager calls ActiveProfile() so we need at least one profile installed.
scoped_refptr<MockProfile> profile(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
AdoptProfile(manager(), profile);
KeyValueStore args;
Error error;
manager()->ConfigureService(args, &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("must specify service type", error.message());
}
#if !defined(DISABLE_WIFI)
// TODO(zqiu): Consider creating a TestProvider to provide generic services,
// (MockService) instead of using technology specific (wifi) services. This
// will remove the dependency for wifi from ConfigureXXX tests.
//
// A registered service in the ephemeral profile should be moved to the
// active profile as a part of configuration if no profile was explicitly
// specified.
TEST_F(ManagerTest, ConfigureRegisteredServiceWithoutProfile) {
scoped_refptr<MockProfile> profile(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
AdoptProfile(manager(), profile); // This is now the active profile.
const vector<uint8_t> ssid;
scoped_refptr<MockWiFiService> service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
ssid,
"",
"",
false));
manager()->RegisterService(service);
service->set_profile(GetEphemeralProfile(manager()));
EXPECT_CALL(*wifi_provider_, GetService(_, _))
.WillOnce(Return(service));
EXPECT_CALL(*profile, UpdateService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile, AdoptService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
Error error;
manager()->ConfigureService(args, &error);
EXPECT_TRUE(error.IsSuccess());
}
// If we configure a service that was already registered and explicitly
// specify a profile, it should be moved from the profile it was previously
// in to the specified profile if one was requested.
TEST_F(ManagerTest, ConfigureRegisteredServiceWithProfile) {
scoped_refptr<MockProfile> profile0(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
scoped_refptr<MockProfile> profile1(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
const string kProfileName0 = "profile0";
const string kProfileName1 = "profile1";
EXPECT_CALL(*profile0, GetRpcIdentifier())
.WillRepeatedly(Return(kProfileName0));
EXPECT_CALL(*profile1, GetRpcIdentifier())
.WillRepeatedly(Return(kProfileName1));
AdoptProfile(manager(), profile0);
AdoptProfile(manager(), profile1); // profile1 is now the ActiveProfile.
const vector<uint8_t> ssid;
scoped_refptr<MockWiFiService> service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
ssid,
"",
"",
false));
manager()->RegisterService(service);
service->set_profile(profile1);
EXPECT_CALL(*wifi_provider_, GetService(_, _))
.WillOnce(Return(service));
EXPECT_CALL(*profile0, LoadService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile0, UpdateService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile0, AdoptService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile1, AbandonService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kProfileProperty, kProfileName0);
Error error;
manager()->ConfigureService(args, &error);
EXPECT_TRUE(error.IsSuccess());
service->set_profile(nullptr); // Breaks refcounting loop.
}
// If we configure a service that is already a member of the specified
// profile, the Manager should not call LoadService or AdoptService again
// on this service.
TEST_F(ManagerTest, ConfigureRegisteredServiceWithSameProfile) {
scoped_refptr<MockProfile> profile0(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
const string kProfileName0 = "profile0";
EXPECT_CALL(*profile0, GetRpcIdentifier())
.WillRepeatedly(Return(kProfileName0));
AdoptProfile(manager(), profile0); // profile0 is now the ActiveProfile.
const vector<uint8_t> ssid;
scoped_refptr<MockWiFiService> service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
ssid,
"",
"",
false));
manager()->RegisterService(service);
service->set_profile(profile0);
EXPECT_CALL(*wifi_provider_, GetService(_, _))
.WillOnce(Return(service));
EXPECT_CALL(*profile0, LoadService(ServiceRefPtr(service.get())))
.Times(0);
EXPECT_CALL(*profile0, UpdateService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile0, AdoptService(ServiceRefPtr(service.get())))
.Times(0);
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kProfileProperty, kProfileName0);
Error error;
manager()->ConfigureService(args, &error);
EXPECT_TRUE(error.IsSuccess());
service->set_profile(nullptr); // Breaks refcounting loop.
}
// An unregistered service should remain unregistered, but its contents should
// be saved to the specified profile nonetheless.
TEST_F(ManagerTest, ConfigureUnregisteredServiceWithProfile) {
scoped_refptr<MockProfile> profile0(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
scoped_refptr<MockProfile> profile1(
new NiceMock<MockProfile>(
control_interface(), metrics(), manager(), ""));
const string kProfileName0 = "profile0";
const string kProfileName1 = "profile1";
EXPECT_CALL(*profile0, GetRpcIdentifier())
.WillRepeatedly(Return(kProfileName0));
EXPECT_CALL(*profile1, GetRpcIdentifier())
.WillRepeatedly(Return(kProfileName1));
AdoptProfile(manager(), profile0);
AdoptProfile(manager(), profile1); // profile1 is now the ActiveProfile.
const vector<uint8_t> ssid;
scoped_refptr<MockWiFiService> service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
ssid,
"",
"",
false));
service->set_profile(profile1);
EXPECT_CALL(*wifi_provider_, GetService(_, _))
.WillOnce(Return(service));
EXPECT_CALL(*profile0, UpdateService(ServiceRefPtr(service.get())))
.WillOnce(Return(true));
EXPECT_CALL(*profile0, AdoptService(_))
.Times(0);
EXPECT_CALL(*profile1, AdoptService(_))
.Times(0);
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kProfileProperty, kProfileName0);
Error error;
manager()->ConfigureService(args, &error);
EXPECT_TRUE(error.IsSuccess());
}
TEST_F(ManagerTest, ConfigureServiceForProfileWithNoType) {
KeyValueStore args;
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile("", args, &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("must specify service type", error.message());
EXPECT_EQ(nullptr, service.get());
}
TEST_F(ManagerTest, ConfigureServiceForProfileWithWrongType) {
KeyValueStore args;
args.SetString(kTypeProperty, kTypeCellular);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile("", args, &error);
EXPECT_EQ(Error::kNotSupported, error.type());
EXPECT_EQ("service type is unsupported", error.message());
EXPECT_EQ(nullptr, service.get());
}
TEST_F(ManagerTest, ConfigureServiceForProfileWithMissingProfile) {
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile("/profile/foo", args, &error);
EXPECT_EQ(Error::kNotFound, error.type());
EXPECT_EQ("Profile specified was not found", error.message());
EXPECT_EQ(nullptr, service.get());
}
TEST_F(ManagerTest, ConfigureServiceForProfileWithProfileMismatch) {
const string kProfileName0 = "profile0";
const string kProfileName1 = "profile1";
scoped_refptr<MockProfile> profile0(
AddNamedMockProfileToManager(manager(), kProfileName0));
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kProfileProperty, kProfileName1);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName0, args, &error);
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ("Profile argument does not match that in "
"the configuration arguments", error.message());
EXPECT_EQ(nullptr, service.get());
}
TEST_F(ManagerTest,
ConfigureServiceForProfileWithNoMatchingServiceFailGetService) {
const string kProfileName0 = "profile0";
scoped_refptr<MockProfile> profile0(
AddNamedMockProfileToManager(manager(), kProfileName0));
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kProfileProperty, kProfileName0);
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _))
.WillOnce(Return(WiFiServiceRefPtr()));
EXPECT_CALL(*wifi_provider_, GetService(_, _))
.WillOnce(Return(WiFiServiceRefPtr()));
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName0, args, &error);
// Since we didn't set the error in the GetService expectation above...
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(nullptr, service.get());
}
TEST_F(ManagerTest, ConfigureServiceForProfileCreateNewService) {
const string kProfileName0 = "profile0";
scoped_refptr<MockProfile> profile0(
AddNamedMockProfileToManager(manager(), kProfileName0));
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
scoped_refptr<MockWiFiService> mock_service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
vector<uint8_t>(),
kModeManaged,
kSecurityNone,
false));
ServiceRefPtr mock_service_generic(mock_service.get());
mock_service->set_profile(profile0);
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _))
.WillOnce(Return(WiFiServiceRefPtr()));
EXPECT_CALL(*wifi_provider_, GetService(_, _)).WillOnce(Return(mock_service));
EXPECT_CALL(*profile0, UpdateService(mock_service_generic))
.WillOnce(Return(true));
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName0, args, &error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(mock_service.get(), service.get());
mock_service->set_profile(nullptr); // Breaks reference cycle.
}
TEST_F(ManagerTest, ConfigureServiceForProfileMatchingServiceByGUID) {
scoped_refptr<MockService> mock_service(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
const string kGUID = "a guid";
mock_service->SetGuid(kGUID, nullptr);
manager()->RegisterService(mock_service);
ServiceRefPtr mock_service_generic(mock_service.get());
const string kProfileName = "profile";
scoped_refptr<MockProfile> profile(
AddNamedMockProfileToManager(manager(), kProfileName));
mock_service->set_profile(profile);
EXPECT_CALL(*mock_service, technology())
.WillOnce(Return(Technology::kCellular))
.WillOnce(Return(Technology::kWifi));
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _)).Times(0);
EXPECT_CALL(*wifi_provider_, GetService(_, _)).Times(0);
EXPECT_CALL(*profile, AdoptService(mock_service_generic)).Times(0);
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
args.SetString(kGuidProperty, kGUID);
// The first attempt should fail because the service reports a technology
// other than "WiFi".
{
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName, args, &error);
EXPECT_EQ(nullptr, service.get());
EXPECT_EQ(Error::kNotSupported, error.type());
EXPECT_EQ("This GUID matches a non-wifi service", error.message());
}
EXPECT_CALL(*mock_service, Configure(_, _)).Times(1);
EXPECT_CALL(*profile, UpdateService(mock_service_generic)).Times(1);
{
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName, args, &error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(mock_service.get(), service.get());
EXPECT_EQ(profile.get(), service->profile().get());
}
mock_service->set_profile(nullptr); // Breaks reference cycle.
}
TEST_F(ManagerTest, ConfigureServiceForProfileMatchingServiceAndProfile) {
const string kProfileName = "profile";
scoped_refptr<MockProfile> profile(
AddNamedMockProfileToManager(manager(), kProfileName));
scoped_refptr<MockWiFiService> mock_service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
vector<uint8_t>(),
kModeManaged,
kSecurityNone,
false));
mock_service->set_profile(profile);
ServiceRefPtr mock_service_generic(mock_service.get());
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _))
.WillOnce(Return(mock_service));
EXPECT_CALL(*wifi_provider_, GetService(_, _)).Times(0);
EXPECT_CALL(*profile, AdoptService(mock_service_generic)).Times(0);
EXPECT_CALL(*mock_service, Configure(_, _)).Times(1);
EXPECT_CALL(*profile, UpdateService(mock_service_generic)).Times(1);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName, args, &error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(mock_service.get(), service.get());
EXPECT_EQ(profile.get(), service->profile().get());
mock_service->set_profile(nullptr); // Breaks reference cycle.
}
TEST_F(ManagerTest, ConfigureServiceForProfileMatchingServiceEphemeralProfile) {
const string kProfileName = "profile";
scoped_refptr<MockProfile> profile(
AddNamedMockProfileToManager(manager(), kProfileName));
scoped_refptr<MockWiFiService> mock_service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
vector<uint8_t>(),
kModeManaged,
kSecurityNone,
false));
mock_service->set_profile(GetEphemeralProfile(manager()));
ServiceRefPtr mock_service_generic(mock_service.get());
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _))
.WillOnce(Return(mock_service));
EXPECT_CALL(*wifi_provider_, GetService(_, _)).Times(0);
EXPECT_CALL(*mock_service, Configure(_, _)).Times(1);
EXPECT_CALL(*profile, UpdateService(mock_service_generic)).Times(1);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName, args, &error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(mock_service.get(), service.get());
EXPECT_EQ(profile.get(), service->profile().get());
mock_service->set_profile(nullptr); // Breaks reference cycle.
}
TEST_F(ManagerTest, ConfigureServiceForProfileMatchingServicePrecedingProfile) {
const string kProfileName0 = "profile0";
scoped_refptr<MockProfile> profile0(
AddNamedMockProfileToManager(manager(), kProfileName0));
const string kProfileName1 = "profile1";
scoped_refptr<MockProfile> profile1(
AddNamedMockProfileToManager(manager(), kProfileName1));
scoped_refptr<MockWiFiService> mock_service(
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
vector<uint8_t>(),
kModeManaged,
kSecurityNone,
false));
manager()->RegisterService(mock_service);
mock_service->set_profile(profile0);
ServiceRefPtr mock_service_generic(mock_service.get());
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _))
.WillOnce(Return(mock_service));
EXPECT_CALL(*wifi_provider_, GetService(_, _)).Times(0);
EXPECT_CALL(*profile0, AbandonService(_)).Times(0);
EXPECT_CALL(*profile1, AdoptService(_)).Times(0);
// This happens once to make the service loadable for the ConfigureService
// below, and a second time after the service is modified.
EXPECT_CALL(*profile1, ConfigureService(mock_service_generic)).Times(0);
EXPECT_CALL(*wifi_provider_, CreateTemporaryService(_, _)).Times(0);
EXPECT_CALL(*mock_service, Configure(_, _)).Times(1);
EXPECT_CALL(*profile1, UpdateService(mock_service_generic)).Times(1);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName1, args, &error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(mock_service.get(), service.get());
mock_service->set_profile(nullptr); // Breaks reference cycle.
}
TEST_F(ManagerTest,
ConfigureServiceForProfileMatchingServiceProceedingProfile) {
const string kProfileName0 = "profile0";
scoped_refptr<MockProfile> profile0(
AddNamedMockProfileToManager(manager(), kProfileName0));
const string kProfileName1 = "profile1";
scoped_refptr<MockProfile> profile1(
AddNamedMockProfileToManager(manager(), kProfileName1));
scoped_refptr<MockWiFiService> matching_service(
new StrictMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
vector<uint8_t>(),
kModeManaged,
kSecurityNone,
false));
matching_service->set_profile(profile1);
// We need to get rid of our reference to this mock service as soon
// as Manager::ConfigureServiceForProfile() takes a reference in its
// call to WiFiProvider::CreateTemporaryService(). This way the
// latter function can keep a DCHECK(service->HasOneRef() even in
// unit tests.
temp_mock_service_ =
new NiceMock<MockWiFiService>(control_interface(),
dispatcher(),
metrics(),
manager(),
wifi_provider_,
vector<uint8_t>(),
kModeManaged,
kSecurityNone,
false);
// Only hold a pointer here so we don't affect the refcount.
MockWiFiService* mock_service_ptr = temp_mock_service_.get();
KeyValueStore args;
args.SetString(kTypeProperty, kTypeWifi);
EXPECT_CALL(*wifi_provider_, FindSimilarService(_, _))
.WillOnce(Return(matching_service));
EXPECT_CALL(*wifi_provider_, GetService(_, _)).Times(0);
EXPECT_CALL(*profile1, AbandonService(_)).Times(0);
EXPECT_CALL(*profile0, AdoptService(_)).Times(0);
EXPECT_CALL(*wifi_provider_, CreateTemporaryService(_, _))
.WillOnce(InvokeWithoutArgs(this, &ManagerTest::ReleaseTempMockService));
EXPECT_CALL(*profile0, ConfigureService(IsRefPtrTo(mock_service_ptr)))
.Times(1);
EXPECT_CALL(*mock_service_ptr, Configure(_, _)).Times(1);
EXPECT_CALL(*profile0, UpdateService(IsRefPtrTo(mock_service_ptr))).Times(1);
Error error;
ServiceRefPtr service =
manager()->ConfigureServiceForProfile(kProfileName0, args, &error);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(nullptr, service.get());
EXPECT_EQ(profile1.get(), matching_service->profile().get());
}
#if defined(__BRILLO__)
TEST_F(ManagerTest, SetupApModeInterface) {
const string kApInterfaceName = "Test-Interface";
string ap_interface;
Error error;
// Failed to setup AP mode interface.
EXPECT_CALL(wifi_driver_hal_, SetupApModeInterface()).WillOnce(Return(""));
EXPECT_FALSE(
manager()->SetupApModeInterface(&ap_interface, &error));
Mock::VerifyAndClearExpectations(&wifi_driver_hal_);
EXPECT_TRUE(error.IsFailure());
EXPECT_EQ("Failed to setup AP mode interface", error.message());
// AP mode interface setup succeed.
error.Reset();
EXPECT_CALL(wifi_driver_hal_, SetupApModeInterface())
.WillOnce(Return(kApInterfaceName));
EXPECT_TRUE(
manager()->SetupApModeInterface(&ap_interface, &error));
Mock::VerifyAndClearExpectations(&wifi_driver_hal_);
Mock::VerifyAndClearExpectations(control_interface());
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(kApInterfaceName, ap_interface);
}
TEST_F(ManagerTest, SetupStationModeInterface) {
const string kStationInterfaceName = "Test-Interface";
string station_interface;
Error error;
// Failed to setup station mode interface.
EXPECT_CALL(wifi_driver_hal_, SetupStationModeInterface())
.WillOnce(Return(""));
EXPECT_FALSE(
manager()->SetupStationModeInterface(&station_interface, &error));
Mock::VerifyAndClearExpectations(&wifi_driver_hal_);
EXPECT_TRUE(error.IsFailure());
EXPECT_EQ("Failed to setup station mode interface", error.message());
// Station mode interface setup succeed.
error.Reset();
EXPECT_CALL(wifi_driver_hal_, SetupStationModeInterface())
.WillOnce(Return(kStationInterfaceName));
EXPECT_TRUE(
manager()->SetupStationModeInterface(&station_interface, &error));
Mock::VerifyAndClearExpectations(&wifi_driver_hal_);
EXPECT_TRUE(error.IsSuccess());
EXPECT_EQ(kStationInterfaceName, station_interface);
}
TEST_F(ManagerTest, OnApModeSetterVanished) {
const string kStationInterfaceName = "Test-Interface";
EXPECT_CALL(wifi_driver_hal_, SetupStationModeInterface())
.WillOnce(Return(kStationInterfaceName));
manager()->OnApModeSetterVanished();
Mock::VerifyAndClearExpectations(&wifi_driver_hal_);
}
#endif // __BRILLO__
#endif // DISABLE_WIFI
TEST_F(ManagerTest, FindMatchingService) {
KeyValueStore args;
{
Error error;
ServiceRefPtr service = manager()->FindMatchingService(args, &error);
EXPECT_EQ(Error::kNotFound, error.type());
}
scoped_refptr<MockService> mock_service0(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
scoped_refptr<MockService> mock_service1(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
manager()->RegisterService(mock_service0);
manager()->RegisterService(mock_service1);
EXPECT_CALL(*mock_service0, DoPropertiesMatch(_))
.WillOnce(Return(true))
.WillRepeatedly(Return(false));
{
Error error;
EXPECT_EQ(mock_service0, manager()->FindMatchingService(args, &error));
EXPECT_TRUE(error.IsSuccess());
}
EXPECT_CALL(*mock_service1, DoPropertiesMatch(_))
.WillOnce(Return(true))
.WillRepeatedly(Return(false));
{
Error error;
EXPECT_EQ(mock_service1, manager()->FindMatchingService(args, &error));
EXPECT_TRUE(error.IsSuccess());
}
{
Error error;
EXPECT_FALSE(manager()->FindMatchingService(args, &error));
EXPECT_EQ(Error::kNotFound, error.type());
}
}
TEST_F(ManagerTest, TechnologyOrder) {
// If the Manager is not running, setting the technology order should not
// lauch a service sorting task.
SetRunning(false);
Error error;
manager()->SetTechnologyOrder("vpn,ethernet,wifi,wimax,cellular", &error);
ASSERT_TRUE(error.IsSuccess());
EXPECT_FALSE(IsSortServicesTaskPending());
EXPECT_THAT(GetTechnologyOrder(), ElementsAre(Technology::kVPN,
Technology::kEthernet,
Technology::kWifi,
Technology::kWiMax,
Technology::kCellular));
SetRunning(true);
manager()->SetTechnologyOrder(string(kTypeEthernet) + "," + string(kTypeWifi),
&error);
EXPECT_TRUE(IsSortServicesTaskPending());
ASSERT_TRUE(error.IsSuccess());
EXPECT_EQ(manager()->GetTechnologyOrder(),
string(kTypeEthernet) + "," + string(kTypeWifi));
manager()->SetTechnologyOrder(string(kTypeEthernet) + "x," +
string(kTypeWifi), &error);
ASSERT_FALSE(error.IsSuccess());
EXPECT_EQ(Error::kInvalidArguments, error.type());
EXPECT_EQ(string(kTypeEthernet) + "," + string(kTypeWifi),
manager()->GetTechnologyOrder());
}
TEST_F(ManagerTest, ConnectionStatusCheck) {
// Setup mock metrics and service.
MockMetrics mock_metrics(dispatcher());
SetMetrics(&mock_metrics);
scoped_refptr<MockService> mock_service = new NiceMock<MockService>(
control_interface(), dispatcher(), metrics(), manager());
manager()->RegisterService(mock_service);
// Device not connected.
EXPECT_CALL(*mock_service.get(), IsConnected())
.WillOnce(Return(false));
EXPECT_CALL(mock_metrics,
NotifyDeviceConnectionStatus(Metrics::kConnectionStatusOffline));
manager()->ConnectionStatusCheck();
// Device connected, but not online.
EXPECT_CALL(*mock_service.get(), IsConnected())
.WillOnce(Return(true));
EXPECT_CALL(*mock_service.get(), IsOnline())
.WillOnce(Return(false));
EXPECT_CALL(mock_metrics,
NotifyDeviceConnectionStatus(Metrics::kConnectionStatusOnline)).Times(0);
EXPECT_CALL(mock_metrics,
NotifyDeviceConnectionStatus(Metrics::kConnectionStatusConnected));
manager()->ConnectionStatusCheck();
// Device connected and online.
EXPECT_CALL(*mock_service.get(), IsConnected())
.WillOnce(Return(true));
EXPECT_CALL(*mock_service.get(), IsOnline())
.WillOnce(Return(true));
EXPECT_CALL(mock_metrics,
NotifyDeviceConnectionStatus(Metrics::kConnectionStatusOnline));
EXPECT_CALL(mock_metrics,
NotifyDeviceConnectionStatus(Metrics::kConnectionStatusConnected));
manager()->ConnectionStatusCheck();
}
TEST_F(ManagerTest, DevicePresenceStatusCheck) {
// Setup mock metrics and service.
MockMetrics mock_metrics(dispatcher());
SetMetrics(&mock_metrics);
manager()->RegisterDevice(mock_devices_[0]);
manager()->RegisterDevice(mock_devices_[1]);
manager()->RegisterDevice(mock_devices_[2]);
manager()->RegisterDevice(mock_devices_[3]);
ON_CALL(*mock_devices_[0].get(), technology())
.WillByDefault(Return(Technology::kEthernet));
ON_CALL(*mock_devices_[1].get(), technology())
.WillByDefault(Return(Technology::kWifi));
ON_CALL(*mock_devices_[2].get(), technology())
.WillByDefault(Return(Technology::kCellular));
ON_CALL(*mock_devices_[3].get(), technology())
.WillByDefault(Return(Technology::kWifi));
EXPECT_CALL(mock_metrics,
NotifyDevicePresenceStatus(Technology::kEthernet, true));
EXPECT_CALL(mock_metrics,
NotifyDevicePresenceStatus(Technology::kWifi, true));
EXPECT_CALL(mock_metrics,
NotifyDevicePresenceStatus(Technology::kWiMax, false));
EXPECT_CALL(mock_metrics,
NotifyDevicePresenceStatus(Technology::kCellular, true));
manager()->DevicePresenceStatusCheck();
}
TEST_F(ManagerTest, SortServicesWithConnection) {
MockMetrics mock_metrics(dispatcher());
SetMetrics(&mock_metrics);
scoped_refptr<MockService> mock_service0(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
scoped_refptr<MockService> mock_service1(
new NiceMock<MockService>(control_interface(),
dispatcher(),
metrics(),
manager()));
scoped_refptr<MockConnection> mock_connection0(
new NiceMock<MockConnection>(device_info_.get()));
scoped_refptr<MockConnection> mock_connection1(
new NiceMock<MockConnection>(device_info_.get()));
// A single registered Service, without a connection. The
// DefaultService should be nullptr. If a change notification is
// generated, it should reference kNullPath.
EXPECT_CALL(mock_metrics, NotifyDefaultServiceChanged(nullptr));
EXPECT_CALL(*manager_adaptor_,
EmitRpcIdentifierChanged(
kDefaultServiceProperty,
control_interface()->NullRPCIdentifier()))
.Times(AnyNumber());
manager()->RegisterService(mock_service0);
CompleteServiceSort();
// Adding another Service, also without a connection, does not
// change DefaultService. Furthermore, we do not send a change
// notification for DefaultService.
EXPECT_CALL(mock_metrics, NotifyDefaultServiceChanged(nullptr));
EXPECT_CALL(*manager_adaptor_,
EmitRpcIdentifierChanged(kDefaultServiceProperty, _))
.Times(0);
manager()->RegisterService(mock_service1);
CompleteServiceSort();
// An explicit sort doesn't change anything, and does not emit a
// change notification for DefaultService.
EXPECT_CALL(mock_metrics, NotifyDefaultServiceChanged(nullptr));
EXPECT_CALL(*manager_adaptor_,
EmitRpcIdentifierChanged(kDefaultServiceProperty, _))
.Times(0);
manager()->SortServicesTask();
EXPECT_TRUE(ServiceOrderIs(mock_service0, mock_service1));
// Re-ordering the unconnected Services doesn't change
// DefaultService, and (hence) does not emit a change notification
// for DefaultService.
mock_service1->SetPriority(1, nullptr);
EXPECT_CALL(mock_metrics, NotifyDefaultServiceChanged(nullptr));
EXPECT_CALL(*manager_adaptor_,
EmitRpcIdentifierChanged(kDefaultServiceProperty, _))
.Times(0);
manager()->SortServicesTask();
EXPECT_TRUE(ServiceOrd