TetherNotificationPresenter: Connect to a network when the 'Connect' button is pressed.

chrome/browser/chromeos/net/tether_notification_presenter_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 "chrome/browser/chromeos/net/tether_notification_presenter.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/observer_list.h"
@@ skipping 84 matching lines @@
 
 cryptauth::RemoteDevice CreateTestRemoteDevice() {
   cryptauth::RemoteDevice device = cryptauth::GenerateTestRemoteDevices(1)[0];
   device.name = "testDevice";
   return device;
 }
 
 }  // namespace
 
 class TetherNotificationPresenterTest : public testing::Test {
+ public:
+  class TestNetworkConnect : public NetworkConnect {
+   public:
+    TestNetworkConnect() {}
+    ~TestNetworkConnect() override {}
+
+    std::string network_id_to_connect() { return network_id_to_connect_; }
+
+    // NetworkConnect:
+    void DisconnectFromNetworkId(const std::string& network_id) override {}
+    bool MaybeShowConfigureUI(const std::string& network_id,
+                              const std::string& connect_error) override {
+      return false;
+    }
+    void SetTechnologyEnabled(const chromeos::NetworkTypePattern& technology,
+                              bool enabled_state) override {}
+    void ShowMobileSetup(const std::string& network_id) override {}
+    void ConfigureNetworkIdAndConnect(
+        const std::string& network_id,
+        const base::DictionaryValue& shill_properties,
+        bool shared) override {}
+    void CreateConfigurationAndConnect(base::DictionaryValue* shill_properties,
+                                       bool shared) override {}
+    void SetTetherDelegate(TetherDelegate* tether_delegate) override {}
+
+    void CreateConfiguration(base::DictionaryValue* shill_properties,
+                             bool shared) override {}
+
+    void ConnectToNetworkId(const std::string& network_id) override {
+      network_id_to_connect_ = network_id;
+    }
+
+   private:
+    std::string network_id_to_connect_;
+  };
+
  protected:
   TetherNotificationPresenterTest() : test_device_(CreateTestRemoteDevice()) {}
 
   void SetUp() override {
     test_message_center_ = base::WrapUnique(new TestMessageCenter());
-    notification_presenter_ = base::WrapUnique(
-        new TetherNotificationPresenter(test_message_center_.get()));
+    test_network_connect_ = base::WrapUnique(new TestNetworkConnect());
+    notification_presenter_ = base::WrapUnique(new TetherNotificationPresenter(
+        test_message_center_.get(), test_network_connect_.get()));
   }
 
   std::string GetActiveHostNotificationId() {
     return std::string(TetherNotificationPresenter::kActiveHostNotificationId);
   }
 
   std::string GetPotentialHotspotNotificationId() {
     return std::string(
         TetherNotificationPresenter::kPotentialHotspotNotificationId);
   }
 
   const cryptauth::RemoteDevice test_device_;
 
   std::unique_ptr<TestMessageCenter> test_message_center_;
+  std::unique_ptr<TestNetworkConnect> test_network_connect_;
 
   std::unique_ptr<TetherNotificationPresenter> notification_presenter_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TetherNotificationPresenterTest);
 };
 
 TEST_F(TetherNotificationPresenterTest,
        TestHostConnectionFailedNotification_RemoveProgrammatically) {
   EXPECT_FALSE(test_message_center_->FindVisibleNotificationById(
@@ skipping 73 matching lines @@
 
   message_center::Notification* notification =
       test_message_center_->FindVisibleNotificationById(
           GetPotentialHotspotNotificationId());
   EXPECT_TRUE(notification);
   EXPECT_EQ(GetPotentialHotspotNotificationId(), notification->id());
 
   // Tap the notification's button.
   test_message_center_->NotifyNotificationButtonTapped(
       GetPotentialHotspotNotificationId(), 0 /* button_index */);
-  // TODO(khorimoto): Test that the connection dialog is shown.
+
+  EXPECT_EQ(test_device_.GetDeviceId(),
+            test_network_connect_->network_id_to_connect());
+
+  // TODO(hansberry): Test for the case of the user not yet going through
+  // the connection dialog.
 }
 
 TEST_F(TetherNotificationPresenterTest,
        TestMultiplePotentialHotspotNotification_RemoveProgrammatically) {
   EXPECT_FALSE(test_message_center_->FindVisibleNotificationById(
       GetPotentialHotspotNotificationId()));
   notification_presenter_->NotifyMultiplePotentialHotspotsNearby();
 
   message_center::Notification* notification =
       test_message_center_->FindVisibleNotificationById(
@@ skipping 50 matching lines @@
   EXPECT_EQ(1u, test_message_center_->GetNumNotifications());
 
   notification_presenter_->RemovePotentialHotspotNotification();
   EXPECT_FALSE(test_message_center_->FindVisibleNotificationById(
       GetPotentialHotspotNotificationId()));
 }
 
 }  // namespace tether
 
 }  // namespace chromeos