Tether: record each type of host connection result.

chromeos/components/tether/tether_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/tether_connector.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "chromeos/components/tether/connect_tethering_operation.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
 #include "chromeos/components/tether/fake_active_host.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
 #include "chromeos/components/tether/fake_host_scan_cache.h"
 #include "chromeos/components/tether/fake_notification_presenter.h"
 #include "chromeos/components/tether/fake_tether_host_fetcher.h"
 #include "chromeos/components/tether/fake_wifi_hotspot_connector.h"
+#include "chromeos/components/tether/mock_host_connection_metrics_logger.h"
 #include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/components/tether/tether_connector.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_test.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/cryptauth/remote_device_test_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"
 
+using testing::StrictMock;
+
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 const char kSuccessResult[] = "success";
 
 const char kSsid[] = "ssid";
 const char kPassword[] = "password";
@@ skipping 99 matching lines @@
     fake_tether_host_fetcher_ = base::MakeUnique<FakeTetherHostFetcher>(
         test_devices_, false /* synchronously_reply_with_results */);
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
     mock_tether_host_response_recorder_ =
         base::MakeUnique<MockTetherHostResponseRecorder>();
     device_id_tether_network_guid_map_ =
         base::MakeUnique<DeviceIdTetherNetworkGuidMap>();
     fake_host_scan_cache_ = base::MakeUnique<FakeHostScanCache>();
     fake_notification_presenter_ =
         base::MakeUnique<FakeNotificationPresenter>();
+    mock_host_connection_metrics_logger_ =
+        base::WrapUnique(new StrictMock<MockHostConnectionMetricsLogger>);
 
     result_.clear();
 
     tether_connector_ = base::WrapUnique(new TetherConnector(
         network_state_handler(), fake_wifi_hotspot_connector_.get(),
         fake_active_host_.get(), fake_tether_host_fetcher_.get(),
         fake_ble_connection_manager_.get(),
         mock_tether_host_response_recorder_.get(),
         device_id_tether_network_guid_map_.get(), fake_host_scan_cache_.get(),
-        fake_notification_presenter_.get()));
+        fake_notification_presenter_.get(),
+        mock_host_connection_metrics_logger_.get()));
 
     SetUpTetherNetworks();
   }
 
   void TearDown() override {
     // Must delete |fake_wifi_hotspot_connector_| before NetworkStateHandler is
     // destroyed to ensure that NetworkStateHandler has zero observers by the
     // time it reaches its destructor.
     fake_wifi_hotspot_connector_.reset();
 
@@ skipping 49 matching lines @@
 
   void CallConnect(const std::string& tether_network_guid) {
     tether_connector_->ConnectToNetwork(
         tether_network_guid,
         base::Bind(&TetherConnectorTest::SuccessCallback,
                    base::Unretained(this)),
         base::Bind(&TetherConnectorTest::ErrorCallback,
                    base::Unretained(this)));
   }
 
+  void TestConnectTetheringOperationFails(

[Kyle Horimoto, 2017/07/12 17:23:21]

VerifyConnectTetheringOperationFails

[Ryan Hansberry, 2017/07/12 17:51:17]

Done.

+      ConnectTetheringResponse_ResponseCode response_code,
+      bool setup_required,
+      HostConnectionMetricsLogger::ConnectionToHostResult expected_event_type) {
+    EXPECT_CALL(*mock_host_connection_metrics_logger_,
+                RecordConnectionToHostResult(expected_event_type));
+
+    EXPECT_FALSE(
+        fake_notification_presenter_->is_setup_required_notification_shown());
+
+    cryptauth::RemoteDevice test_device = test_devices_[setup_required ? 1 : 0];

[Kyle Horimoto, 2017/07/12 17:23:21]

It's hard to tell why setup_required determines the index used without reading
through the whole test. Add a comment explaining that this corresponds to the
AddTetherNetwork() call in SetUpTetherNetworks() above.

[Ryan Hansberry, 2017/07/12 17:51:17]

Done.

+
+    CallConnect(GetTetherNetworkGuid(test_device.GetDeviceId()));
+    EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
+              fake_active_host_->GetActiveHostStatus());
+    EXPECT_EQ(test_device.GetDeviceId(),
+              fake_active_host_->GetActiveHostDeviceId());
+    EXPECT_EQ(GetTetherNetworkGuid(test_device.GetDeviceId()),
+              fake_active_host_->GetTetherNetworkGuid());
+    EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
+
+    EXPECT_EQ(
+        setup_required,
+        fake_notification_presenter_->is_setup_required_notification_shown());
+
+    fake_tether_host_fetcher_->InvokePendingCallbacks();
+
+    EXPECT_EQ(
+        setup_required,
+        fake_notification_presenter_->is_setup_required_notification_shown());
+    EXPECT_EQ(
+        setup_required,
+        fake_operation_factory_->created_operations()[0]->setup_required());
+
+    // Simulate a failed connection attempt (either the host cannot provide
+    // tethering at this time or a timeout occurs).
+    EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
+    fake_operation_factory_->created_operations()[0]->SendFailedResponse(
+        response_code);
+
+    EXPECT_FALSE(
+        fake_notification_presenter_->is_setup_required_notification_shown());
+
+    // The failure should have resulted in the host being disconnected.
+    EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
+              fake_active_host_->GetActiveHostStatus());
+    EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed,
+              GetResultAndReset());
+  }
+
   std::string GetResultAndReset() {
     std::string result;
     result.swap(result_);
     return result;
   }
 
   const std::vector<cryptauth::RemoteDevice> test_devices_;
   const base::MessageLoop message_loop_;
 
   std::unique_ptr<FakeConnectTetheringOperationFactory> fake_operation_factory_;
   std::unique_ptr<FakeWifiHotspotConnector> fake_wifi_hotspot_connector_;
   std::unique_ptr<FakeActiveHost> fake_active_host_;
   std::unique_ptr<FakeTetherHostFetcher> fake_tether_host_fetcher_;
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
   std::unique_ptr<MockTetherHostResponseRecorder>
       mock_tether_host_response_recorder_;
   // TODO(hansberry): Use a fake for this when a real mapping scheme is created.
   std::unique_ptr<DeviceIdTetherNetworkGuidMap>
       device_id_tether_network_guid_map_;
   std::unique_ptr<FakeHostScanCache> fake_host_scan_cache_;
   std::unique_ptr<FakeNotificationPresenter> fake_notification_presenter_;
+  std::unique_ptr<StrictMock<MockHostConnectionMetricsLogger>>
+      mock_host_connection_metrics_logger_;
 
   std::string result_;
 
   std::unique_ptr<TetherConnector> tether_connector_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TetherConnectorTest);
 };
 
 TEST_F(TetherConnectorTest, TestCannotFetchDevice) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_INTERNAL_ERROR));
+
   // Base64-encoded version of "nonexistentDeviceId".
   const char kNonexistentDeviceId[] = "bm9uZXhpc3RlbnREZXZpY2VJZA==";
 
   CallConnect(GetTetherNetworkGuid(kNonexistentDeviceId));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(kNonexistentDeviceId, fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(kNonexistentDeviceId),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
 
   // Since an invalid device ID was used, no connection should have been
   // started.
   EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
 }
 
 TEST_F(TetherConnectorTest, TestCancelWhileOperationActive) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_USER));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
 
   // Simulate a failed connection attempt (either the host cannot provide
   // tethering at this time or a timeout occurs).
   EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
   EXPECT_FALSE(
       fake_operation_factory_->created_operations()[0]->setup_required());
   tether_connector_->CancelConnectionAttempt(
       GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
 
   EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectCanceled,
             GetResultAndReset());
 }
 
-TEST_F(TetherConnectorTest, TestConnectTetheringOperationFails) {
+TEST_F(TetherConnectorTest,
+       TestConnectTetheringOperationFails_SetupNotRequired) {
+  TestConnectTetheringOperationFails(
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR,
+      false /* setup_required */,
+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_FAILURE_UNKNOWN_ERROR);
+}
+
+TEST_F(TetherConnectorTest, TestConnectTetheringOperationFails_SetupRequired) {
+  TestConnectTetheringOperationFails(
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR,
+      true /* setup_required */,
+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_FAILURE_UNKNOWN_ERROR);
+}
+
+TEST_F(TetherConnectorTest,
+       TestConnectTetheringOperationFails_ProvisioningFailed) {
+  TestConnectTetheringOperationFails(
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_PROVISIONING_FAILED,
+      false /* setup_required */,
+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_PROVISIONING_FAILED);
+}
+
+TEST_F(TetherConnectorTest,
+       TestConnectTetheringOperationFails_TetheringTimeout_SetupNotRequired) {
+  TestConnectTetheringOperationFails(
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_TETHERING_TIMEOUT,
+      false /* setup_required */,
+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_FAILURE_TETHERING_TIMED_OUT_FIRST_TIME_SETUP_WAS_NOT_REQUIRED);
+}
+
+TEST_F(TetherConnectorTest,
+       TestConnectTetheringOperationFails_TetheringTimeout_SetupRequired) {
+  TestConnectTetheringOperationFails(
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_TETHERING_TIMEOUT,
+      true /* setup_required */,
+      HostConnectionMetricsLogger::ConnectionToHostResult::
+          CONNECTION_RESULT_FAILURE_TETHERING_TIMED_OUT_FIRST_TIME_SETUP_WAS_REQUIRED);
+}
+
+TEST_F(TetherConnectorTest, TestConnectingToWifiFails) {
+  EXPECT_CALL(*mock_host_connection_metrics_logger_,
+              RecordConnectionToHostResult(
+                  HostConnectionMetricsLogger::ConnectionToHostResult::
+                      CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_TIMEOUT));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
-  EXPECT_EQ(test_devices_[0].GetDeviceId(),
-            fake_active_host_->GetActiveHostDeviceId());
-  EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
-            fake_active_host_->GetTetherNetworkGuid());
-  EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
-
-  fake_tether_host_fetcher_->InvokePendingCallbacks();
-
-  // Simulate a failed connection attempt (either the host cannot provide
-  // tethering at this time or a timeout occurs).
-  EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
-  EXPECT_FALSE(
-      fake_operation_factory_->created_operations()[0]->setup_required());
-  fake_operation_factory_->created_operations()[0]->SendFailedResponse(
-      ConnectTetheringResponse_ResponseCode::
-          ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR);
-
-  // The failure should have resulted in the host being disconnected.
-  EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
-            fake_active_host_->GetActiveHostStatus());
-  EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
-}
-
-TEST_F(TetherConnectorTest, TestConnectTetheringOperationFails_SetupRequired) {
-  EXPECT_FALSE(
-      fake_notification_presenter_->is_setup_required_notification_shown());
-
-  CallConnect(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()));
-
-  EXPECT_TRUE(
-      fake_notification_presenter_->is_setup_required_notification_shown());
-
-  fake_tether_host_fetcher_->InvokePendingCallbacks();
-
-  EXPECT_TRUE(
-      fake_notification_presenter_->is_setup_required_notification_shown());
-  EXPECT_TRUE(
-      fake_operation_factory_->created_operations()[0]->setup_required());
-
-  fake_operation_factory_->created_operations()[0]->SendFailedResponse(
-      ConnectTetheringResponse_ResponseCode::
-          ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR);
-
-  EXPECT_FALSE(
-      fake_notification_presenter_->is_setup_required_notification_shown());
-
-  EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
-}
-
-TEST_F(TetherConnectorTest, TestConnectingToWifiFails) {
-  CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
-  EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
-            fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
 
   // Receive a successful response. We should still be connecting.
   EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
@@ skipping 13 matching lines @@
             fake_wifi_hotspot_connector_->most_recent_tether_network_guid());
   fake_wifi_hotspot_connector_->CallMostRecentCallback("");
 
   // The failure should have resulted in the host being disconnected.
   EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
 }
 
 TEST_F(TetherConnectorTest, TestCancelWhileConnectingToWifi) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_USER));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
@@ skipping 10 matching lines @@
   tether_connector_->CancelConnectionAttempt(
       GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
 
   EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectCanceled,
             GetResultAndReset());
 }
 
 TEST_F(TetherConnectorTest, TestSuccessfulConnection) {
+  EXPECT_CALL(*mock_host_connection_metrics_logger_,
+              RecordConnectionToHostResult(
+                  HostConnectionMetricsLogger::ConnectionToHostResult::
+                      CONNECTION_RESULT_SUCCESS));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
   EXPECT_FALSE(
       fake_notification_presenter_->is_setup_required_notification_shown());
@@ skipping 24 matching lines @@
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_EQ(kWifiNetworkGuid, fake_active_host_->GetWifiNetworkGuid());
 
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 TEST_F(TetherConnectorTest, TestSuccessfulConnection_SetupRequired) {
+  EXPECT_CALL(*mock_host_connection_metrics_logger_,
+              RecordConnectionToHostResult(
+                  HostConnectionMetricsLogger::ConnectionToHostResult::
+                      CONNECTION_RESULT_SUCCESS));
+
   EXPECT_FALSE(
       fake_notification_presenter_->is_setup_required_notification_shown());
 
   CallConnect(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()));
 
   EXPECT_TRUE(
       fake_notification_presenter_->is_setup_required_notification_shown());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
 
@@ skipping 11 matching lines @@
   SuccessfullyJoinWifiNetwork();
 
   EXPECT_FALSE(
       fake_notification_presenter_->is_setup_required_notification_shown());
 
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 TEST_F(TetherConnectorTest,
        TestNewConnectionAttemptDuringFetch_DifferentDevice) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_USER));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
 
   // Instead of invoking the pending callbacks on |fake_tether_host_fetcher_|,
   // attempt another connection attempt, this time to another device.
   CallConnect(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()));
   // The first connection attempt should have resulted in a connect canceled
   // error.
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectCanceled,
             GetResultAndReset());
 
   // Now invoke the callbacks. An operation should have been created for the
   // device 1, not device 0.
   fake_tether_host_fetcher_->InvokePendingCallbacks();
   EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
   EXPECT_EQ(
       test_devices_[1],
       fake_operation_factory_->created_operations()[0]->GetRemoteDevice());
 }
 
 TEST_F(TetherConnectorTest,
        TestNewConnectionAttemptDuringOperation_DifferentDevice) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_USER));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
@@ skipping 32 matching lines @@
   fake_operation_factory_->created_operations()[1]->SendSuccessfulResponse(
       kSsid, kPassword);
   EXPECT_EQ(kSsid, fake_wifi_hotspot_connector_->most_recent_ssid());
   EXPECT_EQ(kPassword, fake_wifi_hotspot_connector_->most_recent_password());
   EXPECT_EQ(fake_active_host_->GetTetherNetworkGuid(),
             fake_wifi_hotspot_connector_->most_recent_tether_network_guid());
 }
 
 TEST_F(TetherConnectorTest,
        TestNewConnectionAttemptDuringWifiConnection_DifferentDevice) {
+  EXPECT_CALL(
+      *mock_host_connection_metrics_logger_,
+      RecordConnectionToHostResult(
+          HostConnectionMetricsLogger::ConnectionToHostResult::
+              CONNECTION_RESULT_FAILURE_CLIENT_CONNECTION_CANCELED_BY_USER));
+
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
 
   EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
   fake_operation_factory_->created_operations()[0]->SendSuccessfulResponse(
@@ skipping 22 matching lines @@
   EXPECT_EQ(test_devices_[1].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 }
 
 }  // namespace tether
 
 }  // namespace chromeos