src/chrome/test/data/extensions/api_test/networking/test.js

   1 // Copyright (c) 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 var callbackPass = chrome.test.callbackPass;
   6 var callbackFail = chrome.test.callbackFail;
   7 var assertTrue = chrome.test.assertTrue;
   8 var assertFalse = chrome.test.assertFalse;
   9 var assertEq = chrome.test.assertEq;
  10
  11 // Test properties for the verification API.
  12 var verificationProperties = {
  13   "certificate": "certificate",
  14   "publicKey": "public_key",
  15   "nonce": "nonce",
  16   "signedData": "signed_data",
  17   "deviceSerial": "device_serial",
  18   "deviceSsid": "Device 0123",
  19   "deviceBssid": "00:01:02:03:04:05"
  20 };
  21
  22 var privateHelpers = {
  23   // Watches for the states |expectedStates| in reverse order. If all states
  24   // were observed in the right order, succeeds and calls |done|. If any
  25   // unexpected state is observed, fails.
  26   watchForStateChanges: function(network, expectedStates, done) {
  27     var self = this;
  28     var collectProperties = function(properties) {
  29       var finishTest = function() {
  30         chrome.networkingPrivate.onNetworksChanged.removeListener(
  31             self.onNetworkChange);
  32         done();
  33       };
  34       if (expectedStates.length > 0) {
  35         var expectedState = expectedStates.pop();
  36         assertEq(expectedState, properties.ConnectionState);
  37         if (expectedStates.length == 0)
  38           finishTest();
  39       }
  40     };
  41     this.onNetworkChange = function(changes) {
  42       assertEq([network], changes);
  43       chrome.networkingPrivate.getProperties(
  44           network,
  45           callbackPass(collectProperties));
  46     };
  47     chrome.networkingPrivate.onNetworksChanged.addListener(
  48         this.onNetworkChange);
  49   },
  50   listListener: function(expected, done) {
  51     var self = this;
  52     this.listenForChanges = function(list) {
  53       assertEq(expected, list);
  54       chrome.networkingPrivate.onNetworkListChanged.removeListener(
  55           self.listenForChanges);
  56       done();
  57     };
  58   },
  59   watchForCaptivePortalState: function(expectedNetworkPath,
  60                                        expectedState,
  61                                        done) {
  62     var self = this;
  63     this.onPortalDetectionCompleted = function(networkPath, state) {
  64       assertEq(expectedNetworkPath, networkPath);
  65       assertEq(expectedState, state);
  66       chrome.networkingPrivate.onPortalDetectionCompleted.removeListener(
  67           self.onPortalDetectionCompleted);
  68       done();
  69     };
  70     chrome.networkingPrivate.onPortalDetectionCompleted.addListener(
  71         self.onPortalDetectionCompleted);
  72   }
  73 };
  74
  75 var availableTests = [
  76   function startConnect() {
  77     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass());
  78   },
  79   function startDisconnect() {
  80     // Must connect to a network before we can disconnect from it.
  81     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass(
  82       function() {
  83         chrome.networkingPrivate.startDisconnect("stub_wifi2", callbackPass());
  84       }));
  85   },
  86   function startConnectNonexistent() {
  87     chrome.networkingPrivate.startConnect(
  88       "nonexistent_path",
  89       callbackFail("configure-failed"));
  90   },
  91   function startDisconnectNonexistent() {
  92     chrome.networkingPrivate.startDisconnect(
  93       "nonexistent_path",
  94       callbackFail("not-found"));
  95   },
  96   function startGetPropertiesNonexistent() {
  97     chrome.networkingPrivate.getProperties(
  98       "nonexistent_path",
  99       callbackFail("Error.DBusFailed"));
 100   },
 101   function createNetwork() {
 102     chrome.networkingPrivate.createNetwork(
 103       false,  // shared
 104       { "Type": "WiFi",
 105         "GUID": "ignored_guid",
 106         "WiFi": {
 107           "SSID": "wifi_created",
 108           "Security": "WEP-PSK"
 109         }
 110       },
 111       callbackPass(function(guid) {
 112         assertFalse(guid == "");
 113         assertFalse(guid == "ignored_guid");
 114         chrome.networkingPrivate.getProperties(
 115           guid,
 116           callbackPass(function(properties) {
 117             assertEq("WiFi", properties.Type);
 118             assertEq(guid, properties.GUID);
 119             assertEq("wifi_created", properties.WiFi.SSID);
 120             assertEq("WEP-PSK", properties.WiFi.Security);
 121           }));
 122       }));
 123   },
 124   function getVisibleNetworks() {
 125     chrome.networkingPrivate.getVisibleNetworks(
 126       "All",
 127       callbackPass(function(result) {
 128         assertEq([{
 129                     "ConnectionState": "Connected",
 130                     "Ethernet": {
 131                       "Authentication": "None"
 132                     },
 133                     "GUID": "stub_ethernet",
 134                     "Name": "eth0",
 135                     "Type": "Ethernet"
 136                   },
 137                   {
 138                     "Connectable": true,
 139                     "ConnectionState": "Connected",
 140                     "GUID": "stub_wifi1",
 141                     "Name": "wifi1",
 142                     "Type": "WiFi",
 143                     "WiFi": {
 144                       "Security": "WEP-PSK",
 145                       "SignalStrength": 40
 146                     }
 147                   },
 148                   {
 149                     "ConnectionState": "Connected",
 150                     "GUID": "stub_vpn1",
 151                     "Name": "vpn1",
 152                     "Type": "VPN",
 153                   },
 154                   {
 155                     "Connectable": true,
 156                     "ConnectionState": "NotConnected",
 157                     "GUID": "stub_wifi2",
 158                     "Name": "wifi2_PSK",
 159                     "Type": "WiFi",
 160                     "WiFi": {
 161                       "Security": "WPA-PSK",
 162                       "SignalStrength": 80
 163                     }
 164                   }], result);
 165       }));
 166   },
 167   function getVisibleNetworksWifi() {
 168     chrome.networkingPrivate.getVisibleNetworks(
 169       "WiFi",
 170       callbackPass(function(result) {
 171         assertEq([{
 172                     "Connectable": true,
 173                     "ConnectionState": "Connected",
 174                     "GUID": "stub_wifi1",
 175                     "Name": "wifi1",
 176                     "Type": "WiFi",
 177                     "WiFi": {
 178                       "Security": "WEP-PSK",
 179                       "SignalStrength": 40
 180                     }
 181                   },
 182                   {
 183                     "Connectable": true,
 184                     "ConnectionState": "NotConnected",
 185                     "GUID": "stub_wifi2",
 186                     "Name": "wifi2_PSK",
 187                     "Type": "WiFi",
 188                     "WiFi": {
 189                       "Security": "WPA-PSK",
 190                       "SignalStrength": 80
 191                     }
 192                   }
 193                   ], result);
 194       }));
 195   },
 196   function requestNetworkScan() {
 197     // Connected or Connecting networks should be listed first, sorted by type.
 198     var expected = ["stub_ethernet",
 199                     "stub_wifi1",
 200                     "stub_vpn1",
 201                     "stub_wifi2"];
 202     var done = chrome.test.callbackAdded();
 203     var listener = new privateHelpers.listListener(expected, done);
 204     chrome.networkingPrivate.onNetworkListChanged.addListener(
 205       listener.listenForChanges);
 206     chrome.networkingPrivate.requestNetworkScan();
 207   },
 208   function getProperties() {
 209     chrome.networkingPrivate.getProperties(
 210       "stub_wifi1",
 211       callbackPass(function(result) {
 212         assertEq({ "Connectable": true,
 213                    "ConnectionState": "Connected",
 214                    "GUID": "stub_wifi1",
 215                    "IPConfigs": [{
 216                      "Gateway": "0.0.0.1",
 217                      "IPAddress": "0.0.0.0",
 218                      "RoutingPrefix": 0,
 219                      "Type": "IPv4"
 220                    }],
 221                    "Name": "wifi1",
 222                    "Type": "WiFi",
 223                    "WiFi": {
 224                      "Frequency": 2400,
 225                      "FrequencyList": [2400],
 226                      "SSID": "wifi1",
 227                      "Security": "WEP-PSK",
 228                      "SignalStrength": 40
 229                    }
 230                  }, result);
 231       }));
 232   },
 233   function getManagedProperties() {
 234     chrome.networkingPrivate.getManagedProperties(
 235       "stub_wifi2",
 236       callbackPass(function(result) {
 237         assertEq({
 238                    "Connectable": {
 239                      "Active": true,
 240                      "Effective": "Unmanaged"
 241                    },
 242                    "ConnectionState": {
 243                      "Active": "NotConnected",
 244                      "Effective": "Unmanaged"
 245                    },
 246                    "GUID": "stub_wifi2",
 247                    "Name": {
 248                      "Active": "wifi2_PSK",
 249                      "Effective": "UserPolicy",
 250                      "UserPolicy": "My WiFi Network"
 251                    },
 252                    "Type": {
 253                      "Active": "WiFi",
 254                      "Effective": "UserPolicy",
 255                      "UserPolicy": "WiFi"
 256                    },
 257                    "WiFi": {
 258                      "AutoConnect": {
 259                        "Active": false,
 260                        "UserEditable": true
 261                      },
 262                      "Frequency" : {
 263                        "Active": 5000,
 264                        "Effective": "Unmanaged"
 265                      },
 266                      "FrequencyList" : {
 267                        "Active": [2400, 5000],
 268                        "Effective": "Unmanaged"
 269                      },
 270                      "Passphrase": {
 271                        "Effective": "UserSetting",
 272                        "UserEditable": true,
 273                        "UserSetting": "FAKE_CREDENTIAL_VPaJDV9x"
 274                      },
 275                      "SSID": {
 276                        "Active": "wifi2_PSK",
 277                        "Effective": "UserPolicy",
 278                        "UserPolicy": "wifi2_PSK"
 279                      },
 280                      "Security": {
 281                        "Active": "WPA-PSK",
 282                        "Effective": "UserPolicy",
 283                        "UserPolicy": "WPA-PSK"
 284                      },
 285                      "SignalStrength": {
 286                        "Active": 80,
 287                        "Effective": "Unmanaged"
 288                      }
 289                    }
 290                  }, result);
 291       }));
 292   },
 293   function setProperties() {
 294     var done = chrome.test.callbackAdded();
 295     chrome.networkingPrivate.getProperties(
 296       "stub_wifi2",
 297       callbackPass(function(result) {
 298         result.WiFi.Security = "WEP-PSK";
 299         chrome.networkingPrivate.setProperties("stub_wifi2", result,
 300           callbackPass(function() {
 301             chrome.networkingPrivate.getProperties(
 302               "stub_wifi2",
 303               callbackPass(function(result) {
 304                 assertEq("WEP-PSK", result.WiFi.Security);
 305                 done();
 306               }));
 307           }));
 308       }));
 309   },
 310   function getState() {
 311     chrome.networkingPrivate.getState(
 312       "stub_wifi2",
 313       callbackPass(function(result) {
 314         assertEq({
 315           "Connectable": true,
 316           "ConnectionState": "NotConnected",
 317           "GUID": "stub_wifi2",
 318           "Name": "wifi2_PSK",
 319           "Type": "WiFi",
 320           "WiFi": {
 321             "Security": "WPA-PSK",
 322             "SignalStrength": 80
 323           }
 324         }, result);
 325       }));
 326   },
 327   function getStateNonExistent() {
 328     chrome.networkingPrivate.getState(
 329       'non_existent',
 330       callbackFail('Error.InvalidParameter'));
 331   },
 332   function onNetworksChangedEventConnect() {
 333     var network = "stub_wifi2";
 334     var done = chrome.test.callbackAdded();
 335     var expectedStates = ["Connected"];
 336     var listener =
 337         new privateHelpers.watchForStateChanges(network, expectedStates, done);
 338     chrome.networkingPrivate.startConnect(network, callbackPass());
 339   },
 340   function onNetworksChangedEventDisconnect() {
 341     var network = "stub_wifi1";
 342     var done = chrome.test.callbackAdded();
 343     var expectedStates = ["NotConnected"];
 344     var listener =
 345         new privateHelpers.watchForStateChanges(network, expectedStates, done);
 346     chrome.networkingPrivate.startDisconnect(network, callbackPass());
 347   },
 348   function onNetworkListChangedEvent() {
 349     // Connecting to wifi2 should set wifi1 to offline. Connected or Connecting
 350     // networks should be listed first, sorted by type.
 351     var expected = ["stub_ethernet",
 352                     "stub_wifi2",
 353                     "stub_vpn1",
 354                     "stub_wifi1"];
 355     var done = chrome.test.callbackAdded();
 356     var listener = new privateHelpers.listListener(expected, done);
 357     chrome.networkingPrivate.onNetworkListChanged.addListener(
 358       listener.listenForChanges);
 359     var network = "stub_wifi2";
 360     chrome.networkingPrivate.startConnect(network, callbackPass());
 361   },
 362   function verifyDestination() {
 363     chrome.networkingPrivate.verifyDestination(
 364       verificationProperties,
 365       callbackPass(function(isValid) {
 366         assertTrue(isValid);
 367       }));
 368   },
 369   function verifyAndEncryptCredentials() {
 370     chrome.networkingPrivate.verifyAndEncryptCredentials(
 371       verificationProperties,
 372       "guid",
 373       callbackPass(function(result) {
 374         assertEq("encrypted_credentials", result);
 375       }));
 376   },
 377   function verifyAndEncryptData() {
 378     chrome.networkingPrivate.verifyAndEncryptData(
 379       verificationProperties,
 380       "data",
 381       callbackPass(function(result) {
 382         assertEq("encrypted_data", result);
 383       }));
 384   },
 385   function setWifiTDLSEnabledState() {
 386     chrome.networkingPrivate.setWifiTDLSEnabledState(
 387       "aa:bb:cc:dd:ee:ff",
 388       true,
 389       callbackPass(function(result) {
 390         assertEq("Connected", result);
 391       }));
 392   },
 393   function getWifiTDLSStatus() {
 394     chrome.networkingPrivate.getWifiTDLSStatus(
 395       "aa:bb:cc:dd:ee:ff",
 396       callbackPass(function(result) {
 397         assertEq("Connected", result);
 398       }));
 399   },
 400   function getCaptivePortalStatus() {
 401     var networks = [['stub_ethernet', 'Online'],
 402                     ['stub_wifi1', 'Offline'],
 403                     ['stub_wifi2', 'Portal'],
 404                     ['stub_cellular1', 'ProxyAuthRequired'],
 405                     ['stub_vpn1', 'Unknown']];
 406     networks.forEach(function(network) {
 407       var servicePath = network[0];
 408       var expectedStatus = network[1];
 409       chrome.networkingPrivate.getCaptivePortalStatus(
 410         servicePath,
 411         callbackPass(function(status) {
 412           assertEq(expectedStatus, status);
 413         }));
 414     });
 415   },
 416   function captivePortalNotification() {
 417     var done = chrome.test.callbackAdded();
 418     var listener =
 419         new privateHelpers.watchForCaptivePortalState('wifi', 'Online', done);
 420     chrome.test.sendMessage('notifyPortalDetectorObservers');
 421   },
 422 ];
 423
 424 var testToRun = window.location.search.substring(1);
 425 chrome.test.runTests(availableTests.filter(function(op) {
 426   return op.name == testToRun;
 427 }));