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/network/network_state_handler.h" 6 7 #include <map> 8 #include <set> 9 #include <string> 10 11 #include "base/bind.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/message_loop/message_loop.h" 14 #include "base/values.h" 15 #include "chromeos/dbus/dbus_thread_manager.h" 16 #include "chromeos/dbus/shill_device_client.h" 17 #include "chromeos/dbus/shill_ipconfig_client.h" 18 #include "chromeos/dbus/shill_manager_client.h" 19 #include "chromeos/dbus/shill_profile_client.h" 20 #include "chromeos/dbus/shill_service_client.h" 21 #include "chromeos/network/device_state.h" 22 #include "chromeos/network/network_state.h" 23 #include "chromeos/network/network_state_handler.h" 24 #include "chromeos/network/network_state_handler_observer.h" 25 #include "dbus/object_path.h" 26 #include "testing/gtest/include/gtest/gtest.h" 27 #include "third_party/cros_system_api/dbus/service_constants.h" 28 29 namespace { 30 31 void ErrorCallbackFunction(const std::string& error_name, 32 const std::string& error_message) { 33 LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message; 34 } 35 36 const std::string kShillManagerClientStubWifiDevice = 37 "/device/stub_wifi_device1"; 38 const std::string kShillManagerClientStubCellularDevice = 39 "/device/stub_cellular_device1"; 40 const std::string kShillManagerClientStubDefaultService = "/service/eth1"; 41 const std::string kShillManagerClientStubDefaultWifi = "/service/wifi1"; 42 const std::string kShillManagerClientStubWifi2 = "/service/wifi2"; 43 const std::string kShillManagerClientStubCellular = "/service/cellular1"; 44 45 using chromeos::DeviceState; 46 using chromeos::NetworkState; 47 using chromeos::NetworkStateHandler; 48 49 class TestObserver : public chromeos::NetworkStateHandlerObserver { 50 public: 51 explicit TestObserver(NetworkStateHandler* handler) 52 : handler_(handler), 53 device_list_changed_count_(0), 54 device_count_(0), 55 network_list_changed_count_(0), 56 network_count_(0), 57 default_network_change_count_(0) { 58 } 59 60 virtual ~TestObserver() { 61 } 62 63 virtual void DeviceListChanged() OVERRIDE { 64 NetworkStateHandler::DeviceStateList devices; 65 handler_->GetDeviceList(&devices); 66 device_count_ = devices.size(); 67 ++device_list_changed_count_; 68 } 69 70 virtual void NetworkListChanged() OVERRIDE { 71 NetworkStateHandler::NetworkStateList networks; 72 handler_->GetNetworkListByType(chromeos::NetworkTypePattern::Default(), 73 false /* configured_only */, 74 false /* visible_only */, 75 0 /* no limit */, 76 &networks); 77 network_count_ = networks.size(); 78 if (network_count_ == 0) { 79 default_network_ = ""; 80 default_network_connection_state_ = ""; 81 } 82 ++network_list_changed_count_; 83 } 84 85 virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE { 86 ++default_network_change_count_; 87 default_network_ = network ? network->path() : ""; 88 default_network_connection_state_ = 89 network ? network->connection_state() : ""; 90 DVLOG(1) << "DefaultNetworkChanged: " << default_network_ 91 << " State: " << default_network_connection_state_; 92 } 93 94 virtual void NetworkConnectionStateChanged( 95 const NetworkState* network) OVERRIDE { 96 network_connection_state_[network->path()] = network->connection_state(); 97 connection_state_changes_[network->path()]++; 98 } 99 100 virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE { 101 DCHECK(network); 102 property_updates_[network->path()]++; 103 } 104 105 virtual void DevicePropertiesUpdated(const DeviceState* device) OVERRIDE { 106 DCHECK(device); 107 device_property_updates_[device->path()]++; 108 } 109 110 size_t device_list_changed_count() { return device_list_changed_count_; } 111 size_t device_count() { return device_count_; } 112 size_t network_list_changed_count() { return network_list_changed_count_; } 113 size_t network_count() { return network_count_; } 114 size_t default_network_change_count() { 115 return default_network_change_count_; 116 } 117 void reset_change_counts() { 118 DVLOG(1) << "=== RESET CHANGE COUNTS ==="; 119 default_network_change_count_ = 0; 120 device_list_changed_count_ = 0; 121 network_list_changed_count_ = 0; 122 connection_state_changes_.clear(); 123 } 124 void reset_updates() { 125 property_updates_.clear(); 126 device_property_updates_.clear(); 127 } 128 std::string default_network() { return default_network_; } 129 std::string default_network_connection_state() { 130 return default_network_connection_state_; 131 } 132 133 int PropertyUpdatesForService(const std::string& service_path) { 134 return property_updates_[service_path]; 135 } 136 137 int PropertyUpdatesForDevice(const std::string& device_path) { 138 return device_property_updates_[device_path]; 139 } 140 141 int ConnectionStateChangesForService(const std::string& service_path) { 142 return connection_state_changes_[service_path]; 143 } 144 145 std::string NetworkConnectionStateForService( 146 const std::string& service_path) { 147 return network_connection_state_[service_path]; 148 } 149 150 private: 151 NetworkStateHandler* handler_; 152 size_t device_list_changed_count_; 153 size_t device_count_; 154 size_t network_list_changed_count_; 155 size_t network_count_; 156 size_t default_network_change_count_; 157 std::string default_network_; 158 std::string default_network_connection_state_; 159 std::map<std::string, int> property_updates_; 160 std::map<std::string, int> device_property_updates_; 161 std::map<std::string, int> connection_state_changes_; 162 std::map<std::string, std::string> network_connection_state_; 163 164 DISALLOW_COPY_AND_ASSIGN(TestObserver); 165 }; 166 167 } // namespace 168 169 namespace chromeos { 170 171 class NetworkStateHandlerTest : public testing::Test { 172 public: 173 NetworkStateHandlerTest() 174 : device_test_(NULL), 175 manager_test_(NULL), 176 profile_test_(NULL), 177 service_test_(NULL) {} 178 virtual ~NetworkStateHandlerTest() {} 179 180 virtual void SetUp() OVERRIDE { 181 // Initialize DBusThreadManager with a stub implementation. 182 DBusThreadManager::Initialize(); 183 SetupDefaultShillState(); 184 network_state_handler_.reset(new NetworkStateHandler); 185 test_observer_.reset(new TestObserver(network_state_handler_.get())); 186 network_state_handler_->AddObserver(test_observer_.get(), FROM_HERE); 187 network_state_handler_->InitShillPropertyHandler(); 188 message_loop_.RunUntilIdle(); 189 test_observer_->reset_change_counts(); 190 } 191 192 virtual void TearDown() OVERRIDE { 193 network_state_handler_->RemoveObserver(test_observer_.get(), FROM_HERE); 194 test_observer_.reset(); 195 network_state_handler_.reset(); 196 DBusThreadManager::Shutdown(); 197 } 198 199 protected: 200 void AddService(const std::string& service_path, 201 const std::string& guid, 202 const std::string& name, 203 const std::string& type, 204 const std::string& state) { 205 service_test_->AddService(service_path, guid, name, type, state, 206 true /* add_to_visible */); 207 } 208 209 void SetupDefaultShillState() { 210 message_loop_.RunUntilIdle(); // Process any pending updates 211 device_test_ = 212 DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface(); 213 ASSERT_TRUE(device_test_); 214 device_test_->ClearDevices(); 215 device_test_->AddDevice(kShillManagerClientStubWifiDevice, 216 shill::kTypeWifi, "stub_wifi_device1"); 217 device_test_->AddDevice(kShillManagerClientStubCellularDevice, 218 shill::kTypeCellular, "stub_cellular_device1"); 219 220 manager_test_ = 221 DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface(); 222 ASSERT_TRUE(manager_test_); 223 224 profile_test_ = 225 DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface(); 226 ASSERT_TRUE(profile_test_); 227 profile_test_->ClearProfiles(); 228 229 service_test_ = 230 DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface(); 231 ASSERT_TRUE(service_test_); 232 service_test_->ClearServices(); 233 AddService(kShillManagerClientStubDefaultService, 234 "eth1_guid", 235 "eth1", 236 shill::kTypeEthernet, 237 shill::kStateOnline); 238 AddService(kShillManagerClientStubDefaultWifi, 239 "wifi1_guid", 240 "wifi1", 241 shill::kTypeWifi, 242 shill::kStateOnline); 243 AddService(kShillManagerClientStubWifi2, 244 "wifi2_guid", 245 "wifi2", 246 shill::kTypeWifi, 247 shill::kStateIdle); 248 AddService(kShillManagerClientStubCellular, 249 "cellular1_guid", 250 "cellular1", 251 shill::kTypeCellular, 252 shill::kStateIdle); 253 } 254 255 void UpdateManagerProperties() { 256 message_loop_.RunUntilIdle(); 257 } 258 259 base::MessageLoopForUI message_loop_; 260 scoped_ptr<NetworkStateHandler> network_state_handler_; 261 scoped_ptr<TestObserver> test_observer_; 262 ShillDeviceClient::TestInterface* device_test_; 263 ShillManagerClient::TestInterface* manager_test_; 264 ShillProfileClient::TestInterface* profile_test_; 265 ShillServiceClient::TestInterface* service_test_; 266 267 private: 268 DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerTest); 269 }; 270 271 TEST_F(NetworkStateHandlerTest, NetworkStateHandlerStub) { 272 // Ensure that the device and network list are the expected size. 273 const size_t kNumShillManagerClientStubImplDevices = 2; 274 EXPECT_EQ(kNumShillManagerClientStubImplDevices, 275 test_observer_->device_count()); 276 const size_t kNumShillManagerClientStubImplServices = 4; 277 EXPECT_EQ(kNumShillManagerClientStubImplServices, 278 test_observer_->network_count()); 279 // Ensure that the first stub network is the default network. 280 EXPECT_EQ(kShillManagerClientStubDefaultService, 281 test_observer_->default_network()); 282 ASSERT_TRUE(network_state_handler_->DefaultNetwork()); 283 EXPECT_EQ(kShillManagerClientStubDefaultService, 284 network_state_handler_->DefaultNetwork()->path()); 285 EXPECT_EQ(kShillManagerClientStubDefaultService, 286 network_state_handler_->ConnectedNetworkByType( 287 NetworkTypePattern::Ethernet())->path()); 288 EXPECT_EQ(kShillManagerClientStubDefaultWifi, 289 network_state_handler_->ConnectedNetworkByType( 290 NetworkTypePattern::WiFi())->path()); 291 EXPECT_EQ(kShillManagerClientStubCellular, 292 network_state_handler_->FirstNetworkByType( 293 NetworkTypePattern::Mobile())->path()); 294 EXPECT_EQ( 295 kShillManagerClientStubCellular, 296 network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular()) 297 ->path()); 298 EXPECT_EQ(shill::kStateOnline, 299 test_observer_->default_network_connection_state()); 300 } 301 302 TEST_F(NetworkStateHandlerTest, GetNetworkList) { 303 // Ensure that the network list is the expected size. 304 const size_t kNumShillManagerClientStubImplServices = 4; 305 EXPECT_EQ(kNumShillManagerClientStubImplServices, 306 test_observer_->network_count()); 307 // Add a non-visible network to the profile. 308 const std::string profile = "/profile/profile1"; 309 const std::string wifi_favorite_path = "/service/wifi_faviorite"; 310 service_test_->AddService(wifi_favorite_path, 311 "wifi_faviorite_guid", 312 "wifi_faviorite", 313 shill::kTypeWifi, 314 shill::kStateIdle, 315 false /* add_to_visible */); 316 profile_test_->AddProfile(profile, "" /* userhash */); 317 EXPECT_TRUE(profile_test_->AddService(profile, wifi_favorite_path)); 318 UpdateManagerProperties(); 319 message_loop_.RunUntilIdle(); 320 EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, 321 test_observer_->network_count()); 322 323 // Get all networks. 324 NetworkStateHandler::NetworkStateList networks; 325 network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(), 326 false /* configured_only */, 327 false /* visible_only */, 328 0 /* no limit */, 329 &networks); 330 EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, networks.size()); 331 // Limit number of results. 332 network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(), 333 false /* configured_only */, 334 false /* visible_only */, 335 2 /* limit */, 336 &networks); 337 EXPECT_EQ(2u, networks.size()); 338 // Get all wifi networks. 339 network_state_handler_->GetNetworkListByType(NetworkTypePattern::WiFi(), 340 false /* configured_only */, 341 false /* visible_only */, 342 0 /* no limit */, 343 &networks); 344 EXPECT_EQ(3u, networks.size()); 345 // Get visible networks. 346 network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(), 347 false /* configured_only */, 348 true /* visible_only */, 349 0 /* no limit */, 350 &networks); 351 EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size()); 352 network_state_handler_->GetVisibleNetworkList(&networks); 353 EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size()); 354 // Get configured (profile) networks. 355 network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(), 356 true /* configured_only */, 357 false /* visible_only */, 358 0 /* no limit */, 359 &networks); 360 EXPECT_EQ(1u, networks.size()); 361 } 362 363 TEST_F(NetworkStateHandlerTest, NetworkListChanged) { 364 size_t stub_network_count = test_observer_->network_count(); 365 // Set up two additional visible networks. 366 const std::string wifi3 = "/service/wifi3"; 367 const std::string wifi4 = "/service/wifi4"; 368 service_test_->SetServiceProperties( 369 wifi3, "wifi3_guid", "wifi3", 370 shill::kTypeWifi, shill::kStateIdle, true /* visible */); 371 service_test_->SetServiceProperties( 372 wifi4, "wifi4_guid", "wifi4", 373 shill::kTypeWifi, shill::kStateIdle, true /* visible */); 374 // Add the services to the Manager. Only notify when the second service is 375 // added. 376 manager_test_->AddManagerService(wifi3, false); 377 manager_test_->AddManagerService(wifi4, true); 378 UpdateManagerProperties(); 379 // Expect two service updates and one list update. 380 EXPECT_EQ(stub_network_count + 2, test_observer_->network_count()); 381 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(wifi3)); 382 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(wifi4)); 383 EXPECT_EQ(1u, test_observer_->network_list_changed_count()); 384 } 385 386 TEST_F(NetworkStateHandlerTest, GetVisibleNetworks) { 387 // Ensure that the network list is the expected size. 388 const size_t kNumShillManagerClientStubImplServices = 4; 389 EXPECT_EQ(kNumShillManagerClientStubImplServices, 390 test_observer_->network_count()); 391 // Add a non-visible network to the profile. 392 const std::string profile = "/profile/profile1"; 393 const std::string wifi_favorite_path = "/service/wifi_faviorite"; 394 service_test_->AddService(wifi_favorite_path, 395 "wifi_faviorite_guid", 396 "wifi_faviorite", 397 shill::kTypeWifi, 398 shill::kStateIdle, 399 false /* add_to_visible */); 400 message_loop_.RunUntilIdle(); 401 EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, 402 test_observer_->network_count()); 403 404 // Get visible networks. 405 NetworkStateHandler::NetworkStateList networks; 406 network_state_handler_->GetVisibleNetworkList(&networks); 407 EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size()); 408 409 // Change the visible state of a network. 410 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( 411 dbus::ObjectPath(kShillManagerClientStubWifi2), 412 shill::kVisibleProperty, base::FundamentalValue(false), 413 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); 414 message_loop_.RunUntilIdle(); 415 network_state_handler_->GetVisibleNetworkList(&networks); 416 EXPECT_EQ(kNumShillManagerClientStubImplServices - 1, networks.size()); 417 } 418 419 TEST_F(NetworkStateHandlerTest, TechnologyChanged) { 420 // Disable a technology. Will immediately set the state to AVAILABLE and 421 // notify observers. 422 network_state_handler_->SetTechnologyEnabled( 423 NetworkTypePattern::WiFi(), false, network_handler::ErrorCallback()); 424 EXPECT_EQ(1u, test_observer_->device_list_changed_count()); 425 EXPECT_EQ( 426 NetworkStateHandler::TECHNOLOGY_AVAILABLE, 427 network_state_handler_->GetTechnologyState(NetworkTypePattern::WiFi())); 428 429 // Run the message loop. An additional notification will be received when 430 // Shill updates the enabled technologies. The state should remain AVAILABLE. 431 test_observer_->reset_change_counts(); 432 message_loop_.RunUntilIdle(); 433 EXPECT_EQ(1u, test_observer_->device_list_changed_count()); 434 EXPECT_EQ( 435 NetworkStateHandler::TECHNOLOGY_AVAILABLE, 436 network_state_handler_->GetTechnologyState(NetworkTypePattern::WiFi())); 437 438 // Enable a technology. Will immediately set the state to ENABLING and 439 // notify observers. 440 test_observer_->reset_change_counts(); 441 network_state_handler_->SetTechnologyEnabled( 442 NetworkTypePattern::WiFi(), true, network_handler::ErrorCallback()); 443 EXPECT_EQ(1u, test_observer_->device_list_changed_count()); 444 EXPECT_EQ( 445 NetworkStateHandler::TECHNOLOGY_ENABLING, 446 network_state_handler_->GetTechnologyState(NetworkTypePattern::WiFi())); 447 448 // Run the message loop. State should change to ENABLED. 449 test_observer_->reset_change_counts(); 450 message_loop_.RunUntilIdle(); 451 EXPECT_EQ(1u, test_observer_->device_list_changed_count()); 452 EXPECT_EQ( 453 NetworkStateHandler::TECHNOLOGY_ENABLED, 454 network_state_handler_->GetTechnologyState(NetworkTypePattern::WiFi())); 455 } 456 457 TEST_F(NetworkStateHandlerTest, TechnologyState) { 458 manager_test_->RemoveTechnology(shill::kTypeWimax); 459 message_loop_.RunUntilIdle(); 460 EXPECT_EQ( 461 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, 462 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); 463 464 manager_test_->AddTechnology(shill::kTypeWimax, false); 465 message_loop_.RunUntilIdle(); 466 EXPECT_EQ( 467 NetworkStateHandler::TECHNOLOGY_AVAILABLE, 468 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); 469 470 manager_test_->SetTechnologyInitializing(shill::kTypeWimax, true); 471 message_loop_.RunUntilIdle(); 472 EXPECT_EQ( 473 NetworkStateHandler::TECHNOLOGY_UNINITIALIZED, 474 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); 475 476 manager_test_->SetTechnologyInitializing(shill::kTypeWimax, false); 477 network_state_handler_->SetTechnologyEnabled( 478 NetworkTypePattern::Wimax(), true, network_handler::ErrorCallback()); 479 message_loop_.RunUntilIdle(); 480 EXPECT_EQ( 481 NetworkStateHandler::TECHNOLOGY_ENABLED, 482 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); 483 484 manager_test_->RemoveTechnology(shill::kTypeWimax); 485 message_loop_.RunUntilIdle(); 486 EXPECT_EQ( 487 NetworkStateHandler::TECHNOLOGY_UNAVAILABLE, 488 network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax())); 489 } 490 491 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) { 492 // Set a service property. 493 const std::string eth1 = kShillManagerClientStubDefaultService; 494 const NetworkState* ethernet = network_state_handler_->GetNetworkState(eth1); 495 ASSERT_TRUE(ethernet); 496 EXPECT_EQ("", ethernet->security()); 497 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth1)); 498 base::StringValue security_value("TestSecurity"); 499 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( 500 dbus::ObjectPath(eth1), 501 shill::kSecurityProperty, security_value, 502 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); 503 message_loop_.RunUntilIdle(); 504 ethernet = network_state_handler_->GetNetworkState(eth1); 505 EXPECT_EQ("TestSecurity", ethernet->security()); 506 EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1)); 507 508 // Changing a service to the existing value should not trigger an update. 509 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( 510 dbus::ObjectPath(eth1), 511 shill::kSecurityProperty, security_value, 512 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); 513 message_loop_.RunUntilIdle(); 514 EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1)); 515 } 516 517 TEST_F(NetworkStateHandlerTest, GetState) { 518 const std::string profile = "/profile/profile1"; 519 const std::string wifi_path = kShillManagerClientStubDefaultWifi; 520 521 // Add a wifi service to a Profile. 522 profile_test_->AddProfile(profile, "" /* userhash */); 523 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); 524 UpdateManagerProperties(); 525 526 // Ensure that a NetworkState exists. 527 const NetworkState* wifi_network = 528 network_state_handler_->GetNetworkStateFromServicePath( 529 wifi_path, true /* configured_only */); 530 ASSERT_TRUE(wifi_network); 531 532 // Test looking up by GUID. 533 ASSERT_FALSE(wifi_network->guid().empty()); 534 const NetworkState* wifi_network_guid = 535 network_state_handler_->GetNetworkStateFromGuid(wifi_network->guid()); 536 EXPECT_EQ(wifi_network, wifi_network_guid); 537 538 // Remove the service, verify that there is no longer a NetworkState for it. 539 service_test_->RemoveService(wifi_path); 540 UpdateManagerProperties(); 541 EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path)); 542 } 543 544 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) { 545 const std::string eth1 = kShillManagerClientStubDefaultService; 546 EXPECT_EQ(0, test_observer_->ConnectionStateChangesForService(eth1)); 547 548 // Change a network state. 549 base::StringValue connection_state_idle_value(shill::kStateIdle); 550 service_test_->SetServiceProperty(eth1, shill::kStateProperty, 551 connection_state_idle_value); 552 message_loop_.RunUntilIdle(); 553 EXPECT_EQ(shill::kStateIdle, 554 test_observer_->NetworkConnectionStateForService(eth1)); 555 EXPECT_EQ(1, test_observer_->ConnectionStateChangesForService(eth1)); 556 // Confirm that changing the connection state to the same value does *not* 557 // signal the observer. 558 service_test_->SetServiceProperty(eth1, shill::kStateProperty, 559 connection_state_idle_value); 560 message_loop_.RunUntilIdle(); 561 EXPECT_EQ(1, test_observer_->ConnectionStateChangesForService(eth1)); 562 } 563 564 TEST_F(NetworkStateHandlerTest, DefaultServiceDisconnected) { 565 const std::string eth1 = kShillManagerClientStubDefaultService; 566 const std::string wifi1 = kShillManagerClientStubDefaultWifi; 567 568 EXPECT_EQ(0u, test_observer_->default_network_change_count()); 569 // Disconnect ethernet. 570 base::StringValue connection_state_idle_value(shill::kStateIdle); 571 service_test_->SetServiceProperty(eth1, shill::kStateProperty, 572 connection_state_idle_value); 573 message_loop_.RunUntilIdle(); 574 // Expect two changes: first when eth1 becomes disconnected, second when 575 // wifi1 becomes the default. 576 EXPECT_EQ(2u, test_observer_->default_network_change_count()); 577 EXPECT_EQ(wifi1, test_observer_->default_network()); 578 579 // Disconnect wifi. 580 test_observer_->reset_change_counts(); 581 service_test_->SetServiceProperty(wifi1, shill::kStateProperty, 582 connection_state_idle_value); 583 message_loop_.RunUntilIdle(); 584 EXPECT_EQ(1u, test_observer_->default_network_change_count()); 585 EXPECT_EQ("", test_observer_->default_network()); 586 } 587 588 TEST_F(NetworkStateHandlerTest, DefaultServiceConnected) { 589 const std::string eth1 = kShillManagerClientStubDefaultService; 590 const std::string wifi1 = kShillManagerClientStubDefaultWifi; 591 592 // Disconnect ethernet and wifi. 593 base::StringValue connection_state_idle_value(shill::kStateIdle); 594 service_test_->SetServiceProperty(eth1, shill::kStateProperty, 595 connection_state_idle_value); 596 service_test_->SetServiceProperty(wifi1, shill::kStateProperty, 597 connection_state_idle_value); 598 message_loop_.RunUntilIdle(); 599 EXPECT_EQ(std::string(), test_observer_->default_network()); 600 601 // Connect ethernet, should become the default network. 602 test_observer_->reset_change_counts(); 603 base::StringValue connection_state_ready_value(shill::kStateReady); 604 service_test_->SetServiceProperty(eth1, shill::kStateProperty, 605 connection_state_ready_value); 606 message_loop_.RunUntilIdle(); 607 EXPECT_EQ(eth1, test_observer_->default_network()); 608 EXPECT_EQ(shill::kStateReady, 609 test_observer_->default_network_connection_state()); 610 EXPECT_EQ(1u, test_observer_->default_network_change_count()); 611 } 612 613 TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) { 614 const std::string eth1 = kShillManagerClientStubDefaultService; 615 // The default service should be eth1. 616 EXPECT_EQ(eth1, test_observer_->default_network()); 617 618 // Change the default network by changing Manager.DefaultService. 619 const std::string wifi1 = kShillManagerClientStubDefaultWifi; 620 base::StringValue wifi1_value(wifi1); 621 manager_test_->SetManagerProperty( 622 shill::kDefaultServiceProperty, wifi1_value); 623 message_loop_.RunUntilIdle(); 624 EXPECT_EQ(wifi1, test_observer_->default_network()); 625 EXPECT_EQ(1u, test_observer_->default_network_change_count()); 626 627 // Change the state of the default network. 628 test_observer_->reset_change_counts(); 629 base::StringValue connection_state_ready_value(shill::kStateReady); 630 service_test_->SetServiceProperty(wifi1, shill::kStateProperty, 631 connection_state_ready_value); 632 message_loop_.RunUntilIdle(); 633 EXPECT_EQ(shill::kStateReady, 634 test_observer_->default_network_connection_state()); 635 EXPECT_EQ(1u, test_observer_->default_network_change_count()); 636 637 // Updating a property on the default network should trigger 638 // a default network change. 639 test_observer_->reset_change_counts(); 640 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( 641 dbus::ObjectPath(wifi1), 642 shill::kSecurityProperty, base::StringValue("TestSecurity"), 643 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); 644 message_loop_.RunUntilIdle(); 645 EXPECT_EQ(1u, test_observer_->default_network_change_count()); 646 647 // No default network updates for signal strength changes. 648 test_observer_->reset_change_counts(); 649 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( 650 dbus::ObjectPath(wifi1), 651 shill::kSignalStrengthProperty, base::FundamentalValue(32), 652 base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction)); 653 message_loop_.RunUntilIdle(); 654 EXPECT_EQ(0u, test_observer_->default_network_change_count()); 655 } 656 657 TEST_F(NetworkStateHandlerTest, RequestUpdate) { 658 // Request an update for kShillManagerClientStubDefaultWifi. 659 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService( 660 kShillManagerClientStubDefaultWifi)); 661 network_state_handler_->RequestUpdateForNetwork( 662 kShillManagerClientStubDefaultWifi); 663 message_loop_.RunUntilIdle(); 664 EXPECT_EQ(2, test_observer_->PropertyUpdatesForService( 665 kShillManagerClientStubDefaultWifi)); 666 } 667 668 TEST_F(NetworkStateHandlerTest, NetworkGuidInProfile) { 669 const std::string profile = "/profile/profile1"; 670 const std::string wifi_path = "/service/wifi_with_guid"; 671 const std::string wifi_guid = "wifi_guid"; 672 const std::string wifi_name = "WifiWithGuid"; 673 const bool is_service_configured = true; 674 675 // Add a network to the default Profile with a specified GUID. 676 AddService(wifi_path, wifi_guid, wifi_name, 677 shill::kTypeWifi, shill::kStateOnline); 678 profile_test_->AddProfile(profile, "" /* userhash */); 679 EXPECT_TRUE(profile_test_->AddService(profile, wifi_path)); 680 UpdateManagerProperties(); 681 682 // Verify that a NetworkState exists with a matching GUID. 683 const NetworkState* network = 684 network_state_handler_->GetNetworkStateFromServicePath( 685 wifi_path, is_service_configured); 686 ASSERT_TRUE(network); 687 EXPECT_EQ(wifi_guid, network->guid()); 688 689 // Remove the service (simulating a network going out of range). 690 service_test_->RemoveService(wifi_path); 691 UpdateManagerProperties(); 692 EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path)); 693 694 // Add the service (simulating a network coming back in range) and verify that 695 // the NetworkState was created with the same GUID. 696 AddService(wifi_path, "" /* guid */, wifi_name, 697 shill::kTypeWifi, shill::kStateOnline); 698 UpdateManagerProperties(); 699 network = network_state_handler_->GetNetworkStateFromServicePath( 700 wifi_path, is_service_configured); 701 ASSERT_TRUE(network); 702 EXPECT_EQ(wifi_guid, network->guid()); 703 } 704 705 TEST_F(NetworkStateHandlerTest, NetworkGuidNotInProfile) { 706 const std::string wifi_path = "/service/wifi_with_guid"; 707 const std::string wifi_name = "WifiWithGuid"; 708 const bool is_service_configured = false; 709 710 // Add a network without specifying a GUID or adding it to a profile. 711 AddService(wifi_path, "" /* guid */, wifi_name, 712 shill::kTypeWifi, shill::kStateOnline); 713 UpdateManagerProperties(); 714 715 // Verify that a NetworkState exists with an assigned GUID. 716 const NetworkState* network = 717 network_state_handler_->GetNetworkStateFromServicePath( 718 wifi_path, is_service_configured); 719 ASSERT_TRUE(network); 720 std::string wifi_guid = network->guid(); 721 EXPECT_FALSE(wifi_guid.empty()); 722 723 // Remove the service (simulating a network going out of range). 724 service_test_->RemoveService(wifi_path); 725 UpdateManagerProperties(); 726 EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path)); 727 728 // Add the service (simulating a network coming back in range) and verify that 729 // the NetworkState was created with the same GUID. 730 AddService(wifi_path, "" /* guid */, wifi_name, 731 shill::kTypeWifi, shill::kStateOnline); 732 UpdateManagerProperties(); 733 network = network_state_handler_->GetNetworkStateFromServicePath( 734 wifi_path, is_service_configured); 735 ASSERT_TRUE(network); 736 EXPECT_EQ(wifi_guid, network->guid()); 737 } 738 739 TEST_F(NetworkStateHandlerTest, DeviceListChanged) { 740 size_t stub_device_count = test_observer_->device_count(); 741 // Add an additional device. 742 const std::string wifi_device = "/service/stub_wifi_device2"; 743 device_test_->AddDevice(wifi_device, shill::kTypeWifi, "stub_wifi_device2"); 744 UpdateManagerProperties(); 745 // Expect a device list update. 746 EXPECT_EQ(stub_device_count + 1, test_observer_->device_count()); 747 EXPECT_EQ(0, test_observer_->PropertyUpdatesForDevice(wifi_device)); 748 // Change a device property. 749 device_test_->SetDeviceProperty( 750 wifi_device, shill::kScanningProperty, base::FundamentalValue(true)); 751 UpdateManagerProperties(); 752 EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(wifi_device)); 753 } 754 755 TEST_F(NetworkStateHandlerTest, IPConfigChanged) { 756 test_observer_->reset_updates(); 757 EXPECT_EQ(0, test_observer_->PropertyUpdatesForDevice( 758 kShillManagerClientStubWifiDevice)); 759 EXPECT_EQ(0, test_observer_->PropertyUpdatesForService( 760 kShillManagerClientStubDefaultWifi)); 761 762 // Change IPConfigs property. 763 ShillIPConfigClient::TestInterface* ip_config_test = 764 DBusThreadManager::Get()->GetShillIPConfigClient()->GetTestInterface(); 765 const std::string kIPConfigPath = "test_ip_config"; 766 base::DictionaryValue ip_config_properties; 767 ip_config_test->AddIPConfig(kIPConfigPath, ip_config_properties); 768 base::ListValue device_ip_configs; 769 device_ip_configs.Append(new base::StringValue(kIPConfigPath)); 770 device_test_->SetDeviceProperty( 771 kShillManagerClientStubWifiDevice, shill::kIPConfigsProperty, 772 device_ip_configs); 773 service_test_->SetServiceProperty( 774 kShillManagerClientStubDefaultWifi, shill::kIPConfigProperty, 775 base::StringValue(kIPConfigPath)); 776 UpdateManagerProperties(); 777 EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice( 778 kShillManagerClientStubWifiDevice)); 779 EXPECT_EQ(1, test_observer_->PropertyUpdatesForService( 780 kShillManagerClientStubDefaultWifi)); 781 } 782 783 } // namespace chromeos 784
