Use NetworkConnectionObserver to trigger connect failure notifications

chromeos/network/network_connection_handler_unittest.cc

 // Copyright (c) 2012 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/network/network_connection_handler.h"
 
+#include <map>
+#include <set>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/cert_loader.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/managed_network_configuration_handler_impl.h"
 #include "chromeos/network/network_configuration_handler.h"
+#include "chromeos/network/network_connection_observer.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/onc/onc_constants.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_test_nss_chromeos_user.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/nss_cert_database_chromeos.h"
 #include "net/cert/x509_certificate.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 // http://crbug.com/418369
 #ifdef NDEBUG
 
+namespace chromeos {
+
 namespace {
 
 const char* kSuccessResult = "success";
 
 void ConfigureCallback(const dbus::ObjectPath& result) {
 }
 
 void ConfigureErrorCallback(const std::string& error_name,
                             const std::string& error_message) {
 }
 
+class TestNetworkConnectionObserver : public NetworkConnectionObserver {
+ public:
+  TestNetworkConnectionObserver() {}
+  ~TestNetworkConnectionObserver() override {}
+
+  // NetworkConnectionObserver
+  void ConnectToNetworkRequested(const std::string& service_path) override {
+    requests_.insert(service_path);
+  }
+
+  void ConnectSucceeded(const std::string& service_path) override {
+    results_[service_path] = kSuccessResult;
+  }
+
+  void ConnectFailed(const std::string& service_path,
+                     const std::string& error_name) override {
+    results_[service_path] = error_name;
+  }
+
+  void DiconnectRequested(const std::string& service_path) override {
+    requests_.insert(service_path);
+  }
+
+  bool GetRequested(const std::string& service_path) {
+    return requests_.count(service_path) != 0;
+  }
+
+  std::string GetResult(const std::string& service_path) {
+    auto iter = results_.find(service_path);
+    if (iter == results_.end())
+      return "";
+    return iter->second;
+  }
+
+ private:
+  std::set<std::string> requests_;
+  std::map<std::string, std::string> results_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestNetworkConnectionObserver);
+};
+
 }  // namespace
 
-namespace chromeos {
-
 class NetworkConnectionHandlerTest : public testing::Test {
  public:
   NetworkConnectionHandlerTest()
       : user_("userhash"),
         test_manager_client_(NULL),
         test_service_client_(NULL) {}
 
   virtual ~NetworkConnectionHandlerTest() {
   }
 
@@ skipping 41 matching lines @@
     managed_config_handler_.reset(new ManagedNetworkConfigurationHandlerImpl());
     managed_config_handler_->Init(network_state_handler_.get(),
                                   network_profile_handler_.get(),
                                   network_config_handler_.get(),
                                   NULL /* network_device_handler */);
 
     network_connection_handler_.reset(new NetworkConnectionHandler);
     network_connection_handler_->Init(network_state_handler_.get(),
                                       network_config_handler_.get(),
                                       managed_config_handler_.get());
+    network_connection_observer_.reset(new TestNetworkConnectionObserver);
+    network_connection_handler_->AddObserver(
+        network_connection_observer_.get());
 
     base::RunLoop().RunUntilIdle();
   }
 
   virtual void TearDown() override {
     managed_config_handler_.reset();
     network_profile_handler_.reset();
+    network_connection_handler_->RemoveObserver(
+        network_connection_observer_.get());
+    network_connection_observer_.reset();
     network_connection_handler_.reset();
     network_config_handler_.reset();
     network_state_handler_.reset();
     CertLoader::Shutdown();
     LoginState::Shutdown();
     DBusThreadManager::Shutdown();
   }
 
  protected:
   bool Configure(const std::string& json_string) {
@@ skipping 137 matching lines @@
                                          std::string(),  // no username hash
                                          *network_configs,
                                          global_config);
     }
     base::RunLoop().RunUntilIdle();
   }
 
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<NetworkConfigurationHandler> network_config_handler_;
   scoped_ptr<NetworkConnectionHandler> network_connection_handler_;
+  scoped_ptr<TestNetworkConnectionObserver> network_connection_observer_;
   scoped_ptr<ManagedNetworkConfigurationHandlerImpl> managed_config_handler_;
   scoped_ptr<NetworkProfileHandler> network_profile_handler_;
   crypto::ScopedTestNSSChromeOSUser user_;
   ShillManagerClient::TestInterface* test_manager_client_;
   ShillServiceClient::TestInterface* test_service_client_;
   scoped_ptr<net::NSSCertDatabaseChromeOS> test_nssdb_;
   base::MessageLoopForUI message_loop_;
   std::string result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandlerTest);
 };
 
 namespace {
 
+const char* kNoNetwork = "no-network";
+const char* kWifi0 = "wifi0";
+const char* kWifi1 = "wifi1";
+const char* kWifi2 = "wifi2";
+const char* kWifi3 = "wifi3";
+
 const char* kConfigConnectable =
     "{ \"GUID\": \"wifi0\", \"Type\": \"wifi\", \"State\": \"idle\", "
     "  \"Connectable\": true }";
 const char* kConfigConnected =
     "{ \"GUID\": \"wifi1\", \"Type\": \"wifi\", \"State\": \"online\" }";
 const char* kConfigConnecting =
     "{ \"GUID\": \"wifi2\", \"Type\": \"wifi\", \"State\": \"association\" }";
 const char* kConfigRequiresPassphrase =
     "{ \"GUID\": \"wifi3\", \"Type\": \"wifi\", "
     "  \"PassphraseRequired\": true }";
 
 }  // namespace
 
 TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectSuccess) {
   EXPECT_TRUE(Configure(kConfigConnectable));
-  Connect("wifi0");
+  Connect(kWifi0);
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
   EXPECT_EQ(shill::kStateOnline,
-            GetServiceStringProperty("wifi0", shill::kStateProperty));
+            GetServiceStringProperty(kWifi0, shill::kStateProperty));
+  // Observer expectations
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi0));
+  EXPECT_EQ(kSuccessResult, network_connection_observer_->GetResult(kWifi0));
 }
 
 // Handles basic failure cases.
 TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectFailure) {
-  Connect("no-network");
+  Connect(kNoNetwork);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
             GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kNoNetwork));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
+            network_connection_observer_->GetResult(kNoNetwork));
 
   EXPECT_TRUE(Configure(kConfigConnected));
-  Connect("wifi1");
+  Connect(kWifi1);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnected, GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi1));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorConnected,
+            network_connection_observer_->GetResult(kWifi1));
 
   EXPECT_TRUE(Configure(kConfigConnecting));
-  Connect("wifi2");
+  Connect(kWifi2);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConnecting, GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi2));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorConnecting,
+            network_connection_observer_->GetResult(kWifi2));
 
   EXPECT_TRUE(Configure(kConfigRequiresPassphrase));
-  Connect("wifi3");
+  Connect(kWifi3);
   EXPECT_EQ(NetworkConnectionHandler::kErrorPassphraseRequired,
             GetResultAndReset());
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi3));
+  EXPECT_EQ(NetworkConnectionHandler::kErrorPassphraseRequired,
+            network_connection_observer_->GetResult(kWifi3));
 }
 
 namespace {
 
 const char* kPolicyWithCertPatternTemplate =
     "[ { \"GUID\": \"wifi4\","
     "    \"Name\": \"wifi4\","
     "    \"Type\": \"WiFi\","
     "    \"WiFi\": {"
     "      \"Security\": \"WPA-EAP\","
@@ skipping 60 matching lines @@
 
   // |StartCertLoader| should have triggered certificate loading.
   // When the certificates got loaded, the connection request should have
   // proceeded and eventually succeeded.
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 TEST_F(NetworkConnectionHandlerTest,
        NetworkConnectionHandlerDisconnectSuccess) {
   EXPECT_TRUE(Configure(kConfigConnected));
-  Disconnect("wifi1");
+  Disconnect(kWifi1);
+  EXPECT_TRUE(network_connection_observer_->GetRequested(kWifi1));
   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 }
 
 TEST_F(NetworkConnectionHandlerTest,
        NetworkConnectionHandlerDisconnectFailure) {
-  Connect("no-network");
+  Connect(kNoNetwork);
   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
             GetResultAndReset());
 
   EXPECT_TRUE(Configure(kConfigConnectable));
-  Disconnect("wifi0");
+  Disconnect(kWifi0);
   EXPECT_EQ(NetworkConnectionHandler::kErrorNotConnected, GetResultAndReset());
 }
 
 }  // namespace chromeos
 
 #endif