Add FlimflamProfileClientTest

chromeos/dbus/flimflam_client_unittest_base.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/flimflam_client_unittest_base.h"
 
 #include "base/bind.h"
+#include "base/json/json_writer.h"
 #include "base/values.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/values_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace chromeos {
 
 FlimflamClientUnittestBase::FlimflamClientUnittestBase(
-    const std::string& interface_name) : interface_name_(interface_name) {
+    const std::string& interface_name,
+    const dbus::ObjectPath& object_path)
+    : interface_name_(interface_name),
+      object_path_(object_path) {
 }
 
 FlimflamClientUnittestBase::~FlimflamClientUnittestBase() {
 }
 
 void FlimflamClientUnittestBase::SetUp() {
   // Create a mock bus.
   dbus::Bus::Options options;
   options.bus_type = dbus::Bus::SYSTEM;
   mock_bus_ = new dbus::MockBus(options);
 
   // Create a mock proxy.
   mock_proxy_ = new dbus::MockObjectProxy(
       mock_bus_.get(),
       flimflam::kFlimflamServiceName,
-      dbus::ObjectPath(flimflam::kFlimflamServicePath));
+      object_path_);
 
   // Set an expectation so mock_proxy's CallMethod() will use OnCallMethod()
   // to return responses.
   EXPECT_CALL(*mock_proxy_, CallMethod(_, _, _))
       .WillRepeatedly(Invoke(this, &FlimflamClientUnittestBase::OnCallMethod));
 
   // Set an expectation so mock_proxy's ConnectToSignal() will use
   // OnConnectToSignal() to run the callback.
   EXPECT_CALL(*mock_proxy_, ConnectToSignal(
       interface_name_,
       flimflam::kMonitorPropertyChanged, _, _))
       .WillRepeatedly(Invoke(this,
                              &FlimflamClientUnittestBase::OnConnectToSignal));
 
   // Set an expectation so mock_bus's GetObjectProxy() for the given
   // service name and the object path will return mock_proxy_.
-  EXPECT_CALL(*mock_bus_, GetObjectProxy(
-      flimflam::kFlimflamServiceName,
-      dbus::ObjectPath(flimflam::kFlimflamServicePath)))
+  EXPECT_CALL(*mock_bus_, GetObjectProxy(flimflam::kFlimflamServiceName,
+                                         object_path_))
       .WillOnce(Return(mock_proxy_.get()));
 
   // ShutdownAndBlock() will be called in TearDown().
   EXPECT_CALL(*mock_bus_, ShutdownAndBlock()).WillOnce(Return());
 }
 
 void FlimflamClientUnittestBase::TearDown() {
   mock_bus_->ShutdownAndBlock();
 }
 
@@ skipping 75 matching lines @@
   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
   EXPECT_EQ(expected_result, result);
 }
 
 // static
 void FlimflamClientUnittestBase::ExpectDictionaryValueResult(
     const base::DictionaryValue* expected_result,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& result) {
   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
-  EXPECT_TRUE(expected_result->Equals(&result));
+  std::string expected_result_string;
+  base::JSONWriter::Write(expected_result, &expected_result_string);
+  std::string result_string;
+  base::JSONWriter::Write(&result, &result_string);
+  EXPECT_EQ(expected_result_string, result_string);
 }
 
 void FlimflamClientUnittestBase::OnConnectToSignal(
     const std::string& interface_name,
     const std::string& signal_name,
     const dbus::ObjectProxy::SignalCallback& signal_callback,
     const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
   property_changed_handler_ = signal_callback;
   const bool success = true;
   message_loop_.PostTask(FROM_HERE,
                          base::Bind(on_connected_callback,
                                     interface_name,
                                     signal_name,
                                     success));
 }
 
 void FlimflamClientUnittestBase::OnCallMethod(
     dbus::MethodCall* method_call,
     int timeout_ms,
     const dbus::ObjectProxy::ResponseCallback& response_callback) {
   EXPECT_EQ(interface_name_, method_call->GetInterface());
   EXPECT_EQ(expected_method_name_, method_call->GetMember());
   dbus::MessageReader reader(method_call);
   argument_checker_.Run(&reader);
   message_loop_.PostTask(FROM_HERE,
                          base::Bind(response_callback, response_));
 }
 
 }  // namespace chromeos