Add DevicePropertiesUpdated to NetworkStateHandlerObserver

chromeos/network/network_state_handler_unittest.cc

Index: chromeos/network/network_state_handler_unittest.cc
diff --git a/chromeos/network/network_state_handler_unittest.cc b/chromeos/network/network_state_handler_unittest.cc
index 619a284f62944b31c685c55aa6c30956f7493949..74c9b6de4a6689abaec1b0b06ef5b4020460b6ec 100644
--- a/chromeos/network/network_state_handler_unittest.cc
+++ b/chromeos/network/network_state_handler_unittest.cc
@@ -14,9 +14,11 @@
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
+#include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
+#include "chromeos/network/device_state.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_handler_observer.h"
@@ -31,11 +33,16 @@ void ErrorCallbackFunction(const std::string& error_name,
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
+const std::string kShillManagerClientStubWifiDevice =
+    "/device/stub_wifi_device1";
+const std::string kShillManagerClientStubCellularDevice =
+    "/device/stub_cellular_device1";
 const std::string kShillManagerClientStubDefaultService = "/service/eth1";
 const std::string kShillManagerClientStubDefaultWifi = "/service/wifi1";
 const std::string kShillManagerClientStubWifi2 = "/service/wifi2";
 const std::string kShillManagerClientStubCellular = "/service/cellular1";
 
+using chromeos::DeviceState;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
@@ -95,6 +102,11 @@ class TestObserver : public chromeos::NetworkStateHandlerObserver {
     property_updates_[network->path()]++;
   }
 
+  virtual void DevicePropertiesUpdated(const DeviceState* device) OVERRIDE {
+    DCHECK(device);
+    device_property_updates_[device->path()]++;
+  }
+
   size_t device_list_changed_count() { return device_list_changed_count_; }
   size_t device_count() { return device_count_; }
   size_t network_list_changed_count() { return network_list_changed_count_; }
@@ -107,6 +119,11 @@ class TestObserver : public chromeos::NetworkStateHandlerObserver {
     default_network_change_count_ = 0;
     device_list_changed_count_ = 0;
     network_list_changed_count_ = 0;
+    connection_state_changes_.clear();
+  }
+  void reset_updates() {
+    property_updates_.clear();
+    device_property_updates_.clear();
   }
   std::string default_network() { return default_network_; }
   std::string default_network_connection_state() {
@@ -117,6 +134,10 @@ class TestObserver : public chromeos::NetworkStateHandlerObserver {
     return property_updates_[service_path];
   }
 
+  int PropertyUpdatesForDevice(const std::string& device_path) {
+    return device_property_updates_[device_path];
+  }
+
   int ConnectionStateChangesForService(const std::string& service_path) {
     return connection_state_changes_[service_path];
   }
@@ -136,6 +157,7 @@ class TestObserver : public chromeos::NetworkStateHandlerObserver {
   std::string default_network_;
   std::string default_network_connection_state_;
   std::map<std::string, int> property_updates_;
+  std::map<std::string, int> device_property_updates_;
   std::map<std::string, int> connection_state_changes_;
   std::map<std::string, std::string> network_connection_state_;
 
@@ -190,11 +212,10 @@ class NetworkStateHandlerTest : public testing::Test {
         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     ASSERT_TRUE(device_test_);
     device_test_->ClearDevices();
-    device_test_->AddDevice(
-        "/device/stub_wifi_device1", shill::kTypeWifi, "stub_wifi_device1");
-    device_test_->AddDevice("/device/stub_cellular_device1",
-                            shill::kTypeCellular,
-                            "stub_cellular_device1");
+    device_test_->AddDevice(kShillManagerClientStubWifiDevice,
+                            shill::kTypeWifi, "stub_wifi_device1");
+    device_test_->AddDevice(kShillManagerClientStubCellularDevice,
+                            shill::kTypeCellular, "stub_cellular_device1");
 
     manager_test_ =
         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
@@ -521,21 +542,23 @@ TEST_F(NetworkStateHandlerTest, GetState) {
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
-  // Change a network state.
   const std::string eth1 = kShillManagerClientStubDefaultService;
+  EXPECT_EQ(0, test_observer_->ConnectionStateChangesForService(eth1));
+
+  // Change a network state.
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(shill::kStateIdle,
             test_observer_->NetworkConnectionStateForService(eth1));
-  EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
+  EXPECT_EQ(1, test_observer_->ConnectionStateChangesForService(eth1));

[pneubeck (no reviews), 2014/07/16 21:43:35]

I'm confused, maybe because it's to late. Why did this result change?

[stevenjb, 2014/07/16 22:14:15]

reset_change_counts() which gets called in SetUp() now clears
connection_state_changes_. There is a single connection state change in SetUp
which we were implicitly accounting for here before (my bad).
 

   // Confirm that changing the connection state to the same value does *not*
   // signal the observer.
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
-  EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
+  EXPECT_EQ(1, test_observer_->ConnectionStateChangesForService(eth1));
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceDisconnected) {
@@ -713,4 +736,48 @@ TEST_F(NetworkStateHandlerTest, NetworkGuidNotInProfile) {
   EXPECT_EQ(wifi_guid, network->guid());
 }
 
+TEST_F(NetworkStateHandlerTest, DeviceListChanged) {
+  size_t stub_device_count = test_observer_->device_count();
+  // Add an additional device.
+  const std::string wifi_device = "/service/stub_wifi_device2";
+  device_test_->AddDevice(wifi_device, shill::kTypeWifi, "stub_wifi_device2");
+  UpdateManagerProperties();
+  // Expect a device list update.
+  EXPECT_EQ(stub_device_count + 1, test_observer_->device_count());
+  EXPECT_EQ(0, test_observer_->PropertyUpdatesForDevice(wifi_device));
+  // Change a device property.
+  device_test_->SetDeviceProperty(
+      wifi_device, shill::kScanningProperty, base::FundamentalValue(true));
+  UpdateManagerProperties();
+  EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(wifi_device));
+}
+
+TEST_F(NetworkStateHandlerTest, IPConfigChanged) {
+  test_observer_->reset_updates();
+  EXPECT_EQ(0, test_observer_->PropertyUpdatesForDevice(
+      kShillManagerClientStubWifiDevice));
+  EXPECT_EQ(0, test_observer_->PropertyUpdatesForService(
+      kShillManagerClientStubDefaultWifi));
+
+  // Change IPConfigs property.
+  ShillIPConfigClient::TestInterface* ip_config_test =
+      DBusThreadManager::Get()->GetShillIPConfigClient()->GetTestInterface();
+  const std::string kIPConfigPath = "test_ip_config";
+  base::DictionaryValue ip_config_properties;
+  ip_config_test->AddIPConfig(kIPConfigPath, ip_config_properties);
+  base::ListValue device_ip_configs;
+  device_ip_configs.Append(new base::StringValue(kIPConfigPath));
+  device_test_->SetDeviceProperty(
+      kShillManagerClientStubWifiDevice, shill::kIPConfigsProperty,
+      device_ip_configs);
+  service_test_->SetServiceProperty(
+      kShillManagerClientStubDefaultWifi, shill::kIPConfigProperty,
+      base::StringValue(kIPConfigPath));
+  UpdateManagerProperties();
+  EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(
+      kShillManagerClientStubWifiDevice));
+  EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
+      kShillManagerClientStubDefaultWifi));
+}
+
 }  // namespace chromeos