chromeos/network/network_connection_handler_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/network/network_connection_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "chromeos/dbus/dbus_thread_manager.h"
  11 #include "chromeos/dbus/shill_manager_client.h"
  12 #include "chromeos/dbus/shill_service_client.h"
  13 #include "chromeos/network/network_configuration_handler.h"
  14 #include "chromeos/network/network_state_handler.h"
  15 #include "chromeos/network/onc/onc_utils.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "third_party/cros_system_api/dbus/service_constants.h"
  18
  19 namespace {
  20
  21 const char* kSuccessResult = "success";
  22
  23 void ConfigureCallback(const dbus::ObjectPath& result) {
  24 }
  25
  26 void ConfigureErrorCallback(const std::string& error_name,
  27                             const std::string& error_message) {
  28 }
  29
  30 }  // namespace
  31
  32 namespace chromeos {
  33
  34 class NetworkConnectionHandlerTest : public testing::Test {
  35  public:
  36   NetworkConnectionHandlerTest() {
  37   }
  38   virtual ~NetworkConnectionHandlerTest() {
  39   }
  40
  41   virtual void SetUp() OVERRIDE {
  42     // Initialize DBusThreadManager with a stub implementation.
  43     DBusThreadManager::InitializeWithStub();
  44     message_loop_.RunUntilIdle();
  45     DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()
  46         ->ClearServices();
  47     message_loop_.RunUntilIdle();
  48     LoginState::Initialize();
  49     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
  50     network_configuration_handler_.reset(
  51         NetworkConfigurationHandler::InitializeForTest(
  52             network_state_handler_.get()));
  53     network_connection_handler_.reset(new NetworkConnectionHandler);
  54     // TODO(stevenjb): Test integration with CertLoader using a stub or mock.
  55     network_connection_handler_->Init(network_state_handler_.get(),
  56                                       network_configuration_handler_.get());
  57   }
  58
  59   virtual void TearDown() OVERRIDE {
  60     network_connection_handler_.reset();
  61     network_configuration_handler_.reset();
  62     network_state_handler_.reset();
  63     LoginState::Shutdown();
  64     DBusThreadManager::Shutdown();
  65   }
  66
  67  protected:
  68   bool Configure(const std::string& json_string) {
  69     scoped_ptr<base::DictionaryValue> json_dict =
  70         onc::ReadDictionaryFromJson(json_string);
  71     if (!json_dict) {
  72       LOG(ERROR) << "Error parsing json: " << json_string;
  73       return false;
  74     }
  75     DBusThreadManager::Get()->GetShillManagerClient()->ConfigureService(
  76         *json_dict,
  77         base::Bind(&ConfigureCallback),
  78         base::Bind(&ConfigureErrorCallback));
  79     message_loop_.RunUntilIdle();
  80     return true;
  81   }
  82
  83   void Connect(const std::string& service_path) {
  84     const bool check_error_state = true;
  85     network_connection_handler_->ConnectToNetwork(
  86         service_path,
  87         base::Bind(&NetworkConnectionHandlerTest::SuccessCallback,
  88                    base::Unretained(this)),
  89         base::Bind(&NetworkConnectionHandlerTest::ErrorCallback,
  90                    base::Unretained(this)),
  91         check_error_state);
  92     message_loop_.RunUntilIdle();
  93   }
  94
  95   void Disconnect(const std::string& service_path) {
  96     network_connection_handler_->DisconnectNetwork(
  97         service_path,
  98         base::Bind(&NetworkConnectionHandlerTest::SuccessCallback,
  99                    base::Unretained(this)),
 100         base::Bind(&NetworkConnectionHandlerTest::ErrorCallback,
 101                    base::Unretained(this)));
 102     message_loop_.RunUntilIdle();
 103   }
 104
 105   void SuccessCallback() {
 106     result_ = kSuccessResult;
 107   }
 108
 109   void ErrorCallback(const std::string& error_name,
 110                      scoped_ptr<base::DictionaryValue> error_data) {
 111     result_ = error_name;
 112   }
 113
 114   std::string GetResultAndReset() {
 115     std::string result;
 116     result.swap(result_);
 117     return result;
 118   }
 119
 120   std::string GetServiceStringProperty(const std::string& service_path,
 121                                        const std::string& key) {
 122     std::string result;
 123     const base::DictionaryValue* properties =
 124         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()->
 125         GetServiceProperties(service_path);
 126     if (properties)
 127       properties->GetStringWithoutPathExpansion(key, &result);
 128     return result;
 129   }
 130
 131   scoped_ptr<NetworkStateHandler> network_state_handler_;
 132   scoped_ptr<NetworkConfigurationHandler> network_configuration_handler_;
 133   scoped_ptr<NetworkConnectionHandler> network_connection_handler_;
 134   base::MessageLoopForUI message_loop_;
 135   std::string result_;
 136
 137  private:
 138   DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandlerTest);
 139 };
 140
 141 namespace {
 142
 143 const char* kConfigConnectable =
 144     "{ \"GUID\": \"wifi0\", \"Type\": \"wifi\", \"State\": \"idle\", "
 145     "  \"Connectable\": true }";
 146 const char* kConfigConnected =
 147     "{ \"GUID\": \"wifi1\", \"Type\": \"wifi\", \"State\": \"online\" }";
 148 const char* kConfigConnecting =
 149     "{ \"GUID\": \"wifi2\", \"Type\": \"wifi\", \"State\": \"association\" }";
 150 const char* kConfigRequiresPassphrase =
 151     "{ \"GUID\": \"wifi3\", \"Type\": \"wifi\", "
 152     "  \"PassphraseRequired\": true }";
 153 const char* kConfigRequiresActivation =
 154     "{ \"GUID\": \"cellular1\", \"Type\": \"cellular\","
 155     "  \"Cellular.ActivationState\": \"not-activated\" }";
 156
 157 }  // namespace
 158
 159 TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectSuccess) {
 160   EXPECT_TRUE(Configure(kConfigConnectable));
 161   Connect("wifi0");
 162   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 163   EXPECT_EQ(shill::kStateOnline,
 164             GetServiceStringProperty("wifi0", shill::kStateProperty));
 165 }
 166
 167 // Handles basic failure cases.
 168 TEST_F(NetworkConnectionHandlerTest, NetworkConnectionHandlerConnectFailure) {
 169   Connect("no-network");
 170   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
 171             GetResultAndReset());
 172
 173   EXPECT_TRUE(Configure(kConfigConnected));
 174   Connect("wifi1");
 175   EXPECT_EQ(NetworkConnectionHandler::kErrorConnected, GetResultAndReset());
 176
 177   EXPECT_TRUE(Configure(kConfigConnecting));
 178   Connect("wifi2");
 179   EXPECT_EQ(NetworkConnectionHandler::kErrorConnecting, GetResultAndReset());
 180
 181   EXPECT_TRUE(Configure(kConfigRequiresPassphrase));
 182   Connect("wifi3");
 183   EXPECT_EQ(NetworkConnectionHandler::kErrorPassphraseRequired,
 184             GetResultAndReset());
 185
 186   EXPECT_TRUE(Configure(kConfigRequiresActivation));
 187   Connect("cellular1");
 188   EXPECT_EQ(NetworkConnectionHandler::kErrorActivationRequired,
 189             GetResultAndReset());
 190 }
 191
 192 namespace {
 193
 194 const char* kConfigRequiresCertificate =
 195     "{ \"GUID\": \"wifi4\", \"Type\": \"wifi\", \"Connectable\": false,"
 196     "  \"Security\": \"802_1x\","
 197     "  \"UIData\": \"{"
 198     "    \\\"certificate_type\\\": \\\"pattern\\\","
 199     "    \\\"certificate_pattern\\\": {"
 200     "      \\\"Subject\\\": { \\\"CommonName\\\": \\\"Foo\\\" }"
 201     "   } }\" }";
 202
 203 }  // namespace
 204
 205 // Handle certificates. TODO(stevenjb): Add certificate stubs to improve
 206 // test coverage.
 207 TEST_F(NetworkConnectionHandlerTest,
 208        NetworkConnectionHandlerConnectCertificate) {
 209   EXPECT_TRUE(Configure(kConfigRequiresCertificate));
 210   Connect("wifi4");
 211   EXPECT_EQ(NetworkConnectionHandler::kErrorCertificateRequired,
 212             GetResultAndReset());
 213 }
 214
 215 TEST_F(NetworkConnectionHandlerTest,
 216        NetworkConnectionHandlerDisconnectSuccess) {
 217   EXPECT_TRUE(Configure(kConfigConnected));
 218   Disconnect("wifi1");
 219   EXPECT_EQ(kSuccessResult, GetResultAndReset());
 220 }
 221
 222 TEST_F(NetworkConnectionHandlerTest,
 223        NetworkConnectionHandlerDisconnectFailure) {
 224   Connect("no-network");
 225   EXPECT_EQ(NetworkConnectionHandler::kErrorConfigureFailed,
 226             GetResultAndReset());
 227
 228   EXPECT_TRUE(Configure(kConfigConnectable));
 229   Disconnect("wifi0");
 230   EXPECT_EQ(NetworkConnectionHandler::kErrorNotConnected, GetResultAndReset());
 231 }
 232
 233 }  // namespace chromeos