Home | History | Annotate | Download | only in network 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/network/shill_property_handler.h"
      6 
      7 #include <map>
      8 #include <set>
      9 #include <string>
     10 
     11 #include "base/bind.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/values.h"
     15 #include "chromeos/dbus/dbus_thread_manager.h"
     16 #include "chromeos/dbus/shill_device_client.h"
     17 #include "chromeos/dbus/shill_ipconfig_client.h"
     18 #include "chromeos/dbus/shill_manager_client.h"
     19 #include "chromeos/dbus/shill_profile_client.h"
     20 #include "chromeos/dbus/shill_service_client.h"
     21 #include "dbus/object_path.h"
     22 #include "testing/gtest/include/gtest/gtest.h"
     23 #include "third_party/cros_system_api/dbus/service_constants.h"
     24 
     25 namespace chromeos {
     26 
     27 namespace {
     28 
     29 void DoNothingWithCallStatus(DBusMethodCallStatus call_status) {
     30 }
     31 
     32 void ErrorCallbackFunction(const std::string& error_name,
     33                            const std::string& error_message) {
     34   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
     35 }
     36 
     37 class TestListener : public internal::ShillPropertyHandler::Listener {
     38  public:
     39   TestListener() : technology_list_updates_(0),
     40                    errors_(0) {
     41   }
     42 
     43   virtual void UpdateManagedList(ManagedState::ManagedType type,
     44                                  const base::ListValue& entries) OVERRIDE {
     45     VLOG(1) << "UpdateManagedList[" << ManagedState::TypeToString(type) << "]: "
     46             << entries.GetSize();
     47     UpdateEntries(GetTypeString(type), entries);
     48   }
     49 
     50   virtual void UpdateManagedStateProperties(
     51       ManagedState::ManagedType type,
     52       const std::string& path,
     53       const base::DictionaryValue& properties) OVERRIDE {
     54     VLOG(2) << "UpdateManagedStateProperties: " << GetTypeString(type);
     55     initial_property_updates(GetTypeString(type))[path] += 1;
     56   }
     57 
     58   virtual void ProfileListChanged() OVERRIDE {
     59   }
     60 
     61   virtual void UpdateNetworkServiceProperty(
     62       const std::string& service_path,
     63       const std::string& key,
     64       const base::Value& value) OVERRIDE {
     65     AddPropertyUpdate(shill::kServiceCompleteListProperty, service_path);
     66   }
     67 
     68   virtual void UpdateDeviceProperty(
     69       const std::string& device_path,
     70       const std::string& key,
     71       const base::Value& value) OVERRIDE {
     72     AddPropertyUpdate(shill::kDevicesProperty, device_path);
     73   }
     74 
     75   virtual void UpdateIPConfigProperties(
     76       ManagedState::ManagedType type,
     77       const std::string& path,
     78       const std::string& ip_config_path,
     79       const base::DictionaryValue& properties) OVERRIDE {
     80     AddPropertyUpdate(shill::kIPConfigsProperty, ip_config_path);
     81   }
     82 
     83   virtual void TechnologyListChanged() OVERRIDE {
     84     VLOG(1) << "TechnologyListChanged.";
     85     ++technology_list_updates_;
     86   }
     87 
     88   virtual void CheckPortalListChanged(
     89       const std::string& check_portal_list) OVERRIDE {
     90   }
     91 
     92   virtual void ManagedStateListChanged(
     93       ManagedState::ManagedType type) OVERRIDE {
     94     VLOG(1) << "ManagedStateListChanged: " << GetTypeString(type);
     95     AddStateListUpdate(GetTypeString(type));
     96   }
     97 
     98   virtual void DefaultNetworkServiceChanged(
     99       const std::string& service_path) OVERRIDE {
    100   }
    101 
    102   std::vector<std::string>& entries(const std::string& type) {
    103     return entries_[type];
    104   }
    105   std::map<std::string, int>& property_updates(const std::string& type) {
    106     return property_updates_[type];
    107   }
    108   std::map<std::string, int>& initial_property_updates(
    109       const std::string& type) {
    110     return initial_property_updates_[type];
    111   }
    112   int list_updates(const std::string& type) { return list_updates_[type]; }
    113   int technology_list_updates() { return technology_list_updates_; }
    114   void reset_list_updates() {
    115     VLOG(1) << "=== RESET LIST UPDATES ===";
    116     list_updates_.clear();
    117     technology_list_updates_ = 0;
    118   }
    119   int errors() { return errors_; }
    120 
    121  private:
    122   std::string GetTypeString(ManagedState::ManagedType type) {
    123     if (type == ManagedState::MANAGED_TYPE_NETWORK)
    124       return shill::kServiceCompleteListProperty;
    125     if (type == ManagedState::MANAGED_TYPE_DEVICE)
    126       return shill::kDevicesProperty;
    127     NOTREACHED();
    128     return std::string();
    129   }
    130 
    131   void UpdateEntries(const std::string& type, const base::ListValue& entries) {
    132     if (type.empty())
    133       return;
    134     entries_[type].clear();
    135     for (base::ListValue::const_iterator iter = entries.begin();
    136          iter != entries.end(); ++iter) {
    137       std::string path;
    138       if ((*iter)->GetAsString(&path))
    139         entries_[type].push_back(path);
    140     }
    141   }
    142 
    143   void AddPropertyUpdate(const std::string& type, const std::string& path) {
    144     DCHECK(!type.empty());
    145     VLOG(2) << "AddPropertyUpdate: " << type;
    146     property_updates(type)[path] += 1;
    147   }
    148 
    149   void AddStateListUpdate(const std::string& type) {
    150     DCHECK(!type.empty());
    151     list_updates_[type] += 1;
    152   }
    153 
    154   // Map of list-type -> paths
    155   std::map<std::string, std::vector<std::string> > entries_;
    156   // Map of list-type -> map of paths -> update counts
    157   std::map<std::string, std::map<std::string, int> > property_updates_;
    158   std::map<std::string, std::map<std::string, int> > initial_property_updates_;
    159   // Map of list-type -> list update counts
    160   std::map<std::string, int > list_updates_;
    161   int technology_list_updates_;
    162   int errors_;
    163 };
    164 
    165 }  // namespace
    166 
    167 class ShillPropertyHandlerTest : public testing::Test {
    168  public:
    169   ShillPropertyHandlerTest()
    170       : manager_test_(NULL),
    171         device_test_(NULL),
    172         service_test_(NULL),
    173         profile_test_(NULL) {
    174   }
    175   virtual ~ShillPropertyHandlerTest() {
    176   }
    177 
    178   virtual void SetUp() OVERRIDE {
    179     // Initialize DBusThreadManager with a stub implementation.
    180     DBusThreadManager::Initialize();
    181     // Get the test interface for manager / device / service and clear the
    182     // default stub properties.
    183     manager_test_ =
    184         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
    185     ASSERT_TRUE(manager_test_);
    186     device_test_ =
    187         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
    188     ASSERT_TRUE(device_test_);
    189     service_test_ =
    190         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
    191     ASSERT_TRUE(service_test_);
    192     profile_test_ =
    193         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
    194     ASSERT_TRUE(profile_test_);
    195     SetupShillPropertyHandler();
    196     message_loop_.RunUntilIdle();
    197   }
    198 
    199   virtual void TearDown() OVERRIDE {
    200     shill_property_handler_.reset();
    201     listener_.reset();
    202     DBusThreadManager::Shutdown();
    203   }
    204 
    205   void AddDevice(const std::string& type, const std::string& id) {
    206     ASSERT_TRUE(IsValidType(type));
    207     device_test_->AddDevice(id, type, id);
    208   }
    209 
    210   void RemoveDevice(const std::string& id) {
    211     device_test_->RemoveDevice(id);
    212   }
    213 
    214   void AddService(const std::string& type,
    215                   const std::string& id,
    216                   const std::string& state) {
    217     VLOG(2) << "AddService: " << type << ": " << id << ": " << state;
    218     ASSERT_TRUE(IsValidType(type));
    219     service_test_->AddService(id /* service_path */,
    220                               id /* guid */,
    221                               id /* name */,
    222                               type,
    223                               state,
    224                               true /* visible */);
    225   }
    226 
    227   void AddServiceWithIPConfig(const std::string& type,
    228                               const std::string& id,
    229                               const std::string& state,
    230                               const std::string& ipconfig_path) {
    231     ASSERT_TRUE(IsValidType(type));
    232     service_test_->AddServiceWithIPConfig(id, /* service_path */
    233                                           id /* guid */,
    234                                           id /* name */,
    235                                           type,
    236                                           state,
    237                                           ipconfig_path,
    238                                           true /* visible */);
    239   }
    240 
    241   void AddServiceToProfile(const std::string& type,
    242                            const std::string& id,
    243                            bool visible) {
    244     service_test_->AddService(id /* service_path */,
    245                               id /* guid */,
    246                               id /* name */,
    247                               type,
    248                               shill::kStateIdle,
    249                               visible);
    250     std::vector<std::string> profiles;
    251     profile_test_->GetProfilePaths(&profiles);
    252     ASSERT_TRUE(profiles.size() > 0);
    253     base::DictionaryValue properties;  // Empty entry
    254     profile_test_->AddService(profiles[0], id);
    255   }
    256 
    257   void RemoveService(const std::string& id) {
    258     service_test_->RemoveService(id);
    259   }
    260 
    261   // Call this after any initial Shill client setup
    262   void SetupShillPropertyHandler() {
    263     SetupDefaultShillState();
    264     listener_.reset(new TestListener);
    265     shill_property_handler_.reset(
    266         new internal::ShillPropertyHandler(listener_.get()));
    267     shill_property_handler_->Init();
    268   }
    269 
    270   bool IsValidType(const std::string& type) {
    271     return (type == shill::kTypeEthernet ||
    272             type == shill::kTypeEthernetEap ||
    273             type == shill::kTypeWifi ||
    274             type == shill::kTypeWimax ||
    275             type == shill::kTypeBluetooth ||
    276             type == shill::kTypeCellular ||
    277             type == shill::kTypeVPN);
    278   }
    279 
    280  protected:
    281   void SetupDefaultShillState() {
    282     message_loop_.RunUntilIdle();  // Process any pending updates
    283     device_test_->ClearDevices();
    284     AddDevice(shill::kTypeWifi, "stub_wifi_device1");
    285     AddDevice(shill::kTypeCellular, "stub_cellular_device1");
    286     service_test_->ClearServices();
    287     AddService(shill::kTypeEthernet, "stub_ethernet", shill::kStateOnline);
    288     AddService(shill::kTypeWifi, "stub_wifi1", shill::kStateOnline);
    289     AddService(shill::kTypeWifi, "stub_wifi2", shill::kStateIdle);
    290     AddService(shill::kTypeCellular, "stub_cellular1", shill::kStateIdle);
    291   }
    292 
    293   base::MessageLoopForUI message_loop_;
    294   scoped_ptr<TestListener> listener_;
    295   scoped_ptr<internal::ShillPropertyHandler> shill_property_handler_;
    296   ShillManagerClient::TestInterface* manager_test_;
    297   ShillDeviceClient::TestInterface* device_test_;
    298   ShillServiceClient::TestInterface* service_test_;
    299   ShillProfileClient::TestInterface* profile_test_;
    300 
    301  private:
    302   DISALLOW_COPY_AND_ASSIGN(ShillPropertyHandlerTest);
    303 };
    304 
    305 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerStub) {
    306   EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable(shill::kTypeWifi));
    307   EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWifi));
    308   const size_t kNumShillManagerClientStubImplDevices = 2;
    309   EXPECT_EQ(kNumShillManagerClientStubImplDevices,
    310             listener_->entries(shill::kDevicesProperty).size());
    311   const size_t kNumShillManagerClientStubImplServices = 4;
    312   EXPECT_EQ(kNumShillManagerClientStubImplServices,
    313             listener_->entries(shill::kServiceCompleteListProperty).size());
    314 
    315   EXPECT_EQ(0, listener_->errors());
    316 }
    317 
    318 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerTechnologyChanged) {
    319   const int initial_technology_updates = 2;  // Available and Enabled lists
    320   EXPECT_EQ(initial_technology_updates, listener_->technology_list_updates());
    321 
    322   // Remove an enabled technology. Updates both the Available and Enabled lists.
    323   listener_->reset_list_updates();
    324   manager_test_->RemoveTechnology(shill::kTypeWifi);
    325   message_loop_.RunUntilIdle();
    326   EXPECT_EQ(2, listener_->technology_list_updates());
    327 
    328   // Add a disabled technology.
    329   listener_->reset_list_updates();
    330   manager_test_->AddTechnology(shill::kTypeWifi, false);
    331   message_loop_.RunUntilIdle();
    332   EXPECT_EQ(1, listener_->technology_list_updates());
    333   EXPECT_TRUE(shill_property_handler_->IsTechnologyAvailable(
    334       shill::kTypeWifi));
    335   EXPECT_FALSE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWifi));
    336 
    337   // Enable the technology.
    338   listener_->reset_list_updates();
    339   DBusThreadManager::Get()->GetShillManagerClient()->EnableTechnology(
    340       shill::kTypeWifi,
    341       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
    342   message_loop_.RunUntilIdle();
    343   EXPECT_EQ(1, listener_->technology_list_updates());
    344   EXPECT_TRUE(shill_property_handler_->IsTechnologyEnabled(shill::kTypeWifi));
    345 
    346   EXPECT_EQ(0, listener_->errors());
    347 }
    348 
    349 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerDevicePropertyChanged) {
    350   const size_t kNumShillManagerClientStubImplDevices = 2;
    351   EXPECT_EQ(kNumShillManagerClientStubImplDevices,
    352             listener_->entries(shill::kDevicesProperty).size());
    353   // Add a device.
    354   listener_->reset_list_updates();
    355   const std::string kTestDevicePath("test_wifi_device1");
    356   AddDevice(shill::kTypeWifi, kTestDevicePath);
    357   message_loop_.RunUntilIdle();
    358   EXPECT_EQ(1, listener_->list_updates(shill::kDevicesProperty));
    359   EXPECT_EQ(kNumShillManagerClientStubImplDevices + 1,
    360             listener_->entries(shill::kDevicesProperty).size());
    361 
    362   // Remove a device
    363   listener_->reset_list_updates();
    364   RemoveDevice(kTestDevicePath);
    365   message_loop_.RunUntilIdle();
    366   EXPECT_EQ(1, listener_->list_updates(shill::kDevicesProperty));
    367   EXPECT_EQ(kNumShillManagerClientStubImplDevices,
    368             listener_->entries(shill::kDevicesProperty).size());
    369 
    370   EXPECT_EQ(0, listener_->errors());
    371 }
    372 
    373 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServicePropertyChanged) {
    374   const size_t kNumShillManagerClientStubImplServices = 4;
    375   EXPECT_EQ(kNumShillManagerClientStubImplServices,
    376             listener_->entries(shill::kServiceCompleteListProperty).size());
    377 
    378   // Add a service.
    379   listener_->reset_list_updates();
    380   const std::string kTestServicePath("test_wifi_service1");
    381   AddService(shill::kTypeWifi, kTestServicePath, shill::kStateIdle);
    382   message_loop_.RunUntilIdle();
    383   // Add should trigger a service list update and update entries.
    384   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
    385   EXPECT_EQ(kNumShillManagerClientStubImplServices + 1,
    386             listener_->entries(shill::kServiceCompleteListProperty).size());
    387   // Service receives an initial property update.
    388   EXPECT_EQ(1, listener_->initial_property_updates(
    389       shill::kServiceCompleteListProperty)[kTestServicePath]);
    390   // Change a property.
    391   base::FundamentalValue scan_interval(3);
    392   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
    393       dbus::ObjectPath(kTestServicePath),
    394       shill::kScanIntervalProperty,
    395       scan_interval,
    396       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
    397   message_loop_.RunUntilIdle();
    398   // Property change triggers an update (but not a service list update).
    399   EXPECT_EQ(1, listener_->property_updates(
    400       shill::kServiceCompleteListProperty)[kTestServicePath]);
    401 
    402   // Change the visibility of a service. This will trigger a service list
    403   // updates.
    404   listener_->reset_list_updates();
    405   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
    406       dbus::ObjectPath(kTestServicePath),
    407       shill::kVisibleProperty,
    408       base::FundamentalValue(false),
    409       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
    410   message_loop_.RunUntilIdle();
    411   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
    412 
    413   // Remove a service. This will update the entries and signal a service list
    414   // update.
    415   listener_->reset_list_updates();
    416   RemoveService(kTestServicePath);
    417   message_loop_.RunUntilIdle();
    418   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
    419   EXPECT_EQ(kNumShillManagerClientStubImplServices,
    420             listener_->entries(shill::kServiceCompleteListProperty).size());
    421 
    422   EXPECT_EQ(0, listener_->errors());
    423 }
    424 
    425 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerIPConfigPropertyChanged) {
    426   // Set the properties for an IP Config object.
    427   const std::string kTestIPConfigPath("test_ip_config_path");
    428 
    429   base::StringValue ip_address("192.168.1.1");
    430   DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
    431       dbus::ObjectPath(kTestIPConfigPath),
    432       shill::kAddressProperty, ip_address,
    433       base::Bind(&DoNothingWithCallStatus));
    434   base::ListValue dns_servers;
    435   dns_servers.Append(new base::StringValue("192.168.1.100"));
    436   dns_servers.Append(new base::StringValue("192.168.1.101"));
    437   DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
    438       dbus::ObjectPath(kTestIPConfigPath),
    439       shill::kNameServersProperty, dns_servers,
    440       base::Bind(&DoNothingWithCallStatus));
    441   base::FundamentalValue prefixlen(8);
    442   DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
    443       dbus::ObjectPath(kTestIPConfigPath),
    444       shill::kPrefixlenProperty, prefixlen,
    445       base::Bind(&DoNothingWithCallStatus));
    446   base::StringValue gateway("192.0.0.1");
    447   DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
    448       dbus::ObjectPath(kTestIPConfigPath),
    449       shill::kGatewayProperty, gateway,
    450       base::Bind(&DoNothingWithCallStatus));
    451   message_loop_.RunUntilIdle();
    452 
    453   // Add a service with an empty ipconfig and then update
    454   // its ipconfig property.
    455   const std::string kTestServicePath1("test_wifi_service1");
    456   AddService(shill::kTypeWifi, kTestServicePath1, shill::kStateIdle);
    457   message_loop_.RunUntilIdle();
    458   // This is the initial property update.
    459   EXPECT_EQ(1, listener_->initial_property_updates(
    460       shill::kServiceCompleteListProperty)[kTestServicePath1]);
    461   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
    462       dbus::ObjectPath(kTestServicePath1),
    463       shill::kIPConfigProperty,
    464       base::StringValue(kTestIPConfigPath),
    465       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
    466   message_loop_.RunUntilIdle();
    467   // IPConfig property change on the service should trigger an IPConfigs update.
    468   EXPECT_EQ(1, listener_->property_updates(
    469       shill::kIPConfigsProperty)[kTestIPConfigPath]);
    470 
    471   // Now, Add a new service with the IPConfig already set.
    472   const std::string kTestServicePath2("test_wifi_service2");
    473   AddServiceWithIPConfig(shill::kTypeWifi, kTestServicePath2,
    474                          shill::kStateIdle, kTestIPConfigPath);
    475   message_loop_.RunUntilIdle();
    476   // A service with the IPConfig property already set should trigger an
    477   // additional IPConfigs update.
    478   EXPECT_EQ(2, listener_->property_updates(
    479       shill::kIPConfigsProperty)[kTestIPConfigPath]);
    480 }
    481 
    482 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceList) {
    483   // Add an entry to the profile only.
    484   const std::string kTestServicePath1("stub_wifi_profile_only1");
    485   AddServiceToProfile(shill::kTypeWifi, kTestServicePath1, false /* visible */);
    486   message_loop_.RunUntilIdle();
    487 
    488   // Update the Manager properties. This should trigger a single list update,
    489   // an initial property update, and a regular property update.
    490   listener_->reset_list_updates();
    491   shill_property_handler_->UpdateManagerProperties();
    492   message_loop_.RunUntilIdle();
    493   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
    494   EXPECT_EQ(1, listener_->initial_property_updates(
    495       shill::kServiceCompleteListProperty)[kTestServicePath1]);
    496   EXPECT_EQ(1, listener_->property_updates(
    497       shill::kServiceCompleteListProperty)[kTestServicePath1]);
    498 
    499   // Add a new entry to the services and the profile; should also trigger a
    500   // service list update, and a property update.
    501   listener_->reset_list_updates();
    502   const std::string kTestServicePath2("stub_wifi_profile_only2");
    503   AddServiceToProfile(shill::kTypeWifi, kTestServicePath2, true);
    504   shill_property_handler_->UpdateManagerProperties();
    505   message_loop_.RunUntilIdle();
    506   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
    507   EXPECT_EQ(1, listener_->initial_property_updates(
    508       shill::kServiceCompleteListProperty)[kTestServicePath2]);
    509   EXPECT_EQ(1, listener_->property_updates(
    510       shill::kServiceCompleteListProperty)[kTestServicePath2]);
    511 }
    512 
    513 }  // namespace chromeos
    514