Add FlimflamProfileClientTest

BUG=chromium-os:16557
TEST=chromeos_unittests --gtest_filter="FlimflamProfileClientTest.*"

Review URL: https://chromiumcodereview.appspot.com/10038011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@132513 0039d316-1c4b-4281-b951-d872f2087c98

chromeos/chromeos.gyp

@@ -148,6 +148,7 @@
         'dbus/flimflam_client_unittest_base.h',
         'dbus/flimflam_manager_client_unittest.cc',
         'dbus/flimflam_network_client_unittest.cc',
+        'dbus/flimflam_profile_client_unittest.cc',
       ],
       'include_dirs': [
         '..',

chromeos/dbus/flimflam_client_unittest_base.cc

@@ -5,6 +5,7 @@
 #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"
@@ -20,7 +21,10 @@ 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() {
@@ -36,7 +40,7 @@ void FlimflamClientUnittestBase::SetUp() {
   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.
@@ -53,9 +57,8 @@ void FlimflamClientUnittestBase::SetUp() {
 
   // 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().
@@ -151,7 +154,11 @@ void FlimflamClientUnittestBase::ExpectDictionaryValueResult(
     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(

chromeos/dbus/flimflam_client_unittest_base.h

@@ -34,7 +34,8 @@ namespace chromeos {
 // A class to provide functionalities needed for testing Flimflam D-Bus clients.
 class FlimflamClientUnittestBase : public testing::Test {
  public:
-  explicit FlimflamClientUnittestBase(const std::string& interface_name);
+  explicit FlimflamClientUnittestBase(const std::string& interface_name,
+                                      const dbus::ObjectPath& object_path);
   virtual ~FlimflamClientUnittestBase();
 
   virtual void SetUp() OVERRIDE;
@@ -112,6 +113,8 @@ class FlimflamClientUnittestBase : public testing::Test {
 
   // The interface name.
   const std::string interface_name_;
+  // The object path.
+  const dbus::ObjectPath object_path_;
   // The mock object proxy.
   scoped_refptr<dbus::MockObjectProxy> mock_proxy_;
   // The PropertyChanged signal handler given by the tested client.

chromeos/dbus/flimflam_manager_client_unittest.cc

@@ -99,7 +99,9 @@ base::DictionaryValue* CreateExampleProperties() {
 class FlimflamManagerClientTest : public FlimflamClientUnittestBase {
  public:
   FlimflamManagerClientTest()
-      : FlimflamClientUnittestBase(flimflam::kFlimflamManagerInterface) {
+      : FlimflamClientUnittestBase(
+          flimflam::kFlimflamManagerInterface,
+          dbus::ObjectPath(flimflam::kFlimflamServicePath)) {
   }
 
   virtual void SetUp() {

chromeos/dbus/flimflam_network_client_unittest.cc

@@ -16,7 +16,9 @@ namespace chromeos {
 class FlimflamNetworkClientTest : public FlimflamClientUnittestBase {
  public:
   FlimflamNetworkClientTest()
-      : FlimflamClientUnittestBase(flimflam::kFlimflamNetworkInterface) {
+      : FlimflamClientUnittestBase(
+          flimflam::kFlimflamNetworkInterface,
+          dbus::ObjectPath(flimflam::kFlimflamServicePath)) {
   }
 
   virtual void SetUp() {

chromeos/dbus/flimflam_profile_client_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 "base/bind.h"
+#include "base/values.h"
+#include "chromeos/dbus/flimflam_client_unittest_base.h"
+#include "chromeos/dbus/flimflam_profile_client.h"
+#include "dbus/message.h"
+#include "dbus/object_path.h"
+#include "dbus/values_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+namespace {
+
+const char kDefaultProfilePath[] = "/profile/default";
+const char kExampleEntryPath[] = "example_entry_path";
+
+void AppendVariantOfArrayOfStrings(dbus::MessageWriter* writer,
+                                   const std::vector<std::string>& strings) {
+  dbus::MessageWriter variant_writer(NULL);
+  writer->OpenVariant("as", &variant_writer);
+  variant_writer.AppendArrayOfStrings(strings);
+  writer->CloseContainer(&variant_writer);
+}
+
+}  // namespace
+
+class FlimflamProfileClientTest : public FlimflamClientUnittestBase {
+ public:
+  FlimflamProfileClientTest()
+      : FlimflamClientUnittestBase(flimflam::kFlimflamProfileInterface,
+                                   dbus::ObjectPath(kDefaultProfilePath)) {
+  }
+
+  virtual void SetUp() {
+    FlimflamClientUnittestBase::SetUp();
+    // Create a client with the mock bus.
+    client_.reset(FlimflamProfileClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION,
+                                                mock_bus_));
+    // Run the message loop to run the signal connection result callback.
+    message_loop_.RunAllPending();
+  }
+
+  virtual void TearDown() {
+    FlimflamClientUnittestBase::TearDown();
+  }
+
+ protected:
+  scoped_ptr<FlimflamProfileClient> client_;
+};
+
+TEST_F(FlimflamProfileClientTest, PropertyChanged) {
+  // Create a signal.
+  dbus::Signal signal(flimflam::kFlimflamProfileInterface,
+                      flimflam::kMonitorPropertyChanged);
+  dbus::MessageWriter writer(&signal);
+  writer.AppendString(flimflam::kEntriesProperty);
+  AppendVariantOfArrayOfStrings(&writer,
+                                std::vector<std::string>(1, kExampleEntryPath));
+
+  // Set expectations.
+  base::ListValue* value = new base::ListValue;
+  value->Append(base::Value::CreateStringValue(kExampleEntryPath));
+
+  client_->SetPropertyChangedHandler(dbus::ObjectPath(kDefaultProfilePath),
+                                     base::Bind(&ExpectPropertyChanged,
+                                                flimflam::kEntriesProperty,
+                                                value));
+  // Run the signal callback.
+  SendPropertyChangedSignal(&signal);
+
+  // Reset the handler.
+  client_->ResetPropertyChangedHandler(dbus::ObjectPath(kDefaultProfilePath));
+}
+
+TEST_F(FlimflamProfileClientTest, GetProperties) {
+  // Create response.
+  scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  dbus::MessageWriter array_writer(NULL);
+  writer.OpenArray("{sv}", &array_writer);
+  dbus::MessageWriter entry_writer(NULL);
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kEntriesProperty);
+  AppendVariantOfArrayOfStrings(&entry_writer,
+                                std::vector<std::string>(1, kExampleEntryPath));
+  array_writer.CloseContainer(&entry_writer);
+  writer.CloseContainer(&array_writer);
+
+  // Create the expected value.
+  base::ListValue* entries = new base::ListValue;
+  entries->Append(base::Value::CreateStringValue(kExampleEntryPath));
+  base::DictionaryValue value;
+  value.SetWithoutPathExpansion(flimflam::kEntriesProperty, entries);
+  // Set expectations.
+  PrepareForMethodCall(flimflam::kGetPropertiesFunction,
+                       base::Bind(&ExpectNoArgument),
+                       response.get());
+  // Call method.
+  client_->GetProperties(dbus::ObjectPath(kDefaultProfilePath),
+                         base::Bind(&ExpectDictionaryValueResult, &value));
+  // Run the message loop.
+  message_loop_.RunAllPending();
+}
+
+TEST_F(FlimflamProfileClientTest, GetEntry) {
+  // Create response.
+  scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  dbus::MessageWriter array_writer(NULL);
+  writer.OpenArray("{sv}", &array_writer);
+  dbus::MessageWriter entry_writer(NULL);
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kTypeProperty);
+  entry_writer.AppendVariantOfString(flimflam::kTypeWifi);
+  array_writer.CloseContainer(&entry_writer);
+  writer.CloseContainer(&array_writer);
+
+  // Create the expected value.
+  base::DictionaryValue value;
+  value.SetWithoutPathExpansion(
+      flimflam::kTypeProperty,
+      base::Value::CreateStringValue(flimflam::kTypeWifi));
+  // Set expectations.
+  PrepareForMethodCall(flimflam::kGetEntryFunction,
+                       base::Bind(&ExpectStringArgument, kExampleEntryPath),
+                       response.get());
+  // Call method.
+  client_->GetEntry(dbus::ObjectPath(kDefaultProfilePath),
+                    kExampleEntryPath,
+                    base::Bind(&ExpectDictionaryValueResult, &value));
+  // Run the message loop.
+  message_loop_.RunAllPending();
+}
+
+TEST_F(FlimflamProfileClientTest, DeleteEntry) {
+  // Create response.
+  scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+
+  // Create the expected value.
+  base::DictionaryValue value;
+  value.SetWithoutPathExpansion(flimflam::kOfflineModeProperty,
+                                base::Value::CreateBooleanValue(true));
+  // Set expectations.
+  PrepareForMethodCall(flimflam::kDeleteEntryFunction,
+                       base::Bind(&ExpectStringArgument, kExampleEntryPath),
+                       response.get());
+  // Call method.
+  client_->DeleteEntry(dbus::ObjectPath(kDefaultProfilePath),
+                       kExampleEntryPath,
+                       base::Bind(&ExpectNoResultValue));
+  // Run the message loop.
+  message_loop_.RunAllPending();
+}
+
+}  // namespace chromeos