Tether: record each type of host connection result.

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/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/mock_host_connection_metrics_logger.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"
@@ skipping 107 matching lines @@
     network_state_handler()->AddTetherNetworkState(
         kTetherNetworkGuid, "tetherNetworkName" /* name */,
         "tetherNetworkCarrier" /* carrier */, 100 /* full battery */,
         100 /* full signal strength */, false /* has_connected_to_host */);
 
     network_state_handler()->AddTetherNetworkState(
         kTetherNetworkGuid2, "tetherNetworkName2" /* name */,
         "tetherNetworkCarrier2" /* carrier */, 100 /* full battery */,
         100 /* full signal strength */, false /* has_connected_to_host */);
 
+    mock_host_connection_metrics_logger_ =
+        base::MakeUnique<MockHostConnectionMetricsLogger>();
+
     wifi_hotspot_connector_ = base::WrapUnique(new WifiHotspotConnector(
-        network_state_handler(), test_network_connect_.get()));
+        network_state_handler(), test_network_connect_.get(),
+        mock_host_connection_metrics_logger_.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 95 matching lines @@
     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<MockHostConnectionMetricsLogger>
+      mock_host_connection_metrics_logger_;
 
   std::unique_ptr<WifiHotspotConnector> wifi_hotspot_connector_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WifiHotspotConnectorTest);
 };
 
 TEST_F(WifiHotspotConnectorTest, TestConnect_NetworkDoesNotBecomeConnectable) {
+  EXPECT_CALL(*mock_host_connection_metrics_logger_,
+              RecordConnectionToHostResult(
+                  HostConnectionMetricsLogger::ConnectionToHostResult::
+                      CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_TIMEOUT));
+
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       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) {
+  EXPECT_CALL(*mock_host_connection_metrics_logger_,
+              RecordConnectionToHostResult(
+                  HostConnectionMetricsLogger::ConnectionToHostResult::
+                      CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_TIMEOUT));
+
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       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_);
   VerifyNetworkNotAssociated(wifi_guid);
   std::string other_wifi_guid = network_state_handler()
                                     ->GetNetworkState(other_wifi_service_path_)
                                     ->guid();
   VerifyNetworkNotAssociated(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) {
+  EXPECT_CALL(*mock_host_connection_metrics_logger_,
+              RecordConnectionToHostResult(
+                  HostConnectionMetricsLogger::ConnectionToHostResult::
+                      CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_TIMEOUT));
+
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       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.
@@ skipping 53 matching lines @@
 
   // 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) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_NEW_ATTEMPT));
+
   wifi_hotspot_connector_->ConnectToWifiHotspot(
       "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());
@@ skipping 35 matching lines @@
 
   // 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) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_NEW_ATTEMPT));
+
   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());
@@ skipping 37 matching lines @@
   // 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