[CrOS Tether] Update NetworkState to include tether properties and integrate into NetworkStateHandl…

chromeos/network/network_state_handler_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/network/network_state_handler.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 36 matching lines @@
 const char kShillManagerClientStubWifi2[] = "/service/wifi2";
 const char kShillManagerClientStubCellular[] = "/service/cellular1";
 
 const char kWifiGuid1[] = "wifi1";
 const char kWifiName1[] = "WiFi 1";
 
 const char kTetherGuid1[] = "tether1";
 const char kTetherGuid2[] = "tether2";
 const char kTetherName1[] = "Device1";
 const char kTetherName2[] = "Device2";
+const char kTetherCarrier1[] = "Carrier1";
+const char kTetherCarrier2[] = "Carrier2";
+const int kTetherBatteryPercentage1 = 85;
+const int kTetherBatteryPercentage2 = 90;
+const int kTetherSignalStrength1 = 75;
+const int kTetherSignalStrength2 = 80;
 
 using chromeos::DeviceState;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 
 class TestObserver : public chromeos::NetworkStateHandlerObserver {
  public:
   explicit TestObserver(NetworkStateHandler* handler)
       : handler_(handler),
         device_list_changed_count_(0),
@@ skipping 201 matching lines @@
   void UpdateManagerProperties() { base::RunLoop().RunUntilIdle(); }
 
   void SetServiceProperty(const std::string& service_path,
                           const std::string& key,
                           const base::Value& value) {
     DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
         dbus::ObjectPath(service_path), key, value,
         base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   }
 
+  void GetTetherNetworkList(int limit,
+                            NetworkStateHandler::NetworkStateList* list) {
+    network_state_handler_->GetTetherNetworkList(limit, list);
+  }
+
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<NetworkStateHandler> network_state_handler_;
   std::unique_ptr<TestObserver> test_observer_;
   ShillDeviceClient::TestInterface* device_test_;
   ShillManagerClient::TestInterface* manager_test_;
   ShillProfileClient::TestInterface* profile_test_;
   ShillServiceClient::TestInterface* service_test_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerTest);
@@ skipping 44 matching lines @@
                             shill::kTypeWifi,
                             shill::kStateIdle,
                             false /* add_to_visible */);
   profile_test_->AddProfile(profile, "" /* userhash */);
   EXPECT_TRUE(profile_test_->AddService(profile, wifi_favorite_path));
   UpdateManagerProperties();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kNumShillManagerClientStubImplServices + 1,
             test_observer_->network_count());
 
+  // Add two Tether networks.
+  const size_t kNumTetherNetworks = 2;
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid2, kTetherName2, kTetherCarrier2, kTetherBatteryPercentage2,
+      kTetherSignalStrength2);
+  EXPECT_EQ(kNumShillManagerClientStubImplServices + 3,
+            test_observer_->network_count());
+
   // Get all networks.
   NetworkStateHandler::NetworkStateList networks;
   network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
                                                false /* configured_only */,
                                                false /* visible_only */,
                                                0 /* no limit */,
                                                &networks);
-  EXPECT_EQ(kNumShillManagerClientStubImplServices + 1, networks.size());
-  // Limit number of results.
+  EXPECT_EQ(kNumShillManagerClientStubImplServices + kNumTetherNetworks + 1,
+            networks.size());
+  // Limit number of results, including only tether networks.
   network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
                                                false /* configured_only */,
                                                false /* visible_only */,
                                                2 /* limit */,
                                                &networks);
   EXPECT_EQ(2u, networks.size());
+  // Limit number of results, including more than only tether networks.
+  network_state_handler_->GetNetworkListByType(
+      NetworkTypePattern::Default(), false /* configured_only */,
+      false /* visible_only */, 4 /* limit */, &networks);
+  EXPECT_EQ(4u, networks.size());
+  // Get all tether networks.
+  network_state_handler_->GetNetworkListByType(
+      NetworkTypePattern::Tether(), false /* configured_only */,
+      false /* visible_only */, 0 /* no limit */, &networks);
+  EXPECT_EQ(2u, networks.size());
   // Get all wifi networks.
   network_state_handler_->GetNetworkListByType(NetworkTypePattern::WiFi(),
                                                false /* configured_only */,
                                                false /* visible_only */,
                                                0 /* no limit */,
                                                &networks);
   EXPECT_EQ(3u, networks.size());
   // Get visible networks.
   network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
                                                false /* configured_only */,
                                                true /* visible_only */,
                                                0 /* no limit */,
                                                &networks);
-  EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size());
+  EXPECT_EQ(kNumShillManagerClientStubImplServices + kNumTetherNetworks,
+            networks.size());
   network_state_handler_->GetVisibleNetworkList(&networks);
-  EXPECT_EQ(kNumShillManagerClientStubImplServices, networks.size());
+  EXPECT_EQ(kNumShillManagerClientStubImplServices + kNumTetherNetworks,
+            networks.size());
   // Get configured (profile) networks.
   network_state_handler_->GetNetworkListByType(NetworkTypePattern::Default(),
                                                true /* configured_only */,
                                                false /* visible_only */,
                                                0 /* no limit */,
                                                &networks);
-  EXPECT_EQ(1u, networks.size());
+  EXPECT_EQ(kNumTetherNetworks + 1u, networks.size());
 }
 
 TEST_F(NetworkStateHandlerTest, GetTetherNetworkList) {
   NetworkStateHandler::NetworkStateList tether_networks;
 
-  network_state_handler_->GetTetherNetworkList(0 /* no limit */,
-                                               &tether_networks);
+  GetTetherNetworkList(0 /* no limit */, &tether_networks);
   EXPECT_EQ(0u, tether_networks.size());
 
-  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
 
-  network_state_handler_->GetTetherNetworkList(0 /* no limit */,
-                                               &tether_networks);
+  GetTetherNetworkList(0 /* no limit */, &tether_networks);
   EXPECT_EQ(1u, tether_networks.size());
+  EXPECT_TRUE(tether_networks[0]->connectable());
 
-  network_state_handler_->AddTetherNetworkState(kTetherGuid2, kTetherName2);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid2, kTetherName2, kTetherCarrier2, kTetherBatteryPercentage2,
+      kTetherSignalStrength2);
 
-  network_state_handler_->GetTetherNetworkList(0 /* no limit */,
-                                               &tether_networks);
+  GetTetherNetworkList(0 /* no limit */, &tether_networks);
   EXPECT_EQ(2u, tether_networks.size());
+  EXPECT_TRUE(tether_networks[1]->connectable());
 
-  network_state_handler_->GetTetherNetworkList(1 /* no limit */,
-                                               &tether_networks);
+  GetTetherNetworkList(1 /* no limit */, &tether_networks);
   EXPECT_EQ(1u, tether_networks.size());
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkListChanged) {
   size_t stub_network_count = test_observer_->network_count();
   // Set up two additional visible networks.
   const std::string wifi3 = "/service/wifi3";
   const std::string wifi4 = "/service/wifi4";
   service_test_->SetServiceProperties(
       wifi3, "wifi3_guid", "wifi3",
@@ skipping 172 matching lines @@
 
   // Remove the service, verify that there is no longer a NetworkState for it.
   service_test_->RemoveService(wifi_path);
   UpdateManagerProperties();
   EXPECT_FALSE(network_state_handler_->GetNetworkState(wifi_path));
 }
 
 TEST_F(NetworkStateHandlerTest, TetherNetworkState) {
   EXPECT_EQ(0u, test_observer_->network_list_changed_count());
 
-  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
 
   EXPECT_EQ(1u, test_observer_->network_list_changed_count());
 
   const NetworkState* tether_network =
       network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1);
   ASSERT_TRUE(tether_network);
   EXPECT_EQ(kTetherName1, tether_network->name());
   EXPECT_EQ(kTetherGuid1, tether_network->path());
+  EXPECT_EQ(kTetherCarrier1, tether_network->carrier());
+  EXPECT_EQ(kTetherBatteryPercentage1, tether_network->battery_percentage());
+  EXPECT_EQ(kTetherSignalStrength1, tether_network->signal_strength());
+
+  // Update the tether properties and verify the changes.
+  EXPECT_TRUE(network_state_handler_->UpdateTetherNetworkProperties(
+      kTetherGuid1, "NewCarrier", 5 /* battery_percentage */,
+      10 /* signal_strength */));
+
+  EXPECT_EQ(2u, test_observer_->network_list_changed_count());
+
+  tether_network =
+      network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1);
+  ASSERT_TRUE(tether_network);
+  EXPECT_EQ(kTetherName1, tether_network->name());
+  EXPECT_EQ(kTetherGuid1, tether_network->path());
+  EXPECT_EQ("NewCarrier", tether_network->carrier());
+  EXPECT_EQ(5, tether_network->battery_percentage());
+  EXPECT_EQ(10, tether_network->signal_strength());
 
   network_state_handler_->RemoveTetherNetworkState(kTetherGuid1);
 
-  EXPECT_EQ(2u, test_observer_->network_list_changed_count());
+  EXPECT_EQ(3u, test_observer_->network_list_changed_count());
 
   ASSERT_FALSE(network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1));
+
+  // Updating tether properties should fail since the network was removed.
+  EXPECT_FALSE(network_state_handler_->UpdateTetherNetworkProperties(
+      kTetherGuid1, "NewNewCarrier", 15 /* battery_percentage */,
+      20 /* signal_strength */));
 }
 
 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation) {
   EXPECT_EQ(0u, test_observer_->network_list_changed_count());
 
   const std::string profile = "/profile/profile1";
   const std::string wifi_path = "/service/wifi_with_guid";
   AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi,
              shill::kStateOnline);
   profile_test_->AddProfile(profile, "" /* userhash */);
   EXPECT_TRUE(profile_test_->AddService(profile, wifi_path));
   UpdateManagerProperties();
 
   EXPECT_EQ(1u, test_observer_->network_list_changed_count());
 
-  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
 
   EXPECT_EQ(2u, test_observer_->network_list_changed_count());
 
   EXPECT_TRUE(
       network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork(
           kTetherGuid1, kWifiGuid1));
 
   EXPECT_EQ(3u, test_observer_->network_list_changed_count());
 
   const NetworkState* wifi_network =
@@ skipping 14 matching lines @@
 
 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociationWifiRemoved) {
   const std::string profile = "/profile/profile1";
   const std::string wifi_path = "/service/wifi_with_guid";
   AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi,
              shill::kStateOnline);
   profile_test_->AddProfile(profile, "" /* userhash */);
   EXPECT_TRUE(profile_test_->AddService(profile, wifi_path));
   UpdateManagerProperties();
 
-  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
   EXPECT_TRUE(
       network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork(
           kTetherGuid1, kWifiGuid1));
 
   const NetworkState* wifi_network =
       network_state_handler_->GetNetworkStateFromGuid(kWifiGuid1);
   EXPECT_EQ(kTetherGuid1, wifi_network->tether_guid());
 
   const NetworkState* tether_network =
       network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1);
   EXPECT_EQ(kWifiGuid1, tether_network->tether_guid());
 
   service_test_->RemoveService(wifi_path);
   UpdateManagerProperties();
 
   tether_network =
       network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1);
   ASSERT_TRUE(tether_network->tether_guid().empty());
 }
 
 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation_NoWifiNetwork) {
-  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
 
   EXPECT_FALSE(
       network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork(
           kTetherGuid1, kWifiGuid1));
 }
 
 TEST_F(NetworkStateHandlerTest, TetherNetworkStateAssociation_NoTetherNetwork) {
   const std::string profile = "/profile/profile1";
   const std::string wifi_path = "/service/wifi_with_guid";
   AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi,
              shill::kStateOnline);
   profile_test_->AddProfile(profile, "" /* userhash */);
   EXPECT_TRUE(profile_test_->AddService(profile, wifi_path));
   UpdateManagerProperties();
 
   ASSERT_FALSE(
       network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork(
           kTetherGuid1, kWifiGuid1));
 }
 
 TEST_F(NetworkStateHandlerTest, SetTetherNetworkStateConnectionState) {
-  network_state_handler_->AddTetherNetworkState(kTetherGuid1, kTetherName1);
+  network_state_handler_->AddTetherNetworkState(
+      kTetherGuid1, kTetherName1, kTetherCarrier1, kTetherBatteryPercentage1,
+      kTetherSignalStrength1);
+
+  // Add corresponding Wi-Fi network.
+  const std::string profile = "/profile/profile1";
+  const std::string wifi_path = "/service/wifi_with_guid";
+  AddService(wifi_path, kWifiGuid1, kWifiName1, shill::kTypeWifi,
+             shill::kStateOnline);
+  profile_test_->AddProfile(profile, "" /* userhash */);
+  EXPECT_TRUE(profile_test_->AddService(profile, wifi_path));
+  UpdateManagerProperties();
+
+  // Associate tether and Wi-Fi networks.
+  network_state_handler_->AssociateTetherNetworkStateWithWifiNetwork(
+      kTetherGuid1, kWifiGuid1);
 
   const NetworkState* tether_network =
       network_state_handler_->GetNetworkStateFromGuid(kTetherGuid1);
 
   EXPECT_FALSE(tether_network->IsConnectingState());
   EXPECT_FALSE(tether_network->IsConnectedState());
 
   network_state_handler_->SetTetherNetworkStateConnecting(kTetherGuid1);
   EXPECT_TRUE(tether_network->IsConnectingState());
 
@@ skipping 258 matching lines @@
                                     shill::kIPConfigProperty,
                                     base::Value(kIPConfigPath));
   UpdateManagerProperties();
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForDevice(
       kShillManagerClientStubWifiDevice));
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultWifi));
 }
 
 }  // namespace chromeos