st 1.2.2 → 2.0.0

package/test/multi-mount.js

@@ -0,0 +1,251 @@
+const st = require('../st.js')
+const test = require('tap').test
+const port = process.env.PORT || 1337
+const path = require('path')
+const request = require('request')
+const assert = require('assert')
+const fs = require('fs')
+const http = require('http')
+
+let middlewareServer
+let server
+
+// mount the dirname on the /test url
+const mount1 = st({
+  autoindex: true,
+  path: path.dirname(__dirname),
+  url: '/test',
+  cache: {
+    fd: {
+      max: 3
+    }
+  }
+})
+
+// mount the test dir on the /blerg url
+const mount2 = st({
+  autoindex: true,
+  path: __dirname,
+  url: '/blerg',
+  cache: {
+    fd: {
+      max: 3
+    }
+  }
+})
+
+function req (url, headers, cb) {
+  if (typeof headers === 'function') {
+    cb = headers
+    headers = {}
+  }
+
+  let reqs = 0
+  let errState = null
+  let prev = null
+
+  request({
+    encoding: null,
+    url: `http://localhost:${port}${url}`,
+    headers: headers,
+    agentOptions: { maxSockets: 50 }
+  }, next)
+  request({
+    encoding: null,
+    url: `http://localhost:${(port + 1)}${url}`,
+    headers: headers,
+    agentOptions: { maxSockets: 50 }
+  }, next)
+
+  function next (er, res, body) {
+    if (errState) {
+      return
+    }
+    if (er) {
+      errState = er
+      return cb(er, res, body)
+    }
+    if (++reqs === 2) {
+      assert.strictEqual(res.statusCode, prev.res.statusCode)
+      // compare dates, they should be approximately the same
+      assert(Math.abs(new Date(res.headers.date).getTime() -
+                      new Date(res.headers.date).getTime()) < 1000)
+      // compare the headers minus the 'date' value
+      res.headers.date = prev.res.headers.date = null
+      assert.deepStrictEqual(res.headers, prev.res.headers)
+      assert.strictEqual(`${body}`, `${prev.body}`)
+      return cb(er, res, body)
+    }
+    prev = { res: res, body: body }
+  }
+}
+
+test('setup middleware server', function (t) {
+  // using the middleware approach
+  middlewareServer = http.createServer(function (req, res) {
+    mount1(req, res, function () {
+      mount2(req, res, function () {
+        res.statusCode = 404
+        return res.end(`Not a match: ${req.url}`)
+      })
+    })
+  })
+  middlewareServer.listen(port, '127.0.0.1', function () {
+    t.pass('listening')
+    t.end()
+  })
+})
+
+test('setup regular server', function (t) {
+  server = http.createServer(function (req, res) {
+    if (!mount1(req, res) && !mount2(req, res)) {
+      res.statusCode = 404
+      return res.end(`Not a match: ${req.url}`)
+    }
+  })
+  server.listen(port + 1, '127.0.0.1', function () {
+    t.pass('listening')
+    t.end()
+  })
+})
+
+let stEtag
+const stExpect = fs.readFileSync(require.resolve('../st.js')).toString()
+
+test('/test/st.js', function (t) {
+  req('/test/st.js', function (er, res, body) {
+    t.equal(res.statusCode, 200)
+    t.ok(res.headers.etag)
+    stEtag = res.headers.etag
+    t.equal(body.toString(), stExpect)
+    t.end()
+  })
+})
+
+test('/test/st.js 304', function (t) {
+  req('/test/st.js', { 'if-none-match': stEtag }, function (er, res, body) {
+    t.equal(res.statusCode, 304)
+    t.equal(body.length, 0)
+    t.end()
+  })
+})
+
+let mmEtag
+const mmExpect = fs.readFileSync(__filename, 'utf8')
+test('/blerg/multi-mount.js', function (t) {
+  req('/blerg/multi-mount.js', function (er, res, body) {
+    t.equal(res.statusCode, 200)
+    t.ok(res.headers.etag)
+    mmEtag = res.headers.etag
+    t.equal(body.toString(), mmExpect)
+    t.end()
+  })
+})
+
+test('/test/test/multi-mount.js', function (t) {
+  req('/test/test/multi-mount.js', function (er, res, body) {
+    t.equal(res.statusCode, 200)
+    t.equal(mmEtag, res.headers.etag)
+    t.equal(body.toString(), mmExpect)
+    t.end()
+  })
+})
+
+let rmEtag
+const rmExpect = fs.readFileSync(path.resolve(__dirname, '../README.md'), 'utf8')
+let pjEtag
+const pjExpect = fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8')
+let idEtag
+const idExpect = fs.readFileSync(path.join(__dirname, '/fixtures/index.html'), 'utf8')
+test('just get a few more etags', function (t) {
+  let n = 3
+
+  req('/test/package.json', function (er, res, body) {
+    if (er) {
+      throw er
+    }
+    t.equal(body.toString(), pjExpect)
+    pjEtag = res.headers.etag
+    if (--n === 0) {
+      t.end()
+    }
+  })
+
+  req('/test/README.md', function (er, res, body) {
+    if (er) {
+      throw er
+    }
+    t.equal(body.toString(), rmExpect)
+    rmEtag = res.headers.etag
+    if (--n === 0) {
+      t.end()
+    }
+  })
+
+  req('/test/test/fixtures/index.html', function (er, res, body) {
+    if (er) {
+      throw er
+    }
+    t.equal(body.toString(), idExpect)
+    idEtag = res.headers.etag
+    if (--n === 0) {
+      t.end()
+    }
+  })
+})
+
+test('many parallel requests', function (t) {
+  const n = 50
+  const reqs =
+    [['/test/test/multi-mount.js', mmEtag, mmExpect],
+      ['/blerg/multi-mount.js', mmEtag, mmExpect],
+      ['/test/st.js', stEtag, stExpect],
+      ['/test/README.md', rmEtag, rmExpect],
+      ['/test/package.json', pjEtag, pjExpect],
+      ['/test/test/fixtures/index.html', idEtag, idExpect],
+      ['/blerg/fixtures/index.html', idEtag, idExpect]]
+
+  let total = n * reqs.length
+
+  for (let i = 0; i < n; i++) {
+    reqs.forEach(function (r) {
+      req(r[0], next(r))
+    })
+  }
+
+  function next (r) {
+    return (er, res, body) => {
+      if (er) {
+        console.error('problem with', r[0])
+        throw er
+      }
+
+      t.pass(r[0])
+      t.ok(res)
+      t.ok(res.headers)
+      t.equal(res.headers.etag, r[1])
+      t.equal(body.toString(), r[2].toString())
+
+      if (--total === 0) {
+        process.nextTick(() => {
+          t.ok(require('fd')._totalOpenFds <= 6) // max of 3 fds per mount
+          t.end()
+        })
+      }
+    }
+  }
+})
+
+test('shutdown regular server', (t) => {
+  server.close(() => {
+    t.pass('closed')
+    t.end()
+  })
+})
+
+test('shutdown middleware server', (t) => {
+  middlewareServer.close(() => {
+    t.pass('closed')
+    t.end()
+  })
+})

package/test/no-cache.js

@@ -0,0 +1,19 @@
+// turn off ALL caching.
+global.options = {
+  cache: false
+}
+
+// otherwise just the same as basic.
+const { mount } = require('./basic.js')
+const { test } = require('tap')
+
+// additional tests to ensure that it's actually not caching.
+
+test('all caches should be empty', (t) => {
+  t.same(mount._this.cache.fd._cache.dump(), [])
+  t.same(mount._this.cache.stat._cache.dump(), [])
+  t.same(mount._this.cache.index._cache.dump(), [])
+  t.same(mount._this.cache.readdir._cache.dump(), [])
+  t.same(mount._this.cache.content._cache.dump(), [])
+  t.end()
+})

package/test/no-content-maxage.js

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

package/test/no-cors.js

@@ -0,0 +1,14 @@
+global.options = {
+  cors: false
+}
+
+const { req } = require('./common')
+const test = require('tap').test
+
+test('without CORS headers', function (t) {
+  req('/test/st.js', function (er, res) {
+    t.error(er)
+    t.notOk(res.headers['access-control-allow-origin'])
+    t.end()
+  })
+})

package/test/no-fd-cache.js

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

package/test/no-gzip-accepted-no-cache.js

@@ -0,0 +1,32 @@
+global.options = {
+  cache: false // cache invokes a separate path
+}
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const rimraf = require('rimraf')
+const { test } = require('tap')
+const { req } = require('./common.js')
+const testFileName = 'no-gzip-accepted-no-cache.testfile'
+const testFile = path.join(__dirname, '../', testFileName)
+
+const rndData = crypto.randomBytes(1024 * 128).toString('hex') // significantly larger than highWaterMark
+
+test('does not gzip the response', (t) => {
+  t.on('end', () => {
+    rimraf(testFile, () => {})
+  })
+
+  fs.writeFile(testFile, rndData, (err) => {
+    t.error(err)
+
+    req(`/test/${testFileName}`, { 'accept-encoding': 'none' }, (er, res, body) => {
+      t.error(er)
+      t.equal(res.statusCode, 200)
+      t.notOk(res.headers['content-encoding'])
+      t.equal(body.toString(), rndData)
+      t.end()
+    })
+  })
+})

package/test/no-gzip-accepted.js

@@ -0,0 +1,31 @@
+global.options = {
+}
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const rimraf = require('rimraf')
+const { test } = require('tap')
+const { req } = require('./common.js')
+const testFileName = 'no-gzip-accepted.testfile'
+const testFile = path.join(__dirname, '../', testFileName)
+
+const rndData = crypto.randomBytes(1024 * 128).toString('hex') // significantly larger than highWaterMark
+
+test('does not gzip the response', (t) => {
+  t.on('end', () => {
+    rimraf(testFile, () => {})
+  })
+
+  fs.writeFile(testFile, rndData, (err) => {
+    t.error(err)
+
+    req('/test/' + testFileName, { 'accept-encoding': 'none' }, (er, res, body) => {
+      t.error(er)
+      t.equal(res.statusCode, 200)
+      t.notOk(res.headers['content-encoding'])
+      t.equal(body.toString(), rndData)
+      t.end()
+    })
+  })
+})

package/test/no-gzip.js

@@ -0,0 +1,18 @@
+// turn off gzip compression
+global.options = {
+  gzip: false
+}
+
+const { test } = require('tap')
+const { req, stExpect } = require('./basic.js')
+
+// additional test to ensure that it's actually not gzipping
+
+test('does not gzip the response', (t) => {
+  req('/test/st.js', { 'accept-encoding': 'gzip' }, (er, res, body) => {
+    t.equal(res.statusCode, 200)
+    t.notOk(res.headers['content-encoding'])
+    t.equal(body.toString(), stExpect)
+    t.end()
+  })
+})

package/test/parent-path.js

@@ -0,0 +1,8 @@
+const path = require('path')
+
+global.options = {
+  path: path.dirname(__filename) + '/..'
+}
+
+// otherwise just the same as basic.
+require('./basic.js')

package/test/passthrough.js

@@ -0,0 +1,75 @@
+const { test } = require('tap')
+const path = require('path')
+const st = require('../st.js')
+
+const opts = Object.assign({
+  index: false,
+  path: path.resolve(__dirname, './fixtures'),
+  url: '/',
+  passthrough: true
+}, global.options || {})
+
+const mount = st(opts)
+
+test('call next() if passthrough is set', (t) => {
+  const req = { method: 'GET', url: '/doesnotexist.txt', headers: {} }
+  const res = {
+    error: () => t.end(),
+    setHeader: () => {},
+    end: () => {}
+  }
+  t.plan(2)
+  mount(req, res, () => {
+    t.ok(true, 'next called with nonexistant file')
+    req.url = '/'
+    mount(req, res, () => {
+      t.ok(true, 'next called without indexing')
+      t.end()
+    })
+  })
+})
+
+const opts2 = Object.assign({
+  autoindex: true,
+  path: path.resolve(__dirname, './fixtures'),
+  url: '/'
+}, global.options || {})
+const mount2 = st(opts2)
+
+test('return error if passthrough is not set', (t) => {
+  const req = { method: 'GET', url: '/doesnotexist.txt', headers: {} }
+  const res = {
+    setHeader: () => {},
+    error: () => {
+      t.ok(true, 'error used')
+      t.end()
+    },
+    end: () => {}
+  }
+  t.plan(1)
+  mount2(req, res, () => {
+    t.end()
+  })
+})
+
+test('does not set headers if passthrough is set', (t) => {
+  const req = { method: 'GET', url: '/doesnotexist.txt', headers: {} }
+  const res = {
+    error: () => t.end(),
+    _headers: [],
+    setHeader: (header) => {
+      res._headers.push(header)
+    },
+    end: () => {}
+  }
+  t.plan(2)
+  mount(req, res, () => {
+    t.notOk(res._headers.length, 'headers are not set on a non-existant file')
+    req.url = '/'
+
+    mount(req, res, () => {
+      t.notOk(res._headers.length, 'headers are not set with no index')
+      t.end()
+    })
+  })
+})

package/test/preset-cache-control.js

@@ -0,0 +1,65 @@
+const st = require('../st.js')
+const { test, tearDown } = require('tap')
+const path = require('path')
+const http = require('http')
+const request = require('request')
+const port = process.env.PORT || 1337
+
+const opts = Object.assign({
+  index: false,
+  path: path.dirname(__dirname),
+  url: '/test'
+}, global.options || {})
+
+const mount = st(opts)
+let server
+let cacheControl = null
+
+function req (url, headers, cb) {
+  if (typeof headers === 'function') {
+    cb = headers
+    headers = {}
+  }
+  request({
+    encoding: null,
+    url: 'http://localhost:' + port + url,
+    headers: headers
+  }, cb)
+}
+
+test('setup', (t) => {
+  server = http.createServer((req, res) => {
+    if (cacheControl) {
+      res.setHeader('cache-control', cacheControl)
+    }
+    if (!mount(req, res)) {
+      res.statusCode = 404
+      return res.end('Not a match: ' + req.url)
+    }
+  }).listen(port, () => {
+    t.pass('listening')
+    t.end()
+  })
+})
+
+tearDown(() => {
+  server.close()
+})
+
+test('simple request', (t) => {
+  cacheControl = null
+  req('/test/st.js', (er, res, body) => {
+    t.error(er)
+    t.equal(res.headers['cache-control'], 'public, max-age=600')
+    t.end()
+  })
+})
+
+test('pre-set cache-control', (t) => {
+  cacheControl = 'I\'m so excited, and I just can\'t hide it'
+  req('/test/st.js', (er, res, body) => {
+    t.error(er)
+    t.equal(res.headers['cache-control'], cacheControl)
+    t.end()
+  })
+})