[CrOS Tether] Sort Tether network lists.

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 "base/test/scoped_task_environment.h"

[Ryan Hansberry, 2017/06/19 19:17:48]

It's a shame that this and host_scanner's test need to take on additional (and
obscure) complexity because of the change to HostScanDevicePrioritizer.
Proposal: Make a general HostScanDevicePrioritizer interface that doesn't take a
NetworkStateHandler argument, and which is extended by
MockHostScanDevicePrioritizer, to allow for easy testing. Thoughts?

[Kyle Horimoto, 2017/06/20 23:44:54]

You're right - done.

 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/fake_ble_connection_manager.h"
+#include "chromeos/components/tether/host_scan_device_prioritizer.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 "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"
 
 using testing::_;
 using testing::StrictMock;
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 const char kDefaultCarrier[] = "Google Fi";
 
-class TestHostScanDevicePrioritizer : public MockHostScanDevicePrioritizer {
+class TestHostScanDevicePrioritizer : public HostScanDevicePrioritizer {
  public:
-  TestHostScanDevicePrioritizer() : MockHostScanDevicePrioritizer() {}
+  TestHostScanDevicePrioritizer(NetworkStateHandler* network_state_handler)
+      : HostScanDevicePrioritizer(
+            network_state_handler,
+            nullptr /* tether_host_response_recorder */,
+            nullptr /* device_id_tether_network_guid_map */) {}
   ~TestHostScanDevicePrioritizer() override {}
 
-  // Simply reverses the device order.
+  // HostScanDevicePrioritizer:
   void SortByHostScanOrder(
       std::vector<cryptauth::RemoteDevice>* remote_devices) const override {
+    // Simply reverses the device order.
     for (size_t i = 0; i < remote_devices->size() / 2; ++i) {
       std::iter_swap(remote_devices->begin() + i,
                      remote_devices->end() - i - 1);
     }
   }
 
   void VerifyHasBeenPrioritized(
       const std::vector<cryptauth::RemoteDevice>& original,
       const std::vector<cryptauth::RemoteDevice>& prioritized) {
     std::vector<cryptauth::RemoteDevice> copy_of_original = original;
@@ skipping 36 matching lines @@
     const std::string& cell_provider_name) {
   TetherAvailabilityResponse response;
   response.set_response_code(response_code);
   response.mutable_device_status()->CopyFrom(
       CreateFakeDeviceStatus(cell_provider_name));
   return MessageWrapper(response).ToRawMessage();
 }
 
 }  // namespace
 
-class HostScannerOperationTest : public testing::Test {
+class HostScannerOperationTest : public NetworkStateTest {
  protected:
   HostScannerOperationTest()
       : tether_availability_request_string_(
             CreateTetherAvailabilityRequestString()),
         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 {
+    DBusThreadManager::Initialize();
+    NetworkStateTest::SetUp();
+
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
     test_host_scan_device_prioritizer_ =
-        base::MakeUnique<StrictMock<TestHostScanDevicePrioritizer>>();
+        base::MakeUnique<TestHostScanDevicePrioritizer>(
+            network_state_handler());
     mock_tether_host_response_recorder_ =
         base::MakeUnique<StrictMock<MockTetherHostResponseRecorder>>();
     test_observer_ = base::WrapUnique(new TestObserver());
   }
 
+  void TearDown() override {
+    test_host_scan_device_prioritizer_.reset();
+    ShutdownNetworkState();
+    NetworkStateTest::TearDown();
+    DBusThreadManager::Shutdown();
+  }
+
   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(),
         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(
@@ skipping 65 matching lines @@
   }
 
   void TestOperationWithOneDevice(
       TetherAvailabilityResponse_ResponseCode response_code) {
     ConstructOperation(std::vector<cryptauth::RemoteDevice>{test_devices_[0]});
     SimulateDeviceAuthenticationAndVerifyMessageSent(test_devices_[0], 1u);
     SimulateResponseReceivedAndVerifyObserverCallbackInvoked(
         test_devices_[0], response_code, std::string(kDefaultCarrier), true);
   }
 
+  const base::test::ScopedTaskEnvironment scoped_task_environment_;
   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>>
+  std::unique_ptr<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);
 };
 
@@ skipping 142 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 chromeos