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

chromeos/components/tether/host_scanner_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.h"
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
 #include "chromeos/components/tether/fake_notification_presenter.h"
 #include "chromeos/components/tether/fake_tether_host_fetcher.h"
 #include "chromeos/components/tether/host_scan_device_prioritizer.h"
 #include "chromeos/components/tether/host_scanner.h"
+#include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_test.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 class FakeHostScanDevicePrioritizer : public HostScanDevicePrioritizer {
  public:
   FakeHostScanDevicePrioritizer() : HostScanDevicePrioritizer(nullptr) {}
   ~FakeHostScanDevicePrioritizer() override {}
 
   // Simply leave |remote_devices| as-is.
   void SortByHostScanOrder(
       std::vector<cryptauth::RemoteDevice>* remote_devices) const override {}
 };
 
 class FakeHostScannerOperation : public HostScannerOperation {
  public:
   FakeHostScannerOperation(
       const std::vector<cryptauth::RemoteDevice>& devices_to_connect,
       BleConnectionManager* connection_manager,
-      HostScanDevicePrioritizer* host_scan_device_prioritizer)
+      HostScanDevicePrioritizer* host_scan_device_prioritizer,
+      TetherHostResponseRecorder* tether_host_response_recorder)
       : HostScannerOperation(devices_to_connect,
                              connection_manager,
-                             host_scan_device_prioritizer) {}
+                             host_scan_device_prioritizer,
+                             tether_host_response_recorder) {}
 
   ~FakeHostScannerOperation() override {}
 
   void SendScannedDeviceListUpdate(
       const std::vector<HostScannerOperation::ScannedDeviceInfo>&
           scanned_device_list_so_far,
       bool is_final_scan_result) {
     scanned_device_list_so_far_ = scanned_device_list_so_far;
     NotifyObserversOfScannedDeviceList(is_final_scan_result);
   }
 };
 
 class FakeHostScannerOperationFactory : public HostScannerOperation::Factory {
  public:
   FakeHostScannerOperationFactory(
       const std::vector<cryptauth::RemoteDevice>& test_devices)
       : expected_devices_(test_devices) {}
   virtual ~FakeHostScannerOperationFactory() {}
 
   std::vector<FakeHostScannerOperation*>& created_operations() {
     return created_operations_;
   }
 
  protected:
   // HostScannerOperation::Factory:
   std::unique_ptr<HostScannerOperation> BuildInstance(
       const std::vector<cryptauth::RemoteDevice>& devices_to_connect,
       BleConnectionManager* connection_manager,
-      HostScanDevicePrioritizer* host_scan_device_prioritizer) override {
+      HostScanDevicePrioritizer* host_scan_device_prioritizer,
+      TetherHostResponseRecorder* tether_host_response_recorder) override {
     EXPECT_EQ(expected_devices_, devices_to_connect);
     FakeHostScannerOperation* operation = new FakeHostScannerOperation(
-        devices_to_connect, connection_manager, host_scan_device_prioritizer);
+        devices_to_connect, connection_manager, host_scan_device_prioritizer,
+        tether_host_response_recorder);
     created_operations_.push_back(operation);
     return base::WrapUnique(operation);
   }
 
  private:
   const std::vector<cryptauth::RemoteDevice>& expected_devices_;
   std::vector<FakeHostScannerOperation*> created_operations_;
 };
 
 std::string GenerateCellProviderForDevice(
@@ skipping 47 matching lines @@
     network_state_handler()->SetTetherTechnologyState(
         NetworkStateHandler::TECHNOLOGY_ENABLED);
 
     scanned_device_infos_so_far_.clear();
 
     fake_tether_host_fetcher_ = base::MakeUnique<FakeTetherHostFetcher>(
         test_devices_, false /* synchronously_reply_with_results */);
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
     fake_host_scan_device_prioritizer_ =
         base::MakeUnique<FakeHostScanDevicePrioritizer>();
+    mock_tether_host_response_recorder_ =
+        base::MakeUnique<MockTetherHostResponseRecorder>();
     fake_notification_presenter_ =
         base::MakeUnique<FakeNotificationPresenter>();
     device_id_tether_network_guid_map_ =
         base::MakeUnique<DeviceIdTetherNetworkGuidMap>();
 
     fake_host_scanner_operation_factory_ =
         base::WrapUnique(new FakeHostScannerOperationFactory(test_devices_));
     HostScannerOperation::Factory::SetInstanceForTesting(
         fake_host_scanner_operation_factory_.get());
 
     host_scanner_ = base::WrapUnique(new HostScanner(
         fake_tether_host_fetcher_.get(), fake_ble_connection_manager_.get(),
-        fake_host_scan_device_prioritizer_.get(), network_state_handler(),
+        fake_host_scan_device_prioritizer_.get(),
+        mock_tether_host_response_recorder_.get(), network_state_handler(),
         fake_notification_presenter_.get(),
         device_id_tether_network_guid_map_.get()));
   }
 
   void TearDown() override {
     ShutdownNetworkState();
     NetworkStateTest::TearDown();
     DBusThreadManager::Shutdown();
 
     HostScannerOperation::Factory::SetInstanceForTesting(nullptr);
@@ skipping 39 matching lines @@
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
 
   const std::vector<cryptauth::RemoteDevice> test_devices_;
   const std::vector<HostScannerOperation::ScannedDeviceInfo>
       test_scanned_device_infos;
 
   std::unique_ptr<FakeTetherHostFetcher> fake_tether_host_fetcher_;
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
   std::unique_ptr<HostScanDevicePrioritizer> fake_host_scan_device_prioritizer_;
+  std::unique_ptr<MockTetherHostResponseRecorder>
+      mock_tether_host_response_recorder_;
   std::unique_ptr<FakeNotificationPresenter> fake_notification_presenter_;
   // 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<FakeHostScannerOperationFactory>
       fake_host_scanner_operation_factory_;
 
   std::vector<HostScannerOperation::ScannedDeviceInfo>
       scanned_device_infos_so_far_;
@@ skipping 126 matching lines @@
       ->SendScannedDeviceListUpdate(scanned_device_infos_so_far_,
                                     true /* is_final_scan_result */);
   EXPECT_EQ(scanned_device_infos_so_far_,
             host_scanner_->most_recent_scan_results());
   EXPECT_FALSE(host_scanner_->IsScanActive());
 }
 
 }  // namespace tether
 
 }  // namespace chromeos