Next phase for chrome.networkingPrivate interface.

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;
 
-chrome.test.runTests([
-  function getVisibleNetworks() {
+function connectListener_(network, done) {
+    var self = this;
+    var collectProperties_ = function(testingConnect, 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 (testingConnect)
+                finishTest();
+            else
+                startConnect();
+        }
+        if (properties.ConnectionState == "Connected") {
+            if (testingConnect)
+                startDisconnect();
+            else
+                finishTest();
+        }
+    }
+    this.watchForConnect = function(changes) {
+        assertEq([network], changes);
+        chrome.networkingPrivate.getProperties(
+            network, collectProperties_.bind(undefined, true));
+    }
+    this.watchForDisconnect = function(changes) {
+        assertEq([network], changes);
+        chrome.networkingPrivate.getProperties(
+            network, collectProperties_.bind(undefined, false));
+    }
+}
+
+function listListener_(network, expected, done) {
+    var self = this;
+    this.listenForChanges = function(list) {
+        assertEq(expected, list);
+        chrome.networkingPrivate.onNetworkListChanged.removeListener(
+            self.listenForChanges);
+        done();
+    }
+}
+
+/////////////////////////////////////////////////////
+// Tests
+
+function startConnect() {
+    chrome.networkingPrivate.startConnect("stub_wifi2",
+                                          callbackPass(function() {}));
+}
+
+function startDisconnect() {
+    chrome.networkingPrivate.startDisconnect("stub_wifi2",
+                                             callbackPass(function() {}));
+}
+
+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() {}));
+}
+
+function getVisibleNetworks() {
     chrome.networkingPrivate.getVisibleNetworks(
         "All",
         callbackPass(function(result) {
-          assertTrue(!!result);
-          assertEq(4, result.length);
-          assertEq([{ "Name": "eth0",
-                      "GUID": "stub_ethernet",
-                      "ConnectionState": "Connected",
-                      "Type": "Ethernet"
-                    },
-                    { "Name": "wifi1",
-                      "GUID": "stub_wifi1",
-                      "ConnectionState": "Connected",
-                      "Type": "WiFi",
-                      "WiFi": {
+            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",
                         "Type": "WiFi"
-                      }
-                    },
-                    { "Name": "wifi2_PSK",
-                      "GUID": "stub_wifi2",
-                      "ConnectionState": "NotConnected",
-                      "Type": "WiFi",
-                      "WiFi": {
+                    }
+                },
+                {
+                    "ConnectionState": "NotConnected",
+                    "GUID": "stub_wifi2",
+                    "Name": "wifi2_PSK",
+                    "Type": "WiFi",
+                    "WiFi": {
                         "SSID": "stub_wifi2",
                         "Type": "WiFi"
-                      }
-                    },
-                    { "Name": "cellular1",
-                      "GUID": "stub_cellular1",
-                      "ConnectionState": "NotConnected",
-                      "Type": "Cellular"
-                    }], result);
+                    }
+                },
+                {
+                    "ConnectionState": "NotConnected",
+                    "GUID": "stub_cellular1",
+                    "Name": "cellular1",
+                    "Type": "Cellular"
+                }
+            ], result);
         }));
-  },
-  function getVisibleNetworksWifi() {
+}
+
+function getVisibleNetworksWifi() {
     chrome.networkingPrivate.getVisibleNetworks(
-      "WiFi",
-      callbackPass(function(result) {
-        assertTrue(!!result);
-        assertEq(2, result.length);
-        assertEq([{ "Name": "wifi1",
+        "WiFi",
+        callbackPass(function(result) {
+            assertTrue(!!result);
+            assertEq(2, result.length);
+            assertEq([
+                {
+                    "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
-                    "ConnectionState": "Connected",
+                    "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
-                      "SSID": "stub_wifi1",
-                      "Type":"WiFi"
+                        "SSID": "stub_wifi1",
+                        "Type": "WiFi"
                     }
-                  },
-                  { "Name": "wifi2_PSK",
+                },
+                {
+                    "ConnectionState": "NotConnected",
                     "GUID": "stub_wifi2",
-                    "ConnectionState": "NotConnected",
+                    "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
-                      "SSID": "stub_wifi2",
-                      "Type": "WiFi"
+                        "SSID": "stub_wifi2",
+                        "Type": "WiFi"
                     }
-                  }], result);
-      }));
-  },
-  function getProperties() {
+                }
+            ], 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);
+            assertTrue(!!result);
+            assertEq("wifi2_PSK", result.Name);
+            assertEq("NotConnected", result.ConnectionState);
+            assertEq("WiFi", result.Type);
         }));
-  },
-  function startConnect() {
-    chrome.networkingPrivate.startConnect("stub_wifi2",
+}
+
+function onNetworksChangedEvent() {
+    var network = "stub_wifi2";
+    var done = chrome.test.callbackAdded();
+    var listener = new connectListener_(network, done);
+    chrome.networkingPrivate.onNetworksChanged.addListener(
+        listener.watchForConnect);
+    chrome.networkingPrivate.startConnect(network,
                                           callbackPass(function() {}));
-  },
-  function startDisconnect() {
-    chrome.networkingPrivate.startDisconnect("stub_wifi2",
-                                             callbackPass(function() {}));
-  },
-  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() {}));
-  }
-]);
+}
+
+function onNetworkListChangedEvent() {
+    var network = "stub_wifi2";
+    var expected = ["stub_wifi2","stub_ethernet", "stub_wifi1",
+                    "stub_cellular1"];
+    var done = chrome.test.callbackAdded();
+    var listener = new listListener_(network, expected, done);
+    chrome.networkingPrivate.onNetworkListChanged.addListener(
+        listener.listenForChanges);
+    chrome.networkingPrivate.startConnect(network,
+                                          callbackPass(function() {}));
+}
+
+var testToRun = window.location.hash.substring(1);
+chrome.test.runTests([window[testToRun]]);