chromeos/dbus/shill_client_unittest_base.cc

   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 #include "chromeos/dbus/shill_client_unittest_base.h"
   6
   7 #include "base/bind.h"
   8 #include "base/json/json_writer.h"
   9 #include "base/values.h"
  10 #include "chromeos/network/shill_property_util.h"
  11 #include "dbus/message.h"
  12 #include "dbus/object_path.h"
  13 #include "dbus/values_util.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "third_party/cros_system_api/dbus/service_constants.h"
  17
  18 using ::testing::_;
  19 using ::testing::Invoke;
  20 using ::testing::Return;
  21
  22 namespace chromeos {
  23
  24 namespace {
  25
  26 // Pops a string-to-string dictionary from the reader.
  27 base::DictionaryValue* PopStringToStringDictionary(
  28     dbus::MessageReader* reader) {
  29   dbus::MessageReader array_reader(NULL);
  30   if (!reader->PopArray(&array_reader))
  31     return NULL;
  32   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
  33   while (array_reader.HasMoreData()) {
  34     dbus::MessageReader entry_reader(NULL);
  35     std::string key;
  36     std::string value;
  37     if (!array_reader.PopDictEntry(&entry_reader) ||
  38         !entry_reader.PopString(&key) ||
  39         !entry_reader.PopString(&value))
  40       return NULL;
  41     result->SetWithoutPathExpansion(key, new base::StringValue(value));
  42   }
  43   return result.release();
  44 }
  45
  46 }  // namespace
  47
  48 ValueMatcher::ValueMatcher(const base::Value& value)
  49   : expected_value_(value.DeepCopy()) {}
  50
  51 bool ValueMatcher::MatchAndExplain(const base::Value& value,
  52                              MatchResultListener* listener) const {
  53   return expected_value_->Equals(&value);
  54 }
  55
  56 void ValueMatcher::DescribeTo(::std::ostream* os) const {
  57   std::string expected_value_str;
  58   base::JSONWriter::WriteWithOptions(expected_value_.get(),
  59                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
  60                                      &expected_value_str);
  61   *os << "value equals " << expected_value_str;
  62 }
  63
  64 void ValueMatcher::DescribeNegationTo(::std::ostream* os) const {
  65   std::string expected_value_str;
  66   base::JSONWriter::WriteWithOptions(expected_value_.get(),
  67                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
  68                                      &expected_value_str);
  69   *os << "value does not equal " << expected_value_str;
  70 }
  71
  72
  73 ShillClientUnittestBase::MockClosure::MockClosure() {}
  74
  75 ShillClientUnittestBase::MockClosure::~MockClosure() {}
  76
  77 base::Closure ShillClientUnittestBase::MockClosure::GetCallback() {
  78   return base::Bind(&MockClosure::Run, base::Unretained(this));
  79 }
  80
  81
  82 ShillClientUnittestBase::MockListValueCallback::MockListValueCallback() {}
  83
  84 ShillClientUnittestBase::MockListValueCallback::~MockListValueCallback() {}
  85
  86 ShillClientHelper::ListValueCallback
  87 ShillClientUnittestBase::MockListValueCallback::GetCallback() {
  88   return base::Bind(&MockListValueCallback::Run, base::Unretained(this));
  89 }
  90
  91
  92 ShillClientUnittestBase::MockErrorCallback::MockErrorCallback() {}
  93
  94 ShillClientUnittestBase::MockErrorCallback::~MockErrorCallback() {}
  95
  96 ShillClientUnittestBase::MockPropertyChangeObserver::
  97   MockPropertyChangeObserver() {}
  98
  99 ShillClientUnittestBase::MockPropertyChangeObserver::
 100   ~MockPropertyChangeObserver() {}
 101
 102 ShillClientHelper::ErrorCallback
 103 ShillClientUnittestBase::MockErrorCallback::GetCallback() {
 104   return base::Bind(&MockErrorCallback::Run, base::Unretained(this));
 105 }
 106
 107
 108 ShillClientUnittestBase::ShillClientUnittestBase(
 109     const std::string& interface_name,
 110     const dbus::ObjectPath& object_path)
 111     : interface_name_(interface_name),
 112       object_path_(object_path),
 113       response_(NULL) {
 114 }
 115
 116 ShillClientUnittestBase::~ShillClientUnittestBase() {
 117 }
 118
 119 void ShillClientUnittestBase::SetUp() {
 120   // Create a mock bus.
 121   dbus::Bus::Options options;
 122   options.bus_type = dbus::Bus::SYSTEM;
 123   mock_bus_ = new dbus::MockBus(options);
 124
 125   // Create a mock proxy.
 126   mock_proxy_ = new dbus::MockObjectProxy(
 127       mock_bus_.get(),
 128       shill::kFlimflamServiceName,
 129       object_path_);
 130
 131   // Set an expectation so mock_proxy's CallMethod() will use OnCallMethod()
 132   // to return responses.
 133   EXPECT_CALL(*mock_proxy_.get(), CallMethod(_, _, _))
 134       .WillRepeatedly(Invoke(this, &ShillClientUnittestBase::OnCallMethod));
 135
 136   // Set an expectation so mock_proxy's CallMethodWithErrorCallback() will use
 137   // OnCallMethodWithErrorCallback() to return responses.
 138   EXPECT_CALL(*mock_proxy_.get(), CallMethodWithErrorCallback(_, _, _, _))
 139       .WillRepeatedly(Invoke(
 140            this, &ShillClientUnittestBase::OnCallMethodWithErrorCallback));
 141
 142   // Set an expectation so mock_proxy's ConnectToSignal() will use
 143   // OnConnectToSignal() to run the callback.
 144   EXPECT_CALL(
 145       *mock_proxy_.get(),
 146       ConnectToSignal(interface_name_, shill::kMonitorPropertyChanged, _, _))
 147       .WillRepeatedly(
 148            Invoke(this, &ShillClientUnittestBase::OnConnectToSignal));
 149
 150   // Set an expectation so mock_bus's GetObjectProxy() for the given
 151   // service name and the object path will return mock_proxy_.
 152   EXPECT_CALL(*mock_bus_.get(),
 153               GetObjectProxy(shill::kFlimflamServiceName, object_path_))
 154       .WillOnce(Return(mock_proxy_.get()));
 155
 156   // Set an expectation so mock_bus's GetDBusTaskRunner will return the current
 157   // task runner.
 158   EXPECT_CALL(*mock_bus_.get(), GetDBusTaskRunner())
 159       .WillRepeatedly(Return(message_loop_.message_loop_proxy().get()));
 160
 161   // ShutdownAndBlock() will be called in TearDown().
 162   EXPECT_CALL(*mock_bus_.get(), ShutdownAndBlock()).WillOnce(Return());
 163 }
 164
 165 void ShillClientUnittestBase::TearDown() {
 166   mock_bus_->ShutdownAndBlock();
 167 }
 168
 169 void ShillClientUnittestBase::PrepareForMethodCall(
 170     const std::string& method_name,
 171     const ArgumentCheckCallback& argument_checker,
 172     dbus::Response* response) {
 173   expected_method_name_ = method_name;
 174   argument_checker_ = argument_checker;
 175   response_ = response;
 176 }
 177
 178 void ShillClientUnittestBase::SendPropertyChangedSignal(
 179     dbus::Signal* signal) {
 180   ASSERT_FALSE(property_changed_handler_.is_null());
 181   property_changed_handler_.Run(signal);
 182 }
 183
 184 // static
 185 void ShillClientUnittestBase::ExpectPropertyChanged(
 186     const std::string& expected_name,
 187     const base::Value* expected_value,
 188     const std::string& name,
 189     const base::Value& value) {
 190   EXPECT_EQ(expected_name, name);
 191   EXPECT_TRUE(expected_value->Equals(&value));
 192 }
 193
 194 // static
 195 void ShillClientUnittestBase::ExpectNoArgument(dbus::MessageReader* reader) {
 196   EXPECT_FALSE(reader->HasMoreData());
 197 }
 198
 199 // static
 200 void ShillClientUnittestBase::ExpectStringArgument(
 201     const std::string& expected_string,
 202     dbus::MessageReader* reader) {
 203   std::string str;
 204   ASSERT_TRUE(reader->PopString(&str));
 205   EXPECT_EQ(expected_string, str);
 206   EXPECT_FALSE(reader->HasMoreData());
 207 }
 208
 209 // static
 210 void ShillClientUnittestBase::ExpectArrayOfStringsArgument(
 211     const std::vector<std::string>& expected_strings,
 212     dbus::MessageReader* reader) {
 213   std::vector<std::string> strs;
 214   ASSERT_TRUE(reader->PopArrayOfStrings(&strs));
 215   EXPECT_EQ(expected_strings, strs);
 216   EXPECT_FALSE(reader->HasMoreData());
 217 }
 218
 219 // static
 220 void ShillClientUnittestBase::ExpectValueArgument(
 221     const base::Value* expected_value,
 222     dbus::MessageReader* reader) {
 223   scoped_ptr<base::Value> value(dbus::PopDataAsValue(reader));
 224   ASSERT_TRUE(value.get());
 225   EXPECT_TRUE(value->Equals(expected_value));
 226   EXPECT_FALSE(reader->HasMoreData());
 227 }
 228
 229 // static
 230 void ShillClientUnittestBase::ExpectStringAndValueArguments(
 231     const std::string& expected_string,
 232     const base::Value* expected_value,
 233     dbus::MessageReader* reader) {
 234   std::string str;
 235   ASSERT_TRUE(reader->PopString(&str));
 236   EXPECT_EQ(expected_string, str);
 237   scoped_ptr<base::Value> value(dbus::PopDataAsValue(reader));
 238   ASSERT_TRUE(value.get());
 239   EXPECT_TRUE(value->Equals(expected_value));
 240   EXPECT_FALSE(reader->HasMoreData());
 241 }
 242
 243 // static
 244 void ShillClientUnittestBase::ExpectDictionaryValueArgument(
 245     const base::DictionaryValue* expected_dictionary,
 246     dbus::MessageReader* reader) {
 247   dbus::MessageReader array_reader(NULL);
 248   ASSERT_TRUE(reader->PopArray(&array_reader));
 249   while (array_reader.HasMoreData()) {
 250     dbus::MessageReader entry_reader(NULL);
 251     ASSERT_TRUE(array_reader.PopDictEntry(&entry_reader));
 252     std::string key;
 253     ASSERT_TRUE(entry_reader.PopString(&key));
 254     dbus::MessageReader variant_reader(NULL);
 255     ASSERT_TRUE(entry_reader.PopVariant(&variant_reader));
 256     scoped_ptr<base::Value> value;
 257     // Variants in the dictionary can be basic types or string-to-string
 258     // dictinoary.
 259     switch (variant_reader.GetDataType()) {
 260       case dbus::Message::ARRAY:
 261         value.reset(PopStringToStringDictionary(&variant_reader));
 262         break;
 263       case dbus::Message::BOOL:
 264       case dbus::Message::INT32:
 265       case dbus::Message::STRING:
 266         value.reset(dbus::PopDataAsValue(&variant_reader));
 267         break;
 268       default:
 269         NOTREACHED();
 270     }
 271     ASSERT_TRUE(value.get());
 272     const base::Value* expected_value = NULL;
 273     EXPECT_TRUE(expected_dictionary->GetWithoutPathExpansion(key,
 274                                                              &expected_value));
 275     EXPECT_TRUE(value->Equals(expected_value));
 276   }
 277 }
 278
 279 // static
 280 base::DictionaryValue*
 281 ShillClientUnittestBase::CreateExampleServiceProperties() {
 282   base::DictionaryValue* properties = new base::DictionaryValue;
 283   properties->SetWithoutPathExpansion(
 284       shill::kGuidProperty,
 285       new base::StringValue("00000000-0000-0000-0000-000000000000"));
 286   properties->SetWithoutPathExpansion(
 287       shill::kModeProperty, new base::StringValue(shill::kModeManaged));
 288   properties->SetWithoutPathExpansion(shill::kTypeProperty,
 289                                       new base::StringValue(shill::kTypeWifi));
 290   shill_property_util::SetSSID("testssid", properties);
 291   properties->SetWithoutPathExpansion(
 292       shill::kSecurityProperty, new base::StringValue(shill::kSecurityPsk));
 293   return properties;
 294 }
 295
 296
 297 // static
 298 void ShillClientUnittestBase::ExpectNoResultValue(
 299     DBusMethodCallStatus call_status) {
 300   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
 301 }
 302
 303 // static
 304 void ShillClientUnittestBase::ExpectObjectPathResult(
 305     const dbus::ObjectPath& expected_result,
 306     DBusMethodCallStatus call_status,
 307     const dbus::ObjectPath& result) {
 308   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
 309   EXPECT_EQ(expected_result, result);
 310 }
 311
 312 // static
 313 void ShillClientUnittestBase::ExpectObjectPathResultWithoutStatus(
 314     const dbus::ObjectPath& expected_result,
 315     const dbus::ObjectPath& result) {
 316   EXPECT_EQ(expected_result, result);
 317 }
 318
 319 // static
 320 void ShillClientUnittestBase::ExpectBoolResultWithoutStatus(
 321     bool expected_result,
 322     bool result) {
 323   EXPECT_EQ(expected_result, result);
 324 }
 325
 326 // static
 327 void ShillClientUnittestBase::ExpectStringResultWithoutStatus(
 328     const std::string& expected_result,
 329     const std::string& result) {
 330   EXPECT_EQ(expected_result, result);
 331 }
 332
 333 // static
 334 void ShillClientUnittestBase::ExpectDictionaryValueResultWithoutStatus(
 335     const base::DictionaryValue* expected_result,
 336     const base::DictionaryValue& result) {
 337   std::string expected_result_string;
 338   base::JSONWriter::Write(expected_result, &expected_result_string);
 339   std::string result_string;
 340   base::JSONWriter::Write(&result, &result_string);
 341   EXPECT_EQ(expected_result_string, result_string);
 342 }
 343
 344 // static
 345 void ShillClientUnittestBase::ExpectDictionaryValueResult(
 346     const base::DictionaryValue* expected_result,
 347     DBusMethodCallStatus call_status,
 348     const base::DictionaryValue& result) {
 349   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
 350   ExpectDictionaryValueResultWithoutStatus(expected_result, result);
 351 }
 352
 353 void ShillClientUnittestBase::OnConnectToSignal(
 354     const std::string& interface_name,
 355     const std::string& signal_name,
 356     const dbus::ObjectProxy::SignalCallback& signal_callback,
 357     const dbus::ObjectProxy::OnConnectedCallback& on_connected_callback) {
 358   property_changed_handler_ = signal_callback;
 359   const bool success = true;
 360   message_loop_.PostTask(FROM_HERE,
 361                          base::Bind(on_connected_callback,
 362                                     interface_name,
 363                                     signal_name,
 364                                     success));
 365 }
 366
 367 void ShillClientUnittestBase::OnCallMethod(
 368     dbus::MethodCall* method_call,
 369     int timeout_ms,
 370     const dbus::ObjectProxy::ResponseCallback& response_callback) {
 371   EXPECT_EQ(interface_name_, method_call->GetInterface());
 372   EXPECT_EQ(expected_method_name_, method_call->GetMember());
 373   dbus::MessageReader reader(method_call);
 374   argument_checker_.Run(&reader);
 375   message_loop_.PostTask(FROM_HERE,
 376                          base::Bind(response_callback, response_));
 377 }
 378
 379 void ShillClientUnittestBase::OnCallMethodWithErrorCallback(
 380     dbus::MethodCall* method_call,
 381     int timeout_ms,
 382     const dbus::ObjectProxy::ResponseCallback& response_callback,
 383     const dbus::ObjectProxy::ErrorCallback& error_callback) {
 384   OnCallMethod(method_call, timeout_ms, response_callback);
 385 }
 386
 387 }  // namespace chromeos