network_state_handler_unittest.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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
29namespace {
30
31void ErrorCallbackFunction(const std::string& error_name,
32                           const std::string& error_message) {
33  LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
34}
35
36const std::string kShillManagerClientStubWifiDevice =
37    "/device/stub_wifi_device1";
38const std::string kShillManagerClientStubCellularDevice =
39    "/device/stub_cellular_device1";
40const std::string kShillManagerClientStubDefaultService = "/service/eth1";
41const std::string kShillManagerClientStubDefaultWifi = "/service/wifi1";
42const std::string kShillManagerClientStubWifi2 = "/service/wifi2";
43const std::string kShillManagerClientStubCellular = "/service/cellular1";
44
45using chromeos::DeviceState;
46using chromeos::NetworkState;
47using chromeos::NetworkStateHandler;
48
49class 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
169namespace chromeos {
170
171class 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::InitializeWithStub();
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
271TEST_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
302TEST_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
363TEST_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
386TEST_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
419TEST_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
457TEST_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
491TEST_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
517TEST_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
544TEST_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
564TEST_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
588TEST_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
613TEST_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
657TEST_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
668TEST_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
705TEST_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
739TEST_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
755TEST_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