Add FlimflamNetworkClientTest

Add chromeos::FlimflamClientUnittestBase

TEST=unit_tests --gtest_filter="FlimflamNetworkClientTest.*"
BUG=chromium-os:16557

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

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

4 files changed, 423 insertions, 0 deletions

diff --git a/chrome/browser/chromeos/dbus/flimflam_client_unittest_base.cc b/chrome/browser/chromeos/dbus/flimflam_client_unittest_base.cc
new file mode 100644
index 0000000..981ded3
--- /dev/null
+++ b/chrome/browser/chromeos/dbus/flimflam_client_unittest_base.cc
@@ -0,0 +1,173 @@
+// 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 "chrome/browser/chromeos/dbus/flimflam_client_unittest_base.h"
+
+#include "base/bind.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) {
+}
+
+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));
+
+  // 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)))
+      .WillOnce(Return(mock_proxy_.get()));
+
+  // ShutdownAndBlock() will be called in TearDown().
+  EXPECT_CALL(*mock_bus_, ShutdownAndBlock()).WillOnce(Return());
+}
+
+void FlimflamClientUnittestBase::TearDown() {
+  mock_bus_->ShutdownAndBlock();
+}
+
+void FlimflamClientUnittestBase::PrepareForMethodCall(
+    const std::string& method_name,
+    ArgumentCheckCallback argument_checker,
+    dbus::Response* response) {
+  expected_method_name_ = method_name;
+  argument_checker_ = argument_checker;
+  response_ = response;
+}
+
+void FlimflamClientUnittestBase::SendPropertyChangedSignal(
+    dbus::Signal* signal) {
+  ASSERT_FALSE(property_changed_handler_.is_null());
+  property_changed_handler_.Run(signal);
+}
+
+// static
+void FlimflamClientUnittestBase::ExpectPropertyChanged(
+    const std::string& expected_name,
+    const base::Value* expected_value,
+    const std::string& name,
+    const base::Value& value) {
+  EXPECT_EQ(expected_name, name);
+  EXPECT_TRUE(expected_value->Equals(&value));
+}
+
+// static
+void FlimflamClientUnittestBase::ExpectNoArgument(dbus::MessageReader* reader) {
+  EXPECT_FALSE(reader->HasMoreData());
+}
+
+// static
+void FlimflamClientUnittestBase::ExpectStringArgument(
+    const std::string& expected_string,
+    dbus::MessageReader* reader) {
+  std::string str;
+  ASSERT_TRUE(reader->PopString(&str));
+  EXPECT_EQ(expected_string, str);
+  EXPECT_FALSE(reader->HasMoreData());
+}
+
+// static
+void FlimflamClientUnittestBase::ExpectValueArgument(
+    const base::Value* expected_value,
+    dbus::MessageReader* reader) {
+  scoped_ptr<base::Value> value(dbus::PopDataAsValue(reader));
+  ASSERT_TRUE(value.get());
+  EXPECT_TRUE(value->Equals(expected_value));
+  EXPECT_FALSE(reader->HasMoreData());
+}
+
+// static
+void FlimflamClientUnittestBase::ExpectStringAndValueArguments(
+    const std::string& expected_string,
+    const base::Value* expected_value,
+    dbus::MessageReader* reader) {
+  std::string str;
+  ASSERT_TRUE(reader->PopString(&str));
+  EXPECT_EQ(expected_string, str);
+  scoped_ptr<base::Value> value(dbus::PopDataAsValue(reader));
+  ASSERT_TRUE(value.get());
+  EXPECT_TRUE(value->Equals(expected_value));
+  EXPECT_FALSE(reader->HasMoreData());
+}
+
+// static
+void FlimflamClientUnittestBase::ExpectNoResultValue(
+    DBusMethodCallStatus call_status) {
+  EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
+}
+
+// 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));
+}
+
+void FlimflamClientUnittestBase::OnConnectToSignal(
+    const std::string& interface_name,
+    const std::string& signal_name,
+    dbus::ObjectProxy::SignalCallback signal_callback,
+    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,
+    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
diff --git a/chrome/browser/chromeos/dbus/flimflam_client_unittest_base.h b/chrome/browser/chromeos/dbus/flimflam_client_unittest_base.h
new file mode 100644
index 0000000..cf59bb1
--- /dev/null
+++ b/chrome/browser/chromeos/dbus/flimflam_client_unittest_base.h
@@ -0,0 +1,123 @@
+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_DBUS_FLIMFLAM_CLIENT_UNITTEST_BASE_H_
+#define CHROME_BROWSER_CHROMEOS_DBUS_FLIMFLAM_CLIENT_UNITTEST_BASE_H_
+
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "chrome/browser/chromeos/dbus/dbus_method_call_status.h"
+#include "dbus/mock_bus.h"
+#include "dbus/mock_object_proxy.h"
+#include "dbus/object_proxy.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+class Value;
+class DictionaryValue;
+
+}  // namespace base
+
+namespace dbus {
+
+class MessageReader;
+
+}  // namespace dbus
+
+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);
+  virtual ~FlimflamClientUnittestBase();
+
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
+
+ protected:
+  // A callback to intercept and check the method call arguments.
+  typedef base::Callback<void(
+      dbus::MessageReader* reader)> ArgumentCheckCallback;
+
+  // Sets expectations for called method name and arguments, and sets response.
+  void PrepareForMethodCall(const std::string& method_name,
+                            ArgumentCheckCallback argument_checker,
+                            dbus::Response* response);
+
+  // Sends property changed signal to the tested client.
+  void SendPropertyChangedSignal(dbus::Signal* signal);
+
+  // Checks the name and the value which are sent by PropertyChanged signal.
+  static void ExpectPropertyChanged(const std::string& expected_name,
+                                    const base::Value* expected_value,
+                                    const std::string& name,
+                                    const base::Value& value);
+
+  // Expects the reader to be empty.
+  static void ExpectNoArgument(dbus::MessageReader* reader);
+
+  // Expects the reader to have a string.
+  static void ExpectStringArgument(const std::string& expected_string,
+                                   dbus::MessageReader* reader);
+
+  // Expects the reader to have a Value.
+  static void ExpectValueArgument(const base::Value* expected_value,
+                                  dbus::MessageReader* reader);
+
+  // Expects the reader to have a string and a Value.
+  static void ExpectStringAndValueArguments(const std::string& expected_string,
+                                            const base::Value* expected_value,
+                                            dbus::MessageReader* reader);
+
+  // Expects the call status to be SUCCESS.
+  static void ExpectNoResultValue(DBusMethodCallStatus call_status);
+
+  // Checks the result and expects the call status to be SUCCESS.
+  static void ExpectDictionaryValueResult(
+      const base::DictionaryValue* expected_result,
+      DBusMethodCallStatus call_status,
+      const base::DictionaryValue& result);
+
+  // A message loop to emulate asynchronous behavior.
+  MessageLoop message_loop_;
+  // The mock bus.
+  scoped_refptr<dbus::MockBus> mock_bus_;
+
+ private:
+  // Checks the requested interface name and signal name.
+  // Used to implement the mock proxy.
+  void OnConnectToSignal(
+      const std::string& interface_name,
+      const std::string& signal_name,
+      dbus::ObjectProxy::SignalCallback signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback);
+
+  // Checks the content of the method call and returns the response.
+  // Used to implement the mock proxy.
+  void OnCallMethod(dbus::MethodCall* method_call,
+                    int timeout_ms,
+                    dbus::ObjectProxy::ResponseCallback response_callback);
+
+  // The interface name.
+  const std::string interface_name_;
+  // The mock object proxy.
+  scoped_refptr<dbus::MockObjectProxy> mock_proxy_;
+  // The PropertyChanged signal handler given by the tested client.
+  dbus::ObjectProxy::SignalCallback property_changed_handler_;
+  // The name of the method which is expected to be called.
+  std::string expected_method_name_;
+  // The response which the mock object proxy returns.
+  dbus::Response* response_;
+  // A callback to intercept and check the method call arguments.
+  ArgumentCheckCallback argument_checker_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_DBUS_FLIMFLAM_CLIENT_UNITTEST_BASE_H_
diff --git a/chrome/browser/chromeos/dbus/flimflam_network_client_unittest.cc b/chrome/browser/chromeos/dbus/flimflam_network_client_unittest.cc
new file mode 100644
index 0000000..8b9b4ef1
--- /dev/null
+++ b/chrome/browser/chromeos/dbus/flimflam_network_client_unittest.cc
@@ -0,0 +1,124 @@
+// 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 "chrome/browser/chromeos/dbus/flimflam_client_unittest_base.h"
+#include "chrome/browser/chromeos/dbus/flimflam_network_client.h"
+#include "dbus/message.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 {
+
+class FlimflamNetworkClientTest : public FlimflamClientUnittestBase {
+ public:
+  FlimflamNetworkClientTest()
+      : FlimflamClientUnittestBase(flimflam::kFlimflamNetworkInterface) {
+  }
+
+  virtual void SetUp() {
+    FlimflamClientUnittestBase::SetUp();
+    // Create a client with the mock bus.
+    client_.reset(FlimflamNetworkClient::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<FlimflamNetworkClient> client_;
+};
+
+TEST_F(FlimflamNetworkClientTest, PropertyChanged) {
+  // Create a signal.
+  const base::FundamentalValue kConnected(true);
+  dbus::Signal signal(flimflam::kFlimflamNetworkInterface,
+                      flimflam::kMonitorPropertyChanged);
+  dbus::MessageWriter writer(&signal);
+  writer.AppendString(flimflam::kConnectedProperty);
+  dbus::AppendBasicTypeValueDataAsVariant(&writer, kConnected);
+
+  // Set expectations.
+  client_->SetPropertyChangedHandler(base::Bind(&ExpectPropertyChanged,
+                                                flimflam::kConnectedProperty,
+                                                &kConnected));
+  // Run the signal callback.
+  SendPropertyChangedSignal(&signal);
+
+  // Reset the handler.
+  client_->ResetPropertyChangedHandler();
+}
+
+TEST_F(FlimflamNetworkClientTest, GetProperties) {
+  const char kAddress[] = "address";
+  const char kName[] = "name";
+  const uint8 kSignalStrength = 1;
+  const uint32 kWifiChannel = 1;
+  const bool kConnected = true;
+
+  // 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);
+  // Append address.
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kAddressProperty);
+  entry_writer.AppendVariantOfString(kAddress);
+  array_writer.CloseContainer(&entry_writer);
+  // Append name.
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kNameProperty);
+  entry_writer.AppendVariantOfString(kName);
+  array_writer.CloseContainer(&entry_writer);
+  // Append signal strength.
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kSignalStrengthProperty);
+  entry_writer.AppendVariantOfByte(kSignalStrength);
+  array_writer.CloseContainer(&entry_writer);
+  // Append Wifi channel.
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kWifiChannelProperty);
+  entry_writer.AppendVariantOfUint32(kWifiChannel);
+  array_writer.CloseContainer(&entry_writer);
+  // Append connected.
+  array_writer.OpenDictEntry(&entry_writer);
+  entry_writer.AppendString(flimflam::kConnectedProperty);
+  entry_writer.AppendVariantOfBool(kConnected);
+  array_writer.CloseContainer(&entry_writer);
+  writer.CloseContainer(&array_writer);
+
+  // Create the expected value.
+  base::DictionaryValue value;
+  value.SetWithoutPathExpansion(flimflam::kAddressProperty,
+                                base::Value::CreateStringValue(kAddress));
+  value.SetWithoutPathExpansion(flimflam::kNameProperty,
+                                base::Value::CreateStringValue(kName));
+  value.SetWithoutPathExpansion(
+      flimflam::kSignalStrengthProperty,
+      base::Value::CreateIntegerValue(kSignalStrength));
+  // WiFi.Channel is set as a double because uint32 is larger than int32.
+  value.SetWithoutPathExpansion(flimflam::kWifiChannelProperty,
+                                base::Value::CreateDoubleValue(kWifiChannel));
+  value.SetWithoutPathExpansion(flimflam::kConnectedProperty,
+                                base::Value::CreateBooleanValue(kConnected));
+
+  // Set expectations.
+  PrepareForMethodCall(flimflam::kGetPropertiesFunction,
+                       base::Bind(&ExpectNoArgument),
+                       response.get());
+  // Call method.
+  client_->GetProperties(base::Bind(&ExpectDictionaryValueResult,
+                                    &value));
+  // Run the message loop.
+  message_loop_.RunAllPending();
+}
+
+}  // namespace chromeos
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index 66ef68b..7beaa2b 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -1321,6 +1321,9 @@
         'browser/chromeos/customization_document_unittest.cc',
         'browser/chromeos/dbus/blocking_method_caller_unittest.cc',
         'browser/chromeos/dbus/cros_dbus_service_unittest.cc',
+        'browser/chromeos/dbus/flimflam_client_unittest_base.cc',
+        'browser/chromeos/dbus/flimflam_client_unittest_base.h',
+        'browser/chromeos/dbus/flimflam_network_client_unittest.cc',
         'browser/chromeos/dbus/introspect_util_unittest.cc',
         'browser/chromeos/dbus/proxy_resolution_service_provider_unittest.cc',
         'browser/chromeos/extensions/file_browser_notifications_unittest.cc',