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

   1 // Copyright 2014 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 <map>
   6 #include <vector>
   7
   8 #include "base/command_line.h"
   9 #include "base/logging.h"
  10 #include "chrome/browser/extensions/api/networking_private/networking_private_delegate.h"
  11 #include "chrome/browser/extensions/extension_apitest.h"
  12 #include "components/keyed_service/core/keyed_service.h"
  13 #include "components/onc/onc_constants.h"
  14 #include "content/public/test/test_utils.h"
  15 #include "extensions/common/switches.h"
  16
  17 #if defined(OS_CHROMEOS)
  18 #include "chrome/browser/extensions/api/networking_private/networking_private_factory_chromeos.h"
  19 #else
  20 #include "chrome/browser/extensions/api/networking_private/networking_private_service_client_factory.h"
  21 #endif
  22
  23 namespace extensions {
  24
  25 // This tests just the interface for the networkingPrivate API, i.e. it ensures
  26 // that the delegate methods are called as expected.
  27
  28 namespace {
  29
  30 const char kFailure[] = "Failure";
  31 const char kSuccess[] = "Success";
  32 const char kGuid[] = "SOME_GUID";
  33
  34 class TestDelegate : public KeyedService,
  35                      public NetworkingPrivateDelegate {
  36  public:
  37   TestDelegate() : fail_(false) {
  38   }
  39
  40   // Asynchronous methods
  41   void GetProperties(const std::string& guid,
  42                      const DictionaryCallback& success_callback,
  43                      const FailureCallback& failure_callback) override {
  44     DictionaryResult(guid, success_callback, failure_callback);
  45   }
  46
  47   void GetManagedProperties(const std::string& guid,
  48                             const DictionaryCallback& success_callback,
  49                             const FailureCallback& failure_callback) override {
  50     DictionaryResult(guid, success_callback, failure_callback);
  51   }
  52
  53   void GetState(const std::string& guid,
  54                 const DictionaryCallback& success_callback,
  55                 const FailureCallback& failure_callback) override {
  56     DictionaryResult(guid, success_callback, failure_callback);
  57   }
  58
  59   void SetProperties(const std::string& guid,
  60                      scoped_ptr<base::DictionaryValue> properties,
  61                      const VoidCallback& success_callback,
  62                      const FailureCallback& failure_callback) override {
  63     VoidResult(success_callback, failure_callback);
  64   }
  65
  66   void CreateNetwork(bool shared,
  67                      scoped_ptr<base::DictionaryValue> properties,
  68                      const StringCallback& success_callback,
  69                      const FailureCallback& failure_callback) override {
  70     StringResult(success_callback, failure_callback);
  71   }
  72
  73   void GetNetworks(const std::string& network_type,
  74                    bool configured_only,
  75                    bool visible_only,
  76                    int limit,
  77                    const NetworkListCallback& success_callback,
  78                    const FailureCallback& failure_callback) override {
  79     if (fail_) {
  80       failure_callback.Run(kFailure);
  81     } else {
  82       scoped_ptr<base::ListValue> result(new base::ListValue);
  83       scoped_ptr<base::DictionaryValue> network(new base::DictionaryValue);
  84       network->SetString(::onc::network_config::kType,
  85                          ::onc::network_config::kEthernet);
  86       network->SetString(::onc::network_config::kGUID, kGuid);
  87       result->Append(network.release());
  88       success_callback.Run(result.Pass());
  89     }
  90   }
  91
  92   void StartConnect(const std::string& guid,
  93                     const VoidCallback& success_callback,
  94                     const FailureCallback& failure_callback) override {
  95     VoidResult(success_callback, failure_callback);
  96   }
  97
  98   void StartDisconnect(const std::string& guid,
  99                        const VoidCallback& success_callback,
 100                        const FailureCallback& failure_callback) override {
 101     VoidResult(success_callback, failure_callback);
 102   }
 103
 104   void VerifyDestination(const VerificationProperties& verification_properties,
 105                          const BoolCallback& success_callback,
 106                          const FailureCallback& failure_callback) override {
 107     BoolResult(success_callback, failure_callback);
 108   }
 109
 110   void VerifyAndEncryptCredentials(
 111       const std::string& guid,
 112       const VerificationProperties& verification_properties,
 113       const StringCallback& success_callback,
 114       const FailureCallback& failure_callback) override {
 115     StringResult(success_callback, failure_callback);
 116   }
 117
 118   void VerifyAndEncryptData(
 119       const VerificationProperties& verification_properties,
 120       const std::string& data,
 121       const StringCallback& success_callback,
 122       const FailureCallback& failure_callback) override {
 123     StringResult(success_callback, failure_callback);
 124   }
 125
 126   void SetWifiTDLSEnabledState(
 127       const std::string& ip_or_mac_address,
 128       bool enabled,
 129       const StringCallback& success_callback,
 130       const FailureCallback& failure_callback) override {
 131     StringResult(success_callback, failure_callback);
 132   }
 133
 134   void GetWifiTDLSStatus(const std::string& ip_or_mac_address,
 135                          const StringCallback& success_callback,
 136                          const FailureCallback& failure_callback) override {
 137     StringResult(success_callback, failure_callback);
 138   }
 139
 140   void GetCaptivePortalStatus(
 141       const std::string& guid,
 142       const StringCallback& success_callback,
 143       const FailureCallback& failure_callback) override {
 144     StringResult(success_callback, failure_callback);
 145   }
 146
 147   // Synchronous methods
 148   scoped_ptr<base::ListValue> GetEnabledNetworkTypes() override {
 149     scoped_ptr<base::ListValue> result;
 150     if (!fail_) {
 151       result.reset(new base::ListValue);
 152       result->AppendString(::onc::network_config::kEthernet);
 153     }
 154     return result.Pass();
 155   }
 156
 157   bool EnableNetworkType(const std::string& type) override {
 158     enabled_[type] = true;
 159     return !fail_;
 160   }
 161
 162   bool DisableNetworkType(const std::string& type) override {
 163     disabled_[type] = true;
 164     return !fail_;
 165   }
 166
 167   bool RequestScan() override {
 168     scan_requested_.push_back(true);
 169     return !fail_;
 170   }
 171
 172   void set_fail(bool fail) { fail_ = fail; }
 173   bool GetEnabled(const std::string& type) { return enabled_[type]; }
 174   bool GetDisabled(const std::string& type) { return disabled_[type]; }
 175   size_t GetScanRequested() { return scan_requested_.size(); }
 176
 177  private:
 178   void DictionaryResult(const std::string& guid,
 179                         const DictionaryCallback& success_callback,
 180                         const FailureCallback& failure_callback) {
 181     if (fail_) {
 182       failure_callback.Run(kFailure);
 183     } else {
 184       scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 185       result->SetString(::onc::network_config::kGUID, guid);
 186       success_callback.Run(result.Pass());
 187     }
 188   }
 189
 190   void StringResult(const StringCallback& success_callback,
 191                     const FailureCallback& failure_callback) {
 192     if (fail_) {
 193       failure_callback.Run(kFailure);
 194     } else {
 195       success_callback.Run(kSuccess);
 196     }
 197   }
 198
 199   void BoolResult(const BoolCallback& success_callback,
 200                   const FailureCallback& failure_callback) {
 201     if (fail_) {
 202       failure_callback.Run(kFailure);
 203     } else {
 204       success_callback.Run(true);
 205     }
 206   }
 207
 208   void VoidResult(const VoidCallback& success_callback,
 209                   const FailureCallback& failure_callback) {
 210     if (fail_) {
 211       failure_callback.Run(kFailure);
 212     } else {
 213       success_callback.Run();
 214     }
 215   }
 216
 217   bool fail_;
 218   std::map<std::string, bool> enabled_;
 219   std::map<std::string, bool> disabled_;
 220   std::vector<bool> scan_requested_;
 221
 222   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 223 };
 224
 225 class NetworkingPrivateApiTest : public ExtensionApiTest {
 226  public:
 227   NetworkingPrivateApiTest() {
 228     if (!s_test_delegate_)
 229       s_test_delegate_ = new TestDelegate;
 230   }
 231
 232   static KeyedService* GetNetworkingPrivateDelegate(
 233       content::BrowserContext* profile) {
 234     CHECK(s_test_delegate_);
 235     return s_test_delegate_;
 236   }
 237
 238   void SetUpCommandLine(CommandLine* command_line) override {
 239     ExtensionApiTest::SetUpCommandLine(command_line);
 240     // Whitelist the extension ID of the test extension.
 241     command_line->AppendSwitchASCII(
 242         extensions::switches::kWhitelistedExtensionID,
 243         "epcifkihnkjgphfkloaaleeakhpmgdmn");
 244   }
 245
 246   void SetUpOnMainThread() override {
 247     ExtensionApiTest::SetUpOnMainThread();
 248 #if defined(OS_CHROMEOS)
 249     NetworkingPrivateChromeOSFactory::GetInstance()->SetTestingFactory(
 250         profile(),
 251         &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
 252 #else
 253     NetworkingPrivateServiceClientFactory::GetInstance()->SetTestingFactory(
 254         profile(),
 255         &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
 256 #endif
 257     content::RunAllPendingInMessageLoop();
 258   }
 259
 260   bool GetEnabled(const std::string& type) {
 261     return s_test_delegate_->GetEnabled(type);
 262   }
 263
 264   bool GetDisabled(const std::string& type) {
 265     return s_test_delegate_->GetDisabled(type);
 266   }
 267
 268   size_t GetScanRequested() {
 269     return s_test_delegate_->GetScanRequested();
 270   }
 271
 272  protected:
 273   bool RunNetworkingSubtest(const std::string& subtest) {
 274     return RunExtensionSubtest(
 275         "networking_private", "main.html?" + subtest,
 276         kFlagEnableFileAccess | kFlagLoadAsComponent);
 277   }
 278
 279   // Static pointer to the TestDelegate so that it can be accessed in
 280   // GetNetworkingPrivateDelegate() passed to SetTestingFactory().
 281   static TestDelegate* s_test_delegate_;
 282
 283   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTest);
 284 };
 285
 286 //static
 287 TestDelegate* NetworkingPrivateApiTest::s_test_delegate_ = NULL;
 288
 289 }  // namespace
 290
 291 // Place each subtest into a separate browser test so that the stub networking
 292 // library state is reset for each subtest run. This way they won't affect each
 293 // other. TODO(stevenjb): Use extensions::ApiUnitTest once moved to
 294 // src/extensions.
 295
 296 // These fail on Windows due to crbug.com/177163. Note: we still have partial
 297 // coverage in NetworkingPrivateServiceClientApiTest. TODO(stevenjb): Enable
 298 // these on Windows once we switch to extensions::ApiUnitTest.
 299
 300 #if !defined(OS_WIN)
 301
 302 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetProperties) {
 303   EXPECT_TRUE(RunNetworkingSubtest("getProperties")) << message_;
 304 }
 305
 306 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetManagedProperties) {
 307   EXPECT_TRUE(RunNetworkingSubtest("getManagedProperties")) << message_;
 308 }
 309
 310 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetState) {
 311   EXPECT_TRUE(RunNetworkingSubtest("getState")) << message_;
 312 }
 313
 314 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, SetProperties) {
 315   EXPECT_TRUE(RunNetworkingSubtest("setProperties")) << message_;
 316 }
 317
 318 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, CreateNetwork) {
 319   EXPECT_TRUE(RunNetworkingSubtest("createNetwork")) << message_;
 320 }
 321
 322 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetNetworks) {
 323   EXPECT_TRUE(RunNetworkingSubtest("getNetworks")) << message_;
 324 }
 325
 326 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetVisibleNetworks) {
 327   EXPECT_TRUE(RunNetworkingSubtest("getVisibleNetworks")) << message_;
 328 }
 329
 330 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetEnabledNetworkTypes) {
 331   EXPECT_TRUE(RunNetworkingSubtest("getEnabledNetworkTypes")) << message_;
 332 }
 333
 334 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, EnableNetworkType) {
 335   EXPECT_TRUE(RunNetworkingSubtest("enableNetworkType")) << message_;
 336   EXPECT_TRUE(GetEnabled(::onc::network_config::kEthernet));
 337 }
 338
 339 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, DisableNetworkType) {
 340   EXPECT_TRUE(RunNetworkingSubtest("disableNetworkType")) << message_;
 341   EXPECT_TRUE(GetDisabled(::onc::network_config::kEthernet));
 342 }
 343
 344 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, RequestNetworkScan) {
 345   EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScan")) << message_;
 346   EXPECT_EQ(1u, GetScanRequested());
 347 }
 348
 349 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, StartConnect) {
 350   EXPECT_TRUE(RunNetworkingSubtest("startConnect")) << message_;
 351 }
 352
 353 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, StartDisconnect) {
 354   EXPECT_TRUE(RunNetworkingSubtest("startDisconnect")) << message_;
 355 }
 356
 357 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, VerifyDestination) {
 358   EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
 359 }
 360
 361 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, VerifyAndEncryptCredentials) {
 362   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
 363 }
 364
 365 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, VerifyAndEncryptData) {
 366   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 367 }
 368
 369 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, SetWifiTDLSEnabledState) {
 370   EXPECT_TRUE(RunNetworkingSubtest("setWifiTDLSEnabledState")) << message_;
 371 }
 372
 373 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetWifiTDLSStatus) {
 374   EXPECT_TRUE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
 375 }
 376
 377 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetCaptivePortalStatus) {
 378   EXPECT_TRUE(RunNetworkingSubtest("getCaptivePortalStatus")) << message_;
 379 }
 380
 381 // Test failure case
 382
 383 class NetworkingPrivateApiTestFail : public NetworkingPrivateApiTest {
 384  public:
 385   NetworkingPrivateApiTestFail() {
 386     s_test_delegate_->set_fail(true);
 387   }
 388
 389  protected:
 390   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTestFail);
 391 };
 392
 393 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetProperties) {
 394   EXPECT_FALSE(RunNetworkingSubtest("getProperties")) << message_;
 395 }
 396
 397 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetManagedProperties) {
 398   EXPECT_FALSE(RunNetworkingSubtest("getManagedProperties")) << message_;
 399 }
 400
 401 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetState) {
 402   EXPECT_FALSE(RunNetworkingSubtest("getState")) << message_;
 403 }
 404
 405 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, SetProperties) {
 406   EXPECT_FALSE(RunNetworkingSubtest("setProperties")) << message_;
 407 }
 408
 409 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, CreateNetwork) {
 410   EXPECT_FALSE(RunNetworkingSubtest("createNetwork")) << message_;
 411 }
 412
 413 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetNetworks) {
 414   EXPECT_FALSE(RunNetworkingSubtest("getNetworks")) << message_;
 415 }
 416
 417 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetVisibleNetworks) {
 418   EXPECT_FALSE(RunNetworkingSubtest("getVisibleNetworks")) << message_;
 419 }
 420
 421 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetEnabledNetworkTypes) {
 422   EXPECT_FALSE(RunNetworkingSubtest("getEnabledNetworkTypes")) << message_;
 423 }
 424
 425 // Note: Synchronous methods never fail:
 426 // * disableNetworkType
 427 // * enableNetworkType
 428 // * requestNetworkScan
 429
 430 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, StartConnect) {
 431   EXPECT_FALSE(RunNetworkingSubtest("startConnect")) << message_;
 432 }
 433
 434 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, StartDisconnect) {
 435   EXPECT_FALSE(RunNetworkingSubtest("startDisconnect")) << message_;
 436 }
 437
 438 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, VerifyDestination) {
 439   EXPECT_FALSE(RunNetworkingSubtest("verifyDestination")) << message_;
 440 }
 441
 442 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail,
 443                        VerifyAndEncryptCredentials) {
 444   EXPECT_FALSE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
 445 }
 446
 447 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, VerifyAndEncryptData) {
 448   EXPECT_FALSE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 449 }
 450
 451 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, SetWifiTDLSEnabledState) {
 452   EXPECT_FALSE(RunNetworkingSubtest("setWifiTDLSEnabledState")) << message_;
 453 }
 454
 455 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetWifiTDLSStatus) {
 456   EXPECT_FALSE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
 457 }
 458
 459 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetCaptivePortalStatus) {
 460   EXPECT_FALSE(RunNetworkingSubtest("getCaptivePortalStatus")) << message_;
 461 }
 462
 463 #endif // defined(OS_WIN)
 464
 465 }  // namespace extensions