chromeos/dbus/shill_manager_client_unittest.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 "base/bind.h"
   6 #include "base/values.h"
   7 #include "chromeos/dbus/shill_client_unittest_base.h"
   8 #include "chromeos/dbus/shill_manager_client.h"
   9 #include "dbus/message.h"
  10 #include "dbus/object_path.h"
  11 #include "dbus/values_util.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "third_party/cros_system_api/dbus/service_constants.h"
  14
  15 using testing::_;
  16 using testing::ByRef;
  17
  18 namespace chromeos {
  19
  20 namespace {
  21
  22 void ExpectStringArguments(const std::vector<std::string>& arguments,
  23                            dbus::MessageReader* reader) {
  24   for (std::vector<std::string>::const_iterator iter = arguments.begin();
  25        iter != arguments.end(); ++iter) {
  26     std::string arg_string;
  27     ASSERT_TRUE(reader->PopString(&arg_string));
  28     EXPECT_EQ(*iter, arg_string);
  29   }
  30   EXPECT_FALSE(reader->HasMoreData());
  31 }
  32
  33 void ExpectStringArgumentsFollowedByObjectPath(
  34       const std::vector<std::string>& arguments,
  35       const dbus::ObjectPath& object_path,
  36       dbus::MessageReader* reader) {
  37   for (std::vector<std::string>::const_iterator iter = arguments.begin();
  38        iter != arguments.end(); ++iter) {
  39     std::string arg_string;
  40     ASSERT_TRUE(reader->PopString(&arg_string));
  41     EXPECT_EQ(*iter, arg_string);
  42   }
  43   dbus::ObjectPath path;
  44   ASSERT_TRUE(reader->PopObjectPath(&path));
  45   EXPECT_EQ(object_path, path);
  46   EXPECT_FALSE(reader->HasMoreData());
  47 }
  48
  49
  50 }  // namespace
  51
  52 class ShillManagerClientTest : public ShillClientUnittestBase {
  53  public:
  54   ShillManagerClientTest()
  55       : ShillClientUnittestBase(shill::kFlimflamManagerInterface,
  56                                 dbus::ObjectPath(shill::kFlimflamServicePath)) {
  57   }
  58
  59   virtual void SetUp() {
  60     ShillClientUnittestBase::SetUp();
  61     // Create a client with the mock bus.
  62     client_.reset(ShillManagerClient::Create());
  63     client_->Init(mock_bus_.get());
  64     // Run the message loop to run the signal connection result callback.
  65     message_loop_.RunUntilIdle();
  66   }
  67
  68   virtual void TearDown() {
  69     ShillClientUnittestBase::TearDown();
  70   }
  71
  72  protected:
  73   scoped_ptr<ShillManagerClient> client_;
  74 };
  75
  76 TEST_F(ShillManagerClientTest, PropertyChanged) {
  77   // Create a signal.
  78   base::FundamentalValue kOfflineMode(true);
  79   dbus::Signal signal(shill::kFlimflamManagerInterface,
  80                       shill::kMonitorPropertyChanged);
  81   dbus::MessageWriter writer(&signal);
  82   writer.AppendString(shill::kOfflineModeProperty);
  83   dbus::AppendBasicTypeValueData(&writer, kOfflineMode);
  84
  85   // Set expectations.
  86   MockPropertyChangeObserver observer;
  87   EXPECT_CALL(observer,
  88               OnPropertyChanged(shill::kOfflineModeProperty,
  89                                 ValueEq(ByRef(kOfflineMode)))).Times(1);
  90
  91   // Add the observer
  92   client_->AddPropertyChangedObserver(&observer);
  93
  94   // Run the signal callback.
  95   SendPropertyChangedSignal(&signal);
  96
  97   // Remove the observer.
  98   client_->RemovePropertyChangedObserver(&observer);
  99
 100   // Make sure it's not called anymore.
 101   EXPECT_CALL(observer, OnPropertyChanged(_, _)).Times(0);
 102
 103   // Run the signal callback again and make sure the observer isn't called.
 104   SendPropertyChangedSignal(&signal);
 105 }
 106
 107 TEST_F(ShillManagerClientTest, GetProperties) {
 108   // Create response.
 109   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 110   dbus::MessageWriter writer(response.get());
 111   dbus::MessageWriter array_writer(NULL);
 112   writer.OpenArray("{sv}", &array_writer);
 113   dbus::MessageWriter entry_writer(NULL);
 114   array_writer.OpenDictEntry(&entry_writer);
 115   entry_writer.AppendString(shill::kOfflineModeProperty);
 116   entry_writer.AppendVariantOfBool(true);
 117   array_writer.CloseContainer(&entry_writer);
 118   writer.CloseContainer(&array_writer);
 119
 120   // Create the expected value.
 121   base::DictionaryValue value;
 122   value.SetWithoutPathExpansion(shill::kOfflineModeProperty,
 123                                 new base::FundamentalValue(true));
 124   // Set expectations.
 125   PrepareForMethodCall(shill::kGetPropertiesFunction,
 126                        base::Bind(&ExpectNoArgument),
 127                        response.get());
 128   // Call method.
 129   client_->GetProperties(base::Bind(&ExpectDictionaryValueResult, &value));
 130   // Run the message loop.
 131   message_loop_.RunUntilIdle();
 132 }
 133
 134 TEST_F(ShillManagerClientTest, GetNetworksForGeolocation) {
 135   // Create response.
 136   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 137
 138   dbus::MessageWriter writer(response.get());
 139   dbus::MessageWriter type_dict_writer(NULL);
 140   writer.OpenArray("{sv}", &type_dict_writer);
 141   dbus::MessageWriter type_entry_writer(NULL);
 142   type_dict_writer.OpenDictEntry(&type_entry_writer);
 143   type_entry_writer.AppendString(shill::kTypeWifi);
 144   dbus::MessageWriter variant_writer(NULL);
 145   type_entry_writer.OpenVariant("aa{ss}", &variant_writer);
 146   dbus::MessageWriter wap_list_writer(NULL);
 147   variant_writer.OpenArray("a{ss}", &wap_list_writer);
 148   dbus::MessageWriter property_dict_writer(NULL);
 149   wap_list_writer.OpenArray("{ss}", &property_dict_writer);
 150   dbus::MessageWriter property_entry_writer(NULL);
 151   property_dict_writer.OpenDictEntry(&property_entry_writer);
 152   property_entry_writer.AppendString(shill::kGeoMacAddressProperty);
 153   property_entry_writer.AppendString("01:23:45:67:89:AB");
 154   property_dict_writer.CloseContainer(&property_entry_writer);
 155   wap_list_writer.CloseContainer(&property_dict_writer);
 156   variant_writer.CloseContainer(&wap_list_writer);
 157   type_entry_writer.CloseContainer(&wap_list_writer);
 158   type_dict_writer.CloseContainer(&type_entry_writer);
 159   writer.CloseContainer(&type_dict_writer);
 160
 161
 162   // Create the expected value.
 163   base::DictionaryValue type_dict_value;
 164   base::ListValue* type_entry_value = new base::ListValue;
 165   base::DictionaryValue* property_dict_value = new base::DictionaryValue;
 166   property_dict_value->SetWithoutPathExpansion(
 167       shill::kGeoMacAddressProperty,
 168       new base::StringValue("01:23:45:67:89:AB"));
 169   type_entry_value->Append(property_dict_value);
 170   type_dict_value.SetWithoutPathExpansion("wifi", type_entry_value);
 171
 172   // Set expectations.
 173   PrepareForMethodCall(shill::kGetNetworksForGeolocation,
 174                        base::Bind(&ExpectNoArgument),
 175                        response.get());
 176   // Call method.
 177   client_->GetNetworksForGeolocation(base::Bind(&ExpectDictionaryValueResult,
 178                                                 &type_dict_value));
 179
 180   // Run the message loop.
 181   message_loop_.RunUntilIdle();
 182 }
 183
 184 TEST_F(ShillManagerClientTest, SetProperty) {
 185   // Create response.
 186   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 187   // Set expectations.
 188   base::StringValue value("portal list");
 189   PrepareForMethodCall(shill::kSetPropertyFunction,
 190                        base::Bind(ExpectStringAndValueArguments,
 191                                   shill::kCheckPortalListProperty,
 192                                   &value),
 193                        response.get());
 194   // Call method.
 195   MockClosure mock_closure;
 196   MockErrorCallback mock_error_callback;
 197   client_->SetProperty(shill::kCheckPortalListProperty,
 198                        value,
 199                        mock_closure.GetCallback(),
 200                        mock_error_callback.GetCallback());
 201   EXPECT_CALL(mock_closure, Run()).Times(1);
 202   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 203
 204   // Run the message loop.
 205   message_loop_.RunUntilIdle();
 206 }
 207
 208 TEST_F(ShillManagerClientTest, RequestScan) {
 209   // Create response.
 210   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 211   // Set expectations.
 212   PrepareForMethodCall(shill::kRequestScanFunction,
 213                        base::Bind(&ExpectStringArgument, shill::kTypeWifi),
 214                        response.get());
 215   // Call method.
 216   MockClosure mock_closure;
 217   MockErrorCallback mock_error_callback;
 218   client_->RequestScan(shill::kTypeWifi,
 219                        mock_closure.GetCallback(),
 220                        mock_error_callback.GetCallback());
 221   EXPECT_CALL(mock_closure, Run()).Times(1);
 222   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 223
 224   // Run the message loop.
 225   message_loop_.RunUntilIdle();
 226 }
 227
 228 TEST_F(ShillManagerClientTest, EnableTechnology) {
 229   // Create response.
 230   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 231   // Set expectations.
 232   PrepareForMethodCall(shill::kEnableTechnologyFunction,
 233                        base::Bind(&ExpectStringArgument, shill::kTypeWifi),
 234                        response.get());
 235   // Call method.
 236   MockClosure mock_closure;
 237   MockErrorCallback mock_error_callback;
 238   client_->EnableTechnology(shill::kTypeWifi,
 239                             mock_closure.GetCallback(),
 240                             mock_error_callback.GetCallback());
 241   EXPECT_CALL(mock_closure, Run()).Times(1);
 242   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 243
 244   // Run the message loop.
 245   message_loop_.RunUntilIdle();
 246 }
 247
 248 TEST_F(ShillManagerClientTest, DisableTechnology) {
 249   // Create response.
 250   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 251   // Set expectations.
 252   PrepareForMethodCall(shill::kDisableTechnologyFunction,
 253                        base::Bind(&ExpectStringArgument, shill::kTypeWifi),
 254                        response.get());
 255   // Call method.
 256   MockClosure mock_closure;
 257   MockErrorCallback mock_error_callback;
 258   client_->DisableTechnology(shill::kTypeWifi,
 259                              mock_closure.GetCallback(),
 260                              mock_error_callback.GetCallback());
 261   EXPECT_CALL(mock_closure, Run()).Times(1);
 262   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 263
 264   // Run the message loop.
 265   message_loop_.RunUntilIdle();
 266 }
 267
 268 TEST_F(ShillManagerClientTest, ConfigureService) {
 269   // Create response.
 270   const dbus::ObjectPath object_path("/");
 271   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 272   dbus::MessageWriter writer(response.get());
 273   writer.AppendObjectPath(object_path);
 274   // Create the argument dictionary.
 275   scoped_ptr<base::DictionaryValue> arg(CreateExampleServiceProperties());
 276   // Set expectations.
 277   PrepareForMethodCall(shill::kConfigureServiceFunction,
 278                        base::Bind(&ExpectDictionaryValueArgument, arg.get()),
 279                        response.get());
 280   // Call method.
 281   MockErrorCallback mock_error_callback;
 282   client_->ConfigureService(*arg,
 283                             base::Bind(&ExpectObjectPathResultWithoutStatus,
 284                                        object_path),
 285                             mock_error_callback.GetCallback());
 286   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 287
 288   // Run the message loop.
 289   message_loop_.RunUntilIdle();
 290 }
 291
 292 TEST_F(ShillManagerClientTest, GetService) {
 293   // Create response.
 294   const dbus::ObjectPath object_path("/");
 295   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 296   dbus::MessageWriter writer(response.get());
 297   writer.AppendObjectPath(object_path);
 298   // Create the argument dictionary.
 299   scoped_ptr<base::DictionaryValue> arg(CreateExampleServiceProperties());
 300   // Set expectations.
 301   PrepareForMethodCall(shill::kGetServiceFunction,
 302                        base::Bind(&ExpectDictionaryValueArgument, arg.get()),
 303                        response.get());
 304   // Call method.
 305   MockErrorCallback mock_error_callback;
 306   client_->GetService(*arg,
 307                       base::Bind(&ExpectObjectPathResultWithoutStatus,
 308                                  object_path),
 309                       mock_error_callback.GetCallback());
 310   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 311
 312   // Run the message loop.
 313   message_loop_.RunUntilIdle();
 314 }
 315
 316 TEST_F(ShillManagerClientTest, VerifyDestination) {
 317   // Create response.
 318   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 319   dbus::MessageWriter writer(response.get());
 320   bool expected = true;
 321   writer.AppendBool(expected);
 322   // Set expectations.
 323   std::vector<std::string> arguments;
 324   arguments.push_back("certificate");
 325   arguments.push_back("public_key");
 326   arguments.push_back("nonce");
 327   arguments.push_back("signed_data");
 328   arguments.push_back("device_serial");
 329   arguments.push_back("device_ssid");
 330   arguments.push_back("device_bssid");
 331   PrepareForMethodCall(shill::kVerifyDestinationFunction,
 332                        base::Bind(&ExpectStringArguments, arguments),
 333                        response.get());
 334
 335   // Call method.
 336   MockErrorCallback mock_error_callback;
 337   ShillManagerClient::VerificationProperties properties;
 338   properties.certificate = arguments[0];
 339   properties.public_key = arguments[1];
 340   properties.nonce = arguments[2];
 341   properties.signed_data = arguments[3];
 342   properties.device_serial = arguments[4];
 343   properties.device_ssid = arguments[5];
 344   properties.device_bssid = arguments[6];
 345   client_->VerifyDestination(
 346       properties,
 347       base::Bind(&ExpectBoolResultWithoutStatus, expected),
 348       mock_error_callback.GetCallback());
 349   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 350
 351   // Run the message loop.
 352   message_loop_.RunUntilIdle();
 353 }
 354
 355 TEST_F(ShillManagerClientTest, VerifyAndEncryptCredentials) {
 356   // Create response.
 357   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 358   dbus::MessageWriter writer(response.get());
 359   std::string expected = "encrypted_credentials";
 360   writer.AppendString(expected);
 361   // Set expectations.
 362   std::vector<std::string> arguments;
 363   arguments.push_back("certificate");
 364   arguments.push_back("public_key");
 365   arguments.push_back("nonce");
 366   arguments.push_back("signed_data");
 367   arguments.push_back("device_serial");
 368   arguments.push_back("device_ssid");
 369   arguments.push_back("device_bssid");
 370   std::string service_path = "/";
 371   dbus::ObjectPath service_path_obj(service_path);
 372   PrepareForMethodCall(shill::kVerifyAndEncryptCredentialsFunction,
 373                        base::Bind(&ExpectStringArgumentsFollowedByObjectPath,
 374                                   arguments,
 375                                   service_path_obj),
 376                        response.get());
 377
 378   // Call method.
 379   MockErrorCallback mock_error_callback;
 380   ShillManagerClient::VerificationProperties properties;
 381   properties.certificate = arguments[0];
 382   properties.public_key = arguments[1];
 383   properties.nonce = arguments[2];
 384   properties.signed_data = arguments[3];
 385   properties.device_serial = arguments[4];
 386   properties.device_ssid = arguments[5];
 387   properties.device_bssid = arguments[6];
 388   client_->VerifyAndEncryptCredentials(
 389       properties,
 390       service_path,
 391       base::Bind(&ExpectStringResultWithoutStatus, expected),
 392       mock_error_callback.GetCallback());
 393   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 394
 395   // Run the message loop.
 396   message_loop_.RunUntilIdle();
 397 }
 398
 399 TEST_F(ShillManagerClientTest, VerifyAndEncryptData) {
 400   // Create response.
 401   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 402   dbus::MessageWriter writer(response.get());
 403   std::string expected = "encrypted_data";
 404   writer.AppendString(expected);
 405   // Set expectations.
 406   std::vector<std::string> arguments;
 407   arguments.push_back("certificate");
 408   arguments.push_back("public_key");
 409   arguments.push_back("nonce");
 410   arguments.push_back("signed_data");
 411   arguments.push_back("device_serial");
 412   arguments.push_back("device_ssid");
 413   arguments.push_back("device_bssid");
 414   arguments.push_back("data");
 415   PrepareForMethodCall(shill::kVerifyAndEncryptDataFunction,
 416                        base::Bind(&ExpectStringArguments, arguments),
 417                        response.get());
 418
 419   // Call method.
 420   MockErrorCallback mock_error_callback;
 421   ShillManagerClient::VerificationProperties properties;
 422   properties.certificate = arguments[0];
 423   properties.public_key = arguments[1];
 424   properties.nonce = arguments[2];
 425   properties.signed_data = arguments[3];
 426   properties.device_serial = arguments[4];
 427   properties.device_ssid = arguments[5];
 428   properties.device_bssid = arguments[6];
 429   client_->VerifyAndEncryptData(
 430       properties,
 431       arguments[7],
 432       base::Bind(&ExpectStringResultWithoutStatus, expected),
 433       mock_error_callback.GetCallback());
 434   EXPECT_CALL(mock_error_callback, Run(_, _)).Times(0);
 435
 436   // Run the message loop.
 437   message_loop_.RunUntilIdle();
 438 }
 439
 440 }  // namespace chromeos