HostScanner: Add scanned hosts to NetworkStateHandler and NotificationPresenter.

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/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/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 "components/cryptauth/remote_device_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 class FakeHostScanDevicePrioritizer : public HostScanDevicePrioritizer {
@@ skipping 87 matching lines @@
     // Require set-up for odd-numbered device indices.
     bool set_up_required = i % 2 == 0;
     scanned_device_infos.push_back(HostScannerOperation::ScannedDeviceInfo(
         remote_devices[i], device_status, set_up_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>();
 
     fake_host_scanner_operation_factory_ =
         base::WrapUnique(new FakeHostScannerOperationFactory(test_devices_));
     HostScannerOperation::Factory::SetInstanceForTesting(
         fake_host_scanner_operation_factory_.get());
 
+    fake_notification_presenter_ =
+        base::MakeUnique<FakeNotificationPresenter>();
+
     host_scanner_ = base::MakeUnique<HostScanner>(
         fake_tether_host_fetcher_.get(), fake_ble_connection_manager_.get(),
-        fake_host_scan_device_prioritizer_.get());
+        fake_host_scan_device_prioritizer_.get(), network_state_handler(),
+        fake_notification_presenter_.get());
+  }
+
+  void TearDown() override {
+    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) {
     scanned_device_infos_so_far_.push_back(
         test_scanned_device_infos[test_device_index]);
     fake_operation->SendScannedDeviceListUpdate(scanned_device_infos_so_far_,
                                                 is_final_scan_result);
     EXPECT_EQ(scanned_device_infos_so_far_,
               host_scanner_->most_recent_scan_results());
+
+    NetworkStateHandler::NetworkStateList tether_networks;
+    network_state_handler()->GetTetherNetworkList(0 /* no limit */,
+                                                  &tether_networks);
+    EXPECT_EQ(scanned_device_infos_so_far_.size(), tether_networks.size());
+    for (auto& scanned_device_info : scanned_device_infos_so_far_) {
+      cryptauth::RemoteDevice remote_device = scanned_device_info.remote_device;
+      const NetworkState* tether_network =
+          network_state_handler()->GetNetworkStateFromGuid(
+              remote_device.GetDeviceId());
+      ASSERT_TRUE(tether_network);
+      EXPECT_EQ(remote_device.name, tether_network->name());
+    }
+
+    if (scanned_device_infos_so_far_.size() == 1) {
+      EXPECT_EQ(FakeNotificationPresenter::PotentialHotspotNotificationState::
+                    SINGLE_HOTSPOT_NEARBY_SHOWN,
+                fake_notification_presenter_->potential_hotspot_state());
+    } else {
+      EXPECT_EQ(FakeNotificationPresenter::PotentialHotspotNotificationState::
+                    MULTIPLE_HOTSPOTS_NEARBY_SHOWN,
+                fake_notification_presenter_->potential_hotspot_state());
+    }
   }
 
+  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<FakeHostScannerOperationFactory>
       fake_host_scanner_operation_factory_;
 
   std::vector<HostScannerOperation::ScannedDeviceInfo>
       scanned_device_infos_so_far_;
 
   std::unique_ptr<HostScanner> host_scanner_;
 
+  std::unique_ptr<FakeNotificationPresenter> fake_notification_presenter_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(HostScannerTest);
 };
 
 TEST_F(HostScannerTest, TestScan_ResultsFromAllDevices) {
   EXPECT_FALSE(host_scanner_->IsScanActive());
   host_scanner_->StartScan();
   EXPECT_TRUE(host_scanner_->IsScanActive());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
@@ skipping 113 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 cryptauth