| // Copyright 2018 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "shill/default_profile.h" |
| |
| #include <memory> |
| #include <set> |
| #include <string> |
| #include <utility> |
| |
| #include <base/files/file_path.h> |
| #include <chromeos/dbus/service_constants.h> |
| #include <gtest/gtest.h> |
| #include <gmock/gmock.h> |
| |
| #include "shill/dhcp/mock_dhcp_properties.h" |
| #include "shill/link_monitor.h" |
| #include "shill/manager.h" |
| #include "shill/mock_control.h" |
| #include "shill/mock_device.h" |
| #include "shill/mock_service.h" |
| #include "shill/mock_store.h" |
| #include "shill/portal_detector.h" |
| #include "shill/property_store_test.h" |
| #include "shill/resolver.h" |
| |
| #if !defined(DISABLE_WIFI) |
| #include "shill/wifi/mock_wifi_provider.h" |
| #include "shill/wifi/wifi_service.h" |
| #endif // DISABLE_WIFI |
| |
| using base::FilePath; |
| using std::set; |
| using std::string; |
| using ::testing::_; |
| using ::testing::DoAll; |
| using ::testing::Return; |
| using ::testing::SetArgPointee; |
| |
| namespace shill { |
| |
| class DefaultProfileTest : public PropertyStoreTest { |
| public: |
| DefaultProfileTest() |
| : profile_(new DefaultProfile(manager(), |
| FilePath(storage_path()), |
| DefaultProfile::kDefaultId, |
| properties_)), |
| device_(new MockDevice(manager(), "null0", "addr0", 0)) {} |
| |
| ~DefaultProfileTest() override = default; |
| |
| protected: |
| static const char kTestStoragePath[]; |
| |
| scoped_refptr<DefaultProfile> profile_; |
| scoped_refptr<MockDevice> device_; |
| Manager::Properties properties_; |
| }; |
| |
| const char DefaultProfileTest::kTestStoragePath[] = "/no/where"; |
| |
| TEST_F(DefaultProfileTest, GetProperties) { |
| // DBusAdaptor::GetProperties() will iterate over all the accessors |
| // provided by Profile. The |kEntriesProperty| accessor calls |
| // GetGroups() on the StoreInterface. |
| auto storage = std::make_unique<MockStore>(); |
| set<string> empty_group_set; |
| EXPECT_CALL(*storage, GetGroups()).WillRepeatedly(Return(empty_group_set)); |
| profile_->SetStorageForTest(std::move(storage)); |
| |
| Error error(Error::kInvalidProperty, ""); |
| { |
| brillo::VariantDictionary props; |
| Error error; |
| profile_->store().GetProperties(&props, &error); |
| ASSERT_FALSE(props.find(kOfflineModeProperty) == props.end()); |
| EXPECT_TRUE(props[kOfflineModeProperty].IsTypeCompatible<bool>()); |
| EXPECT_FALSE(props[kOfflineModeProperty].Get<bool>()); |
| } |
| properties_.offline_mode = true; |
| { |
| brillo::VariantDictionary props; |
| Error error; |
| profile_->store().GetProperties(&props, &error); |
| ASSERT_FALSE(props.find(kOfflineModeProperty) == props.end()); |
| EXPECT_TRUE(props[kOfflineModeProperty].IsTypeCompatible<bool>()); |
| EXPECT_TRUE(props[kOfflineModeProperty].Get<bool>()); |
| } |
| { |
| Error error(Error::kInvalidProperty, ""); |
| EXPECT_FALSE(profile_->mutable_store()->SetBoolProperty( |
| kOfflineModeProperty, true, &error)); |
| } |
| } |
| |
| TEST_F(DefaultProfileTest, Save) { |
| auto storage = std::make_unique<MockStore>(); |
| EXPECT_CALL(*storage, SetBool(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageArpGateway, true)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageName, |
| DefaultProfile::kDefaultId)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageHostName, "")) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, SetBool(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageOfflineMode, false)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageCheckPortalList, "")) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, |
| SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageIgnoredDNSSearchPaths, "")) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, |
| SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageLinkMonitorTechnologies, "")) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, |
| SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageNoAutoConnectTechnologies, "")) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, |
| SetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageProhibitedTechnologies, "")) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*storage, Flush()).WillOnce(Return(true)); |
| |
| EXPECT_CALL(*device_, Save(storage.get())).Times(0); |
| profile_->SetStorageForTest(std::move(storage)); |
| auto dhcp_props = std::make_unique<MockDhcpProperties>(); |
| EXPECT_CALL(*dhcp_props, Save(_, _)); |
| manager()->dhcp_properties_ = std::move(dhcp_props); |
| |
| manager()->RegisterDevice(device_); |
| ASSERT_TRUE(profile_->Save()); |
| manager()->DeregisterDevice(device_); |
| } |
| |
| TEST_F(DefaultProfileTest, LoadManagerDefaultProperties) { |
| auto storage = std::make_unique<MockStore>(); |
| Manager::Properties manager_props; |
| EXPECT_CALL(*storage, GetBool(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageArpGateway, |
| &manager_props.arp_gateway)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageHostName, |
| &manager_props.host_name)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, GetBool(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageOfflineMode, |
| &manager_props.offline_mode)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageCheckPortalList, |
| &manager_props.check_portal_list)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageIgnoredDNSSearchPaths, |
| &manager_props.ignored_dns_search_paths)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageLinkMonitorTechnologies, _)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageNoAutoConnectTechnologies, _)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageProhibitedTechnologies, _)) |
| .WillOnce(Return(false)); |
| auto dhcp_props = std::make_unique<MockDhcpProperties>(); |
| EXPECT_CALL(*dhcp_props, Load(_, DefaultProfile::kStorageId)); |
| manager()->dhcp_properties_ = std::move(dhcp_props); |
| profile_->SetStorageForTest(std::move(storage)); |
| |
| profile_->LoadManagerProperties(&manager_props, |
| manager()->dhcp_properties_.get()); |
| EXPECT_TRUE(manager_props.arp_gateway); |
| EXPECT_EQ("", manager_props.host_name); |
| EXPECT_FALSE(manager_props.offline_mode); |
| EXPECT_EQ(PortalDetector::kDefaultCheckPortalList, |
| manager_props.check_portal_list); |
| EXPECT_EQ(Resolver::kDefaultIgnoredSearchList, |
| manager_props.ignored_dns_search_paths); |
| EXPECT_EQ(LinkMonitor::kDefaultLinkMonitorTechnologies, |
| manager_props.link_monitor_technologies); |
| EXPECT_EQ("", manager_props.no_auto_connect_technologies); |
| EXPECT_EQ(PortalDetector::kDefaultHttpUrl, manager_props.portal_http_url); |
| EXPECT_EQ(PortalDetector::kDefaultHttpsUrl, manager_props.portal_https_url); |
| EXPECT_EQ(PortalDetector::kDefaultFallbackHttpUrls, |
| manager_props.portal_fallback_http_urls); |
| EXPECT_EQ("", manager_props.prohibited_technologies); |
| } |
| |
| TEST_F(DefaultProfileTest, LoadManagerProperties) { |
| auto storage = std::make_unique<MockStore>(); |
| const string host_name("hostname"); |
| EXPECT_CALL(*storage, GetBool(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageArpGateway, _)) |
| .WillOnce(DoAll(SetArgPointee<2>(false), Return(true))); |
| EXPECT_CALL(*storage, GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageHostName, _)) |
| .WillOnce(DoAll(SetArgPointee<2>(host_name), Return(true))); |
| EXPECT_CALL(*storage, GetBool(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageOfflineMode, _)) |
| .WillOnce(DoAll(SetArgPointee<2>(true), Return(true))); |
| const string portal_list("technology1,technology2"); |
| EXPECT_CALL(*storage, GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageCheckPortalList, _)) |
| .WillOnce(DoAll(SetArgPointee<2>(portal_list), Return(true))); |
| const string ignored_paths("chromium.org,google.com"); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageIgnoredDNSSearchPaths, _)) |
| .WillOnce(DoAll(SetArgPointee<2>(ignored_paths), Return(true))); |
| const string link_monitor_technologies("ethernet,wifi"); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageLinkMonitorTechnologies, _)) |
| .WillOnce( |
| DoAll(SetArgPointee<2>(link_monitor_technologies), Return(true))); |
| const string no_auto_connect_technologies("wifi,cellular"); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageNoAutoConnectTechnologies, _)) |
| .WillOnce( |
| DoAll(SetArgPointee<2>(no_auto_connect_technologies), Return(true))); |
| const string prohibited_technologies("vpn,wifi"); |
| EXPECT_CALL(*storage, |
| GetString(DefaultProfile::kStorageId, |
| DefaultProfile::kStorageProhibitedTechnologies, _)) |
| .WillOnce(DoAll(SetArgPointee<2>(prohibited_technologies), Return(true))); |
| profile_->SetStorageForTest(std::move(storage)); |
| Manager::Properties manager_props; |
| auto dhcp_props = std::make_unique<MockDhcpProperties>(); |
| EXPECT_CALL(*dhcp_props, Load(_, DefaultProfile::kStorageId)); |
| manager()->dhcp_properties_ = std::move(dhcp_props); |
| |
| profile_->LoadManagerProperties(&manager_props, |
| manager()->dhcp_properties_.get()); |
| EXPECT_FALSE(manager_props.arp_gateway); |
| EXPECT_EQ(host_name, manager_props.host_name); |
| EXPECT_TRUE(manager_props.offline_mode); |
| EXPECT_EQ(portal_list, manager_props.check_portal_list); |
| EXPECT_EQ(ignored_paths, manager_props.ignored_dns_search_paths); |
| EXPECT_EQ(link_monitor_technologies, manager_props.link_monitor_technologies); |
| EXPECT_EQ(no_auto_connect_technologies, |
| manager_props.no_auto_connect_technologies); |
| EXPECT_EQ(prohibited_technologies, manager_props.prohibited_technologies); |
| } |
| |
| TEST_F(DefaultProfileTest, GetStoragePath) { |
| EXPECT_EQ(storage_path() + "/default.profile", |
| profile_->persistent_profile_path().value()); |
| } |
| |
| TEST_F(DefaultProfileTest, ConfigureService) { |
| auto storage = std::make_unique<MockStore>(); |
| EXPECT_CALL(*storage, ContainsGroup(_)).WillRepeatedly(Return(false)); |
| EXPECT_CALL(*storage, Flush()).WillOnce(Return(true)); |
| |
| scoped_refptr<MockService> unknown_service(new MockService(manager())); |
| EXPECT_CALL(*unknown_service, technology()) |
| .WillOnce(Return(Technology::kUnknown)); |
| EXPECT_CALL(*unknown_service, Save(_)).Times(0); |
| |
| scoped_refptr<MockService> ethernet_service(new MockService(manager())); |
| EXPECT_CALL(*ethernet_service, technology()) |
| .WillOnce(Return(Technology::kEthernet)); |
| EXPECT_CALL(*ethernet_service, Save(storage.get())).WillOnce(Return(true)); |
| |
| profile_->SetStorageForTest(std::move(storage)); |
| EXPECT_FALSE(profile_->ConfigureService(unknown_service)); |
| EXPECT_TRUE(profile_->ConfigureService(ethernet_service)); |
| } |
| |
| TEST_F(DefaultProfileTest, UpdateDevice) { |
| auto storage = std::make_unique<MockStore>(); |
| EXPECT_CALL(*storage, Flush()).WillOnce(Return(true)); |
| EXPECT_CALL(*device_, Save(storage.get())) |
| .WillOnce(Return(true)) |
| .WillOnce(Return(false)); |
| profile_->SetStorageForTest(std::move(storage)); |
| EXPECT_TRUE(profile_->UpdateDevice(device_)); |
| EXPECT_FALSE(profile_->UpdateDevice(device_)); |
| } |
| |
| #if !defined(DISABLE_WIFI) |
| TEST_F(DefaultProfileTest, UpdateWiFiProvider) { |
| MockWiFiProvider wifi_provider; |
| |
| { |
| auto storage = std::make_unique<MockStore>(); |
| EXPECT_CALL(*storage, Flush()).Times(0); |
| EXPECT_CALL(wifi_provider, Save(storage.get())).WillOnce(Return(false)); |
| profile_->SetStorageForTest(std::move(storage)); |
| EXPECT_FALSE(profile_->UpdateWiFiProvider(wifi_provider)); |
| } |
| |
| { |
| auto storage = std::make_unique<MockStore>(); |
| EXPECT_CALL(*storage, Flush()).WillOnce(Return(false)); |
| EXPECT_CALL(wifi_provider, Save(storage.get())).WillOnce(Return(true)); |
| profile_->SetStorageForTest(std::move(storage)); |
| EXPECT_FALSE(profile_->UpdateWiFiProvider(wifi_provider)); |
| } |
| |
| { |
| auto storage = std::make_unique<MockStore>(); |
| EXPECT_CALL(*storage, Flush()).WillOnce(Return(true)); |
| EXPECT_CALL(wifi_provider, Save(storage.get())).WillOnce(Return(true)); |
| profile_->SetStorageForTest(std::move(storage)); |
| EXPECT_TRUE(profile_->UpdateWiFiProvider(wifi_provider)); |
| } |
| } |
| #endif // DISABLE_WIFI |
| |
| } // namespace shill |