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