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

chromeos/components/tether/host_scanner_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/host_scanner_operation.h"
 
 #include <algorithm>
 #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/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::StrictMock;
 
 namespace chromeos {
 
 namespace tether {
@@ skipping 84 matching lines @@
         test_devices_(cryptauth::GenerateTestRemoteDevices(5)) {
     // 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>();
     test_host_scan_device_prioritizer_ =
         base::MakeUnique<StrictMock<TestHostScanDevicePrioritizer>>();
+    mock_tether_host_response_recorder_ =
+        base::MakeUnique<StrictMock<MockTetherHostResponseRecorder>>();
     test_observer_ = base::WrapUnique(new TestObserver());
   }
 
   void ConstructOperation(
       const std::vector<cryptauth::RemoteDevice>& remote_devices) {
     operation_ = base::WrapUnique(new HostScannerOperation(
         remote_devices, fake_ble_connection_manager_.get(),
-        test_host_scan_device_prioritizer_.get()));
+        test_host_scan_device_prioritizer_.get(),
+        mock_tether_host_response_recorder_.get()));
     operation_->AddObserver(test_observer_.get());
 
     // Verify that the devices have been correctly prioritized.
     test_host_scan_device_prioritizer_->VerifyHasBeenPrioritized(
         remote_devices, operation_->remote_devices());
 
     EXPECT_FALSE(test_observer_->has_received_update);
     operation_->Initialize();
     EXPECT_TRUE(test_observer_->has_received_update);
     EXPECT_TRUE(test_observer_->scanned_devices_so_far.empty());
@@ skipping 65 matching lines @@
     SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
         test_devices_[0], response_code, std::string(kDefaultCarrier), true);
   }
 
   const std::string tether_availability_request_string_;
   const std::vector<cryptauth::RemoteDevice> test_devices_;
 
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
   std::unique_ptr<StrictMock<TestHostScanDevicePrioritizer>>
       test_host_scan_device_prioritizer_;
+  std::unique_ptr<StrictMock<MockTetherHostResponseRecorder>>
+      mock_tether_host_response_recorder_;
   std::unique_ptr<TestObserver> test_observer_;
   std::unique_ptr<HostScannerOperation> operation_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HostScannerOperationTest);
 };
 
 TEST_F(HostScannerOperationTest, TestDevicesArePrioritizedDuringConstruction) {
   // Verification of device order prioritization occurs in ConstructOperation().
   ConstructOperation(test_devices_);
 }
 
 TEST_F(HostScannerOperationTest, TestOperation_OneDevice_UnknownError) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(_))
       .Times(0);
 
   TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode ::
           TetherAvailabilityResponse_ResponseCode_UNKNOWN_ERROR);
 }
 
 TEST_F(HostScannerOperationTest, TestOperation_OneDevice_TetherAvailable) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]));
 
   TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode ::
           TetherAvailabilityResponse_ResponseCode_TETHER_AVAILABLE);
 }
 
 TEST_F(HostScannerOperationTest, TestOperation_OneDevice_SetupNeeded) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]));
 
   TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode ::
           TetherAvailabilityResponse_ResponseCode_SETUP_NEEDED);
 }
 
 TEST_F(HostScannerOperationTest, TestOperation_OneDevice_NoReception) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(_))
       .Times(0);
 
   TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode ::
           TetherAvailabilityResponse_ResponseCode_NO_RECEPTION);
 }
 
 TEST_F(HostScannerOperationTest, TestOperation_OneDevice_NoSimCard) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(_))
       .Times(0);
 
   TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode ::
           TetherAvailabilityResponse_ResponseCode_NO_SIM_CARD);
 }
 
 TEST_F(HostScannerOperationTest,
        TestOperation_OneDevice_NotificationsDisabled) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(_))
       .Times(0);
 
   TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode ::
           TetherAvailabilityResponse_ResponseCode_NOTIFICATIONS_DISABLED);
 }
 
 TEST_F(HostScannerOperationTest, TestMultipleDevices) {
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[0]));
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[1]))
       .Times(0);
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[2]));
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[3]))
       .Times(0);
-  EXPECT_CALL(*test_host_scan_device_prioritizer_,
+  EXPECT_CALL(*mock_tether_host_response_recorder_,
               RecordSuccessfulTetherAvailabilityResponse(test_devices_[4]))
       .Times(0);
 
   ConstructOperation(test_devices_);
 
   // Simulate devices 0 and 2 authenticating successfully. Use different carrier
   // names to ensure that the DeviceStatus is being stored correctly.
   SimulateDeviceAuthenticationAndVerifyMessageSent(test_devices_[0], 1u);
   SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
       test_devices_[0],
@@ skipping 56 matching lines @@
       "noService", true /* expected_to_be_last_scan_result */);
 
   // The scan should be over, and still no new scan results should have come in.
   EXPECT_TRUE(test_observer_->has_final_scan_result_been_sent);
   EXPECT_EQ(2u, test_observer_->scanned_devices_so_far.size());
 }
 
 }  // namespace tether
 
 }  // namespace cryptauth