NetworkChangeNotifierChromeos: Handle IPConfig property changes on the default network

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>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/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_service_client.h"
 #include "dbus/object_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
+void DoNothingWithCallStatus(DBusMethodCallStatus call_status) {
+}
+
 void ErrorCallbackFunction(const std::string& error_name,
                            const std::string& error_message) {
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 class TestListener : public internal::ShillPropertyHandler::Listener {
  public:
   TestListener() : manager_updates_(0), errors_(0) {
   }
 
@@ skipping 20 matching lines @@
       const std::string& device_path,
       const std::string& key,
       const base::Value& value) OVERRIDE {
     AddPropertyUpdate(flimflam::kDevicesProperty, device_path);
   }
 
   virtual void ManagerPropertyChanged() OVERRIDE {
     ++manager_updates_;
   }
 
-  virtual void UpdateNetworkServiceIPAddress(
-      const std::string& service_path,
-      const std::string& ip_address) OVERRIDE {
-    AddPropertyUpdate(flimflam::kServicesProperty, service_path);
-  }
-
   virtual void ManagedStateListChanged(
       ManagedState::ManagedType type) OVERRIDE {
     AddStateListUpdate(GetTypeString(type));
   }
 
   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];
@@ skipping 67 matching lines @@
     // default stub properties.
     manager_test_ =
         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
     ASSERT_TRUE(manager_test_);
     device_test_ =
         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     ASSERT_TRUE(device_test_);
     service_test_ =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     ASSERT_TRUE(service_test_);
+    SetupShillPropertyHandler();
+    message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     shill_property_handler_.reset();
     listener_.reset();
     DBusThreadManager::Shutdown();
   }
 
   void AddDevice(const std::string& type, const std::string& id) {
     ASSERT_TRUE(IsValidType(type));
     device_test_->AddDevice(id, type, std::string("/device/" + 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,
                   bool add_to_watch_list) {
     ASSERT_TRUE(IsValidType(type));
-    service_test_->AddService(id, id, type, state, add_to_watch_list);
+    service_test_->AddService(id, id, type, state,
+                              add_to_watch_list);
+  }
+
+  void AddServiceWithIPConfig(const std::string& type,
+                              const std::string& id,
+                              const std::string& state,
+                              const std::string& ipconfig_path,
+                              bool add_to_watch_list) {
+    ASSERT_TRUE(IsValidType(type));
+    service_test_->AddServiceWithIPConfig(id, id, type, state,
+                                          ipconfig_path, add_to_watch_list);
   }
 
   void RemoveService(const std::string& id) {
     service_test_->RemoveService(id);
   }
 
   // Call this after any initial Shill client setup
   void SetupShillPropertyHandler() {
     SetupDefaultShillState();
     listener_.reset(new TestListener);
@@ skipping 34 matching lines @@
   scoped_ptr<internal::ShillPropertyHandler> shill_property_handler_;
   ShillManagerClient::TestInterface* manager_test_;
   ShillDeviceClient::TestInterface* device_test_;
   ShillServiceClient::TestInterface* service_test_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShillPropertyHandlerTest);
 };
 
 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerStub) {
-  SetupShillPropertyHandler();
-  message_loop_.RunUntilIdle();
   EXPECT_EQ(1, listener_->manager_updates());
   EXPECT_TRUE(shill_property_handler_->TechnologyAvailable(
       flimflam::kTypeWifi));
   EXPECT_TRUE(shill_property_handler_->TechnologyEnabled(
       flimflam::kTypeWifi));
   const size_t kNumShillManagerClientStubImplDevices = 2;
   EXPECT_EQ(kNumShillManagerClientStubImplDevices,
             listener_->entries(flimflam::kDevicesProperty).size());
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             listener_->entries(flimflam::kServicesProperty).size());
 
   EXPECT_EQ(0, listener_->errors());
 }
 
 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerTechnologyChanged) {
-  SetupShillPropertyHandler();
-  message_loop_.RunUntilIdle();
   EXPECT_EQ(1, listener_->manager_updates());
   // Add a disabled technology.
   manager_test_->AddTechnology(flimflam::kTypeWimax, false);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, listener_->manager_updates());
   EXPECT_TRUE(shill_property_handler_->TechnologyAvailable(
       flimflam::kTypeWimax));
   EXPECT_FALSE(shill_property_handler_->TechnologyEnabled(
       flimflam::kTypeWimax));
 
   // Enable the technology.
   DBusThreadManager::Get()->GetShillManagerClient()->EnableTechnology(
       flimflam::kTypeWimax,
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(3, listener_->manager_updates());
   EXPECT_TRUE(shill_property_handler_->TechnologyEnabled(
       flimflam::kTypeWimax));
 
   EXPECT_EQ(0, listener_->errors());
 }
 
 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerDevicePropertyChanged) {
-  SetupShillPropertyHandler();
-  message_loop_.RunUntilIdle();
   EXPECT_EQ(1, listener_->manager_updates());
   EXPECT_EQ(1, listener_->list_updates(flimflam::kDevicesProperty));
   const size_t kNumShillManagerClientStubImplDevices = 2;
   EXPECT_EQ(kNumShillManagerClientStubImplDevices,
             listener_->entries(flimflam::kDevicesProperty).size());
   // Add a device.
   const std::string kTestDevicePath("test_wifi_device1");
   AddDevice(flimflam::kTypeWifi, kTestDevicePath);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(1, listener_->manager_updates());  // No new manager updates.
   EXPECT_EQ(2, listener_->list_updates(flimflam::kDevicesProperty));
   EXPECT_EQ(kNumShillManagerClientStubImplDevices + 1,
             listener_->entries(flimflam::kDevicesProperty).size());
   // Device changes are not observed.
   // Remove a device
   RemoveDevice(kTestDevicePath);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(3, listener_->list_updates(flimflam::kDevicesProperty));
   EXPECT_EQ(kNumShillManagerClientStubImplDevices,
             listener_->entries(flimflam::kDevicesProperty).size());
 
   EXPECT_EQ(0, listener_->errors());
 }
 
 TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerServicePropertyChanged) {
-  SetupShillPropertyHandler();
-  message_loop_.RunUntilIdle();
   EXPECT_EQ(1, listener_->manager_updates());
   EXPECT_EQ(1, listener_->list_updates(flimflam::kServicesProperty));
   const size_t kNumShillManagerClientStubImplServices = 4;
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             listener_->entries(flimflam::kServicesProperty).size());
 
   // Add an unwatched service.
   const std::string kTestServicePath("test_wifi_service1");
   AddService(flimflam::kTypeWifi, kTestServicePath,
              flimflam::kStateIdle, false);
@@ skipping 42 matching lines @@
   // Remove a service
   RemoveService(kTestServicePath);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(3, listener_->list_updates(flimflam::kServicesProperty));
   EXPECT_EQ(kNumShillManagerClientStubImplServices,
             listener_->entries(flimflam::kServicesProperty).size());
 
   EXPECT_EQ(0, listener_->errors());
 }
 
-// TODO(stevenjb): Test IP Configs.
+TEST_F(ShillPropertyHandlerTest, ShillPropertyHandlerIPConfigPropertyChanged) {
+  // Set the properties for an IP Config object.
+  const std::string kTestIPConfigPath("test_ip_config_path");
+  base::StringValue ip_address("192.168.1.1");
+  DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
+      dbus::ObjectPath(kTestIPConfigPath),
+      flimflam::kAddressProperty,
+      ip_address,
+      base::Bind(&DoNothingWithCallStatus));
+  base::ListValue dns_servers;
+  dns_servers.Append(base::Value::CreateStringValue("192.168.1.100"));
+  dns_servers.Append(base::Value::CreateStringValue("192.168.1.101"));
+  DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
+      dbus::ObjectPath(kTestIPConfigPath),
+      flimflam::kNameServersProperty,
+      dns_servers,
+      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(flimflam::kTypeWifi, kTestServicePath1,
+             flimflam::kStateIdle, true);
+  message_loop_.RunUntilIdle();
+  // This is the initial property update.
+  EXPECT_EQ(1, listener_->
+            property_updates(flimflam::kServicesProperty)[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 property updates for
+  // IP Address and DNS.
+  EXPECT_EQ(3, listener_->
+            property_updates(flimflam::kServicesProperty)[kTestServicePath1]);
+
+  // Now, Add a new watched service with the IPConfig already set.
+  const std::string kTestServicePath2("test_wifi_service2");
+  AddServiceWithIPConfig(flimflam::kTypeWifi, kTestServicePath2,
+                         flimflam::kStateIdle, kTestIPConfigPath, true);
+  message_loop_.RunUntilIdle();
+  // A watched service with the IPConfig property already set must
+  // trigger property updates for IP Address and DNS when added.
+  EXPECT_EQ(3, listener_->
+            property_updates(flimflam::kServicesProperty)[kTestServicePath2]);
+}
 
 }  // namespace chromeos