Add TestInterface methods for adding shill stub devices and services

chromeos/dbus/shill_device_client.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/dbus/shill_device_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 170 matching lines @@
                           const base::Closure& callback,
                           const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(flimflam::kFlimflamDeviceInterface,
                                  shill::kSetCarrierFunction);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(carrier);
     GetHelper(device_path)->CallVoidMethodWithErrorCallback(
         &method_call, callback, error_callback);
   }
 
+  virtual TestInterface* GetTestInterface() OVERRIDE {
+    return NULL;
+  }
+
  private:
   typedef std::map<std::string, ShillClientHelper*> HelperMap;
 
   // Returns the corresponding ShillClientHelper for the profile.
   ShillClientHelper* GetHelper(const dbus::ObjectPath& device_path) {
     HelperMap::iterator it = helpers_.find(device_path.value());
     if (it != helpers_.end())
       return it->second;
 
     // There is no helper for the profile, create it.
     dbus::ObjectProxy* object_proxy =
         bus_->GetObjectProxy(flimflam::kFlimflamServiceName, device_path);
     ShillClientHelper* helper = new ShillClientHelper(bus_, object_proxy);
     helper->MonitorPropertyChanged(flimflam::kFlimflamDeviceInterface);
     helpers_.insert(HelperMap::value_type(device_path.value(), helper));
     return helper;
   }
 
   dbus::Bus* bus_;
   HelperMap helpers_;
   STLValueDeleter<HelperMap> helpers_deleter_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillDeviceClientImpl);
 };
 
 // A stub implementation of ShillDeviceClient.
 // Implemented: Stub cellular device for SMS testing.
-class ShillDeviceClientStubImpl : public ShillDeviceClient {
+class ShillDeviceClientStubImpl : public ShillDeviceClient,
+                                  public ShillDeviceClient::TestInterface {
  public:
   ShillDeviceClientStubImpl() : weak_ptr_factory_(this) {
-    // Add a cellular device for SMS. Note: name matches Manager entry.
-    const char kStubCellular1[] = "stub_cellular1";
-    base::DictionaryValue* cellular_properties = new base::DictionaryValue;
-    cellular_properties->SetWithoutPathExpansion(
-        flimflam::kTypeProperty,
-        base::Value::CreateStringValue(flimflam::kTypeCellular));
-    cellular_properties->SetWithoutPathExpansion(
-        flimflam::kDBusConnectionProperty,
-        base::Value::CreateStringValue("/stub"));
-    cellular_properties->SetWithoutPathExpansion(
-        flimflam::kDBusObjectProperty,
-        base::Value::CreateStringValue("/device/cellular1"));
-    stub_devices_.Set(kStubCellular1, cellular_properties);
-
-    // Create a second device stubbing a modem managed by
-    // ModemManager1 interfaces.
-    // Note: name matches Manager entry.
-    const char kStubCellular2[] = "stub_cellular2";
-    cellular_properties = new base::DictionaryValue;
-    cellular_properties->SetWithoutPathExpansion(
-        flimflam::kTypeProperty,
-        base::Value::CreateStringValue(flimflam::kTypeCellular));
-    cellular_properties->SetWithoutPathExpansion(
-        flimflam::kDBusConnectionProperty,
-        base::Value::CreateStringValue(":stub.0"));
-    cellular_properties->SetWithoutPathExpansion(
-        flimflam::kDBusObjectProperty,
-        base::Value::CreateStringValue(
-                "/org/freedesktop/ModemManager1/stub/0"));
-    stub_devices_.Set(kStubCellular2, cellular_properties);
+    SetDefaultProperties();
   }
 
   virtual ~ShillDeviceClientStubImpl() {}
 
-  ///////////////////////////////////
   // ShillDeviceClient overrides.
+
   virtual void AddPropertyChangedObserver(
       const dbus::ObjectPath& device_path,
       ShillPropertyChangedObserver* observer) OVERRIDE {}
 
   virtual void RemovePropertyChangedObserver(
       const dbus::ObjectPath& device_path,
       ShillPropertyChangedObserver* observer) OVERRIDE {}
 
   virtual void GetProperties(const dbus::ObjectPath& device_path,
                              const DictionaryValueCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ShillDeviceClientStubImpl::PassStubDeviceProperties,
                    weak_ptr_factory_.GetWeakPtr(),
                    device_path, callback));
   }
 
   virtual base::DictionaryValue* CallGetPropertiesAndBlock(
       const dbus::ObjectPath& device_path) OVERRIDE {
-    return new base::DictionaryValue;
+    base::DictionaryValue* device_properties = NULL;
+    stub_devices_.GetDictionaryWithoutPathExpansion(
+        device_path.value(), &device_properties);
+    return device_properties;
   }
 
   virtual void ProposeScan(const dbus::ObjectPath& device_path,
                            const VoidDBusMethodCallback& callback) OVERRIDE {
     PostVoidCallback(callback, DBUS_METHOD_CALL_SUCCESS);
   }
 
   virtual void SetProperty(const dbus::ObjectPath& device_path,
                            const std::string& name,
                            const base::Value& value,
@@ skipping 72 matching lines @@
     MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
   virtual void Register(const dbus::ObjectPath& device_path,
                         const std::string& network_id,
                         const base::Closure& callback,
                         const ErrorCallback& error_callback) OVERRIDE {
     MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
-  // ShillDeviceClient override.
   virtual void SetCarrier(const dbus::ObjectPath& device_path,
                           const std::string& carrier,
                           const base::Closure& callback,
                           const ErrorCallback& error_callback) OVERRIDE {
     MessageLoop::current()->PostTask(FROM_HERE, callback);
   }
 
+  virtual ShillDeviceClient::TestInterface* GetTestInterface() OVERRIDE {
+    return this;
+  }
+
+  // ShillDeviceClient::TestInterface overrides.
+
+  virtual void AddDevice(const std::string& device_path,
+                         const std::string& type,
+                         const std::string& object_path,
+                         const std::string& connection_path) OVERRIDE {
+    base::DictionaryValue* properties = GetDeviceProperties(device_path);
+    properties->SetWithoutPathExpansion(
+        flimflam::kTypeProperty,
+        base::Value::CreateStringValue(type));
+    properties->SetWithoutPathExpansion(
+        flimflam::kDBusObjectProperty,
+        base::Value::CreateStringValue(object_path));
+    properties->SetWithoutPathExpansion(
+        flimflam::kDBusConnectionProperty,
+        base::Value::CreateStringValue(connection_path));
+  }
+
+  virtual void RemoveDevice(const std::string& device_path) OVERRIDE {
+    stub_devices_.RemoveWithoutPathExpansion(device_path, NULL);
+  }
+
+  virtual void ClearDevices() OVERRIDE {
+    stub_devices_.Clear();
+  }
+
  private:
+  void SetDefaultProperties() {
+    // Add a wifi device. Note: path matches Manager entry.
+    AddDevice("stub_wifi_device1", flimflam::kTypeWifi,
+              "/device/wifi1", "/stub");
+
+    // Add a cellular device. Used in SMS stub. Note: path matches
+    // Manager entry.
+    AddDevice("stub_cellular_device1", flimflam::kTypeCellular,
+              "/device/cellular1", "/stub");
+  }
+
   void PassStubDeviceProperties(const dbus::ObjectPath& device_path,
-                               const DictionaryValueCallback& callback) const {
+                                const DictionaryValueCallback& callback) const {
     const base::DictionaryValue* device_properties = NULL;
-    if (!stub_devices_.GetDictionary(device_path.value(), &device_properties)) {
+    if (!stub_devices_.GetDictionaryWithoutPathExpansion(
+            device_path.value(), &device_properties)) {
       base::DictionaryValue empty_dictionary;
       callback.Run(DBUS_METHOD_CALL_FAILURE, empty_dictionary);
       return;
     }
     callback.Run(DBUS_METHOD_CALL_SUCCESS, *device_properties);
   }
 
   // Posts a task to run a void callback with status code |status|.
   void PostVoidCallback(const VoidDBusMethodCallback& callback,
                         DBusMethodCallStatus status) {
     MessageLoop::current()->PostTask(FROM_HERE,
                                      base::Bind(callback, status));
   }
 
+  base::DictionaryValue* GetDeviceProperties(const std::string& device_path) {
+    base::DictionaryValue* properties = NULL;
+    if (!stub_devices_.GetDictionaryWithoutPathExpansion(
+            device_path, &properties)) {
+      properties = new base::DictionaryValue;
+      stub_devices_.Set(device_path, properties);
+    }
+    return properties;
+  }
+
   // Dictionary of <device_name, Dictionary>.
   base::DictionaryValue stub_devices_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<ShillDeviceClientStubImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillDeviceClientStubImpl);
 };
 
 }  // namespace
 
 ShillDeviceClient::ShillDeviceClient() {}
 
 ShillDeviceClient::~ShillDeviceClient() {}
 
 // static
 ShillDeviceClient* ShillDeviceClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new ShillDeviceClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new ShillDeviceClientStubImpl();
 }
 
 }  // namespace chromeos