chromeos/network/network_configuration_handler_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/json/json_writer.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/strings/string_piece.h"
   9 #include "base/values.h"
  10 #include "chromeos/dbus/dbus_thread_manager.h"
  11 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  12 #include "chromeos/dbus/mock_shill_manager_client.h"
  13 #include "chromeos/dbus/mock_shill_profile_client.h"
  14 #include "chromeos/dbus/mock_shill_service_client.h"
  15 #include "chromeos/dbus/shill_stub_helper.h"
  16 #include "chromeos/network/network_configuration_handler.h"
  17 #include "chromeos/network/network_state.h"
  18 #include "chromeos/network/network_state_handler.h"
  19 #include "chromeos/network/network_state_handler_observer.h"
  20 #include "chromeos/network/shill_property_util.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23 #include "third_party/cros_system_api/dbus/service_constants.h"
  24
  25 using ::testing::_;
  26 using ::testing::AnyNumber;
  27 using ::testing::Invoke;
  28 using ::testing::Pointee;
  29 using ::testing::Return;
  30 using ::testing::SaveArg;
  31 using ::testing::StrEq;
  32
  33 // Matcher to match base::Value.
  34 MATCHER_P(IsEqualTo, value, "") { return arg.Equals(value); }
  35
  36 namespace chromeos {
  37
  38 namespace {
  39
  40 static std::string PrettyJson(const base::DictionaryValue& value) {
  41   std::string pretty;
  42   base::JSONWriter::WriteWithOptions(&value,
  43                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
  44                                      &pretty);
  45   return pretty;
  46 }
  47
  48 void DictionaryValueCallback(
  49     const std::string& expected_id,
  50     const std::string& expected_json,
  51     const std::string& service_path,
  52     const base::DictionaryValue& dictionary) {
  53   std::string dict_str = PrettyJson(dictionary);
  54   EXPECT_EQ(expected_json, dict_str);
  55   EXPECT_EQ(expected_id, service_path);
  56 }
  57
  58 void ErrorCallback(bool error_expected,
  59                    const std::string& expected_id,
  60                    const std::string& error_name,
  61                    scoped_ptr<base::DictionaryValue> error_data) {
  62   EXPECT_TRUE(error_expected) << "Unexpected error: " << error_name
  63       << " with associated data: \n"
  64       << PrettyJson(*error_data);
  65 }
  66
  67 void StringResultCallback(const std::string& expected_result,
  68                           const std::string& result) {
  69   EXPECT_EQ(expected_result, result);
  70 }
  71
  72 void DBusErrorCallback(const std::string& error_name,
  73                        const std::string& error_message) {
  74   EXPECT_TRUE(false) << "DBus Error: " << error_name << "("
  75       << error_message << ")";
  76 }
  77
  78 class TestCallback {
  79  public:
  80   TestCallback() : run_count_(0) {}
  81   void Run() {
  82     ++run_count_;
  83   }
  84   int run_count() const { return run_count_; }
  85
  86  private:
  87   int run_count_;
  88 };
  89
  90 }  // namespace
  91
  92 class NetworkConfigurationHandlerTest : public testing::Test {
  93  public:
  94   NetworkConfigurationHandlerTest()
  95       : mock_manager_client_(NULL),
  96         mock_profile_client_(NULL),
  97         mock_service_client_(NULL),
  98         dictionary_value_result_(NULL) {}
  99   virtual ~NetworkConfigurationHandlerTest() {}
 100
 101   virtual void SetUp() OVERRIDE {
 102     FakeDBusThreadManager* dbus_thread_manager = new FakeDBusThreadManager;
 103     mock_manager_client_ = new MockShillManagerClient();
 104     mock_profile_client_ = new MockShillProfileClient();
 105     mock_service_client_ = new MockShillServiceClient();
 106     dbus_thread_manager->SetShillManagerClient(
 107         scoped_ptr<ShillManagerClient>(mock_manager_client_).Pass());
 108     dbus_thread_manager->SetShillProfileClient(
 109         scoped_ptr<ShillProfileClient>(mock_profile_client_).Pass());
 110     dbus_thread_manager->SetShillServiceClient(
 111         scoped_ptr<ShillServiceClient>(mock_service_client_).Pass());
 112
 113     EXPECT_CALL(*mock_service_client_, GetProperties(_, _))
 114         .Times(AnyNumber());
 115     EXPECT_CALL(*mock_manager_client_, GetProperties(_))
 116         .Times(AnyNumber());
 117     EXPECT_CALL(*mock_manager_client_, AddPropertyChangedObserver(_))
 118         .Times(AnyNumber());
 119     EXPECT_CALL(*mock_manager_client_, RemovePropertyChangedObserver(_))
 120         .Times(AnyNumber());
 121
 122     DBusThreadManager::InitializeForTesting(dbus_thread_manager);
 123
 124     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
 125     network_configuration_handler_.reset(new NetworkConfigurationHandler());
 126     network_configuration_handler_->Init(network_state_handler_.get());
 127     message_loop_.RunUntilIdle();
 128   }
 129
 130   virtual void TearDown() OVERRIDE {
 131     network_configuration_handler_.reset();
 132     network_state_handler_.reset();
 133     DBusThreadManager::Shutdown();
 134   }
 135
 136   // Handles responses for GetProperties method calls.
 137   void OnGetProperties(
 138       const dbus::ObjectPath& path,
 139       const ShillClientHelper::DictionaryValueCallback& callback) {
 140     callback.Run(DBUS_METHOD_CALL_SUCCESS, *dictionary_value_result_);
 141   }
 142
 143   // Handles responses for SetProperties method calls.
 144   void OnSetProperties(const dbus::ObjectPath& service_path,
 145                        const base::DictionaryValue& properties,
 146                        const base::Closure& callback,
 147                        const ShillClientHelper::ErrorCallback& error_callback) {
 148     callback.Run();
 149   }
 150
 151   // Handles responses for ClearProperties method calls.
 152   void OnClearProperties(
 153       const dbus::ObjectPath& service_path,
 154       const std::vector<std::string>& names,
 155       const ShillClientHelper::ListValueCallback& callback,
 156       const ShillClientHelper::ErrorCallback& error_callback) {
 157     base::ListValue result;
 158     result.AppendBoolean(true);
 159     callback.Run(result);
 160   }
 161
 162   // Handles responses for ClearProperties method calls, and simulates an error
 163   // result.
 164   void OnClearPropertiesError(
 165       const dbus::ObjectPath& service_path,
 166       const std::vector<std::string>& names,
 167       const ShillClientHelper::ListValueCallback& callback,
 168       const ShillClientHelper::ErrorCallback& error_callback) {
 169     base::ListValue result;
 170     result.AppendBoolean(false);
 171     callback.Run(result);
 172   }
 173
 174   void OnConfigureService(
 175       const dbus::ObjectPath& profile_path,
 176       const base::DictionaryValue& properties,
 177       const ObjectPathCallback& callback,
 178       const ShillClientHelper::ErrorCallback& error_callback) {
 179     callback.Run(dbus::ObjectPath("/service/2"));
 180   }
 181
 182   void OnGetLoadableProfileEntries(
 183       const dbus::ObjectPath& service_path,
 184       const ShillClientHelper::DictionaryValueCallback& callback) {
 185     base::DictionaryValue entries;
 186     entries.SetString("profile1", "entry1");
 187     entries.SetString("profile2", "entry2");
 188     callback.Run(DBUS_METHOD_CALL_SUCCESS, entries);
 189   }
 190
 191   void OnDeleteEntry(const dbus::ObjectPath& profile_path,
 192                      const std::string& entry_path,
 193                      const base::Closure& callback,
 194                      const ShillClientHelper::ErrorCallback& error_callback) {
 195     // Don't run the callback immediately to emulate actual behavior.
 196     message_loop_.PostTask(FROM_HERE, callback);
 197   }
 198
 199   bool PendingProfileEntryDeleterForTest(const std::string& service_path) {
 200     return network_configuration_handler_->
 201         PendingProfileEntryDeleterForTest(service_path);
 202   }
 203
 204  protected:
 205   MockShillManagerClient* mock_manager_client_;
 206   MockShillProfileClient* mock_profile_client_;
 207   MockShillServiceClient* mock_service_client_;
 208   scoped_ptr<NetworkStateHandler> network_state_handler_;
 209   scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
 210   base::MessageLoopForUI message_loop_;
 211   base::DictionaryValue* dictionary_value_result_;
 212 };
 213
 214 TEST_F(NetworkConfigurationHandlerTest, GetProperties) {
 215   std::string service_path = "/service/1";
 216   std::string expected_json = "{\n   \"SSID\": \"MyNetwork\"\n}\n";
 217   std::string networkName = "MyNetwork";
 218   std::string key = "SSID";
 219   scoped_ptr<base::StringValue> networkNameValue(
 220       base::Value::CreateStringValue(networkName));
 221
 222   base::DictionaryValue value;
 223   value.Set(key, base::Value::CreateStringValue(networkName));
 224   dictionary_value_result_ = &value;
 225   EXPECT_CALL(*mock_service_client_,
 226               SetProperty(dbus::ObjectPath(service_path), key,
 227                           IsEqualTo(networkNameValue.get()), _, _)).Times(1);
 228   mock_service_client_->SetProperty(dbus::ObjectPath(service_path),
 229                                     key,
 230                                     *networkNameValue,
 231                                     base::Bind(&base::DoNothing),
 232                                     base::Bind(&DBusErrorCallback));
 233   message_loop_.RunUntilIdle();
 234
 235   ShillServiceClient::DictionaryValueCallback get_properties_callback;
 236   EXPECT_CALL(*mock_service_client_,
 237               GetProperties(_, _)).WillOnce(
 238                   Invoke(this,
 239                          &NetworkConfigurationHandlerTest::OnGetProperties));
 240   network_configuration_handler_->GetProperties(
 241       service_path,
 242       base::Bind(&DictionaryValueCallback,
 243                  service_path,
 244                  expected_json),
 245                  base::Bind(&ErrorCallback, false, service_path));
 246   message_loop_.RunUntilIdle();
 247 }
 248
 249 TEST_F(NetworkConfigurationHandlerTest, SetProperties) {
 250   std::string service_path = "/service/1";
 251   std::string networkName = "MyNetwork";
 252   std::string key = "SSID";
 253   scoped_ptr<base::StringValue> networkNameValue(
 254       base::Value::CreateStringValue(networkName));
 255
 256   base::DictionaryValue value;
 257   value.Set(key, base::Value::CreateStringValue(networkName));
 258   dictionary_value_result_ = &value;
 259   EXPECT_CALL(*mock_service_client_,
 260               SetProperties(_, _, _, _)).WillOnce(
 261                   Invoke(this,
 262                          &NetworkConfigurationHandlerTest::OnSetProperties));
 263   network_configuration_handler_->SetProperties(
 264       service_path,
 265       value,
 266       base::Bind(&base::DoNothing),
 267       base::Bind(&ErrorCallback, false, service_path));
 268   message_loop_.RunUntilIdle();
 269 }
 270
 271 TEST_F(NetworkConfigurationHandlerTest, ClearProperties) {
 272   std::string service_path = "/service/1";
 273   std::string networkName = "MyNetwork";
 274   std::string key = "SSID";
 275   scoped_ptr<base::StringValue> networkNameValue(
 276       base::Value::CreateStringValue(networkName));
 277
 278   // First set up a value to clear.
 279   base::DictionaryValue value;
 280   value.Set(key, base::Value::CreateStringValue(networkName));
 281   dictionary_value_result_ = &value;
 282   EXPECT_CALL(*mock_service_client_,
 283               SetProperties(_, _, _, _)).WillOnce(
 284                   Invoke(this,
 285                          &NetworkConfigurationHandlerTest::OnSetProperties));
 286   network_configuration_handler_->SetProperties(
 287       service_path,
 288       value,
 289       base::Bind(&base::DoNothing),
 290       base::Bind(&ErrorCallback, false, service_path));
 291   message_loop_.RunUntilIdle();
 292
 293   // Now clear it.
 294   std::vector<std::string> values_to_clear;
 295   values_to_clear.push_back(key);
 296   EXPECT_CALL(*mock_service_client_,
 297               ClearProperties(_, _, _, _)).WillOnce(
 298                   Invoke(this,
 299                          &NetworkConfigurationHandlerTest::OnClearProperties));
 300   network_configuration_handler_->ClearProperties(
 301       service_path,
 302       values_to_clear,
 303       base::Bind(&base::DoNothing),
 304       base::Bind(&ErrorCallback, false, service_path));
 305   message_loop_.RunUntilIdle();
 306 }
 307
 308 TEST_F(NetworkConfigurationHandlerTest, ClearPropertiesError) {
 309   std::string service_path = "/service/1";
 310   std::string networkName = "MyNetwork";
 311   std::string key = "SSID";
 312   scoped_ptr<base::StringValue> networkNameValue(
 313       base::Value::CreateStringValue(networkName));
 314
 315   // First set up a value to clear.
 316   base::DictionaryValue value;
 317   value.Set(key, base::Value::CreateStringValue(networkName));
 318   dictionary_value_result_ = &value;
 319   EXPECT_CALL(*mock_service_client_,
 320               SetProperties(_, _, _, _)).WillOnce(
 321                   Invoke(this,
 322                          &NetworkConfigurationHandlerTest::OnSetProperties));
 323   network_configuration_handler_->SetProperties(
 324       service_path,
 325       value,
 326       base::Bind(&base::DoNothing),
 327       base::Bind(&ErrorCallback, false, service_path));
 328   message_loop_.RunUntilIdle();
 329
 330   // Now clear it.
 331   std::vector<std::string> values_to_clear;
 332   values_to_clear.push_back(key);
 333   EXPECT_CALL(
 334       *mock_service_client_,
 335       ClearProperties(_, _, _, _)).WillOnce(
 336           Invoke(this,
 337                  &NetworkConfigurationHandlerTest::OnClearPropertiesError));
 338   network_configuration_handler_->ClearProperties(
 339       service_path,
 340       values_to_clear,
 341       base::Bind(&base::DoNothing),
 342       base::Bind(&ErrorCallback, true, service_path));
 343   message_loop_.RunUntilIdle();
 344 }
 345
 346 TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) {
 347   std::string networkName = "MyNetwork";
 348   std::string key = "SSID";
 349   std::string profile = "profile path";
 350   base::DictionaryValue value;
 351   shill_property_util::SetSSID(networkName, &value);
 352   value.SetWithoutPathExpansion(shill::kProfileProperty,
 353                                 base::Value::CreateStringValue(profile));
 354
 355   EXPECT_CALL(*mock_manager_client_,
 356               ConfigureServiceForProfile(dbus::ObjectPath(profile), _, _, _))
 357       .WillOnce(
 358            Invoke(this, &NetworkConfigurationHandlerTest::OnConfigureService));
 359   network_configuration_handler_->CreateConfiguration(
 360       value,
 361       base::Bind(&StringResultCallback, std::string("/service/2")),
 362       base::Bind(&ErrorCallback, false, std::string()));
 363   message_loop_.RunUntilIdle();
 364 }
 365
 366 TEST_F(NetworkConfigurationHandlerTest, RemoveConfiguration) {
 367   std::string service_path = "/service/1";
 368
 369   TestCallback test_callback;
 370   EXPECT_CALL(
 371       *mock_service_client_,
 372       GetLoadableProfileEntries(_, _)).WillOnce(Invoke(
 373           this,
 374           &NetworkConfigurationHandlerTest::OnGetLoadableProfileEntries));
 375   EXPECT_CALL(
 376       *mock_profile_client_,
 377       DeleteEntry(_, _, _, _)).WillRepeatedly(Invoke(
 378           this,
 379           &NetworkConfigurationHandlerTest::OnDeleteEntry));
 380
 381   network_configuration_handler_->RemoveConfiguration(
 382       service_path,
 383       base::Bind(&TestCallback::Run, base::Unretained(&test_callback)),
 384       base::Bind(&ErrorCallback, false, service_path));
 385   message_loop_.RunUntilIdle();
 386   EXPECT_EQ(1, test_callback.run_count());
 387   EXPECT_FALSE(PendingProfileEntryDeleterForTest(service_path));
 388 }
 389
 390 ////////////////////////////////////////////////////////////////////////////////
 391 // Stub based tests
 392
 393 namespace {
 394
 395 class TestObserver : public chromeos::NetworkStateHandlerObserver {
 396  public:
 397   TestObserver() : network_list_changed_count_(0) {}
 398   virtual ~TestObserver() {}
 399
 400   virtual void NetworkListChanged() OVERRIDE {
 401     ++network_list_changed_count_;
 402   }
 403
 404   virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE {
 405     property_updates_[network->path()]++;
 406   }
 407
 408   size_t network_list_changed_count() { return network_list_changed_count_; }
 409
 410   int PropertyUpdatesForService(const std::string& service_path) {
 411     return property_updates_[service_path];
 412   }
 413
 414   void ClearPropertyUpdates() {
 415     property_updates_.clear();
 416   }
 417
 418  private:
 419   size_t network_list_changed_count_;
 420   std::map<std::string, int> property_updates_;
 421
 422   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 423 };
 424
 425 }  // namespace
 426
 427 class NetworkConfigurationHandlerStubTest : public testing::Test {
 428  public:
 429   NetworkConfigurationHandlerStubTest()  {
 430   }
 431
 432   virtual ~NetworkConfigurationHandlerStubTest() {
 433   }
 434
 435   virtual void SetUp() OVERRIDE {
 436     DBusThreadManager::InitializeWithStub();
 437
 438     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
 439     test_observer_.reset(new TestObserver());
 440     network_state_handler_->AddObserver(test_observer_.get(), FROM_HERE);
 441
 442     network_configuration_handler_.reset(new NetworkConfigurationHandler());
 443     network_configuration_handler_->Init(network_state_handler_.get());
 444
 445     message_loop_.RunUntilIdle();
 446     test_observer_->ClearPropertyUpdates();
 447   }
 448
 449   virtual void TearDown() OVERRIDE {
 450     network_configuration_handler_.reset();
 451     network_state_handler_->RemoveObserver(test_observer_.get(), FROM_HERE);
 452     network_state_handler_.reset();
 453     DBusThreadManager::Shutdown();
 454   }
 455
 456   void SuccessCallback(const std::string& callback_name) {
 457     success_callback_name_ = callback_name;
 458   }
 459
 460   void GetPropertiesCallback(const std::string& service_path,
 461                              const base::DictionaryValue& dictionary) {
 462     get_properties_path_ = service_path;
 463     get_properties_.reset(dictionary.DeepCopy());
 464   }
 465
 466   void CreateConfigurationCallback(const std::string& service_path) {
 467     create_service_path_ = service_path;
 468   }
 469
 470  protected:
 471   bool GetServiceStringProperty(const std::string& service_path,
 472                                 const std::string& key,
 473                                 std::string* result) {
 474     ShillServiceClient::TestInterface* service_test =
 475         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 476     const base::DictionaryValue* properties =
 477         service_test->GetServiceProperties(service_path);
 478     if (properties && properties->GetStringWithoutPathExpansion(key, result))
 479       return true;
 480     return false;
 481   }
 482
 483   bool GetReceivedStringProperty(const std::string& service_path,
 484                                  const std::string& key,
 485                                  std::string* result) {
 486     if (get_properties_path_ != service_path)
 487       return false;
 488     if (get_properties_ &&
 489         get_properties_->GetStringWithoutPathExpansion(key, result))
 490       return true;
 491     return false;
 492   }
 493
 494   scoped_ptr<NetworkStateHandler> network_state_handler_;
 495   scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
 496   scoped_ptr<TestObserver> test_observer_;
 497   base::MessageLoopForUI message_loop_;
 498   std::string success_callback_name_;
 499   std::string get_properties_path_;
 500   scoped_ptr<base::DictionaryValue> get_properties_;
 501   std::string create_service_path_;
 502 };
 503
 504 TEST_F(NetworkConfigurationHandlerStubTest, StubSetAndClearProperties) {
 505   // TODO(stevenjb): Remove dependency on default Stub service.
 506   const std::string service_path("wifi1");
 507   const std::string test_identity("test_identity");
 508   const std::string test_passphrase("test_passphrase");
 509
 510   // Set Properties
 511   base::DictionaryValue properties_to_set;
 512   properties_to_set.SetStringWithoutPathExpansion(
 513       shill::kIdentityProperty, test_identity);
 514   properties_to_set.SetStringWithoutPathExpansion(
 515       shill::kPassphraseProperty, test_passphrase);
 516   network_configuration_handler_->SetProperties(
 517       service_path,
 518       properties_to_set,
 519       base::Bind(
 520           &NetworkConfigurationHandlerStubTest::SuccessCallback,
 521           base::Unretained(this), "SetProperties"),
 522       base::Bind(&ErrorCallback, false, service_path));
 523   message_loop_.RunUntilIdle();
 524
 525   EXPECT_EQ("SetProperties", success_callback_name_);
 526   std::string identity, passphrase;
 527   EXPECT_TRUE(GetServiceStringProperty(
 528       service_path, shill::kIdentityProperty, &identity));
 529   EXPECT_TRUE(GetServiceStringProperty(
 530       service_path, shill::kPassphraseProperty, &passphrase));
 531   EXPECT_EQ(test_identity, identity);
 532   EXPECT_EQ(test_passphrase, passphrase);
 533   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(service_path));
 534
 535   // Clear Properties
 536   std::vector<std::string> properties_to_clear;
 537   properties_to_clear.push_back(shill::kIdentityProperty);
 538   properties_to_clear.push_back(shill::kPassphraseProperty);
 539   network_configuration_handler_->ClearProperties(
 540       service_path,
 541       properties_to_clear,
 542       base::Bind(
 543           &NetworkConfigurationHandlerStubTest::SuccessCallback,
 544           base::Unretained(this), "ClearProperties"),
 545       base::Bind(&ErrorCallback, false, service_path));
 546   message_loop_.RunUntilIdle();
 547
 548   EXPECT_EQ("ClearProperties", success_callback_name_);
 549   EXPECT_FALSE(GetServiceStringProperty(
 550       service_path, shill::kIdentityProperty, &identity));
 551   EXPECT_FALSE(GetServiceStringProperty(
 552       service_path, shill::kIdentityProperty, &passphrase));
 553   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(service_path));
 554 }
 555
 556 TEST_F(NetworkConfigurationHandlerStubTest, StubGetNameFromWifiHex) {
 557   // TODO(stevenjb): Remove dependency on default Stub service.
 558   const std::string service_path("wifi1");
 559   std::string wifi_hex = "5468697320697320484558205353494421";
 560   std::string expected_name = "This is HEX SSID!";
 561
 562   // Set Properties
 563   base::DictionaryValue properties_to_set;
 564   properties_to_set.SetStringWithoutPathExpansion(
 565       shill::kWifiHexSsid, wifi_hex);
 566   network_configuration_handler_->SetProperties(
 567       service_path,
 568       properties_to_set,
 569       base::Bind(&base::DoNothing),
 570       base::Bind(&ErrorCallback, false, service_path));
 571   message_loop_.RunUntilIdle();
 572   std::string wifi_hex_result;
 573   EXPECT_TRUE(GetServiceStringProperty(
 574       service_path, shill::kWifiHexSsid, &wifi_hex_result));
 575   EXPECT_EQ(wifi_hex, wifi_hex_result);
 576
 577   // Get Properties
 578   network_configuration_handler_->GetProperties(
 579       service_path,
 580       base::Bind(&NetworkConfigurationHandlerStubTest::GetPropertiesCallback,
 581                  base::Unretained(this)),
 582       base::Bind(&ErrorCallback, false, service_path));
 583   message_loop_.RunUntilIdle();
 584
 585   EXPECT_EQ(service_path, get_properties_path_);
 586   std::string name_result;
 587   EXPECT_TRUE(GetReceivedStringProperty(
 588       service_path, shill::kNameProperty, &name_result));
 589   EXPECT_EQ(expected_name, name_result);
 590 }
 591
 592 TEST_F(NetworkConfigurationHandlerStubTest, StubCreateConfiguration) {
 593   const std::string service_path("test_wifi");
 594   base::DictionaryValue properties;
 595   shill_property_util::SetSSID(service_path, &properties);
 596   properties.SetStringWithoutPathExpansion(shill::kNameProperty, service_path);
 597   properties.SetStringWithoutPathExpansion(shill::kGuidProperty, service_path);
 598   properties.SetStringWithoutPathExpansion(
 599       shill::kTypeProperty, shill::kTypeWifi);
 600   properties.SetStringWithoutPathExpansion(
 601       shill::kStateProperty, shill::kStateIdle);
 602   properties.SetStringWithoutPathExpansion(
 603       shill::kProfileProperty, shill_stub_helper::kSharedProfilePath);
 604
 605   network_configuration_handler_->CreateConfiguration(
 606       properties,
 607       base::Bind(
 608           &NetworkConfigurationHandlerStubTest::CreateConfigurationCallback,
 609           base::Unretained(this)),
 610       base::Bind(&ErrorCallback, false, service_path));
 611   message_loop_.RunUntilIdle();
 612
 613   EXPECT_FALSE(create_service_path_.empty());
 614
 615   std::string guid;
 616   EXPECT_TRUE(GetServiceStringProperty(
 617       create_service_path_, shill::kGuidProperty, &guid));
 618   EXPECT_EQ(service_path, guid);
 619
 620   std::string actual_profile;
 621   EXPECT_TRUE(GetServiceStringProperty(
 622       create_service_path_, shill::kProfileProperty, &actual_profile));
 623   EXPECT_EQ(shill_stub_helper::kSharedProfilePath, actual_profile);
 624 }
 625
 626 }  // namespace chromeos