selenium-webdriver 4.0.0-alpha.7 → 4.0.0-beta.3

package/net/index.js

@@ -15,22 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-'use strict';
-
-const os = require('os');
+'use strict'
 
+const os = require('os')
 
 function getLoInterface() {
-  let name;
+  let name
   if (process.platform === 'darwin') {
-    name = 'lo0';
+    name = 'lo0'
   } else if (process.platform === 'linux') {
-    name = 'lo';
+    name = 'lo'
   }
-  return name ? os.networkInterfaces()[name] : null;
+  return name ? os.networkInterfaces()[name] : null
 }
 
-
 /**
  * Queries the system network interfaces for an IP address.
  * @param {boolean} loopback Whether to find a loopback address.
@@ -38,49 +36,45 @@ function getLoInterface() {
  * @return {(string|undefined)} The located IP address or undefined.
  */
 function getAddress(loopback, family) {
-  let interfaces;
+  let interfaces
   if (loopback) {
-    let lo = getLoInterface();
-    interfaces = lo ? [lo] : null;
+    let lo = getLoInterface()
+    interfaces = lo ? [lo] : null
   }
-  interfaces = interfaces || os.networkInterfaces();
+  interfaces = interfaces || os.networkInterfaces()
   for (let key in interfaces) {
-    if (!interfaces.hasOwnProperty(key)) {
-      continue;
+    if (!Object.prototype.hasOwnProperty.call(interfaces, key)) {
+      continue
     }
 
     for (let ipAddress of interfaces[key]) {
       if (ipAddress.family === family && ipAddress.internal === loopback) {
-        return ipAddress.address;
+        return ipAddress.address
       }
     }
   }
-  return undefined;
+  return undefined
 }
 
-
 // PUBLIC API
 
-
 /**
  * Retrieves the external IP address for this host.
  * @param {string=} family The IP family to retrieve. Defaults to "IPv4".
  * @return {(string|undefined)} The IP address or undefined if not available.
  */
-exports.getAddress = function(family = 'IPv4') {
-  return getAddress(false, family);
-};
-
+exports.getAddress = function (family = 'IPv4') {
+  return getAddress(false, family)
+}
 
 /**
  * Retrieves a loopback address for this machine.
  * @param {string=} family The IP family to retrieve. Defaults to "IPv4".
  * @return {(string|undefined)} The IP address or undefined if not available.
  */
-exports.getLoopbackAddress = function(family = 'IPv4') {
-  return getAddress(true, family);
-};
-
+exports.getLoopbackAddress = function (family = 'IPv4') {
+  return getAddress(true, family)
+}
 
 /**
  * Splits a hostport string, e.g. "www.example.com:80", into its component
@@ -90,24 +84,24 @@ exports.getLoopbackAddress = function(family = 'IPv4') {
  * @return {{host: string, port: ?number}} A host and port. If no port is
  *     present in the argument `hostport`, port is null.
  */
-exports.splitHostAndPort = function(hostport) {
-  let lastIndex = hostport.lastIndexOf(':');
+exports.splitHostAndPort = function (hostport) {
+  let lastIndex = hostport.lastIndexOf(':')
   if (lastIndex < 0) {
-    return {host: hostport, port: null};
+    return { host: hostport, port: null }
   }
 
-  let firstIndex = hostport.indexOf(':');
+  let firstIndex = hostport.indexOf(':')
   if (firstIndex != lastIndex && !hostport.includes('[')) {
     // Multiple colons but no brackets, so assume the string is an IPv6 address
     // with no port (e.g. "1234:5678:9:0:1234:5678:9:0").
-    return {host: hostport, port: null};
+    return { host: hostport, port: null }
   }
 
-  let host = hostport.slice(0, lastIndex);
+  let host = hostport.slice(0, lastIndex)
   if (host.startsWith('[') && host.endsWith(']')) {
-    host = host.slice(1, -1);
+    host = host.slice(1, -1)
   }
 
-  let port = parseInt(hostport.slice(lastIndex + 1), 10);
-  return {host, port};
-};
+  let port = parseInt(hostport.slice(lastIndex + 1), 10)
+  return { host, port }
+}

package/net/portprober.js

@@ -15,128 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-'use strict';
-
-const fs = require('fs');
-const net = require('net');
-const {exec} = require('child_process');
-
-
-/**
- * The IANA suggested ephemeral port range.
- * @type {{min: number, max: number}}
- * @const
- * @see http://en.wikipedia.org/wiki/Ephemeral_ports
- */
-const DEFAULT_IANA_RANGE = {min: 49152, max: 65535};
-
-
-/**
- * The epheremal port range for the current system. Lazily computed on first
- * access.
- * @type {Promise<{min: number, max: number}>}
- */
-let systemRange = null;
-
-
-/**
- * Computes the ephemeral port range for the current system. This is based on
- * http://stackoverflow.com/a/924337.
- * @return {!Promise<{min: number, max: number}>} A promise that will resolve to
- *     the ephemeral port range of the current system.
- */
-function findSystemPortRange() {
-  if (systemRange) {
-    return systemRange;
-  }
-  let range =
-      process.platform === 'win32'
-          ? findWindowsPortRange() : findUnixPortRange();
-  return systemRange = range.catch(() => DEFAULT_IANA_RANGE);
-}
-
-
-/**
- * Executes a command and returns its output if it succeeds.
- * @param {string} cmd The command to execute.
- * @return {!Promise<string>} A promise that will resolve with the command's
- *     stdout data.
- */
-function execute(cmd) {
-  return new Promise((resolve, reject) => {
-    exec(cmd, function(err, stdout) {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(stdout);
-      }
-    });
-  });
-}
-
-
-/**
- * Computes the ephemeral port range for a Unix-like system.
- * @return {!Promise<{min: number, max: number}>} A promise that will resolve
- *     with the ephemeral port range on the current system.
- */
-async function findUnixPortRange() {
-  var cmd;
-  if (process.platform === 'sunos') {
-    cmd =
-        '/usr/sbin/ndd /dev/tcp tcp_smallest_anon_port tcp_largest_anon_port';
-  } else if (fs.existsSync('/proc/sys/net/ipv4/ip_local_port_range')) {
-    // Linux
-    cmd = 'cat /proc/sys/net/ipv4/ip_local_port_range';
-  } else {
-    cmd = 'sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last' +
-        ' | sed -e "s/.*:\\s*//"';
-  }
-
-  let stdout = await execute(cmd);
-  if (!stdout || !stdout.length) {
-    return DEFAULT_IANA_RANGE;
-  };
-
-  let range = stdout.trim().split(/\s+/).map(Number);
-  if (range.some(isNaN)) {
-    return DEFAULT_IANA_RANGE;
-  };
-
-  return {min: range[0], max: range[1]};
-}
-
-
-/**
- * Computes the ephemeral port range for a Windows system.
- * @return {!Promise<{min: number, max: number}>} A promise that will resolve
- *     with the ephemeral port range on the current system.
- */
-async function findWindowsPortRange() {
-  // First, check if we're running on XP.  If this initial command fails,
-  // we just fallback on the default IANA range.
-  let stdout = await execute('cmd.exe /c ver');
-  if (/Windows XP/.test(stdout)) {
-    // TODO: Try to read these values from the registry.
-    return {min: 1025, max: 5000};
-  } else {
-    stdout = await execute('netsh int ipv4 show dynamicport tcp');
-    /* > netsh int ipv4 show dynamicport tcp
-      Protocol tcp Dynamic Port Range
-      ---------------------------------
-      Start Port : 49152
-      Number of Ports : 16384
-     */
-    let range = stdout.split(/\n/)
-        .filter((line) => /.*:\s*\d+/.test(line))
-        .map((line) => Number(line.split(/:\s*/)[1]));
-    return {
-      min: range[0],
-      max: range[0] + range[1]
-    };
-  }
-}
+'use strict'
 
+const net = require('net')
 
 /**
  * Tests if a port is free.
@@ -148,41 +29,47 @@ async function findWindowsPortRange() {
  */
 function isFree(port, opt_host) {
   return new Promise((resolve, reject) => {
-    let server = net.createServer().on('error', function(e) {
+    let server = net.createServer().on('error', function (e) {
       if (e.code === 'EADDRINUSE' || e.code === 'EACCES') {
-        resolve(false);
+        resolve(false)
       } else {
-        reject(e);
+        reject(e)
       }
-    });
+    })
 
-    server.listen(port, opt_host, function() {
-      server.close(() => resolve(true));
-    });
-  });
+    server.listen(port, opt_host, function () {
+      server.close(() => resolve(true))
+    })
+  })
 }
 
-
 /**
  * @param {string=} opt_host The bound host to test the {@code port} against.
  *     Defaults to {@code INADDR_ANY}.
  * @return {!Promise<number>} A promise that will resolve to a free port. If a
  *     port cannot be found, the promise will be rejected.
  */
-async function findFreePort(opt_host) {
-  let range = await findSystemPortRange();
-  for (let i = 0; i < 100; i++) {
-    let port = Math.floor(Math.random() * (range.max - range.min) + range.min);
-    if (await isFree(port, opt_host)) {
-      return port;
-    }
-  }
-  throw Error('Unable to find a free port');
-}
 
+function findFreePort(opt_host) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.on('listening', function () {
+      resolve(server.address().port)
+      server.close()
+    })
+    server.on('error', (e) => {
+      if (e.code === 'EADDRINUSE' || e.code === 'EACCES') {
+        resolve('Unable to find a free port')
+      } else {
+        reject(e)
+      }
+    })
+    // By providing 0 we let the operative system find an arbitrary port
+    server.listen(0, opt_host)
+  })
+}
 
 // PUBLIC API
 
-
-exports.findFreePort = findFreePort;
-exports.isFree = isFree;
+exports.findFreePort = findFreePort
+exports.isFree = isFree