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 };
  60
  61 var availableTests = [
  62   function startConnect() {
  63     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass());
  64   },
  65   function startDisconnect() {
  66     // Must connect to a network before we can disconnect from it.
  67     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass(
  68       function() {
  69         chrome.networkingPrivate.startDisconnect("stub_wifi2", callbackPass());
  70       }));
  71   },
  72   function startConnectNonexistent() {
  73     chrome.networkingPrivate.startConnect(
  74       "nonexistent_path",
  75       callbackFail("configure-failed"));
  76   },
  77   function startDisconnectNonexistent() {
  78     chrome.networkingPrivate.startDisconnect(
  79       "nonexistent_path",
  80       callbackFail("not-found"));
  81   },
  82   function startGetPropertiesNonexistent() {
  83     chrome.networkingPrivate.getProperties(
  84       "nonexistent_path",
  85       callbackFail("Error.DBusFailed"));
  86   },
  87   function createNetwork() {
  88     chrome.networkingPrivate.createNetwork(
  89       false,  // shared
  90       { "Type": "WiFi",
  91         "GUID": "ignored_guid",
  92         "WiFi": {
  93           "SSID": "wifi_created",
  94           "Security": "WEP-PSK"
  95         }
  96       },
  97       callbackPass(function(guid) {
  98         assertFalse(guid == "");
  99         assertFalse(guid == "ignored_guid");
 100         chrome.networkingPrivate.getProperties(
 101           guid,
 102           callbackPass(function(properties) {
 103             assertEq("WiFi", properties.Type);
 104             assertEq(guid, properties.GUID);
 105             assertEq("wifi_created", properties.WiFi.SSID);
 106             assertEq("WEP-PSK", properties.WiFi.Security);
 107           }));
 108       }));
 109   },
 110   function getVisibleNetworks() {
 111     chrome.networkingPrivate.getVisibleNetworks(
 112       "All",
 113       callbackPass(function(result) {
 114         assertEq([{
 115                     "ConnectionState": "Connected",
 116                     "GUID": "stub_ethernet",
 117                     "Name": "eth0",
 118                     "Type": "Ethernet",
 119                     "Ethernet": {
 120                       "Authentication": "None"
 121                     }
 122                   },
 123                   {
 124                     "ConnectionState": "Connected",
 125                     "GUID": "stub_wifi1",
 126                     "Name": "wifi1",
 127                     "Type": "WiFi",
 128                     "WiFi": {
 129                       "Security": "WEP-PSK",
 130                       "SignalStrength": 0
 131                     }
 132                   },
 133                   {
 134                     "ConnectionState": "Connected",
 135                     "GUID": "stub_vpn1",
 136                     "Name": "vpn1",
 137                     "Type": "VPN",
 138                   },
 139                   {
 140                     "ConnectionState": "NotConnected",
 141                     "GUID": "stub_wifi2",
 142                     "Name": "wifi2_PSK",
 143                     "Type": "WiFi",
 144                     "WiFi": {
 145                       "Security": "WPA-PSK",
 146                       "SignalStrength": 80
 147                     }
 148                   },
 149                   {
 150                     "Cellular": {
 151                       "ActivateOverNonCellularNetwork": false,
 152                       "ActivationState": "not-activated",
 153                       "NetworkTechnology": "GSM",
 154                       "RoamingState": "home"
 155                     },
 156                     "ConnectionState": "NotConnected",
 157                     "GUID": "stub_cellular1",
 158                     "Name": "cellular1",
 159                     "Type": "Cellular"
 160                   }], result);
 161       }));
 162   },
 163   function getVisibleNetworksWifi() {
 164     chrome.networkingPrivate.getVisibleNetworks(
 165       "WiFi",
 166       callbackPass(function(result) {
 167         assertEq([{
 168                     "ConnectionState": "Connected",
 169                     "GUID": "stub_wifi1",
 170                     "Name": "wifi1",
 171                     "Type": "WiFi",
 172                     "WiFi": {
 173                       "Security": "WEP-PSK",
 174                       "SignalStrength": 0
 175                     }
 176                   },
 177                   {
 178                     "ConnectionState": "NotConnected",
 179                     "GUID": "stub_wifi2",
 180                     "Name": "wifi2_PSK",
 181                     "Type": "WiFi",
 182                     "WiFi": {
 183                       "Security": "WPA-PSK",
 184                       "SignalStrength": 80
 185                     }
 186                   }
 187                   ], result);
 188       }));
 189   },
 190   function requestNetworkScan() {
 191     // Connected or Connecting networks should be listed first, sorted by type.
 192     var expected = ["stub_ethernet",
 193                     "stub_wifi1",
 194                     "stub_vpn1",
 195                     "stub_wifi2",
 196                     "stub_cellular1"];
 197     var done = chrome.test.callbackAdded();
 198     var listener = new privateHelpers.listListener(expected, done);
 199     chrome.networkingPrivate.onNetworkListChanged.addListener(
 200       listener.listenForChanges);
 201     chrome.networkingPrivate.requestNetworkScan();
 202   },
 203   function getProperties() {
 204     chrome.networkingPrivate.getProperties(
 205       "stub_wifi2",
 206       callbackPass(function(result) {
 207         assertEq({
 208                    "ConnectionState": "NotConnected",
 209                    "GUID": "stub_wifi2",
 210                    "Name": "wifi2_PSK",
 211                    "Type": "WiFi",
 212                    "WiFi": {
 213                      "Frequency": 5000,
 214                      "FrequencyList": [2400, 5000],
 215                      "SSID": "wifi2_PSK",
 216                      "Security": "WPA-PSK",
 217                      "SignalStrength": 80
 218                    }
 219                  }, result);
 220       }));
 221   },
 222   function getManagedProperties() {
 223     chrome.networkingPrivate.getManagedProperties(
 224       "stub_wifi2",
 225       callbackPass(function(result) {
 226         assertEq({
 227                    "ConnectionState": {
 228                      "Active": "NotConnected",
 229                      "Effective": "Unmanaged"
 230                    },
 231                    "GUID": "stub_wifi2",
 232                    "Name": {
 233                      "Active": "wifi2_PSK",
 234                      "Effective": "UserPolicy",
 235                      "UserPolicy": "My WiFi Network"
 236                    },
 237                    "Type": {
 238                      "Active": "WiFi",
 239                      "Effective": "UserPolicy",
 240                      "UserPolicy": "WiFi"
 241                    },
 242                    "WiFi": {
 243                      "AutoConnect": {
 244                        "Active": false,
 245                        "UserEditable": true
 246                      },
 247                      "Frequency" : {
 248                        "Active": 5000,
 249                        "Effective": "Unmanaged"
 250                      },
 251                      "FrequencyList" : {
 252                        "Active": [2400, 5000],
 253                        "Effective": "Unmanaged"
 254                      },
 255                      "Passphrase": {
 256                        "Effective": "UserSetting",
 257                        "UserEditable": true,
 258                        "UserSetting": "FAKE_CREDENTIAL_VPaJDV9x"
 259                      },
 260                      "SSID": {
 261                        "Active": "wifi2_PSK",
 262                        "Effective": "UserPolicy",
 263                        "UserPolicy": "wifi2_PSK"
 264                      },
 265                      "Security": {
 266                        "Active": "WPA-PSK",
 267                        "Effective": "UserPolicy",
 268                        "UserPolicy": "WPA-PSK"
 269                      },
 270                      "SignalStrength": {
 271                        "Active": 80,
 272                        "Effective": "Unmanaged"
 273                      }
 274                    }
 275                  }, result);
 276       }));
 277   },
 278   function setProperties() {
 279     var done = chrome.test.callbackAdded();
 280     chrome.networkingPrivate.getProperties(
 281       "stub_wifi2",
 282       callbackPass(function(result) {
 283         result.WiFi.Security = "WEP-PSK";
 284         chrome.networkingPrivate.setProperties("stub_wifi2", result,
 285           callbackPass(function() {
 286             chrome.networkingPrivate.getProperties(
 287               "stub_wifi2",
 288               callbackPass(function(result) {
 289                 assertEq("WEP-PSK", result.WiFi.Security);
 290                 done();
 291               }));
 292           }));
 293       }));
 294   },
 295   function getState() {
 296     chrome.networkingPrivate.getState(
 297       "stub_wifi2",
 298       callbackPass(function(result) {
 299         assertEq({
 300           "ConnectionState": "NotConnected",
 301           "GUID": "stub_wifi2",
 302           "Name": "wifi2_PSK",
 303           "Type": "WiFi",
 304           "WiFi": {
 305             "Security": "WPA-PSK",
 306             "SignalStrength": 80
 307           }
 308         }, result);
 309       }));
 310   },
 311   function getStateNonExistent() {
 312     chrome.networkingPrivate.getState(
 313       'non_existent',
 314       callbackFail('Error.InvalidParameter'));
 315   },
 316   function onNetworksChangedEventConnect() {
 317     var network = "stub_wifi2";
 318     var done = chrome.test.callbackAdded();
 319     var expectedStates = ["Connected"];
 320     var listener =
 321         new privateHelpers.watchForStateChanges(network, expectedStates, done);
 322     chrome.networkingPrivate.startConnect(network, callbackPass());
 323   },
 324   function onNetworksChangedEventDisconnect() {
 325     var network = "stub_wifi1";
 326     var done = chrome.test.callbackAdded();
 327     var expectedStates = ["NotConnected"];
 328     var listener =
 329         new privateHelpers.watchForStateChanges(network, expectedStates, done);
 330     chrome.networkingPrivate.startDisconnect(network, callbackPass());
 331   },
 332   function onNetworkListChangedEvent() {
 333     // Connecting to wifi2 should set wifi1 to offline. Connected or Connecting
 334     // networks should be listed first, sorted by type.
 335     var expected = ["stub_ethernet",
 336                     "stub_wifi2",
 337                     "stub_vpn1",
 338                     "stub_wifi1",
 339                     "stub_cellular1"];
 340     var done = chrome.test.callbackAdded();
 341     var listener = new privateHelpers.listListener(expected, done);
 342     chrome.networkingPrivate.onNetworkListChanged.addListener(
 343       listener.listenForChanges);
 344     var network = "stub_wifi2";
 345     chrome.networkingPrivate.startConnect(network, callbackPass());
 346   },
 347   function verifyDestination() {
 348     chrome.networkingPrivate.verifyDestination(
 349       verificationProperties,
 350       callbackPass(function(isValid) {
 351         assertTrue(isValid);
 352       }));
 353   },
 354   function verifyAndEncryptCredentials() {
 355     chrome.networkingPrivate.verifyAndEncryptCredentials(
 356       verificationProperties,
 357       "guid",
 358       callbackPass(function(result) {
 359         assertEq("encrypted_credentials", result);
 360       }));
 361   },
 362   function verifyAndEncryptData() {
 363     chrome.networkingPrivate.verifyAndEncryptData(
 364       verificationProperties,
 365       "data",
 366       callbackPass(function(result) {
 367         assertEq("encrypted_data", result);
 368       }));
 369   }
 370 ];
 371
 372 var testToRun = window.location.search.substring(1);
 373 chrome.test.runTests(availableTests.filter(function(op) {
 374   return op.name == testToRun;
 375 }));