Changed wifi arcs to mobile bars for Tether network.

chromeos/components/tether/wifi_hotspot_connector_unittest.cc

 // Copyright 2017 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/components/tether/wifi_hotspot_connector.h"
 
 #include <memory>
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/timer/mock_timer.h"
 #include "base/values.h"
+#include "chromeos/components/tether/fake_active_host.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/network_connect.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_test.h"
 #include "chromeos/network/shill_property_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 const char kSsid[] = "ssid";
 const char kPassword[] = "password";
 
 const char kOtherWifiServiceGuid[] = "otherWifiServiceGuid";
 
+const char kDeviceId[] = "deviceId";
+const char kTetherNetworkGuid[] = "tetherNetworkGuid";
+
 std::string CreateConfigurationJsonString(const std::string& guid) {
   std::stringstream ss;
   ss << "{"
      << "  \"GUID\": \"" << guid << "\","
      << "  \"Type\": \"" << shill::kTypeWifi << "\","
      << "  \"State\": \"" << shill::kStateIdle << "\""
      << "}";
   return ss.str();
 }
 
@@ skipping 60 matching lines @@
 
   WifiHotspotConnectorTest() {}
   ~WifiHotspotConnectorTest() override {}
 
   void SetUp() override {
     other_wifi_service_path_.clear();
     connection_callback_responses_.clear();
 
     DBusThreadManager::Initialize();
     NetworkStateTest::SetUp();
+    network_state_handler()->SetTetherTechnologyState(
+        NetworkStateHandler::TechnologyState::TECHNOLOGY_ENABLED);
+
     SetUpShillState();
 
     test_network_connect_ = base::WrapUnique(new TestNetworkConnect(this));
+    fake_active_host_ = base::MakeUnique<FakeActiveHost>();
+
+    network_state_handler()->AddTetherNetworkState(
+        kTetherNetworkGuid, "", /* name */

[Kyle Horimoto, 2017/04/27 01:28:08]

Add the comment before the comma: "" /* name */,

Also, don't add all these spaces before your comment. Just fit as many arguments
as you can on each line. You can run "git cl format ." in your src/ directory to
do this formatting for you.

[lesliewatkins, 2017/04/28 21:30:43]

Done.

I believe 'git cl format' is the culprit for all those spaces, because I didn't
add them. Maybe that will be fixed when I put the comment in front of the comma.

+        "",                     /* carrier */
+        100,                    /* full battery */
+        100 /* full signal strength */);
+
+    fake_active_host_->SetActiveHostConnecting(kDeviceId, kTetherNetworkGuid);
 
     wifi_hotspot_connector_ = base::WrapUnique(new WifiHotspotConnector(
-        network_state_handler(), test_network_connect_.get()));
+        network_state_handler(), test_network_connect_.get(),
+        fake_active_host_.get()));
 
     mock_timer_ = new base::MockTimer(true /* retain_user_task */,
                                       false /* is_repeating */);
     wifi_hotspot_connector_->SetTimerForTest(base::WrapUnique(mock_timer_));
   }
 
   void SetUpShillState() {
     // Add a Wi-Fi service unrelated to the one under test. In some tests, a
     // connection from another device is tested.
     other_wifi_service_path_ = ConfigureService(
@@ skipping 59 matching lines @@
           last_configuration->GetString(shill::kPassphraseProperty, &password));
       EXPECT_EQ(expected_password, password);
     }
 
     std::string wifi_guid;
     EXPECT_TRUE(
         last_configuration->GetString(shill::kGuidProperty, &wifi_guid));
     return wifi_guid;
   }
 
+  void VerifyTetherAndWifiNetworkAssociation(const std::string& wifi_guid) {
+    const NetworkState* wifi_network_state =
+        network_state_handler()->GetNetworkStateFromGuid(wifi_guid);
+    ASSERT_TRUE(wifi_network_state);
+    EXPECT_EQ(fake_active_host_->GetTetherNetworkGuid(),
+              wifi_network_state->tether_guid());
+
+    const NetworkState* tether_network_state =
+        network_state_handler()->GetNetworkStateFromGuid(
+            fake_active_host_->GetTetherNetworkGuid());

[Kyle Horimoto, 2017/04/27 01:28:08]

Note: To get the tether GUID once you change from the ActiveHost approach,
you'll need to add WifiHotspotConnectorTest as a friend class of
WifiHotspotConnector to access a private function.

[lesliewatkins, 2017/04/28 21:30:43]

I ended up added a second parameter to VerifyTetherAndWifiNetworkAssociated and
just used the Tether GUID const defined in the test class.

+    ASSERT_TRUE(tether_network_state);
+    EXPECT_EQ(wifi_guid, tether_network_state->tether_guid());
+  }
+
+  void VerifyTetherAndWifiNetworkNotAssociated(const std::string& wifi_guid) {

[Kyle Horimoto, 2017/04/27 01:28:08]

You aren't verifying anything about a tether network, so just rename this
function VerifyWifiNetworkNotAssociated().

[lesliewatkins, 2017/04/28 21:30:43]

Done.

+    const NetworkState* wifi_network_state =
+        network_state_handler()->GetNetworkStateFromGuid(wifi_guid);
+    ASSERT_TRUE(wifi_network_state);
+    EXPECT_TRUE(wifi_network_state->tether_guid().empty());
+  }
+
   void WifiConnectionCallback(const std::string& wifi_guid) {
     connection_callback_responses_.push_back(wifi_guid);
   }
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
 
   std::string other_wifi_service_path_;
   std::vector<std::string> connection_callback_responses_;
 
   base::MockTimer* mock_timer_;
   std::unique_ptr<TestNetworkConnect> test_network_connect_;
 
   std::unique_ptr<WifiHotspotConnector> wifi_hotspot_connector_;
+  std::unique_ptr<FakeActiveHost> fake_active_host_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WifiHotspotConnectorTest);
 };
 
 TEST_F(WifiHotspotConnectorTest, TestConnect_NetworkDoesNotBecomeConnectable) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       std::string(kSsid), std::string(kPassword),
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
@@ skipping 18 matching lines @@
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid =
       VerifyLastConfiguration(std::string(kSsid), std::string(kPassword));
   EXPECT_FALSE(wifi_guid.empty());
 
   // Another network becomes connectable. This should not cause the connection
   // to start.
   NotifyConnectable(other_wifi_service_path_);
+  VerifyTetherAndWifiNetworkNotAssociated(wifi_guid);

[Kyle Horimoto, 2017/04/27 01:28:08]

Also verify that the network associated with other_wifi_service_path_ isn't
associated. To get the GUID, you'll need to call:

network_state_handler()->GetNetworkState(other_wifi_service_path_)->guid().

[lesliewatkins, 2017/04/28 21:30:43]

Done.

   EXPECT_EQ("", test_network_connect_->network_id_to_connect());
 
   // Timeout timer fires.
   EXPECT_EQ(0u, connection_callback_responses_.size());
   InvokeTimerTask();
   EXPECT_EQ(1u, connection_callback_responses_.size());
   EXPECT_EQ("", connection_callback_responses_[0]);
 }
 
 TEST_F(WifiHotspotConnectorTest, TestConnect_CannotConnectToNetwork) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       std::string(kSsid), std::string(kPassword),
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid =
       VerifyLastConfiguration(std::string(kSsid), std::string(kPassword));
   EXPECT_FALSE(wifi_guid.empty());
 
   // Network becomes connectable.
   NotifyConnectable(test_network_connect_->last_service_path_created());
+  VerifyTetherAndWifiNetworkAssociation(wifi_guid);
   EXPECT_EQ(wifi_guid, test_network_connect_->network_id_to_connect());
 
   // Network connection does not occur.
   EXPECT_EQ(0u, connection_callback_responses_.size());
 
   // Timeout timer fires.
   InvokeTimerTask();
   EXPECT_EQ(1u, connection_callback_responses_.size());
   EXPECT_EQ("", connection_callback_responses_[0]);
 }
 
 TEST_F(WifiHotspotConnectorTest, TestConnect_Success) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       std::string(kSsid), std::string(kPassword),
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid =
       VerifyLastConfiguration(std::string(kSsid), std::string(kPassword));
   EXPECT_FALSE(wifi_guid.empty());
 
   // Network becomes connectable.
   NotifyConnectable(test_network_connect_->last_service_path_created());
+  VerifyTetherAndWifiNetworkAssociation(wifi_guid);
   EXPECT_EQ(wifi_guid, test_network_connect_->network_id_to_connect());
   EXPECT_EQ(0u, connection_callback_responses_.size());
 
   // Connection to network successful.
   NotifyConnected(test_network_connect_->last_service_path_created());
   EXPECT_EQ(1u, connection_callback_responses_.size());
   EXPECT_EQ(wifi_guid, connection_callback_responses_[0]);
   VerifyTimerStopped();
 }
 
 TEST_F(WifiHotspotConnectorTest, TestConnect_Success_EmptyPassword) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       std::string(kSsid), "",
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid = VerifyLastConfiguration(std::string(kSsid), "");
   EXPECT_FALSE(wifi_guid.empty());
 
   // Network becomes connectable.
   NotifyConnectable(test_network_connect_->last_service_path_created());
+  VerifyTetherAndWifiNetworkAssociation(wifi_guid);
   EXPECT_EQ(wifi_guid, test_network_connect_->network_id_to_connect());
   EXPECT_EQ(0u, connection_callback_responses_.size());
 
   // Connection to network successful.
   NotifyConnected(test_network_connect_->last_service_path_created());
   EXPECT_EQ(1u, connection_callback_responses_.size());
   EXPECT_EQ(wifi_guid, connection_callback_responses_[0]);
   VerifyTimerStopped();
 }
 
@@ skipping 24 matching lines @@
   EXPECT_FALSE(service_path2.empty());
 
   EXPECT_NE(service_path1, service_path2);
 
   // The original connection attempt should have gotten a "" response.
   EXPECT_EQ(1u, connection_callback_responses_.size());
   EXPECT_EQ("", connection_callback_responses_[0]);
 
   // First network becomes connectable.
   NotifyConnectable(service_path1);
+  VerifyTetherAndWifiNetworkNotAssociated(wifi_guid1);
 
   // A connection should not have started to that GUID.
   EXPECT_EQ("", test_network_connect_->network_id_to_connect());
   EXPECT_EQ(1u, connection_callback_responses_.size());
 
   // Second network becomes connectable.
   NotifyConnectable(service_path2);
+  VerifyTetherAndWifiNetworkAssociation(wifi_guid2);
   EXPECT_EQ(wifi_guid2, test_network_connect_->network_id_to_connect());
   EXPECT_EQ(1u, connection_callback_responses_.size());
 
   // Connection to network successful.
   NotifyConnected(service_path2);
   EXPECT_EQ(2u, connection_callback_responses_.size());
   EXPECT_EQ(wifi_guid2, connection_callback_responses_[1]);
   VerifyTimerStopped();
 }
 

[Kyle Horimoto, 2017/04/27 01:28:08]

Please add one additional test which tests this situation:

1) Connection requested to device A.
2) Network for device A becomes connectable. Association occurs and connection
attempt is started.
3) Connection requested to device B. The callback for device A is invoked with
"".
4) Connection to device A's hotspot completes, but it is ignored.
5) Network for device B becomes connectable and eventually connected. Success
callback is invoked.

[lesliewatkins, 2017/04/28 21:30:43]

Done.

 }  // namespace tether
 
 }  // namespace chromeos