1. module speedtest-net
   1. function speedtest-net (options)
   2. function speedtest-net.visual (options, callback)

module speedtest-net

function speedtest-net (options)

• description and source-code

  function speedTest(options) {
  
    options = options || {};
  
    options.maxTime = options.maxTime || 10000;
    options.pingCount = options.pingCount || (options.serverId ? 1 : 5);
    options.maxServers = options.maxServers || 1;
  
    var self = new EventEmitter()
      , speedInfo = {}
      , serversUrls = [
          'http://www.speedtest.net/speedtest-servers-static.php',
          'http://www.speedtest.net/speedtest-servers-static.php?really=yes',
          'https://www.speedtest.net/speedtest-servers-static.php',
          'https://www.speedtest.net/speedtest-servers-static.php?really=totally',
          'http://www.speedtest.net/speedtest-servers.php',
          'http://www.speedtest.net/speedtest-servers.php?really=sure',
          'https://www.speedtest.net/speedtest-servers.php',
          'https://www.speedtest.net/speedtest-servers.php?really=absolutely'
        ]
      , curServer = 0
      , serversUrl
      ;
  
    function httpOpts(theUrl) {
      var o = url.parse(theUrl);
      o.headers = options.headers || {};
      return o;
    }
  
    //Fetch config
  
    getXML(httpOpts('http://www.speedtest.net/speedtest-config.php'), gotConfig);
  
    function gotConfig(err, config) {
      if (err) return self.emit('error', err);
      config = config && config.settings || {};
  
      function get(name) {
        return ((config[name] || [])[0] || {}).$ || {}
      }
  
      var client   = get('client')
        , times    = get('times')
        , download = get('download')
        , upload   = get('upload')
        ;
  
      speedInfo.config = {client: client, times: times, download: download, upload: upload};
  
      self.emit('config', speedInfo.config);
      gotData();
    }
  
    if (options.serversUrl) {
      serversUrl = options.serversUrl;
      curServer = -1;
    }
  
    function nextServer(err) {
      if (curServer >= serversUrls.length) {
        return self.emit('error', err || new Error('There was a problem getting the list of servers from SpeedTest.net. Consider using
   a custom serversUrl'));
      }
      if (curServer < 0) {
        curServer = serversUrls.length;
      } else {
        serversUrl = serversUrls[curServer];
        curServer++;
      }
      getXML(httpOpts(serversUrl), gotServers);
    }
  
    nextServer();
  
    function gotServers(err, servers) {
      if (err || !servers) return nextServer(err);
      var s = servers.settings.servers[0].server;
  
      servers = [];
      for (var n = 0; n < s.length; n++) {
        if (options.serverId && s[n].$.id == options.serverId) {
          servers = [s[n].$];
          break;
        }
        servers.push(s[n].$);
      }
  
      speedInfo.servers = servers;
  
      self.emit('servers', servers);
      gotData()
    }
  
    function gotData() {
      if (!speedInfo.config || !speedInfo.servers) return; //not ready yet
  
      //order servers by how close they are:
      var servers = speedInfo.servers;
  
      for (var n = 0; n < servers.length; n++) {
        var server = servers[n]
          , dist   = distance(speedInfo.config.client, server)
          ;
  
        server.dist = dist;
        server.distMi = dist * 0.621371;
      }
  
      servers.sort(function(a, b) {
        return (a.dist - b.dist);
      });
  
      pingServers(servers, options.pingCount, function(err, bestServers) {
        if (!bestServers || !bestServers.length) return self.emit('error', new Error('Could not find a server to test on.'));
  
        speedInfo.bestServers = bestServers;
        speedInfo.bestServer = speedInfo.bestServers[0];
        self.emit('bestservers', bestServers);
  
        startDownload();
      });
    }
  
    function startDownload(ix) {
      ix = ix || 0;
      if (ix >= speedInfo.bestServers.length || ix >= options.maxServers) return startUpload();
      var server = speedInfo.bestServers[ix]
        , svrurl = server.url
        , sizes  = [350, 500, 750, 1000, 1500, 2000, 2500, 3000, 3500, 4000]
        , urls   = []
        , n
        , i
        , size
        ;
  
      for (n = 0; n < sizes.length; n++) {
        size = sizes[n];
        for (i = 0; i < 4; i++) {
          urls.push(url.resolve(svrurl, 'random' + size + 'x' + size + '.jpg'));
        }
      }
  
      self.emit('testserver', server);
  
      downloadSpeed.call(self, urls, options.maxTime, function(err ...

• example usage

  n/a

function speedtest-net.visual (options, callback)

• description and source-code

  function visualSpeedTest(options, callback) {
    // We only need chalk and DraftLog here. Lazy load it.
    var chalk = require('chalk');
    require('draftlog').into(console);
  
    callback = once(callback);
  
    var test = speedTest(options)
      , log  = function() {}
      , finalData
      , percentage = 0
      , speed = 0
      , bar = console.draft()
      ;
  
    if (options.log) {
      if (typeof options.log === "function") {
        log = options.log;
      } else {
        log = console.log.bind(console);
      }
    }
  
    test.on('error', function(err) {
      callback(err);
    });
  
    test.on('testserver', function(server) {
      log('Using server by ' + server.sponsor + ' in ' + server.name + ', ' + server.country + ' (' + (server.distMi * 0.621371).toFixed
  (0) + 'mi, ' + (server.bestPing).toFixed(0) + 'ms)');
    });
  
    test.on('config', function(config) {
      var client = config.client;
      log('Testing from ' + client.ip + ' at ' + client.isp + ', expected dl: ' + (client.ispdlavg / 8000).toFixed(2) + 'MB/s, expected
   ul: ' + (client.ispulavg / 8000).toFixed(2) + 'MB/s');
    });
  
    var size = 50;
    var red = (chalk.supportsColor ? chalk.bgRed(' ') : '─');
    var green = (chalk.supportsColor ? chalk.bgGreen(' ') : '▇');
  
    function prog(what, pct, spd) {
      percentage = pct || percentage;
      speed = spd || speed;
  
      var complete = Math.round(percentage / 100 * size);
      var barStr = '';
  
      // What + padding
      barStr += what;
      barStr += ' '.repeat(12 - what.length);
  
      // Bar
      barStr += green.repeat(complete);
      barStr += red.repeat(size - complete);
  
      // Percent
      pct = percentage + '%';
      barStr += ' ' + pct;
  
      // Speed
      barStr += ' '.repeat(8 - pct.length) + speed;
  
      bar(barStr);
    }
  
    test.on('downloadprogress', function(pct) {
      prog('download', pct, null);
    });
  
    test.on('uploadprogress', function(pct) {
      prog('upload', pct, null);
    });
  
    test.on('downloadspeed', function(speed) {
      log('Download speed: ', speed.toFixed(2) + 'Mbps');
  
      // Create a new line after each new download
      bar = console.draft();
    });
  
    test.on('uploadspeed', function(speed) {
      log('Upload speed: ', speed.toFixed(2) + 'Mbps');
  
      // Create a new line after each new upload
      bar = console.draft();
    });
  
    test.on('downloadspeedprogress', function(speed) {
      prog('download', null, speed.toFixed(2) + 'Mbps')
    });
  
    test.on('uploadspeedprogress', function(speed) {
      prog('upload', null, speed.toFixed(2) + 'Mbps')
    });
  
    test.on('data', function(data) {
      finalData = data;
    });
  
    test.on('result', function(url) {
      log('Results url: ' + url);
    });
  
    test.on('done', function(data) {
      callback(null, finalData);
    });
  
    return test;
  }

• example usage

  ...
  
  ```
  
  Visual use example:
  ```js
  const speedTest = require('speedtest-net');
  
  speedTest.visual({maxTime: 5000}, (err, data) => {
    console.dir(data);
  });
  ```
  
  ## Options
  
  You can pass an optional `options` object.
  ...