st 1.1.0 → 2.0.0

package/test/basic.js

@@ -1,20 +1,16 @@
-var zlib = require('zlib')
-var test = require('tap').test
-var common = require('./common')
+const zlib = require('zlib')
+const { test } = require('tap')
+const { req, stExpect, opts, mount } = require('./common')
 
-var req = common.req
-var stExpect = common.stExpect
-var opts = common.opts
+module.exports.req = req
+module.exports.stExpect = stExpect
+module.exports.mount = mount
 
-var stEtag
+let stEtag
 
-module.exports.mount = common.mount
-module.exports.req = common.req
-module.exports.stExpect = common.stExpect
-
-
-test('simple request', function (t) {
-  req('/test/st.js', function (er, res, body) {
+test('simple request', (t) => {
+  req('/test/st.js', (er, res, body) => {
+    t.error(er)
     t.equal(res.statusCode, 200)
     t.ok(/\/javascript$/.test(res.headers['content-type']))
     t.ok(res.headers.etag)
@@ -24,34 +20,33 @@ test('simple request', function (t) {
   })
 })
 
-
-test('304 request', function (t) {
-  req('/test/st.js', {'if-none-match':stEtag}, function (er, res, body) {
+test('304 request', (t) => {
+  req('/test/st.js', { 'if-none-match': stEtag }, (er, res, body) => {
     t.equal(res.statusCode, 304)
     t.equal(body.length, 0)
     t.end()
   })
 })
 
-
 if (opts.gzip !== false) {
-  test('gzip', function (t) {
-    req('/test/st.js', {'accept-encoding':'gzip'},
-        function (er, res, body) {
-      t.equal(res.statusCode, 200)
-      t.equal(res.headers['content-encoding'], 'gzip')
-      zlib.gunzip(body, function (er, body) {
-        if (er) throw er;
-        t.equal(body.toString(), stExpect)
-        t.end()
+  test('gzip', (t) => {
+    req('/test/st.js', { 'accept-encoding': 'gzip' },
+      (er, res, body) => {
+        t.equal(res.statusCode, 200)
+        t.equal(res.headers['content-encoding'], 'gzip')
+        zlib.gunzip(body, (er, body) => {
+          if (er) {
+            throw er
+          }
+          t.equal(body.toString(), stExpect)
+          t.end()
+        })
       })
-    })
   })
 }
 
-
-test('multiball!', function (t) {
-  var n = 6
+test('multiball!', (t) => {
+  let n = 6
   req('/test/st.js', then)
   req('/test/README.md', then)
   req('/test/LICENSE', then)
@@ -60,13 +55,14 @@ test('multiball!', function (t) {
   req('/test/bin/server.js', then)
 
   function then (er, res) {
-    if (er)
+    if (er) {
       throw er
+    }
     t.equal(res.statusCode, 200)
 
     // give them all time to close, then go again.
-    if (--n === 0)
-      setTimeout(function () {
+    if (--n === 0) {
+      setTimeout(() => {
         n = 6
         req('/test/st.js', then2)
         req('/test/README.md', then2)
@@ -75,50 +71,62 @@ test('multiball!', function (t) {
         req('/test/favicon.ico', then2)
         req('/test/bin/server.js', then2)
       }, 200)
+    }
   }
 
   function then2 (er, res) {
-    if (er)
+    if (er) {
       throw er
+    }
 
     t.equal(res.statusCode, 200)
 
-    if (opts.cache === false)
+    if (opts.cache === false) {
       t.equal(res.headers['cache-control'], 'no-cache')
-    else if (opts.cache && opts.cache.content && opts.cache.content.maxAge === false)
+    } else if (opts.cache && opts.cache.content && opts.cache.content.maxAge === false) {
       t.ok(res.headers['cache-control'] === undefined)
-    else if (opts.cache && opts.cache.content && opts.cache.content.cacheControl)
+    } else if (opts.cache && opts.cache.content && opts.cache.content.cacheControl) {
       t.equal(res.headers['cache-control'], opts.cache.content.cacheControl)
-    else
+    } else {
       t.equal(res.headers['cache-control'], 'public, max-age=600')
+    }
 
-    if (--n === 0)
+    if (--n === 0) {
       t.end()
+    }
   }
 })
 
-
-test('space in filename', function (t) {
-  req('/test/test/fixtures/space in filename.txt', function (er, res, body) {
+test('space in filename', (t) => {
+  req('/test/test/fixtures/space in filename.txt', (er, res, body) => {
     t.equal(res.statusCode, 200)
     t.ok(body)
     t.end()
   })
 })
 
-
-test('malformed URL', function (t) {
-  req('/test%2E%git', function (er, res) {
+test('malformed URL', (t) => {
+  req('/test%2E%git', (er, res) => {
     t.equal(res.statusCode, 404)
     t.end()
   })
 })
 
+test('shenanigans', (t) => {
+  req('/%2e%2E/%2e%2E/%2e%2E/%2e%2E/%2e%2E/%2e%2E/etc/passwd', (er, res) => {
+    if (er) {
+      throw er
+    }
+    t.equal(res.statusCode, 403)
+    t.end()
+  })
+})
 
-test('shenanigans', function(t) {
-  req('/%2e%2E/%2e%2E/%2e%2E/%2e%2E/%2e%2E/%2e%2E/etc/passwd', function(er, res) {
-    if (er)
+test('shenanigans2', (t) => {
+  req('/test//foo/%2e%2E', (er, res) => {
+    if (er) {
       throw er
+    }
     t.equal(res.statusCode, 403)
     t.end()
   })

package/test/cli/basic-test.js

@@ -0,0 +1,32 @@
+const { test } = require('tap')
+const { serve, stExpect } = require('./common')
+
+test('Basic cli operation', (t) => {
+  serve([], (req) => {
+    req('/st.js', (er, res, body) => {
+      t.ifError(er) &&
+      t.equal(res.statusCode, 200) &&
+      t.equal(body.toString(), stExpect)
+    })
+  }, (er, stdout, stderr) => {
+    t.ifError(er)
+    t.match(stdout, /^listening at http:\/\/(\[::\]|0\.0\.0\.0):[0-9]+\n$/)
+    t.equal(stderr, '')
+    t.end()
+  })
+})
+
+test('Listening on localhost only', (t) => {
+  serve(['--localhost'], (req) => {
+    req('/st.js', (er, res, body) => {
+      t.ifError(er) &&
+      t.equal(res.statusCode, 200) &&
+      t.equal(body.toString(), stExpect)
+    })
+  }, (er, stdout, stderr) => {
+    t.ifError(er)
+    t.match(stdout, /^listening at http:\/\/localhost:[0-9]+\n$/)
+    t.equal(stderr, '')
+    t.end()
+  })
+})

package/test/cli/common.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const path = require('path')
+const fs = require('fs')
+const request = require('request')
+const childProcess = require('child_process')
+const bl = require('bl')
+
+const port = process.env.PORT || 1337
+
+const stExpect = fs.readFileSync(require.resolve('../../st.js'), 'utf8')
+
+// Run server with given command line arguments,
+// then allow cbRequests to schedule a bunch of requests,
+// finally call cbDone.
+// cbRequests gets the req function as an argument.
+
+function serve (args, cbRequests, cbDone) {
+  args = [require.resolve('../../bin/server.js')].concat(args || [])
+  const server = childProcess.spawn(process.execPath, args, {
+    cwd: path.dirname(path.dirname(__dirname)),
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { LANG: 'C', LC_ALL: 'C' }
+  })
+  const stdout = bl()
+  const stderr = bl()
+  server.stdout.pipe(stdout)
+  server.stderr.pipe(stderr)
+  let thingsToDo = 4 // cbRequests, exit, stdout, stderr
+  let code = null
+  let signal = null
+  let cbReqEr = null
+  let outputSeen = false
+  server.once('error', (er) => {
+    thingsToDo = -10 // only call cbDone once
+    cbDone(er)
+  })
+  server.once('exit', (c, s) => {
+    code = c
+    signal = s
+    if (!outputSeen) {
+      outputSeen = true
+      --thingsToDo
+    }
+    then()
+  })
+  stdout.once('finish', then)
+  stderr.once('finish', then)
+  server.stdout.once('data', () => {
+    if (outputSeen) return
+    outputSeen = true
+    try {
+      cbRequests(req)
+    } catch (er) {
+      cbReqEr = er
+    } finally {
+      then()
+    }
+  })
+
+  function then () {
+    --thingsToDo
+    if (thingsToDo === 3) { // all requests done, one way or another
+      server.kill()
+    } else if (thingsToDo === 0) {
+      let er = null
+      if (cbReqEr) {
+        er = cbReqEr
+      } else if (signal !== null && signal !== 'SIGTERM') {
+        er = Error('Terminated by signal ' + signal)
+      } else if (code !== null && code !== 0) {
+        er = Error('Exited with code ' + code)
+      }
+      const o = stdout.toString(); const e = stderr.toString()
+      if (er) {
+        console.info(o)
+        console.error(e)
+      }
+      cbDone(er, o, e)
+    }
+  }
+
+  function req (url, headers, cb) {
+    if (typeof headers === 'function') {
+      cb = headers
+      headers = {}
+    }
+    if (!/:\/\//.test(url)) {
+      url = 'http://localhost:' + port + url
+    }
+    ++thingsToDo
+    request({
+      encoding: null,
+      url: url,
+      headers: headers
+    }, (...args) => {
+      try {
+        cb.apply(null, args)
+      } finally {
+        then()
+      }
+    })
+  }
+}
+
+module.exports.port = port
+module.exports.stExpect = stExpect
+module.exports.serve = serve

package/test/cli/host-test.js

@@ -0,0 +1,92 @@
+const os = require('os')
+let { test, fail, comment } = require('tap')
+const { serve } = require('./common')
+const port = 1338
+
+const otherAddress = (() => {
+  const ifaces = os.networkInterfaces()
+  for (const iface in ifaces) {
+    const addrs = ifaces[iface]
+    for (let i = 0; i < addrs.length; ++i) {
+      const addr = addrs[i].address
+      if (/^127\./.test(addr) || /^::1$/.test(addr)) { // loopback device
+        continue
+      }
+      if (/^fe80:/.test(addr)) { // link-local address
+        continue
+      }
+      return addr
+    }
+  }
+  return null
+})()
+if (!otherAddress) {
+  fail('No non-loopback network address found', { skip: true })
+  test = () => {}
+} else {
+  comment('Using ' + otherAddress + ' as non-localhost address')
+}
+
+function addr2url (addr, path) {
+  if (/:/.test(addr)) {
+    addr = '[' + addr + ']'
+  }
+  addr = 'http://' + addr + ':' + port
+  if (path) {
+    addr += path
+  }
+  return addr
+}
+
+function testServer (name, args, addr, canConnect, cannotConnect) {
+  test(name, (t) => {
+    serve(args.concat(['--port', port]), (req) => {
+      canConnect.forEach(checkConnections(t, req, true))
+      cannotConnect.forEach(checkConnections(t, req, false))
+    }, (err, stdout, stderr) => {
+      t.ifError(err)
+      t.equal(stderr, '')
+      if (addr) {
+        t.equal(stdout, 'listening at ' + addr2url(addr) + '\n')
+      }
+      t.end()
+    })
+  })
+}
+
+function checkConnections (t, req, canConnect) {
+  return (addr) => {
+    const url = addr2url(addr, '/st.js')
+    req(url, (er, res, body) => {
+      if (canConnect) {
+        t.ifError(er, url) && t.equal(res.statusCode, 200, url)
+      } else {
+        t.ok(er, url)
+      }
+    })
+  }
+}
+
+testServer(
+  'Listening on all ports by default',
+  [], null,
+  ['127.0.0.1', 'localhost', otherAddress], []
+)
+
+testServer(
+  'Restricted to localhost',
+  ['--localhost'], 'localhost',
+  ['127.0.0.1', 'localhost'], [otherAddress]
+)
+
+testServer(
+  'Restricted to non-local host',
+  ['--host', otherAddress], otherAddress,
+  [otherAddress], ['127.0.0.1']
+)
+
+testServer(
+  'Restricted to IPv4',
+  ['--host', '127.0.0.1'], '127.0.0.1',
+  ['127.0.0.1'], ['::1']
+)

package/test/common.js

@@ -1,54 +1,66 @@
-var path = require('path')
-var fs = require('fs')
-var http = require('http')
-var util = require('util')
-var request = require('request')
-var tap = require('tap')
+const path = require('path')
+const fs = require('fs')
+const http = require('http')
+const request = require('request')
+const { test, tearDown } = require('tap')
 
-var st = require('../st.js')
+const st = require('../st.js')
 
-var port = process.env.PORT || 1337
-var test = tap.test
+let address
+let server
 
-var server
-
-var opts = util._extend({
+const opts = Object.assign({
   autoindex: true,
   path: path.dirname(__dirname),
   url: '/test'
 }, global.options || {})
 
-var stExpect = fs.readFileSync(require.resolve('../st.js'), 'utf8')
-var mount = st(opts)
-
+const stExpect = fs.readFileSync(require.resolve('../st.js'), 'utf8')
+const mount = st(opts)
 
 function req (url, headers, cb) {
-  if (typeof headers === 'function') cb = headers, headers = {}
-  request({ encoding: null,
-            url: 'http://localhost:' + port + url,
-            headers: headers }, cb)
-}
+  if (typeof headers === 'function') {
+    cb = headers
+    headers = {}
+  }
 
+  let host = address.address
+  if (address.family === 'IPv6') {
+    host = `[${host}]`
+  }
 
-test('setup', function (t) {
-  server = http.createServer(function (req, res) {
-    if (!mount(req, res)) {
-      res.statusCode = 404
-      return res.end('Not a match: ' + req.url)
+  request({
+    encoding: null,
+    url: `http://${host}:${address.port}${url}`,
+    headers: headers,
+    followRedirect: false
+  }, cb)
+}
+
+test('setup', (t) => {
+  server = http.createServer((req, res) => {
+    try {
+      if (!mount(req, res)) {
+        res.statusCode = 404
+        return res.end(`Not a match: ${req.url}`)
+      }
+    } catch (e) {
+      res.statusCode = 500
+      console.error(e)
+      return res.end(`Internal error: ${e.message}`)
     }
-  }).listen(port, function () {
+  }).listen(0, '127.0.0.1', () => {
     t.pass('listening')
+    address = server.address()
     t.end()
   })
 })
 
-
-tap.tearDown(function() {
+tearDown(() => {
   server.close()
 })
 
-
 module.exports.mount = mount
 module.exports.req = req
 module.exports.stExpect = stExpect
-module.exports.opts = opts
+module.exports.opts = opts

package/test/cors.js

@@ -2,20 +2,18 @@ global.options = {
   cors: true
 }
 
-var common = require('./common')
+const { test } = require('tap')
+const { req } = require('./common')
 
-var test = require('tap').test
-var req = common.req
-
-test('CORS headers', function (t) {
-  req('/test/st.js', function (er, res) {
-    t.equal(res.headers['access-control-allow-origin'], '*');
-    var headers = res.headers['access-control-allow-headers']
-    t.ok(/Origin/.test(headers));
-    t.ok(/X-Requested-With/.test(headers));
-    t.ok(/Content-Type/.test(headers));
-    t.ok(/Accept/.test(headers));
-    t.ok(/Range/.test(headers));
+test('CORS headers', (t) => {
+  req('/test/st.js', (er, res) => {
+    t.equal(res.headers['access-control-allow-origin'], '*')
+    const headers = res.headers['access-control-allow-headers']
+    t.ok(/Origin/.test(headers))
+    t.ok(/X-Requested-With/.test(headers))
+    t.ok(/Content-Type/.test(headers))
+    t.ok(/Accept/.test(headers))
+    t.ok(/Range/.test(headers))
     t.end()
   })
 })

package/test/dot-common.js

@@ -1,38 +1,44 @@
-var path = require('path')
-var http = require('http')
-var request = require('request')
-var tap = require('tap')
+const path = require('path')
+const http = require('http')
+const request = require('request')
+const { test, tearDown } = require('tap')
 
-var st = require('../st.js')
+const st = require('../st.js')
 
-var port = process.env.PORT || 1337
-var test = exports.test = tap.test
+let address
+let server
 
-var server
-
-var opts = {
+const opts = {
   dot: global.dot,
-  path: path.join(__dirname, "fixtures", ".dotted-dir"),
+  path: path.join(__dirname, 'fixtures', '.dotted-dir')
 }
 
-var mount = st(opts)
+const mount = st(opts)
+
+const req = (url, cb) => {
+  let host = address.address
+  if (address.family === 'IPv6') {
+    host = `[${host}]`
+  }
 
-exports.req = function req (url, cb) {
-  request({ url: 'http://localhost:' + port + url }, cb)
+  request({ url: `http://${host}:${address.port}${url}` }, cb)
 }
 
-test('setup', function (t) {
-  server = http.createServer(function (req, res) {
+test('setup', (t) => {
+  server = http.createServer((req, res) => {
     if (!mount(req, res)) {
       res.statusCode = 404
-      return res.end('Not a match: ' + req.url)
+      return res.end(`Not a match: ${req.url}`)
     }
-  }).listen(port, function () {
+  }).listen(0, '127.0.0.1', () => {
     t.pass('listening')
+    address = server.address()
     t.end()
   })
 })
 
-tap.tearDown(function() {
+tearDown(() => {
   server.close()
 })
+
+module.exports.req = req

package/test/dot-false.js

@@ -1,20 +1,18 @@
 global.dot = false
 
-var common = require('./dot-common')
-
-var req = common.req
-var test = common.test
+const { test } = require('tap')
+const { req } = require('./dot-common')
 
 // failing per https://github.com/isaacs/st/issues/67
-test('non-dotted file', function (t) {
-  req('/index.html', function (er, res, body) {
+test('non-dotted file', (t) => {
+  req('/index.html', (er, res, body) => {
     t.equal(res.statusCode, 200)
     t.end()
   })
 })
 
-test('dotted file', function (t) {
-  req('/.index.html', function (er, res, body) {
+test('dotted file', (t) => {
+  req('/.index.html', (er, res, body) => {
     t.equal(res.statusCode, 403)
     t.end()
   })

package/test/dot-true.js

@@ -1,19 +1,19 @@
 global.dot = true
 
-var common = require('./dot-common')
+const { test } = require('tap')
+const { req } = require('./dot-common')
 
-var req = common.req
-var test = common.test
-
-test('non-dotted file', function (t) {
-  req('/index.html', function (er, res, body) {
+test('non-dotted file', (t) => {
+  req('/index.html', (er, res, body) => {
+    t.error(er)
     t.equal(res.statusCode, 200)
     t.end()
   })
 })
 
-test('dotted file', function (t) {
-  req('/.index.html', function (er, res, body) {
+test('dotted file', (t) => {
+  req('/.index.html', (er, res, body) => {
+    t.error(er)
     t.equal(res.statusCode, 200)
     t.end()
   })