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"
@@ skipping 18 matching lines @@
 
 namespace tether {
 
 namespace {
 
 const char kSsid[] = "ssid";
 const char kPassword[] = "password";
 
 const char kOtherWifiServiceGuid[] = "otherWifiServiceGuid";
 
+const char kTetherNetworkGuid[] = "tetherNetworkGuid";
+const char kTetherNetworkGuid2[] = "tetherNetworkGuid2";
+
 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));
 
+    network_state_handler()->AddTetherNetworkState(
+        kTetherNetworkGuid, "" /* name */, "" /* carrier */,

[Kyle Horimoto, 2017/04/28 22:07:29]

nit: Pass a name like "tetherNetworkName1" instead of just an empty string.
Passing an empty string makes it seem like we are purposely passing a
special-cased value, when we really aren't. Same with carrier.

[lesliewatkins, 2017/04/29 00:57:54]

Done.

+        100 /* full battery */, 100 /* full signal strength */);
+
+    network_state_handler()->AddTetherNetworkState(
+        kTetherNetworkGuid2, "" /* name */, "" /* carrier */,
+        100 /* full battery */, 100 /* full signal strength */);
+
     wifi_hotspot_connector_ = base::WrapUnique(new WifiHotspotConnector(
         network_state_handler(), test_network_connect_.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
@@ skipping 61 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 std::string& tether_guid) {
+    const NetworkState* wifi_network_state =
+        network_state_handler()->GetNetworkStateFromGuid(wifi_guid);
+    ASSERT_TRUE(wifi_network_state);
+    EXPECT_EQ(tether_guid, wifi_network_state->tether_guid());
+
+    const NetworkState* tether_network_state =
+        network_state_handler()->GetNetworkStateFromGuid(tether_guid);
+    ASSERT_TRUE(tether_network_state);
+    EXPECT_EQ(wifi_guid, tether_network_state->tether_guid());
+  }
+
+  void VerifyWifiNetworkNotAssociated(const std::string& wifi_guid) {
+    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_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WifiHotspotConnectorTest);
 };
 
 TEST_F(WifiHotspotConnectorTest, TestConnect_NetworkDoesNotBecomeConnectable) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
-      std::string(kSsid), std::string(kPassword),
+      std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid =
       VerifyLastConfiguration(std::string(kSsid), std::string(kPassword));
   EXPECT_FALSE(wifi_guid.empty());
 
   // Network does not become connectable.
   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_AnotherNetworkBecomesConnectable) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
-      std::string(kSsid), std::string(kPassword),
+      std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
       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_);
+  VerifyWifiNetworkNotAssociated(wifi_guid);
+  std::string other_wifi_guid = network_state_handler()
+                                    ->GetNetworkState(other_wifi_service_path_)
+                                    ->guid();
+  VerifyWifiNetworkNotAssociated(other_wifi_guid);
   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),
+      std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
       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, kTetherNetworkGuid);
   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),
+      std::string(kSsid), std::string(kPassword), kTetherNetworkGuid,
       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, kTetherNetworkGuid);
   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), "",
+      std::string(kSsid), "", kTetherNetworkGuid,

[Kyle Horimoto, 2017/04/28 22:07:29]

nit: Add /* password */ after "".

[lesliewatkins, 2017/04/29 00:57:54]

Done.

       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, kTetherNetworkGuid);
   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_SecondConnectionWhileWaitingForFirstToBecomeConnectable) {
   wifi_hotspot_connector_->ConnectToWifiHotspot(
-      "ssid1", "password1",
+      "ssid1", "password1", "tetherNetworkGuid1",
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid1 = VerifyLastConfiguration("ssid1", "password1");
   EXPECT_FALSE(wifi_guid1.empty());
   std::string service_path1 =
       test_network_connect_->last_service_path_created();
   EXPECT_FALSE(service_path1.empty());
 
   // Before network becomes connectable, start the new connection.
   EXPECT_EQ(0u, connection_callback_responses_.size());
   wifi_hotspot_connector_->ConnectToWifiHotspot(
-      "ssid2", "password2",
+      "ssid2", "password2", kTetherNetworkGuid2,
       base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
                  base::Unretained(this)));
 
   std::string wifi_guid2 = VerifyLastConfiguration("ssid2", "password2");
   EXPECT_FALSE(wifi_guid2.empty());
   std::string service_path2 =
       test_network_connect_->last_service_path_created();
   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);
+  VerifyWifiNetworkNotAssociated(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, kTetherNetworkGuid2);
   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();
+}
+
+TEST_F(WifiHotspotConnectorTest,
+       TestConnect_SecondConnectionWhileWaitingForFirstToConnect) {
+  wifi_hotspot_connector_->ConnectToWifiHotspot(
+      "ssid1", "password1", kTetherNetworkGuid,
+      base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
+                 base::Unretained(this)));
+
+  std::string wifi_guid1 = VerifyLastConfiguration("ssid1", "password1");
+  EXPECT_FALSE(wifi_guid1.empty());
+  std::string service_path1 =
+      test_network_connect_->last_service_path_created();
+  EXPECT_FALSE(service_path1.empty());
+
+  // First network becomes connectable.
+  NotifyConnectable(service_path1);
+  VerifyTetherAndWifiNetworkAssociation(wifi_guid1, kTetherNetworkGuid);
+
+  // After network becomes connectable, request a connection to second network.
+  wifi_hotspot_connector_->ConnectToWifiHotspot(
+      "ssid2", "password2", kTetherNetworkGuid2,
+      base::Bind(&WifiHotspotConnectorTest::WifiConnectionCallback,
+                 base::Unretained(this)));
+
+  std::string wifi_guid2 = VerifyLastConfiguration("ssid2", "password2");
+  EXPECT_FALSE(wifi_guid2.empty());
+  std::string service_path2 =
+      test_network_connect_->last_service_path_created();
+  EXPECT_FALSE(service_path2.empty());
+
+  EXPECT_NE(service_path1, service_path2);
+
+  // Second network becomes connectable.
+  NotifyConnectable(service_path2);
+  VerifyTetherAndWifiNetworkAssociation(wifi_guid2, kTetherNetworkGuid2);
+  EXPECT_EQ(wifi_guid2, test_network_connect_->network_id_to_connect());
+  EXPECT_EQ(1u, connection_callback_responses_.size());
+
+  // The original connection attempt should have gotten a "" response.

[Kyle Horimoto, 2017/04/28 22:07:29]

Move this up to right after the second ConnectToWifiHotspot() call. In general,
you want to make verifications the earliest that you can.

Also, after you address my comment about disassociating the networks, verify
that here as well.

[lesliewatkins, 2017/04/29 00:57:54]

Done.

+  EXPECT_EQ(1u, connection_callback_responses_.size());
+  EXPECT_EQ("", connection_callback_responses_[0]);
+
+  // Connection to network successful.
+  NotifyConnected(service_path2);
+  EXPECT_EQ(2u, connection_callback_responses_.size());
   EXPECT_EQ(wifi_guid2, connection_callback_responses_[1]);
   VerifyTimerStopped();
 }
 
 }  // namespace tether
 
 }  // namespace chromeos