src/chrome/browser/extensions/api/networking_private/networking_private_apitest.cc

   1 // Copyright 2013 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 "base/callback.h"
   6 #include "base/command_line.h"
   7 #include "chrome/browser/browser_process.h"
   8 #include "chrome/browser/chromeos/login/user.h"
   9 #include "chrome/browser/chromeos/login/user_manager.h"
  10 #include "chrome/browser/extensions/extension_apitest.h"
  11 #include "chrome/common/chrome_switches.h"
  12 #include "chrome/test/base/ui_test_utils.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14
  15 #if defined(OS_CHROMEOS)
  16 #include "chrome/browser/policy/browser_policy_connector.h"
  17 #include "chrome/browser/policy/external_data_fetcher.h"
  18 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
  19 #include "chrome/browser/policy/policy_map.h"
  20 #include "chrome/browser/policy/policy_types.h"
  21 #include "chromeos/chromeos_switches.h"
  22 #include "chromeos/dbus/cryptohome_client.h"
  23 #include "chromeos/dbus/dbus_thread_manager.h"
  24 #include "chromeos/dbus/shill_device_client.h"
  25 #include "chromeos/dbus/shill_manager_client.h"
  26 #include "chromeos/dbus/shill_profile_client.h"
  27 #include "chromeos/dbus/shill_service_client.h"
  28 #include "chromeos/dbus/shill_stub_helper.h"
  29 #include "chromeos/network/onc/onc_utils.h"
  30 #include "components/onc/onc_constants.h"
  31 #include "policy/policy_constants.h"
  32 #include "third_party/cros_system_api/dbus/service_constants.h"
  33 #endif  // OS_CHROMEOS
  34
  35 using testing::AnyNumber;
  36 using testing::Return;
  37 using testing::_;
  38
  39 namespace chromeos {
  40
  41 #if defined(OS_CHROMEOS)
  42 const char kUser1ProfilePath[] = "/profile/user1/shill";
  43 #endif  // defined(OS_CHROMEOS)
  44
  45 class ExtensionNetworkingPrivateApiTest :
  46     public ExtensionApiTest,
  47     public testing::WithParamInterface<bool> {
  48  public:
  49   bool RunNetworkingSubtest(const std::string& subtest) {
  50     return RunExtensionSubtest(
  51         "networking", "main.html?" + subtest,
  52         kFlagEnableFileAccess | kFlagLoadAsComponent);
  53   }
  54
  55   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
  56 #if defined(OS_CHROMEOS)
  57     EXPECT_CALL(provider_, IsInitializationComplete(_))
  58         .WillRepeatedly(Return(true));
  59     EXPECT_CALL(provider_, RegisterPolicyDomain(_)).Times(AnyNumber());
  60     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
  61 #endif
  62
  63     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
  64   }
  65
  66 #if defined(OS_CHROMEOS)
  67   static void AssignString(std::string* out,
  68                     DBusMethodCallStatus call_status,
  69                     const std::string& result) {
  70     CHECK_EQ(call_status, DBUS_METHOD_CALL_SUCCESS);
  71     *out = result;
  72   }
  73
  74   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  75     ExtensionApiTest::SetUpCommandLine(command_line);
  76     // Whitelist the extension ID of the test extension.
  77     command_line->AppendSwitchASCII(::switches::kWhitelistedExtensionID,
  78                                     "epcifkihnkjgphfkloaaleeakhpmgdmn");
  79
  80     // TODO(pneubeck): Remove the following hack, once the NetworkingPrivateAPI
  81     // uses the ProfileHelper to obtain the userhash crbug/238623.
  82     std::string login_user =
  83         command_line->GetSwitchValueNative(switches::kLoginUser);
  84     std::string sanitized_user = CryptohomeClient::GetStubSanitizedUsername(
  85         login_user);
  86     command_line->AppendSwitchASCII(switches::kLoginProfile, sanitized_user);
  87     if (GetParam())
  88       command_line->AppendSwitch(::switches::kMultiProfiles);
  89   }
  90
  91   void InitializeSanitizedUsername() {
  92     chromeos::UserManager* user_manager = chromeos::UserManager::Get();
  93     chromeos::User* user = user_manager->GetActiveUser();
  94     CHECK(user);
  95     std::string userhash;
  96     DBusThreadManager::Get()->GetCryptohomeClient()->GetSanitizedUsername(
  97         user->email(),
  98         base::Bind(&AssignString, &userhash_));
  99     content::RunAllPendingInMessageLoop();
 100     CHECK(!userhash_.empty());
 101   }
 102
 103   virtual void SetUpOnMainThread() OVERRIDE {
 104     ExtensionApiTest::SetUpOnMainThread();
 105     content::RunAllPendingInMessageLoop();
 106
 107     InitializeSanitizedUsername();
 108
 109     ShillManagerClient::TestInterface* manager_test =
 110         DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
 111     ShillDeviceClient::TestInterface* device_test =
 112         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
 113     ShillProfileClient::TestInterface* profile_test =
 114         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
 115     ShillServiceClient::TestInterface* service_test =
 116         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 117
 118     device_test->ClearDevices();
 119     service_test->ClearServices();
 120
 121     // Sends a notification about the added profile.
 122     profile_test->AddProfile(kUser1ProfilePath, userhash_);
 123
 124     device_test->AddDevice("/device/stub_wifi_device1",
 125                            shill::kTypeWifi, "stub_wifi_device1");
 126     device_test->AddDevice("/device/stub_cellular_device1",
 127                            shill::kTypeCellular, "stub_cellular_device1");
 128
 129     const bool add_to_watchlist = true;
 130     const bool add_to_visible = true;
 131     service_test->AddService("stub_ethernet", "eth0",
 132                              shill::kTypeEthernet, shill::kStateOnline,
 133                              add_to_visible, add_to_watchlist);
 134     service_test->SetServiceProperty(
 135         "stub_ethernet",
 136         shill::kProfileProperty,
 137         base::StringValue(shill_stub_helper::kSharedProfilePath));
 138     profile_test->AddService(shill_stub_helper::kSharedProfilePath,
 139                              "stub_ethernet");
 140
 141     service_test->AddService("stub_wifi1", "wifi1",
 142                              shill::kTypeWifi, shill::kStateOnline,
 143                              add_to_visible, add_to_watchlist);
 144     service_test->SetServiceProperty("stub_wifi1",
 145                                      shill::kSecurityProperty,
 146                                      base::StringValue(shill::kSecurityWep));
 147     service_test->SetServiceProperty("stub_wifi1",
 148                                      shill::kProfileProperty,
 149                                      base::StringValue(kUser1ProfilePath));
 150     profile_test->AddService(kUser1ProfilePath, "stub_wifi1");
 151     base::ListValue frequencies1;
 152     frequencies1.AppendInteger(2400);
 153     service_test->SetServiceProperty("stub_wifi1",
 154                                      shill::kWifiFrequencyListProperty,
 155                                      frequencies1);
 156     service_test->SetServiceProperty("stub_wifi1",
 157                                      shill::kWifiFrequency,
 158                                      base::FundamentalValue(2400));
 159
 160     service_test->AddService("stub_wifi2", "wifi2_PSK",
 161                              shill::kTypeWifi, shill::kStateIdle,
 162                              add_to_visible, add_to_watchlist);
 163     service_test->SetServiceProperty("stub_wifi2",
 164                                      shill::kGuidProperty,
 165                                      base::StringValue("stub_wifi2"));
 166     service_test->SetServiceProperty("stub_wifi2",
 167                                      shill::kSecurityProperty,
 168                                      base::StringValue(shill::kSecurityPsk));
 169     service_test->SetServiceProperty("stub_wifi2",
 170                                      shill::kSignalStrengthProperty,
 171                                      base::FundamentalValue(80));
 172     service_test->SetServiceProperty("stub_wifi2",
 173                                      shill::kConnectableProperty,
 174                                      base::FundamentalValue(true));
 175
 176     base::ListValue frequencies2;
 177     frequencies2.AppendInteger(2400);
 178     frequencies2.AppendInteger(5000);
 179     service_test->SetServiceProperty("stub_wifi2",
 180                                      shill::kWifiFrequencyListProperty,
 181                                      frequencies2);
 182     service_test->SetServiceProperty("stub_wifi2",
 183                                      shill::kWifiFrequency,
 184                                      base::FundamentalValue(5000));
 185     service_test->SetServiceProperty("stub_wifi2",
 186                                      shill::kProfileProperty,
 187                                      base::StringValue(kUser1ProfilePath));
 188     profile_test->AddService(kUser1ProfilePath, "stub_wifi2");
 189
 190     service_test->AddService("stub_cellular1", "cellular1",
 191                              shill::kTypeCellular, shill::kStateIdle,
 192                              add_to_visible, add_to_watchlist);
 193     service_test->SetServiceProperty(
 194         "stub_cellular1",
 195         shill::kNetworkTechnologyProperty,
 196         base::StringValue(shill::kNetworkTechnologyGsm));
 197     service_test->SetServiceProperty(
 198         "stub_cellular1",
 199         shill::kActivationStateProperty,
 200         base::StringValue(shill::kActivationStateNotActivated));
 201     service_test->SetServiceProperty(
 202         "stub_cellular1",
 203         shill::kRoamingStateProperty,
 204         base::StringValue(shill::kRoamingStateHome));
 205
 206     service_test->AddService("stub_vpn1", "vpn1",
 207                              shill::kTypeVPN,
 208                              shill::kStateOnline,
 209                              add_to_visible, add_to_watchlist);
 210
 211     manager_test->SortManagerServices();
 212
 213     content::RunAllPendingInMessageLoop();
 214   }
 215 #else  // !defined(OS_CHROMEOS)
 216   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 217     ExtensionApiTest::SetUpCommandLine(command_line);
 218     // Whitelist the extension ID of the test extension.
 219     command_line->AppendSwitchASCII(::switches::kWhitelistedExtensionID,
 220                                     "epcifkihnkjgphfkloaaleeakhpmgdmn");
 221   }
 222
 223   virtual void SetUpOnMainThread() OVERRIDE {
 224     ExtensionApiTest::SetUpOnMainThread();
 225     content::RunAllPendingInMessageLoop();
 226   }
 227 #endif  // OS_CHROMEOS
 228
 229  protected:
 230 #if defined(OS_CHROMEOS)
 231   policy::MockConfigurationPolicyProvider provider_;
 232   std::string userhash_;
 233 #endif
 234 };
 235
 236 // Place each subtest into a separate browser test so that the stub networking
 237 // library state is reset for each subtest run. This way they won't affect each
 238 // other.
 239
 240 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, StartConnect) {
 241   EXPECT_TRUE(RunNetworkingSubtest("startConnect")) << message_;
 242 }
 243
 244 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, StartDisconnect) {
 245   EXPECT_TRUE(RunNetworkingSubtest("startDisconnect")) << message_;
 246 }
 247
 248 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 249                        StartConnectNonexistent) {
 250   EXPECT_TRUE(RunNetworkingSubtest("startConnectNonexistent")) << message_;
 251 }
 252
 253 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 254                        StartDisconnectNonexistent) {
 255   EXPECT_TRUE(RunNetworkingSubtest("startDisconnectNonexistent")) << message_;
 256 }
 257
 258 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 259                        StartGetPropertiesNonexistent) {
 260   EXPECT_TRUE(RunNetworkingSubtest("startGetPropertiesNonexistent"))
 261       << message_;
 262 }
 263
 264 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, CreateNetwork) {
 265   EXPECT_TRUE(RunNetworkingSubtest("createNetwork")) << message_;
 266 }
 267
 268 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetVisibleNetworks) {
 269   EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworks")) << message_;
 270 }
 271
 272 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 273                        GetVisibleNetworksWifi) {
 274   EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworksWifi")) << message_;
 275 }
 276
 277 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, RequestNetworkScan) {
 278   EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScan")) << message_;
 279 }
 280
 281 // Properties are filtered and translated through
 282 // ShillToONCTranslator::TranslateWiFiWithState
 283 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetProperties) {
 284   EXPECT_TRUE(RunNetworkingSubtest("getProperties")) << message_;
 285 }
 286
 287 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetState) {
 288   EXPECT_TRUE(RunNetworkingSubtest("getState")) << message_;
 289 }
 290
 291 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, SetProperties) {
 292   EXPECT_TRUE(RunNetworkingSubtest("setProperties")) << message_;
 293 }
 294
 295 #if defined(OS_CHROMEOS)
 296 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, GetStateNonExistent) {
 297   EXPECT_TRUE(RunNetworkingSubtest("getStateNonExistent")) << message_;
 298 }
 299
 300 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 301                        GetManagedProperties) {
 302   ShillServiceClient::TestInterface* service_test =
 303       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 304   const std::string uidata_blob =
 305       "{ \"user_settings\": {"
 306       "      \"WiFi\": {"
 307       "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
 308       "    }"
 309       "}";
 310   service_test->SetServiceProperty("stub_wifi2",
 311                                    shill::kUIDataProperty,
 312                                    base::StringValue(uidata_blob));
 313   service_test->SetServiceProperty("stub_wifi2",
 314                                    shill::kAutoConnectProperty,
 315                                    base::FundamentalValue(false));
 316
 317   ShillProfileClient::TestInterface* profile_test =
 318       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
 319   // Update the profile entry.
 320   profile_test->AddService(kUser1ProfilePath, "stub_wifi2");
 321
 322   content::RunAllPendingInMessageLoop();
 323
 324   const std::string user_policy_blob =
 325       "{ \"NetworkConfigurations\": ["
 326       "    { \"GUID\": \"stub_wifi2\","
 327       "      \"Type\": \"WiFi\","
 328       "      \"Name\": \"My WiFi Network\","
 329       "      \"WiFi\": {"
 330       "        \"Passphrase\": \"passphrase\","
 331       "        \"Recommended\": [ \"AutoConnect\", \"Passphrase\" ],"
 332       "        \"SSID\": \"wifi2_PSK\","
 333       "        \"Security\": \"WPA-PSK\" }"
 334       "    }"
 335       "  ],"
 336       "  \"Certificates\": [],"
 337       "  \"Type\": \"UnencryptedConfiguration\""
 338       "}";
 339
 340   policy::PolicyMap policy;
 341   policy.Set(policy::key::kOpenNetworkConfiguration,
 342              policy::POLICY_LEVEL_MANDATORY,
 343              policy::POLICY_SCOPE_USER,
 344              new base::StringValue(user_policy_blob),
 345              NULL);
 346   provider_.UpdateChromePolicy(policy);
 347
 348   content::RunAllPendingInMessageLoop();
 349
 350   EXPECT_TRUE(RunNetworkingSubtest("getManagedProperties")) << message_;
 351 }
 352 #endif  // OS_CHROMEOS
 353
 354 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 355                        OnNetworksChangedEventConnect) {
 356   EXPECT_TRUE(RunNetworkingSubtest("onNetworksChangedEventConnect"))
 357       << message_;
 358 }
 359
 360 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 361                        OnNetworksChangedEventDisconnect) {
 362   EXPECT_TRUE(RunNetworkingSubtest("onNetworksChangedEventDisconnect"))
 363       << message_;
 364 }
 365
 366 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 367                        OnNetworkListChangedEvent) {
 368   EXPECT_TRUE(RunNetworkingSubtest("onNetworkListChangedEvent")) << message_;
 369 }
 370
 371 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 372                        VerifyDestination) {
 373   EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
 374 }
 375
 376 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 377                        VerifyAndEncryptCredentials) {
 378   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
 379 }
 380
 381 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
 382                        VerifyAndEncryptData) {
 383   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 384 }
 385
 386 INSTANTIATE_TEST_CASE_P(ExtensionNetworkingPrivateApiTestInstantiation,
 387                         ExtensionNetworkingPrivateApiTest,
 388                         testing::Bool());
 389
 390 }  // namespace chromeos