[CrOS Tether] Create TetherHostResponseRecorder, which records ConnectTetheringResponses and Tether…

chromeos/components/tether/connect_tethering_operation_unittest.cc

 // Copyright 2016 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/connect_tethering_operation.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/logging.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
 #include "chromeos/components/tether/message_wrapper.h"
-#include "chromeos/components/tether/mock_host_scan_device_prioritizer.h"
+#include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/components/tether/proto/tether.pb.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::StrictMock;
 
 namespace chromeos {
 
@@ skipping 79 matching lines @@
       : connect_tethering_request_string_(
             CreateConnectTetheringRequestString()),
         test_device_(cryptauth::GenerateTestRemoteDevices(1)[0]) {
     // These tests are written under the assumption that there are a maximum of
     // 3 connection attempts; they need to be edited if this value changes.
     EXPECT_EQ(3u, MessageTransferOperation::kMaxConnectionAttemptsPerDevice);
   }
 
   void SetUp() override {
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
-    mock_host_scan_device_prioritizer_ =
-        base::MakeUnique<StrictMock<MockHostScanDevicePrioritizer>>();
+    mock_tether_host_response_recorder_ =
+        base::MakeUnique<StrictMock<MockTetherHostResponseRecorder>>();
     test_observer_ = base::WrapUnique(new TestObserver());
 
     operation_ = base::WrapUnique(new ConnectTetheringOperation(
         test_device_, fake_ble_connection_manager_.get(),
-        mock_host_scan_device_prioritizer_.get()));
+        mock_tether_host_response_recorder_.get()));
     operation_->AddObserver(test_observer_.get());
     operation_->Initialize();
   }
 
   void SimulateDeviceAuthenticationAndVerifyMessageSent() {
     operation_->OnDeviceAuthenticated(test_device_);
 
     // Verify that the message was sent successfully.
     std::vector<FakeBleConnectionManager::SentMessage>& sent_messages =
         fake_ble_connection_manager_->sent_messages();
@@ skipping 32 matching lines @@
     } else {
       EXPECT_TRUE(test_observer_->has_received_failure);
       EXPECT_EQ(expected_response_code, test_observer_->error_code);
     }
   }
 
   const std::string connect_tethering_request_string_;
   const cryptauth::RemoteDevice test_device_;
 
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
-  std::unique_ptr<StrictMock<MockHostScanDevicePrioritizer>>
-      mock_host_scan_device_prioritizer_;
+  std::unique_ptr<StrictMock<MockTetherHostResponseRecorder>>
+      mock_tether_host_response_recorder_;
   std::unique_ptr<TestObserver> test_observer_;
   std::unique_ptr<ConnectTetheringOperation> operation_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConnectTetheringOperationTest);
 };
 
 TEST_F(ConnectTetheringOperationTest, TestOperation_SuccessButInvalidResponse) {
-  EXPECT_CALL(*mock_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);
 
   SimulateDeviceAuthenticationAndVerifyMessageSent();
   SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_SUCCESS,
       true /* use_proto_without_ssid_and_password */);
 }
 
 TEST_F(ConnectTetheringOperationTest, TestOperation_SuccessWithValidResponse) {
-  EXPECT_CALL(*mock_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(test_device_));
 
   SimulateDeviceAuthenticationAndVerifyMessageSent();
   SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_SUCCESS,
       false /* use_proto_without_ssid_and_password */);
 }
 
 TEST_F(ConnectTetheringOperationTest, TestOperation_UnknownError) {
-  EXPECT_CALL(*mock_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);
 
   SimulateDeviceAuthenticationAndVerifyMessageSent();
   SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR,
       false /* use_proto_without_ssid_and_password */);
 }
 
 TEST_F(ConnectTetheringOperationTest, TestOperation_ProvisioningFailed) {
-  EXPECT_CALL(*mock_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);
 
   SimulateDeviceAuthenticationAndVerifyMessageSent();
   SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_PROVISIONING_FAILED,
       false /* use_proto_without_ssid_and_password */);
 }
 
 TEST_F(ConnectTetheringOperationTest, TestCannotConnect) {
-  EXPECT_CALL(*mock_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulConnectTetheringResponse(_))
       .Times(0);
 
   // Simulate the device failing to connect.
   fake_ble_connection_manager_->SetDeviceStatus(
       test_device_, cryptauth::SecureChannel::Status::CONNECTING);
   fake_ble_connection_manager_->SetDeviceStatus(
       test_device_, cryptauth::SecureChannel::Status::DISCONNECTED);
   fake_ble_connection_manager_->SetDeviceStatus(
       test_device_, cryptauth::SecureChannel::Status::CONNECTING);
   fake_ble_connection_manager_->SetDeviceStatus(
       test_device_, cryptauth::SecureChannel::Status::DISCONNECTED);
   fake_ble_connection_manager_->SetDeviceStatus(
       test_device_, cryptauth::SecureChannel::Status::CONNECTING);
   fake_ble_connection_manager_->SetDeviceStatus(
       test_device_, cryptauth::SecureChannel::Status::DISCONNECTED);
 
   // The maximum number of connection failures has occurred.
   EXPECT_TRUE(test_observer_->has_received_failure);
   EXPECT_EQ(ConnectTetheringResponse_ResponseCode::
                 ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR,
             test_observer_->error_code);
 }
 
 }  // namespace tether
 
 }  // namespace cryptauth