Using the new Network*Handlers in networkingPrivate Extension API.

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

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 var callbackPass = chrome.test.callbackPass;
 var callbackFail = chrome.test.callbackFail;
 var assertTrue = chrome.test.assertTrue;
 var assertEq = chrome.test.assertEq;
 
 // Test properties for the verification API.
 var verificationProperties = {
   "certificate": "certificate",
   "publicKey": "public_key",
   "nonce": "nonce",
   "signedData": "signed_data",
   "deviceSerial": "device_serial"
 };
 
 var privateHelpers = {
-  connectListener: function(network, done) {
+  // Watches for the states |expectedStates| in reverse order. If all states
+  // were observed in the right order, succeeds and calls |done|. If any
+  // unexpected state is observed, fails.
+  watchForStateChanges: function(network, expectedStates, done) {
     var self = this;
-    var collectProperties = function(transition, properties) {
+    var collectProperties = function(properties) {
       var finishTest = function() {
         chrome.networkingPrivate.onNetworksChanged.removeListener(
           self.watchForConnect);
         done();
       };
-      var startDisconnect = function() {
-        chrome.networkingPrivate.startDisconnect(
-          network,
-          callbackPass(function() {}));
-      };
-      var startConnect = function() {
-        chrome.networkingPrivate.startConnect(
-          network,
-          callbackPass(function() {}));
-      };
-      if (properties.ConnectionState == "NotConnected") {
-        if (transition == "connect")
-          finishTest();
-        else
-          startConnect();
-      }
-      if (properties.ConnectionState == "Connected") {
-        if (transition == "connect")
-          startDisconnect();
-        else
-          finishTest();
-      }
+      var expectedState = expectedStates.pop();
+      assertEq(expectedState, properties.ConnectionState);
+      if (expectedStates.length == 0)
+        finishTest();
     };
-    this.watchForConnect = function(changes) {
+    this.onNetworkChange = function(changes) {
       assertEq([network], changes);
-      chrome.networkingPrivate.getProperties(
-        network, collectProperties.bind(undefined, "connect"));
+      chrome.networkingPrivate.getProperties(network,
+                                             collectProperties.bind(undefined));
     };
-    this.watchForDisconnect = function(changes) {
-      assertEq([network], changes);
-      chrome.networkingPrivate.getProperties(
-        network, collectProperties.bind(undefined, "disconnect"));
-    };
+    chrome.networkingPrivate.onNetworksChanged.addListener(
+      this.onNetworkChange);
   },
   listListener: function(network, expected, done) {
     var self = this;
     this.listenForChanges = function(list) {
       assertEq(expected, list);
       chrome.networkingPrivate.onNetworkListChanged.removeListener(
         self.listenForChanges);
       done();
     };
   }
 };
 
-/////////////////////////////////////////////////////
-// Tests
 var availableTests = [
   function startConnect() {
-    chrome.networkingPrivate.startConnect("stub_wifi2",
-      callbackPass(function() {}));
+    chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass());
   },
   function startDisconnect() {
-    chrome.networkingPrivate.startDisconnect("stub_wifi2",
-      callbackPass(function() {}));
+    chrome.networkingPrivate.startDisconnect("stub_wifi2", callbackPass());
   },
   function startConnectNonexistent() {
-    // Make sure we get an error when we try to connect to a nonexistent
-    // network.
     chrome.networkingPrivate.startConnect(
       "nonexistent_path",
-      callbackFail("Error.InvalidService", function() {}));
+      callbackFail("Error.InvalidService"));
+  },
+  function startDisconnectNonexistent() {
+    chrome.networkingPrivate.startDisconnect(
+      "nonexistent_path",
+      callbackFail("Error.InvalidService"));
+  },
+  function startGetPropertiesNonexistent() {
+    chrome.networkingPrivate.getProperties(
+      "nonexistent_path",
+      callbackFail("Error.DBusFailed"));
   },
   function getVisibleNetworks() {
     chrome.networkingPrivate.getVisibleNetworks(
       "All",
       callbackPass(function(result) {
         assertTrue(!!result);
-        assertEq(4, result.length);
         assertEq([{
                     "ConnectionState": "Connected",
                     "GUID": "stub_ethernet",
                     "Name": "eth0",
                     "Type": "Ethernet"
                   },
                   {
                     "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
-                      "SSID": "stub_wifi1",
+                      "Security": "WEP-PSK",
+                      "SignalStrength": 0
                     }
                   },
                   {
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_wifi2",
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
-                      "SSID": "stub_wifi2",
                       "Security": "WPA-PSK",
                       "SignalStrength": 80
                     }
                   },
                   {
+                    "Cellular": {
+                      "ActivationState": "not-activated",
+                      "NetworkTechnology": "GSM",
+                      "RoamingState": "home"
+                    },
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_cellular1",
                     "Name": "cellular1",
                     "Type": "Cellular"
                   }
                   ], result);
       }));
   },
   function getVisibleNetworksWifi() {
     chrome.networkingPrivate.getVisibleNetworks(
       "WiFi",
       callbackPass(function(result) {
         assertTrue(!!result);
-        assertEq(2, result.length);
         assertEq([{
                     "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
-                      "SSID": "stub_wifi1"
+                      "Security": "WEP-PSK",
+                      "SignalStrength": 0
                     }
                   },
                   {
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_wifi2",
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
-                      "SSID": "stub_wifi2",
                       "Security": "WPA-PSK",
                       "SignalStrength": 80
                     }
                   }
                   ], result);
       }));
   },
   function getProperties() {
     chrome.networkingPrivate.getProperties(
       "stub_wifi2",
       callbackPass(function(result) {
         assertTrue(!!result);
-        assertEq("wifi2_PSK", result.Name);
-        assertEq("NotConnected", result.ConnectionState);
-        assertEq("WiFi", result.Type);
+        assertEq({
+                   "ConnectionState": "NotConnected",
+                   "GUID": "stub_wifi2",
+                   "Name": "wifi2_PSK",
+                   "Type": "WiFi",
+                   "WiFi": {
+                     "SSID": "stub_wifi2",
+                     "Security": "WPA-PSK",
+                     "SignalStrength": 80
+                   }
+                 }, result);
       }));
   },
-  function onNetworksChangedEvent() {
+  function onNetworksChangedEventConnect() {
     var network = "stub_wifi2";
     var done = chrome.test.callbackAdded();
-    var listener = new privateHelpers.connectListener(network, done);
-    chrome.networkingPrivate.onNetworksChanged.addListener(
-      listener.watchForConnect);
-    chrome.networkingPrivate.startConnect(network,
-      callbackPass(function() {}));
+    var expectedStates = ["Connected", "Connecting"];
+    var listener =
+        new privateHelpers.watchForStateChanges(network, expectedStates, done);
+    chrome.networkingPrivate.startConnect(network, callbackPass());
+  },
+  function onNetworksChangedEventDisconnect() {
+    var network = "stub_wifi1";
+    var done = chrome.test.callbackAdded();
+    var expectedStates = ["NotConnected"];
+    var listener =
+        new privateHelpers.watchForStateChanges(network, expectedStates, done);
+    chrome.networkingPrivate.startDisconnect(network, callbackPass());
   },
   function onNetworkListChangedEvent() {
     var network = "stub_wifi2";
     var expected = ["stub_wifi2",
                     "stub_ethernet",
                     "stub_wifi1",
                     "stub_cellular1"];
     var done = chrome.test.callbackAdded();
     var listener = new privateHelpers.listListener(network, expected, done);
     chrome.networkingPrivate.onNetworkListChanged.addListener(
       listener.listenForChanges);
-    chrome.networkingPrivate.startConnect(network,
-      callbackPass(function() {}));
+    chrome.networkingPrivate.startConnect(network, callbackPass());
   },
   function verifyDestination() {
     chrome.networkingPrivate.verifyDestination(
       verificationProperties,
       callbackPass(function(isValid) {
         assertTrue(isValid);
       }));
   },
   function verifyAndEncryptCredentials() {
     chrome.networkingPrivate.verifyAndEncryptCredentials(
@@ skipping 10 matching lines @@
       callbackPass(function(result) {
         assertEq("encrypted_data", result);
       }));
   }
 ];
 
 var testToRun = window.location.search.substring(1);
 chrome.test.runTests(availableTests.filter(function(op) {
   return op.name == testToRun;
 }));