Tether: Display a 'setup required' notification when appropriate.

chromeos/components/tether/tether_connector_unittest.cc

 // Copyright 2017 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/tether_connector.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "chromeos/components/tether/connect_tethering_operation.h"
 #include "chromeos/components/tether/device_id_tether_network_guid_map.h"
 #include "chromeos/components/tether/fake_active_host.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/fake_wifi_hotspot_connector.h"
 #include "chromeos/components/tether/mock_tether_host_response_recorder.h"
 #include "chromeos/components/tether/tether_connector.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/network/network_connection_handler.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.h"
@@ skipping 101 matching lines @@
     fake_wifi_hotspot_connector_ =
         base::MakeUnique<FakeWifiHotspotConnector>(network_state_handler());
     fake_active_host_ = base::MakeUnique<FakeActiveHost>();
     fake_tether_host_fetcher_ = base::MakeUnique<FakeTetherHostFetcher>(
         test_devices_, false /* synchronously_reply_with_results */);
     fake_ble_connection_manager_ = base::MakeUnique<FakeBleConnectionManager>();
     mock_tether_host_response_recorder_ =
         base::MakeUnique<MockTetherHostResponseRecorder>();
     device_id_tether_network_guid_map_ =
         base::MakeUnique<DeviceIdTetherNetworkGuidMap>();
+    fake_host_scan_cache_ = base::MakeUnique<FakeHostScanCache>();
+    fake_notification_presenter_ =
+        base::MakeUnique<FakeNotificationPresenter>();
 
     result_.clear();
 
     tether_connector_ = base::WrapUnique(new TetherConnector(
         network_state_handler(), fake_wifi_hotspot_connector_.get(),
         fake_active_host_.get(), fake_tether_host_fetcher_.get(),
         fake_ble_connection_manager_.get(),
         mock_tether_host_response_recorder_.get(),
-        device_id_tether_network_guid_map_.get()));
+        device_id_tether_network_guid_map_.get(), fake_host_scan_cache_.get(),
+        fake_notification_presenter_.get()));
 
     SetUpTetherNetworks();
   }
 
   void TearDown() override {
     // Must delete |fake_wifi_hotspot_connector_| before NetworkStateHandler is
     // destroyed to ensure that NetworkStateHandler has zero observers by the
     // time it reaches its destructor.
     fake_wifi_hotspot_connector_.reset();
 
     ShutdownNetworkState();
     NetworkStateTest::TearDown();
     DBusThreadManager::Shutdown();
   }
 
   std::string GetTetherNetworkGuid(const std::string& device_id) {
     return device_id_tether_network_guid_map_->GetTetherNetworkGuidForDeviceId(
         device_id);
   }
 
   void SetUpTetherNetworks() {
     // Add a tether network corresponding to both of the test devices. These
     // networks are expected to be added already before
     // TetherConnector::ConnectToNetwork is called.
+    AddTetherNetwork(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
+                     "TetherNetworkName1", "TetherNetworkCarrier1",
+                     85 /* battery_percentage */, 75 /* signal_strength */,
+                     true /* has_connected_to_host */,
+                     false /* setup_required */);
+    AddTetherNetwork(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()),
+                     "TetherNetworkName2", "TetherNetworkCarrier2",
+                     90 /* battery_percentage */, 50 /* signal_strength */,
+                     true /* has_connected_to_host */,
+                     true /* setup_required */);
+  }
+
+  virtual void AddTetherNetwork(const std::string& tether_network_guid,
+                                const std::string& device_name,
+                                const std::string& carrier,
+                                int battery_percentage,
+                                int signal_strength,
+                                bool has_connected_to_host,
+                                bool setup_required) {
     network_state_handler()->AddTetherNetworkState(
-        GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
-        "TetherNetworkName1", "TetherNetworkCarrier1",
-        85 /* battery_percentage */, 75 /* signal_strength */,
-        true /* has_connected_to_host */);
-    network_state_handler()->AddTetherNetworkState(
-        GetTetherNetworkGuid(test_devices_[1].GetDeviceId()),
-        "TetherNetworkName2", "TetherNetworkCarrier2",
-        90 /* battery_percentage */, 50 /* signal_strength */,
-        true /* has_connected_to_host */);
+        tether_network_guid, device_name, carrier, battery_percentage,
+        signal_strength, has_connected_to_host);
+    fake_host_scan_cache_->SetHostScanResult(tether_network_guid, device_name,
+                                             carrier, battery_percentage,
+                                             signal_strength, setup_required);
   }
 
   void SuccessfullyJoinWifiNetwork() {
     ConfigureService(CreateWifiConfigurationJsonString());
     fake_wifi_hotspot_connector_->CallMostRecentCallback(kWifiNetworkGuid);
   }
 
   void SuccessCallback() { result_ = kSuccessResult; }
 
   void ErrorCallback(const std::string& error_name) { result_ = error_name; }
@@ skipping 19 matching lines @@
   std::unique_ptr<FakeConnectTetheringOperationFactory> fake_operation_factory_;
   std::unique_ptr<FakeWifiHotspotConnector> fake_wifi_hotspot_connector_;
   std::unique_ptr<FakeActiveHost> fake_active_host_;
   std::unique_ptr<FakeTetherHostFetcher> fake_tether_host_fetcher_;
   std::unique_ptr<FakeBleConnectionManager> fake_ble_connection_manager_;
   std::unique_ptr<MockTetherHostResponseRecorder>
       mock_tether_host_response_recorder_;
   // 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<FakeHostScanCache> fake_host_scan_cache_;
+  std::unique_ptr<FakeNotificationPresenter> fake_notification_presenter_;
 
   std::string result_;
 
   std::unique_ptr<TetherConnector> tether_connector_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TetherConnectorTest);
 };
 
 TEST_F(TetherConnectorTest, TestCannotFetchDevice) {
@@ skipping 59 matching lines @@
   fake_operation_factory_->created_operations()[0]->SendFailedResponse(
       ConnectTetheringResponse_ResponseCode::
           ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR);
 
   // The failure should have resulted in the host being disconnected.
   EXPECT_EQ(ActiveHost::ActiveHostStatus::DISCONNECTED,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
 }
 
+TEST_F(TetherConnectorTest, TestConnectTetheringOperationFails_SetupRequired) {
+  EXPECT_FALSE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  CallConnect(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()));
+
+  EXPECT_TRUE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  fake_tether_host_fetcher_->InvokePendingCallbacks();
+
+  EXPECT_TRUE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  fake_operation_factory_->created_operations()[0]->SendFailedResponse(
+      ConnectTetheringResponse_ResponseCode::
+          ConnectTetheringResponse_ResponseCode_UNKNOWN_ERROR);
+
+  EXPECT_FALSE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  EXPECT_EQ(NetworkConnectionHandler::kErrorConnectFailed, GetResultAndReset());
+}
+
 TEST_F(TetherConnectorTest, TestConnectingToWifiFails) {
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 
@@ skipping 51 matching lines @@
 
 TEST_F(TetherConnectorTest, TestSuccessfulConnection) {
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
+  EXPECT_FALSE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
 
   fake_tether_host_fetcher_->InvokePendingCallbacks();
 
   // Receive a successful response. We should still be connecting.
   EXPECT_EQ(1u, fake_operation_factory_->created_operations().size());
   fake_operation_factory_->created_operations()[0]->SendSuccessfulResponse(
       kSsid, kPassword);
   EXPECT_EQ(ActiveHost::ActiveHostStatus::CONNECTING,
             fake_active_host_->GetActiveHostStatus());
 
@@ skipping 11 matching lines @@
             fake_active_host_->GetActiveHostStatus());
   EXPECT_EQ(test_devices_[0].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_EQ(kWifiNetworkGuid, fake_active_host_->GetWifiNetworkGuid());
 
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
+TEST_F(TetherConnectorTest, TestSuccessfulConnection_SetupRequired) {
+  EXPECT_FALSE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  CallConnect(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()));
+
+  EXPECT_TRUE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  fake_tether_host_fetcher_->InvokePendingCallbacks();
+
+  EXPECT_TRUE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  fake_operation_factory_->created_operations()[0]->SendSuccessfulResponse(
+      kSsid, kPassword);
+
+  EXPECT_TRUE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  SuccessfullyJoinWifiNetwork();
+
+  EXPECT_FALSE(
+      fake_notification_presenter_->is_setup_required_notification_shown());
+
+  EXPECT_EQ(kSuccessResult, GetResultAndReset());
+}
+
 TEST_F(TetherConnectorTest,
        TestNewConnectionAttemptDuringFetch_DifferentDevice) {
   CallConnect(GetTetherNetworkGuid(test_devices_[0].GetDeviceId()));
 
   // Instead of invoking the pending callbacks on |fake_tether_host_fetcher_|,
   // attempt another connection attempt, this time to another device.
   CallConnect(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()));
   // The first connection attempt should have resulted in a connect canceled
   // error.
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnectCanceled,
@@ skipping 97 matching lines @@
   EXPECT_EQ(test_devices_[1].GetDeviceId(),
             fake_active_host_->GetActiveHostDeviceId());
   EXPECT_EQ(GetTetherNetworkGuid(test_devices_[1].GetDeviceId()),
             fake_active_host_->GetTetherNetworkGuid());
   EXPECT_TRUE(fake_active_host_->GetWifiNetworkGuid().empty());
 }
 
 }  // namespace tether
 
 }  // namespace chromeos