Merge FavoriteState into NetworkState

chromeos/network/shill_property_handler_unittest.cc

 // Copyright (c) 2012 The Chromium 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 "chromeos/network/shill_property_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 24 matching lines @@
 }
 
 class TestListener : public internal::ShillPropertyHandler::Listener {
  public:
   TestListener() : technology_list_updates_(0),
                    errors_(0) {
   }
 
   virtual void UpdateManagedList(ManagedState::ManagedType type,
                                  const base::ListValue& entries) OVERRIDE {
+    VLOG(1) << "UpdateManagedList[" << ManagedState::TypeToString(type) << "]: "
+            << entries.GetSize();
     UpdateEntries(GetTypeString(type), entries);
   }
 
+  virtual void UpdateVisibleNetworks(const base::ListValue& entries) OVERRIDE {
+    VLOG(1) << "UpdateVisibleNetworks: " << entries.GetSize();
+    UpdateEntries(shill::kServicesProperty, entries);
+  }
+
   virtual void UpdateManagedStateProperties(
       ManagedState::ManagedType type,
       const std::string& path,
       const base::DictionaryValue& properties) OVERRIDE {
-    AddInitialPropertyUpdate(GetTypeString(type), path);
+    VLOG(2) << "UpdateManagedStateProperties: " << GetTypeString(type);
+    initial_property_updates(GetTypeString(type))[path] += 1;
   }
 
   virtual void ProfileListChanged() OVERRIDE {
   }
 
   virtual void UpdateNetworkServiceProperty(
       const std::string& service_path,
       const std::string& key,
       const base::Value& value) OVERRIDE {
-    AddPropertyUpdate(shill::kServicesProperty, service_path);
+    AddPropertyUpdate(shill::kServiceCompleteListProperty, service_path);
   }
 
   virtual void UpdateDeviceProperty(
       const std::string& device_path,
       const std::string& key,
       const base::Value& value) OVERRIDE {
     AddPropertyUpdate(shill::kDevicesProperty, device_path);
   }
 
   virtual void UpdateIPConfigProperties(
       ManagedState::ManagedType type,
       const std::string& path,
       const std::string& ip_config_path,
       const base::DictionaryValue& properties) OVERRIDE {
     AddPropertyUpdate(shill::kIPConfigsProperty, ip_config_path);
   }
 
   virtual void TechnologyListChanged() OVERRIDE {
     VLOG(1) << "TechnologyListChanged.";
     ++technology_list_updates_;
   }
 
   virtual void CheckPortalListChanged(
       const std::string& check_portal_list) OVERRIDE {
   }
 
   virtual void ManagedStateListChanged(
       ManagedState::ManagedType type) OVERRIDE {
+    VLOG(1) << "ManagedStateListChanged: " << GetTypeString(type);
     AddStateListUpdate(GetTypeString(type));
   }
 
   virtual void DefaultNetworkServiceChanged(
       const std::string& service_path) OVERRIDE {
   }
 
   std::vector<std::string>& entries(const std::string& type) {
     return entries_[type];
   }
   std::map<std::string, int>& property_updates(const std::string& type) {
     return property_updates_[type];
   }
   std::map<std::string, int>& initial_property_updates(
       const std::string& type) {
     return initial_property_updates_[type];
   }
   int list_updates(const std::string& type) { return list_updates_[type]; }
   int technology_list_updates() { return technology_list_updates_; }
   void reset_list_updates() {
     VLOG(1) << "=== RESET LIST UPDATES ===";
     list_updates_.clear();
     technology_list_updates_ = 0;
   }
   int errors() { return errors_; }
 
  private:
   std::string GetTypeString(ManagedState::ManagedType type) {
-    if (type == ManagedState::MANAGED_TYPE_NETWORK) {
-      return shill::kServicesProperty;
-    } else if (type == ManagedState::MANAGED_TYPE_FAVORITE) {
+    if (type == ManagedState::MANAGED_TYPE_NETWORK)
       return shill::kServiceCompleteListProperty;
-    } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
+    if (type == ManagedState::MANAGED_TYPE_DEVICE)
       return shill::kDevicesProperty;
-    }
-    LOG(ERROR) << "UpdateManagedList called with unrecognized type: " << type;
-    ++errors_;
+    NOTREACHED();
     return std::string();
   }
 
   void UpdateEntries(const std::string& type, const base::ListValue& entries) {
     if (type.empty())
       return;
     entries_[type].clear();
     for (base::ListValue::const_iterator iter = entries.begin();
          iter != entries.end(); ++iter) {
       std::string path;
       if ((*iter)->GetAsString(&path))
         entries_[type].push_back(path);
     }
   }
 
   void AddPropertyUpdate(const std::string& type, const std::string& path) {
-    if (type.empty())
-      return;
+    DCHECK(!type.empty());
     VLOG(2) << "AddPropertyUpdate: " << type;
     property_updates(type)[path] += 1;
   }
 
-  void AddInitialPropertyUpdate(const std::string& type,
-                                const std::string& path) {
-    if (type.empty())
-      return;
-    VLOG(2) << "AddInitialPropertyUpdate: " << type;
-    initial_property_updates(type)[path] += 1;
-  }
-
   void AddStateListUpdate(const std::string& type) {
-    if (type.empty())
-      return;
+    DCHECK(!type.empty());
     list_updates_[type] += 1;
   }
 
   // Map of list-type -> paths
   std::map<std::string, std::vector<std::string> > entries_;
   // Map of list-type -> map of paths -> update counts
   std::map<std::string, std::map<std::string, int> > property_updates_;
   std::map<std::string, std::map<std::string, int> > initial_property_updates_;
   // Map of list-type -> list update counts
   std::map<std::string, int > list_updates_;
@@ skipping 46 matching lines @@
     device_test_->AddDevice(id, type, id);
   }
 
   void RemoveDevice(const std::string& id) {
     device_test_->RemoveDevice(id);
   }
 
   void AddService(const std::string& type,
                   const std::string& id,
                   const std::string& state) {
+    VLOG(2) << "AddService: " << type << ": " << id << ": " << state;
     ASSERT_TRUE(IsValidType(type));
-    service_test_->AddService(id, id, type, state,
-                              true /* visible */);
+    service_test_->AddService(id, id, type, state, true /* visible */);
   }
 
   void AddServiceWithIPConfig(const std::string& type,
                               const std::string& id,
                               const std::string& state,
                               const std::string& ipconfig_path) {
     ASSERT_TRUE(IsValidType(type));
     service_test_->AddServiceWithIPConfig(id, /* service_path */
                                           "" /* guid */,
                                           id /* name */,
@@ skipping 133 matching lines @@
 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServicePropertyChanged) {
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             listener_->entries(shill::kServicesProperty).size());
 
   // Add a service.
   listener_->reset_list_updates();
   const std::string kTestServicePath("test_wifi_service1");
   AddService(shill::kTypeWifi, kTestServicePath, shill::kStateIdle);
   message_loop_.RunUntilIdle();
-  // Add should trigger a service list update and should update entries.
-  EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty));
+  // Add should trigger a service list update and update entries.
+  EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
   EXPECT_EQ(kNumShillManagerClientStubImplServices + 1,
             listener_->entries(shill::kServicesProperty).size());
   // Service receives an initial property update.
   EXPECT_EQ(1, listener_->initial_property_updates(
-      shill::kServicesProperty)[kTestServicePath]);
+      shill::kServiceCompleteListProperty)[kTestServicePath]);
   // Change a property.
   base::FundamentalValue scan_interval(3);
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(kTestServicePath),
       shill::kScanIntervalProperty,
       scan_interval,
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   // Property change triggers an update (but not a service list update).
   EXPECT_EQ(1, listener_->property_updates(
-      shill::kServicesProperty)[kTestServicePath]);
+      shill::kServiceCompleteListProperty)[kTestServicePath]);
 
-  // Remove a service.
+  // Remove a service. This will update the entries and signal a service list
+  // update.
   listener_->reset_list_updates();
   RemoveService(kTestServicePath);
   message_loop_.RunUntilIdle();
-  EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty));
+  EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             listener_->entries(shill::kServicesProperty).size());
 
   EXPECT_EQ(0, listener_->errors());
 }
 
 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerIPConfigPropertyChanged) {
   // Set the properties for an IP Config object.
   const std::string kTestIPConfigPath("test_ip_config_path");
 
@@ skipping 21 matching lines @@
       base::Bind(&DoNothingWithCallStatus));
   message_loop_.RunUntilIdle();
 
   // Add a service with an empty ipconfig and then update
   // its ipconfig property.
   const std::string kTestServicePath1("test_wifi_service1");
   AddService(shill::kTypeWifi, kTestServicePath1, shill::kStateIdle);
   message_loop_.RunUntilIdle();
   // This is the initial property update.
   EXPECT_EQ(1, listener_->initial_property_updates(
-      shill::kServicesProperty)[kTestServicePath1]);
+      shill::kServiceCompleteListProperty)[kTestServicePath1]);
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(kTestServicePath1),
       shill::kIPConfigProperty,
       base::StringValue(kTestIPConfigPath),
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   // IPConfig property change on the service should trigger an IPConfigs update.
   EXPECT_EQ(1, listener_->property_updates(
       shill::kIPConfigsProperty)[kTestIPConfigPath]);
 
   // Now, Add a new service with the IPConfig already set.
   const std::string kTestServicePath2("test_wifi_service2");
   AddServiceWithIPConfig(shill::kTypeWifi, kTestServicePath2,
                          shill::kStateIdle, kTestIPConfigPath);
   message_loop_.RunUntilIdle();
   // A service with the IPConfig property already set should trigger an
   // additional IPConfigs update.
   EXPECT_EQ(2, listener_->property_updates(
       shill::kIPConfigsProperty)[kTestIPConfigPath]);
 }
 
-TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceCompleteList) {
-  // Add a new entry to the profile only (triggers a Services update).
+TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServiceList) {
+  // Add an entry to the profile only.
   const std::string kTestServicePath1("stub_wifi_profile_only1");
   AddServiceToProfile(shill::kTypeWifi, kTestServicePath1, false /* visible */);
   message_loop_.RunUntilIdle();
 
   // Update the Manager properties. This should trigger a single list update
-  // for both Services and ServiceCompleteList, and a single property update
-  // for ServiceCompleteList.
+  // and a single initial property update.
   listener_->reset_list_updates();
   shill_property_handler_->UpdateManagerProperties();
   message_loop_.RunUntilIdle();
-  EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty));
   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
-  EXPECT_EQ(0, listener_->initial_property_updates(
-      shill::kServicesProperty)[kTestServicePath1]);
   EXPECT_EQ(1, listener_->initial_property_updates(
       shill::kServiceCompleteListProperty)[kTestServicePath1]);
-  EXPECT_EQ(0, listener_->property_updates(
-      shill::kServicesProperty)[kTestServicePath1]);
+
   EXPECT_EQ(0, listener_->property_updates(
       shill::kServiceCompleteListProperty)[kTestServicePath1]);
 
   // Add a new entry to the services and the profile; should also trigger a
-  // single list update for both Services and ServiceCompleteList, and should
-  // trigger tow property updates for Services (one when the Profile propety
-  // changes, and one for the Request) and one ServiceCompleteList change for
-  // the Request.
+  // service list update, and a property update.
   listener_->reset_list_updates();
   const std::string kTestServicePath2("stub_wifi_profile_only2");
   AddServiceToProfile(shill::kTypeWifi, kTestServicePath2, true);
   shill_property_handler_->UpdateManagerProperties();
   message_loop_.RunUntilIdle();
-  EXPECT_EQ(1, listener_->list_updates(shill::kServicesProperty));
   EXPECT_EQ(1, listener_->list_updates(shill::kServiceCompleteListProperty));
   EXPECT_EQ(1, listener_->initial_property_updates(
-      shill::kServicesProperty)[kTestServicePath2]);
-  EXPECT_EQ(1, listener_->initial_property_updates(
       shill::kServiceCompleteListProperty)[kTestServicePath2]);
-  // Expect one property update for the Profile property of the Network.
   EXPECT_EQ(1, listener_->property_updates(
-      shill::kServicesProperty)[kTestServicePath2]);
-  EXPECT_EQ(0, listener_->property_updates(
-      shill::kServiceCompleteListProperty)[kTestServicePath2]);
-
-  // Change a property of a Network in a Profile.
-  base::FundamentalValue scan_interval(3);
-  DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
-      dbus::ObjectPath(kTestServicePath2),
-      shill::kScanIntervalProperty,
-      scan_interval,
-      base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
-  message_loop_.RunUntilIdle();
-  // Property change should trigger an update for the Network only; no
-  // property updates pushed by Shill affect Favorites.
-  EXPECT_EQ(2, listener_->property_updates(
-      shill::kServicesProperty)[kTestServicePath2]);
-  EXPECT_EQ(0, listener_->property_updates(
       shill::kServiceCompleteListProperty)[kTestServicePath2]);
 }
 
 }  // namespace chromeos