Add DevicePropertiesUpdated to NetworkStateHandlerObserver

chromeos/network/network_state_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/network_state_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #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"
 #include "dbus/object_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 void ErrorCallbackFunction(const std::string& error_name,
                            const std::string& error_message) {
   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;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
         device_list_changed_count_(0),
         device_count_(0),
         network_list_changed_count_(0),
@@ skipping 39 matching lines @@
       const NetworkState* network) OVERRIDE {
     network_connection_state_[network->path()] = network->connection_state();
     connection_state_changes_[network->path()]++;
   }
 
   virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE {
     DCHECK(network);
     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_; }
   size_t network_count() { return network_count_; }
   size_t default_network_change_count() {
     return default_network_change_count_;
   }
   void reset_change_counts() {
     DVLOG(1) << "=== RESET CHANGE COUNTS ===";
     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() {
     return default_network_connection_state_;
   }
 
   int PropertyUpdatesForService(const std::string& service_path) {
     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];
   }
 
   std::string NetworkConnectionStateForService(
       const std::string& service_path) {
     return network_connection_state_[service_path];
   }
 
  private:
   NetworkStateHandler* handler_;
   size_t device_list_changed_count_;
   size_t device_count_;
   size_t network_list_changed_count_;
   size_t network_count_;
   size_t default_network_change_count_;
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 }  // namespace
 
 namespace chromeos {
 
@@ skipping 34 matching lines @@
     service_test_->AddService(service_path, guid, name, type, state,
                               true /* add_to_visible */);
   }
 
   void SetupDefaultShillState() {
     message_loop_.RunUntilIdle();  // Process any pending updates
     device_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();
     ASSERT_TRUE(manager_test_);
 
     profile_test_ =
         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
     ASSERT_TRUE(profile_test_);
     profile_test_->ClearProfiles();
 
@@ skipping 306 matching lines @@
       network_state_handler_->GetNetworkStateFromGuid(wifi_network->guid());
   EXPECT_EQ(wifi_network, wifi_network_guid);
 
   // Remove the service, verify that there is no longer a NetworkState for it.
   service_test_->RemoveService(wifi_path);
   UpdateManagerProperties();
   EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path));
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
+  const std::string eth1 = kShillManagerClientStubDefaultService;
+  EXPECT_EQ(0, test_observer_->ConnectionStateChangesForService(eth1));
+
   // Change a network state.
-  const std::string eth1 = kShillManagerClientStubDefaultService;
   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) {
   const std::string eth1 = kShillManagerClientStubDefaultService;
   const std::string wifi1 = kShillManagerClientStubDefaultWifi;
 
   EXPECT_EQ(0u, test_observer_->default_network_change_count());
   // Disconnect ethernet.
   base::StringValue connection_state_idle_value(shill::kStateIdle);
   service_test_->SetServiceProperty(eth1, shill::kStateProperty,
@@ skipping 157 matching lines @@
   // the NetworkState was created with the same GUID.
   AddService(wifi_path, "" /* guid */, wifi_name,
              shill::kTypeWifi, shill::kStateOnline);
   UpdateManagerProperties();
   network = network_state_handler_->GetNetworkStateFromServicePath(
       wifi_path, is_service_configured);
   ASSERT_TRUE(network);
   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