st 1.2.2 → 2.0.0

package/test/basic.js

@@ -0,0 +1,133 @@
+const zlib = require('zlib')
+const { test } = require('tap')
+const { req, stExpect, opts, mount } = require('./common')
+
+module.exports.req = req
+module.exports.stExpect = stExpect
+module.exports.mount = mount
+
+let stEtag
+
+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)
+    stEtag = res.headers.etag
+    t.equal(body.toString(), stExpect)
+    t.end()
+  })
+})
+
+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', (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!', (t) => {
+  let n = 6
+  req('/test/st.js', then)
+  req('/test/README.md', then)
+  req('/test/LICENSE', then)
+  req('/test/package.json', then)
+  req('/test/favicon.ico', then)
+  req('/test/bin/server.js', then)
+
+  function then (er, res) {
+    if (er) {
+      throw er
+    }
+    t.equal(res.statusCode, 200)
+
+    // give them all time to close, then go again.
+    if (--n === 0) {
+      setTimeout(() => {
+        n = 6
+        req('/test/st.js', then2)
+        req('/test/README.md', then2)
+        req('/test/LICENSE', then2)
+        req('/test/package.json', then2)
+        req('/test/favicon.ico', then2)
+        req('/test/bin/server.js', then2)
+      }, 200)
+    }
+  }
+
+  function then2 (er, res) {
+    if (er) {
+      throw er
+    }
+
+    t.equal(res.statusCode, 200)
+
+    if (opts.cache === false) {
+      t.equal(res.headers['cache-control'], 'no-cache')
+    } 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) {
+      t.equal(res.headers['cache-control'], opts.cache.content.cacheControl)
+    } else {
+      t.equal(res.headers['cache-control'], 'public, max-age=600')
+    }
+
+    if (--n === 0) {
+      t.end()
+    }
+  }
+})
+
+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', (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('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

@@ -0,0 +1,66 @@
+const path = require('path')
+const fs = require('fs')
+const http = require('http')
+const request = require('request')
+const { test, tearDown } = require('tap')
+
+const st = require('../st.js')
+
+let address
+let server
+
+const opts = Object.assign({
+  autoindex: true,
+  path: path.dirname(__dirname),
+  url: '/test'
+}, global.options || {})
+
+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 = {}
+  }
+
+  let host = address.address
+  if (address.family === 'IPv6') {
+    host = `[${host}]`
+  }
+
+  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(0, '127.0.0.1', () => {
+    t.pass('listening')
+    address = server.address()
+    t.end()
+  })
+})
+
+tearDown(() => {
+  server.close()
+})
+
+module.exports.mount = mount
+module.exports.req = req
+module.exports.stExpect = stExpect
+module.exports.opts = opts

package/test/cors.js

@@ -0,0 +1,19 @@
+global.options = {
+  cors: true
+}
+
+const { test } = require('tap')
+const { req } = require('./common')
+
+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

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

package/test/dot-false.js

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

package/test/dot-true.js

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

package/test/explicit-cache-control.js

@@ -0,0 +1,12 @@
+global.options = {
+  cache: {
+    content: {
+      // testing an arbitrary string can be passed through to override
+      // the header value, YES the misspellings are intentional
+      cacheControl: 'pubic, marx-aged=-100'
+    }
+  }
+}
+
+// otherwise just the same as basic.
+require('./basic.js')

package/test/fd-limit.js

@@ -0,0 +1,10 @@
+global.options = {
+  cache: {
+    fd: {
+      max: 2
+    }
+  }
+}
+
+// otherwise just the same as basic.
+require('./basic.js')

package/test/fixtures/.dotted-dir/.index.html

@@ -0,0 +1,11 @@
+<html>
+<head><title>Index of {url}</title></head>
+<body bgcolor="white">
+<h1>Index of {url}</h1><hr><pre><a href="../">../</a>
+<!-- dirs first -->
+<!-- for each show this:
+  <a href="{filename}">{filename}</a> {modified date}  {size}
+-->
+<!-- line up the fields nicely -->
+</pre><hr></body>
+</html>

package/test/fixtures/.dotted-dir/index.html

@@ -0,0 +1,11 @@
+<html>
+<head><title>Index of {url}</title></head>
+<body bgcolor="white">
+<h1>Index of {url}</h1><hr><pre><a href="../">../</a>
+<!-- dirs first -->
+<!-- for each show this:
+  <a href="{filename}">{filename}</a> {modified date}  {size}
+-->
+<!-- line up the fields nicely -->
+</pre><hr></body>
+</html>

package/test/fixtures/index.html

@@ -0,0 +1,11 @@
+<html>
+<head><title>Index of {url}</title></head>
+<body bgcolor="white">
+<h1>Index of {url}</h1><hr><pre><a href="../">../</a>
+<!-- dirs first -->
+<!-- for each show this:
+  <a href="{filename}">{filename}</a> {modified date}  {size}
+-->
+<!-- line up the fields nicely -->
+</pre><hr></body>
+</html>

package/test/fixtures/space in filename.txt

@@ -0,0 +1 @@
+space in filename

package/test/gzip-after-no-gzip.js

@@ -0,0 +1,38 @@
+global.options = {
+  cachedHeader: true // inspect to see if something is served from cache
+}
+
+const zlib = require('zlib')
+const { req, stExpect } = require('./common.js')
+const { test } = require('tap')
+
+test('does not gzip first response', (t) => {
+  req('/test/st.js', { 'accept-encoding': 'none' }, (er, res, body) => {
+    t.equal(res.statusCode, 200)
+    t.notOk(res.headers['content-encoding'])
+    t.notOk(res.headers['x-from-cache'])
+    t.equal(body.toString(), stExpect)
+    t.end()
+  })
+})
+
+test('gzips second response', (t) => {
+  req('/test/st.js', { 'accept-encoding': 'gzip' }, (er, res, body) => {
+    t.error(er, 'no error')
+
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['content-encoding'], 'gzip')
+    t.equal(res.headers['x-from-cache'], 'true')
+
+    t.ok(body, 'returned a body')
+    t.notEqual(body.toString(), stExpect, 'gzipped string')
+
+    zlib.gunzip(body, (er, body) => {
+      if (er) {
+        throw er
+      }
+      t.equal(body.toString(), stExpect)
+      t.end()
+    })
+  })
+})

package/test/middleware.js

@@ -0,0 +1,17 @@
+const st = require('../st.js')
+const { test } = require('tap')
+const path = require('path')
+
+const opts = Object.assign({
+  autoindex: true,
+  path: path.dirname(__dirname),
+  url: '/test'
+}, global.options || {})
+
+const mount = st(opts)
+
+test('call next() if asset not found', (t) => {
+  const req = { url: '/does-not-exist?a=b' }
+  t.plan(1)
+  mount(req, req, () => t.equal(req.url, '/does-not-exist?a=b'))
+})