chromeos/dbus/shill_client_unittest_base.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROMEOS_DBUS_SHILL_CLIENT_UNITTEST_BASE_H_
   6 #define CHROMEOS_DBUS_SHILL_CLIENT_UNITTEST_BASE_H_
   7
   8 #include <string>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "chromeos/dbus/dbus_method_call_status.h"
  14 #include "chromeos/dbus/shill_client_helper.h"
  15 #include "chromeos/dbus/shill_property_changed_observer.h"
  16 #include "dbus/mock_bus.h"
  17 #include "dbus/mock_object_proxy.h"
  18 #include "dbus/object_proxy.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using ::testing::MatcherInterface;
  22 using ::testing::MatchResultListener;
  23 using ::testing::Matcher;
  24 using ::testing::MakeMatcher;
  25
  26 namespace base {
  27
  28 class Value;
  29 class DictionaryValue;
  30
  31 }  // namespace base
  32
  33 namespace dbus {
  34
  35 class MessageReader;
  36
  37 }  // namespace dbus
  38
  39 namespace chromeos {
  40
  41 // A gmock matcher for base::Value types, so we can match them in expectations.
  42 class ValueMatcher : public MatcherInterface<const base::Value&> {
  43  public:
  44   explicit ValueMatcher(const base::Value& value);
  45
  46   // MatcherInterface overrides.
  47   virtual bool MatchAndExplain(const base::Value& value,
  48                                MatchResultListener* listener) const OVERRIDE;
  49   virtual void DescribeTo(::std::ostream* os) const OVERRIDE;
  50   virtual void DescribeNegationTo(::std::ostream* os) const OVERRIDE;
  51
  52  private:
  53   scoped_ptr<base::Value> expected_value_;
  54 };
  55
  56 inline Matcher<const base::Value&> ValueEq(const base::Value& expected_value) {
  57   return MakeMatcher(new ValueMatcher(expected_value));
  58 }
  59
  60 // A class to provide functionalities needed for testing Shill D-Bus clients.
  61 class ShillClientUnittestBase : public testing::Test {
  62  public:
  63   // A mock Closure.
  64   class MockClosure {
  65    public:
  66     MockClosure();
  67     ~MockClosure();
  68     MOCK_METHOD0(Run, void());
  69     base::Closure GetCallback();
  70   };
  71
  72   class MockListValueCallback {
  73    public:
  74     MockListValueCallback();
  75     ~MockListValueCallback();
  76     MOCK_METHOD1(Run, void(const base::ListValue& list));
  77     ShillClientHelper::ListValueCallback GetCallback();
  78   };
  79
  80   // A mock ErrorCallback.
  81   class MockErrorCallback {
  82    public:
  83     MockErrorCallback();
  84     ~MockErrorCallback();
  85     MOCK_METHOD2(Run, void(const std::string& error_name,
  86                            const std::string& error_message));
  87     ShillClientHelper::ErrorCallback GetCallback();
  88   };
  89
  90   // A mock PropertyChangedObserver that can be used to check expected values.
  91   class MockPropertyChangeObserver
  92       : public ShillPropertyChangedObserver {
  93    public:
  94     MockPropertyChangeObserver();
  95     ~MockPropertyChangeObserver();
  96     MOCK_METHOD2(OnPropertyChanged, void(const std::string& name,
  97                                          const base::Value& value));
  98   };
  99
 100   explicit ShillClientUnittestBase(const std::string& interface_name,
 101                                       const dbus::ObjectPath& object_path);
 102   virtual ~ShillClientUnittestBase();
 103
 104   virtual void SetUp() OVERRIDE;
 105   virtual void TearDown() OVERRIDE;
 106
 107  protected:
 108   // A callback to intercept and check the method call arguments.
 109   typedef base::Callback<void(
 110       dbus::MessageReader* reader)> ArgumentCheckCallback;
 111
 112   // Sets expectations for called method name and arguments, and sets response.
 113   void PrepareForMethodCall(const std::string& method_name,
 114                             const ArgumentCheckCallback& argument_checker,
 115                             dbus::Response* response);
 116
 117   // Sends property changed signal to the tested client.
 118   void SendPropertyChangedSignal(dbus::Signal* signal);
 119
 120   // Checks the name and the value which are sent by PropertyChanged signal.
 121   static void ExpectPropertyChanged(const std::string& expected_name,
 122                                     const base::Value* expected_value,
 123                                     const std::string& name,
 124                                     const base::Value& value);
 125
 126   // Expects the reader to be empty.
 127   static void ExpectNoArgument(dbus::MessageReader* reader);
 128
 129   // Expects the reader to have a string.
 130   static void ExpectStringArgument(const std::string& expected_string,
 131                                    dbus::MessageReader* reader);
 132
 133   static void ExpectArrayOfStringsArgument(
 134       const std::vector<std::string>& expected_strings,
 135       dbus::MessageReader* reader);
 136
 137   // Expects the reader to have a Value.
 138   static void ExpectValueArgument(const base::Value* expected_value,
 139                                   dbus::MessageReader* reader);
 140
 141   // Expects the reader to have a string and a Value.
 142   static void ExpectStringAndValueArguments(const std::string& expected_string,
 143                                             const base::Value* expected_value,
 144                                             dbus::MessageReader* reader);
 145
 146   // Expects the reader to have a string-to-variant dictionary.
 147   static void ExpectDictionaryValueArgument(
 148       const base::DictionaryValue* expected_dictionary,
 149       dbus::MessageReader* reader);
 150
 151   // Creates a DictionaryValue with example Service properties. The caller owns
 152   // the result.
 153   static base::DictionaryValue* CreateExampleServiceProperties();
 154
 155   // Expects the call status to be SUCCESS.
 156   static void ExpectNoResultValue(DBusMethodCallStatus call_status);
 157
 158   // Checks the result and expects the call status to be SUCCESS.
 159   static void ExpectObjectPathResult(const dbus::ObjectPath& expected_result,
 160                                      DBusMethodCallStatus call_status,
 161                                      const dbus::ObjectPath& result);
 162
 163   static void ExpectObjectPathResultWithoutStatus(
 164       const dbus::ObjectPath& expected_result,
 165       const dbus::ObjectPath& result);
 166
 167   static void ExpectBoolResultWithoutStatus(
 168       bool expected_result,
 169       bool result);
 170
 171   static void ExpectStringResultWithoutStatus(
 172       const std::string& expected_result,
 173       const std::string& result);
 174
 175   // Checks the result and expects the call status to be SUCCESS.
 176   static void ExpectDictionaryValueResult(
 177       const base::DictionaryValue* expected_result,
 178       DBusMethodCallStatus call_status,
 179       const base::DictionaryValue& result);
 180
 181   // Expects the |expected_result| to match the |result|.
 182   static void ExpectDictionaryValueResultWithoutStatus(
 183       const base::DictionaryValue* expected_result,
 184       const base::DictionaryValue& result);
 185
 186   // A message loop to emulate asynchronous behavior.
 187   base::MessageLoop message_loop_;
 188   // The mock bus.
 189   scoped_refptr<dbus::MockBus> mock_bus_;
 190
 191  private:
 192   // Checks the requested interface name and signal name.
 193   // Used to implement the mock proxy.
 194   void OnConnectToSignal(
 195       const std::string& interface_name,
 196       const std::string& signal_name,
 197       const dbus::ObjectProxy::SignalCallback& signal_callback,
 198       const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback);
 199
 200   // Checks the content of the method call and returns the response.
 201   // Used to implement the mock proxy.
 202   void OnCallMethod(
 203       dbus::MethodCall* method_call,
 204       int timeout_ms,
 205       const dbus::ObjectProxy::ResponseCallback& response_callback);
 206
 207   // Checks the content of the method call and returns the response.
 208   // Used to implement the mock proxy.
 209   void OnCallMethodWithErrorCallback(
 210       dbus::MethodCall* method_call,
 211       int timeout_ms,
 212       const dbus::ObjectProxy::ResponseCallback& response_callback,
 213       const dbus::ObjectProxy::ErrorCallback& error_callback);
 214
 215   // The interface name.
 216   const std::string interface_name_;
 217   // The object path.
 218   const dbus::ObjectPath object_path_;
 219   // The mock object proxy.
 220   scoped_refptr<dbus::MockObjectProxy> mock_proxy_;
 221   // The PropertyChanged signal handler given by the tested client.
 222   dbus::ObjectProxy::SignalCallback property_changed_handler_;
 223   // The name of the method which is expected to be called.
 224   std::string expected_method_name_;
 225   // The response which the mock object proxy returns.
 226   dbus::Response* response_;
 227   // A callback to intercept and check the method call arguments.
 228   ArgumentCheckCallback argument_checker_;
 229 };
 230
 231 }  // namespace chromeos
 232
 233 #endif  // CHROMEOS_DBUS_SHILL_CLIENT_UNITTEST_BASE_H_