[CrOS Tether] Sort Tether network lists.

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 "base/test/simple_test_clock.h"
 #include "base/time/time.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_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/host_scan_device_prioritizer.h"
 #include "chromeos/components/tether/host_scanner.h"
 #include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/components/tether/proto_test_util.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/network/network_state_test.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 class TestObserver : public HostScanner::Observer {
  public:
   void ScanFinished() override { scan_finished_count_++; }
 
   int scan_finished_count() { return scan_finished_count_; }
 
  private:
   int scan_finished_count_ = 0;
 };
 
 class FakeHostScanDevicePrioritizer : public HostScanDevicePrioritizer {
  public:
-  FakeHostScanDevicePrioritizer() : HostScanDevicePrioritizer(nullptr) {}
+  FakeHostScanDevicePrioritizer(NetworkStateHandler* network_state_handler)
+      : HostScanDevicePrioritizer(
+            network_state_handler,
+            nullptr /* tether_host_response_recorder */,
+            nullptr /* device_id_tether_network_guid_map */) {}
   ~FakeHostScanDevicePrioritizer() override {}
 
   // Simply leave |remote_devices| as-is.
   void SortByHostScanOrder(
       std::vector<cryptauth::RemoteDevice>* remote_devices) const override {}
 };
 
 class FakeHostScannerOperation : public HostScannerOperation {
  public:
   FakeHostScannerOperation(
@@ skipping 111 matching lines @@
 
     scanned_device_infos.push_back(HostScannerOperation::ScannedDeviceInfo(
         remote_devices[i], device_status, setup_required));
   }
 
   return scanned_device_infos;
 }
 
 }  // namespace
 
-class HostScannerTest : public testing::Test {
+class HostScannerTest : public NetworkStateTest {
  protected:
   HostScannerTest()
       : test_devices_(cryptauth::GenerateTestRemoteDevices(4)),
         test_scanned_device_infos(CreateFakeScannedDeviceInfos(test_devices_)) {
   }
 
   void SetUp() override {
+    DBusThreadManager::Initialize();
+    NetworkStateTest::SetUp();
+
     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>();
+        base::MakeUnique<FakeHostScanDevicePrioritizer>(
+            network_state_handler());
     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_scan_cache_ = base::MakeUnique<FakeHostScanCache>();
 
     fake_host_scanner_operation_factory_ =
         base::WrapUnique(new FakeHostScannerOperationFactory(test_devices_));
@@ skipping 10 matching lines @@
         device_id_tether_network_guid_map_.get(), fake_host_scan_cache_.get(),
         test_clock_.get()));
 
     test_observer_ = base::MakeUnique<TestObserver>();
     host_scanner_->AddObserver(test_observer_.get());
   }
 
   void TearDown() override {
     host_scanner_->RemoveObserver(test_observer_.get());
     HostScannerOperation::Factory::SetInstanceForTesting(nullptr);
+
+    fake_host_scan_device_prioritizer_.reset();
+    ShutdownNetworkState();
+    NetworkStateTest::TearDown();
+    DBusThreadManager::Shutdown();
   }
 
   // Causes |fake_operation| to receive the scan result in
   // |test_scanned_device_infos| vector at the index |test_device_index| with
   // the "final result" value of |is_final_scan_result|.
   void ReceiveScanResultAndVerifySuccess(
       FakeHostScannerOperation& fake_operation,
       size_t test_device_index,
       bool is_final_scan_result) {
     bool already_in_list = false;
@@ skipping 64 matching lines @@
     if (!status.has_connection_strength() || status.connection_strength() > 4)
       EXPECT_EQ(100, cache_item.signal_strength);
     else if (status.connection_strength() < 0)
       EXPECT_EQ(0, cache_item.signal_strength);
     else
       EXPECT_EQ(status.connection_strength() * 25, cache_item.signal_strength);
 
     EXPECT_EQ(scanned_device_info.setup_required, cache_item.setup_required);
   }
 
+  const 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_;
@@ skipping 248 matching lines @@
   EXPECT_TRUE(host_scanner_->HasRecentlyScanned());
 
   // Move past the limit.
   test_clock_->Advance(base::TimeDelta::FromSeconds(1));
   EXPECT_FALSE(host_scanner_->HasRecentlyScanned());
 }
 
 }  // namespace tether
 
 }  // namespace chromeos