cors: Add specific support for supporting all origin

socket: Set time out and forcibly close timed out sockets. Fix tests for different node versions
random generator benchmark
2023-11-15 09:56:34 +00:00 · 2023-11-03 22:52:09 +00:00 · 2023-10-07 11:49:41 +00:00 · 2023-09-28 10:39:12 +00:00 · 2023-05-11 11:12:23 +00:00 · 2023-05-11 09:50:52 +00:00
14 changed files with 1276 additions and 623 deletions
--- a/README.md
+++ b/README.md
@ -126,9 +126,9 @@ flaska.get('/api/test', function(ctx) {
 })
 ```

-### File stream/pipe
+### pipe

-In cases where the response body is a pipe object (detected from the existance of `.pipe` property), flaska will automatically pipe the file for you. In addition, if a file stream is used, it will read the extension of the file being streamed and automatically fill in the mime-type for you in the `Content-Type` header.
+In cases where the response body is a pipe object (detected from the existance of `.pipe` property), flaska will automatically pipe it for you. In addition, if a file stream is used, it will read the extension of the file being streamed and automatically fill in the mime-type for you in the `Content-Type` header.

 ```
 flaska.get('/test.png', function(ctx) {
@ -138,6 +138,22 @@ flaska.get('/test.png', function(ctx) {

 Flaska will automatically close the file stream for you so you don't have to worry about that.

+### FileResponse
+
+Alternatively, if you want proper file support, I recommend using FileResponse object:
+
+```
+import { FileResponse } from '../flaska.mjs'
+
+flaska.get('/test.txt', function(ctx) {
+  return fs.stat('./test/test.txt').then(function(stat) {
+    ctx.body = new FileResponse('./test/test.txt', stat)
+  })
+})
+```
+
+This performs a real file stream support, uses pipes and supports all the HTTP shenanigans when it comes to dealing with files, including sending proper etag header, supporting partial response and lots of other things. This is one of the few libraries that actually implements full HTTP partial and etag support in a proper way, almost all other have one or two quirks that don't follow the spec properly.
+
 ### String

 In other instances, Flaska will `.toString()` the body and send it in response with the specified type or default to `text/plain` if unspecified.
--- a/benchmark/random.js
+++ b/benchmark/random.js
@ -0,0 +1,46 @@
+import crypto from 'crypto'
+import Benchmark from 'benchmarkjs-pretty'
+
+function TestGenerateRandomString() {
+
+  return new Benchmark.default('test different method to generate random string)')
+    .add('crypto.randomBytes(16)', function() {
+      for (let i = 0; i < 25; i++) {
+        crypto.randomBytes(16).toString('base64')
+      }
+    })
+    .add('crypto.randomBytes(32)', function() {
+      for (let i = 0; i < 25; i++) {
+        crypto.randomBytes(32).toString('base64')
+      }
+    })
+    .add('random (11 characters long)', function() {
+      for (let i = 0; i < 25; i++) {
+        let out = Math.random().toString(36).substring(2, 14)
+      }
+    })
+    .add('random (22 characters long)', function() {
+      for (let i = 0; i < 25; i++) {
+        let out = Math.random().toString(36).substring(2, 24)
+                  + Math.random().toString(36).substring(2, 24)
+      }
+    })
+    .add('random (44 characters long)', function() {
+      for (let i = 0; i < 25; i++) {
+        let out = Math.random().toString(36).substring(2, 24)
+                + Math.random().toString(36).substring(2, 24)
+                + Math.random().toString(36).substring(2, 24)
+                + Math.random().toString(36).substring(2, 24)
+      }
+    })
+    .run()
+    .then(function() {}, function(e) {
+      console.error('error:', e)
+      process.exit(1)
+    })
+}
+
+TestGenerateRandomString()
+.then(function() {
+  process.exit(0)
+})
--- a/flaska.mjs
+++ b/flaska.mjs
@ -139,6 +139,7 @@ export function CorsHandler(opts = {}) {
    exposeHeaders: opts.exposeHeaders || '',
    maxAge: opts.maxAge || '',
  }
+  const allowAll = options.allowedOrigins.includes('*')

  return function(ctx) {
    // Always add vary header on origin. Prevent caches from
@ -154,7 +155,7 @@ export function CorsHandler(opts = {}) {
    // Check origin is specified. Nothing needs to be done if
    // there is no origin or it doesn't match
    let origin = ctx.req.headers['origin']
-    if (!origin || !options.allowedOrigins.includes(origin)) {
+    if (!origin || (!allowAll && !options.allowedOrigins.includes(origin))) {
      return
    }

@ -237,7 +238,7 @@ export function FormidableHandler(formidable, org = {}) {

    return new Promise(function(res, rej) {
      form.parse(ctx.req, function(err, fields, files) {
-        if (err) return rej(err)
+        if (err) return rej(new HttpError(400, err.message))

        if (opts.parseFields) {
          Object.keys(fields).forEach(function(key) {
@ -248,29 +249,45 @@ export function FormidableHandler(formidable, org = {}) {
        }

        ctx.req.body = fields
-        ctx.req.file = files?.file || null
+        ctx.req.files = files
+        ctx.req.file = null

-        if (!ctx.req.file) {
+
+        if (!ctx.req.files) {
          return res()
        }

-        let filename
-        let target
+        let keys = Object.keys(files).filter(key => Boolean(ctx.req.files[key]))

-        try {
-          filename = opts.filename(ctx.req.file) || ctx.req.file.name
-          target = path.join(opts.uploadDir, filename)
-        } catch (err) {
-          return rej(err)
-        }
-
-        rename(ctx.req.file.path, target)
-        .then(function() {
-          ctx.req.file.path = target
-          ctx.req.file.filename = filename
-        })
-        .then(res, rej)
+        Promise.all(
+          keys.map(key => {
+            let filename
+            let target
+    
+            try {
+              filename = opts.filename(ctx.req.files[key]) || ctx.req.files[key].name
+              target = path.join(opts.uploadDir, filename)
+            } catch (err) {
+              return Promise.reject(err)
+            }

+            return rename(ctx.req.files[key].path, target)
+            .then(function() {
+              if (!ctx.req.files[key].type || ctx.req.files[key].type === 'application/octet-stream') {
+                let found = MimeTypeDb[path.extname(filename).slice(1)]
+                ctx.req.files[key].type = found && found[0] || 'application/octet-stream'
+              }
+              ctx.req.files[key].path = target
+              ctx.req.files[key].filename = filename
+            })
+          })
+        )
+        .then(() => {
+          if (keys.length === 1 && keys[0] === 'file') {
+            ctx.req.file = ctx.req.files.file
+          }
+          res()
+        }, rej)
      })
    })
  }
@ -376,10 +393,13 @@ export class FileResponse {
      ctx.type = found[found.length - 1]
    }

-    let stream = useFs.createReadStream(this.filepath, readOptions)
    ctx.headers['Last-Modified'] = lastModified
    ctx.headers['Content-Length'] = size
-    return stream
+    if (ctx.method !== 'HEAD') {
+      let stream = useFs.createReadStream(this.filepath, readOptions)
+      return stream
+    }
+    return null
  }
 }

@ -609,12 +629,10 @@ export class Flaska {
      }
    }
    this._onreqerror = function(err, ctx) {
-      if (err.message === 'aborted') {
-        ctx.log.info(err)
-      } else {
+      if (err.message !== 'aborted') {
        ctx.log.error(err)
+        ctx.res.statusCode = ctx.statusCode = 400
      }
-      ctx.res.statusCode = ctx.statusCode = 400
      ctx.res.end()
    }
    this._onreserror = function(err, ctx) {
@ -625,7 +643,7 @@ export class Flaska {
      defaultHeaders: opts.defaultHeaders || {
        'Server': 'Flaska',
        'X-Content-Type-Options': 'nosniff',
-        'Content-Security-Policy': `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; object-src 'none'; frame-ancestors 'none'`,
+        'Content-Security-Policy': `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'`,
        'Cross-Origin-Opener-Policy': 'same-origin',
        'Cross-Origin-Resource-Policy': 'same-origin',
        'Cross-Origin-Embedder-Policy': 'require-corp',
@ -643,6 +661,13 @@ export class Flaska {
      nonceCacheLength: opts.nonceCacheLength || 25
    }

+    if (opts.appendHeaders) {
+      let appendKeys = Object.keys(opts.appendHeaders)
+      for (let key of appendKeys) {
+        options.defaultHeaders[key] = opts.appendHeaders[key]
+      }
+    }
+
    if (!options.defaultHeaders && options.nonce.length) {
      // throw error
    }
@ -832,11 +857,6 @@ ctx.state.nonce = nonce;
      this._onreserror(err, ctx)
    })

-    req.on('close', () => {
-      ctx.closed = true
-      this.requestEnded(ctx)
-    })
-
    res.on('finish', () => {
      this.requestEnded(ctx)
    })
@ -912,7 +932,8 @@ ctx.state.nonce = nonce;

  requestEnd(orgErr, ctx) {
    let err = orgErr
-    if (ctx.body && ctx.body.handleRequest) {
+    let handleUsed = Boolean(ctx.body && ctx.body.handleRequest)
+    if (handleUsed) {
      try {
        ctx.body = ctx.body.handleRequest(ctx)
      } catch (newErr) {
@ -931,13 +952,18 @@ ctx.state.nonce = nonce;
      return
    }

+    if (ctx.body === null && !handleUsed && ctx.status === 200) {
+      ctx.status = 204
+    }
+
    if (statuses.empty[ctx.status]) {
      ctx.res.writeHead(ctx.status, ctx.headers)
      return ctx.res.end()
    }

    let body = ctx.body
-    let length = 0
+
+    // Special handling for files
    if (body && typeof(body.pipe) === 'function') {
      // Be smart when handling file handles, auto detect mime-type
      // based off of the extension of the file.
@ -951,22 +977,45 @@ ctx.state.nonce = nonce;
      ctx.headers['Content-Type'] = ctx.type || 'application/octet-stream'

      ctx.res.writeHead(ctx.status, ctx.headers)
-      return this.stream.pipeline(body, ctx.res, function() { })
+
+      if (ctx.method !== 'HEAD') {
+        return this.stream.pipeline(body, ctx.res, function() { })
+      } else {
+        try {
+          body.destroy()
+        } catch { }
+        return ctx.res.end()
+      }
    }
-    if (typeof(body) === 'object') {
+
+    let length = 0
+    
+    if (body instanceof Buffer) {
+      length = body.byteLength
+      ctx.type = ctx.type || 'application/octet-stream'
+    } else if (typeof(body) === 'object' && body) {
      body = JSON.stringify(body)
      length = Buffer.byteLength(body)
-      ctx.headers['Content-Type'] = 'application/json; charset=utf-8'
-    } else {
+      ctx.type = 'application/json; charset=utf-8'
+    } else if (body) {
      body = body.toString()
      length = Buffer.byteLength(body)
-      ctx.headers['Content-Type'] = ctx.type || 'text/plain; charset=utf-8'
+      ctx.type = ctx.type || 'text/plain; charset=utf-8'
+    }
+
+    if (ctx.type) {
+      ctx.headers['Content-Type'] = ctx.type
+    }
+    if (!ctx.headers['Content-Length']) {
+      ctx.headers['Content-Length'] = length
    }
-    
-    ctx.headers['Content-Length'] = length

    ctx.res.writeHead(ctx.status, ctx.headers)
-    ctx.res.end(body)
+    if (body && ctx.method !== 'HEAD') {
+      ctx.res.end(body)
+    } else {
+      ctx.res.end()
+    }
  }

  requestEnded(ctx) {
@ -1013,6 +1062,22 @@ ctx.state.nonce = nonce;
    }
  }

+  create() {
+    this.compile()
+    this.server = this.http.createServer(this.requestStart.bind(this))
+
+    this.server.on('connection', function (socket) {
+      // Set socket idle timeout in milliseconds
+      socket.setTimeout(1000 * 60 * 5) // 5 minutes
+  
+      // Wait for timeout event (socket will emit it when idle timeout elapses)
+      socket.on('timeout', function () {
+        // Call destroy again
+        socket.destroy();
+      })
+    })
+  }
+
  listen(port, orgIp, orgcb) {
    let ip = orgIp
    let cb = orgcb
@ -1023,8 +1088,8 @@ ctx.state.nonce = nonce;
    if (typeof(port) !== 'number') {
      throw new Error('Flaska.listen() called with non-number in port')
    }
-    this.compile()
-    this.server = this.http.createServer(this.requestStart.bind(this))
+
+    this.create()
    
    this.server.listen(port, ip, cb)
  }
@ -1034,8 +1099,11 @@ ctx.state.nonce = nonce;
      return Promise.reject(new Error('Flaska.listen() called with non-number in port'))
    }

-    this.compile()
-    this.server = this.http.createServer(this.requestStart.bind(this))
+    this.create()
+
+    if (this.server.listenAsync && typeof(this.server.listenAsync) === 'function') {
+      return this.server.listenAsync(port, ip)
+    }

    return new Promise((res, rej) => {
      this.server.listen(port, ip, function(err) {
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "flaska",
-  "version": "1.1.1",
+  "version": "1.3.5",
  "description": "Flaska is a micro web-framework for node. It is designed to be fast, simple and lightweight, and is distributed as a single file module with no dependencies.",
  "main": "flaska.mjs",
  "scripts": {
@ -39,7 +39,7 @@
  },
  "homepage": "https://git.nfp.is/TheThing/flaska/#readme",
  "devDependencies": {
-    "eltro": "^1.2.3",
+    "eltro": "^1.3.2",
    "formidable": "^1.2.2"
  },
  "files": [
--- a/test/client.mjs
+++ b/test/client.mjs
@ -126,34 +126,54 @@ const random = (length = 8) => {
  return str;
 }

-Client.prototype.upload = function(url, file, method = 'POST', body = {}) {
-  return fs.readFile(file).then(data => {
-    const crlf = '\r\n'
+Client.prototype.upload = function(url, files, method = 'POST', body = {}, overrideType = null) {
+  const boundary = `---------${random(32)}`
+  const crlf = '\r\n'
+  let upload = files
+
+  if (typeof(upload) === 'string') {
+    upload = {
+      file: files
+    }
+  }
+  let keys = Object.keys(upload)
+  let uploadBody = []
+
+  return Promise.all(keys.map(key => {
+    let file = upload[key]
+    return fs.readFile(file).then(data => {
      const filename = path.basename(file)
-      const boundary = `---------${random(32)}`

-      const multipartBody = Buffer.concat([
-        Buffer.from(
-          `${crlf}--${boundary}${crlf}` +
-          `Content-Disposition: form-data; name="file"; filename="${filename}"` + crlf + crlf
-        ),
-        data,
-        Buffer.concat(Object.keys(body).map(function(key) {
-          return Buffer.from(''
-            + `${crlf}--${boundary}${crlf}`
-            + `Content-Disposition: form-data; name="${key}"` + crlf + crlf
-            + JSON.stringify(body[key])
-          )
-        })),
-        Buffer.from(`${crlf}--${boundary}--`),
-      ])
+      uploadBody.push(Buffer.from(
+        `${crlf}--${boundary}${crlf}`
+         + `Content-Disposition: form-data; name="${key}"; filename="${filename}"`
+         + (overrideType ? crlf + `Content-Type: ${overrideType}`: '')
+         + crlf
+         + crlf
+      ))
+      uploadBody.push(data)
+    })
+  }))
+  .then(() => {
+    uploadBody.push(
+      Buffer.concat(Object.keys(body).map(function(key) {
+        return Buffer.from(''
+          + `${crlf}--${boundary}${crlf}`
+          + `Content-Disposition: form-data; name="${key}"` + crlf + crlf
+          + JSON.stringify(body[key])
+        )
+      }))
+    )
+    uploadBody.push(Buffer.from(`${crlf}--${boundary}--`))

-      return this.customRequest(method, url, multipartBody, {
-        timeout: 5000,
-        headers: {
-          'Content-Type': 'multipart/form-data; boundary=' + boundary,
-          'Content-Length': multipartBody.length,
-        },
-      })
+    let multipartBody = Buffer.concat(uploadBody)
+
+    return this.customRequest(method, url, multipartBody, {
+      timeout: 5000,
+      headers: {
+        'Content-Type': 'multipart/form-data; boundary=' + boundary,
+        'Content-Length': multipartBody.length,
+      },
+    })
  })
 }
--- a/test/fileResponse.test.mjs
+++ b/test/fileResponse.test.mjs
@ -13,84 +13,86 @@ t.test('should add path and stat', function() {
 })

 t.describe('CreateReader()', function() {
-  const assertPath = '/some/path/here.png'
-  const assertBody = { a: 1 }
-  const assertSize = 12498
-  const assertmTime = new Date('2021-04-02T11:22:33.777')
-  const roundedModified = new Date('2021-04-02T11:22:33')
-  const assertIno = 3569723027
-  const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
-  const stat = {
-    size: assertSize,
-    mtime: assertmTime,
-    ino: assertIno,
-  }
+  t.describe('return fileReader', function() {
+    const assertPath = '/some/path/here.png'
+    const assertBody = { a: 1 }
+    const assertSize = 12498
+    const assertmTime = new Date('2021-04-02T11:22:33.777')
+    const roundedModified = new Date('2021-04-02T11:22:33')
+    const assertIno = 3569723027
+    const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    
+    let tests = [
+      [
+        'if no range',
+        function() {},
+      ],
+      [
+        'if range start is higher than end',
+        function(headers) { headers['range'] = 'bytes=2000-1000' },
+      ],
+      [
+        'if pre-condition if-match passes',
+        function(headers) { headers['if-match'] = assertEtag },
+      ],
+      [
+        'if pre-condition if-unmodified-since passes',
+        function(headers) { headers['if-unmodified-since'] = roundedModified.toUTCString(); },
+      ],
+      [
+        'if both pre-condition pass',
+        function(headers) { headers['if-unmodified-since'] = new Date(roundedModified.getTime() + 1000).toUTCString(); headers['if-match'] = assertEtag },
+      ],
+      [
+        'if range is specified but if-range etag does not match',
+        function(headers) {
+          headers['if-range'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() + 1}"`
+          headers['range'] = 'bytes=1000-2000'
+        }
+      ],
+      [
+        'if range is specified but if-range modified by is older',
+        function(headers) {
+          headers['if-range'] = `${new Date(roundedModified.getTime() - 1000).toUTCString()}`
+          headers['range'] = 'bytes=1000-2000'
+        }
+      ],
+      [
+        'if range is specified but if-range is garbage',
+        function(headers) {
+          headers['if-range'] = `asdf`
+          headers['range'] = 'bytes=1000-2000'
+        }
+      ],
+    ]
  
-  let tests = [
-    [
-      'if no range',
-      function() {},
-    ],
-    [
-      'if range start is higher than end',
-      function(headers) { headers['range'] = 'bytes=2000-1000' },
-    ],
-    [
-      'if pre-condition if-match passes',
-      function(headers) { headers['if-match'] = assertEtag },
-    ],
-    [
-      'if pre-condition if-unmodified-since passes',
-      function(headers) { headers['if-unmodified-since'] = roundedModified.toUTCString(); },
-    ],
-    [
-      'if both pre-condition pass',
-      function(headers) { headers['if-unmodified-since'] = new Date(roundedModified.getTime() + 1000).toUTCString(); headers['if-match'] = assertEtag },
-    ],
-    [
-      'if range is specified but if-range etag does not match',
-      function(headers) {
-        headers['if-range'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() + 1}"`
-        headers['range'] = 'bytes=1000-2000'
-      }
-    ],
-    [
-      'if range is specified but if-range modified by is older',
-      function(headers) {
-        headers['if-range'] = `${new Date(roundedModified.getTime() - 1000).toUTCString()}`
-        headers['range'] = 'bytes=1000-2000'
-      }
-    ],
-    [
-      'if range is specified but if-range is garbage',
-      function(headers) {
-        headers['if-range'] = `asdf`
-        headers['range'] = 'bytes=1000-2000'
-      }
-    ],
-  ]
-
-  tests.forEach(function(test){
-    t.test('return fileReader ' + test[0], function() {
-      
-      const stubCreateReadStream = stub().returns(assertBody)
-      let ctx = createCtx()
-      test[1](ctx.req.headers)
-      ctx.body = new FileResponse(assertPath, stat)
-      let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
-  
-      assert.strictEqual(checkBody, assertBody)
-      assert.strictEqual(stubCreateReadStream.firstCall[0], assertPath)
-      assert.deepStrictEqual(stubCreateReadStream.firstCall[1], {})
-      assert.strictEqual(ctx.headers['Etag'], assertEtag)
-      assert.strictEqual(ctx.headers['Last-Modified'], assertmTime.toUTCString())
-      assert.strictEqual(ctx.headers['Content-Length'], assertSize)
-      assert.strictEqual(ctx.type, 'image/png')
-      assert.notOk(ctx.headers['Content-Range'])
-      assert.strictEqual(ctx.status, 200)
+    tests.forEach(function(test){
+      t.test(test[0], function() {
+        
+        const stubCreateReadStream = stub().returns(assertBody)
+        let ctx = createCtx()
+        test[1](ctx.req.headers)
+        ctx.body = new FileResponse(assertPath, stat)
+        let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+    
+        assert.strictEqual(checkBody, assertBody)
+        assert.strictEqual(stubCreateReadStream.firstCall[0], assertPath)
+        assert.deepStrictEqual(stubCreateReadStream.firstCall[1], {})
+        assert.strictEqual(ctx.headers['Etag'], assertEtag)
+        assert.strictEqual(ctx.headers['Last-Modified'], assertmTime.toUTCString())
+        assert.strictEqual(ctx.headers['Content-Length'], assertSize)
+        assert.strictEqual(ctx.type, 'image/png')
+        assert.notOk(ctx.headers['Content-Range'])
+        assert.strictEqual(ctx.status, 200)
+      })
    })
  })
-
+  
  t.test('return fileReader with proper length with range', function() {
    const assertPath = '/some/path/here.jpg'
    const assertBody = { a: 1 }
@ -120,6 +122,101 @@ t.describe('CreateReader()', function() {
    assert.strictEqual(ctx.status, 206)
  })

+  t.test('should not call createReadStream if HEAD request', function() {
+    const assertPath = '/some/path/here.png'
+    const assertNotBody = { a: 1 }
+    const assertSize = 12498
+    const assertmTime = new Date('2021-04-02T11:22:33.777')
+    const roundedModified = new Date('2021-04-02T11:22:33')
+    const assertIno = 3569723027
+    const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    
+    let tests = [
+      [
+        'if no range',
+        function() {},
+      ],
+      [
+        'if range start is higher than end',
+        function(headers) { headers['range'] = 'bytes=2000-1000' },
+      ],
+      [
+        'if pre-condition if-match passes',
+        function(headers) { headers['if-match'] = assertEtag },
+      ],
+      [
+        'if pre-condition if-unmodified-since passes',
+        function(headers) { headers['if-unmodified-since'] = roundedModified.toUTCString(); },
+      ],
+      [
+        'if both pre-condition pass',
+        function(headers) { headers['if-unmodified-since'] = new Date(roundedModified.getTime() + 1000).toUTCString(); headers['if-match'] = assertEtag },
+      ],
+      [
+        'if range is specified but if-range etag does not match',
+        function(headers) {
+          headers['if-range'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() + 1}"`
+          headers['range'] = 'bytes=1000-2000'
+        }
+      ],
+      [
+        'if range is specified but if-range modified by is older',
+        function(headers) {
+          headers['if-range'] = `${new Date(roundedModified.getTime() - 1000).toUTCString()}`
+          headers['range'] = 'bytes=1000-2000'
+        }
+      ],
+      [
+        'if range is specified but if-range is garbage',
+        function(headers) {
+          headers['if-range'] = `asdf`
+          headers['range'] = 'bytes=1000-2000'
+        }
+      ],
+    ]
+  
+    tests.forEach(function(test){
+      const stubCreateReadStream = stub().returns(assertNotBody)
+      let ctx = createCtx({
+        method: 'HEAD',
+      })
+      test[1](ctx.req.headers)
+      ctx.body = new FileResponse(assertPath, stat)
+      let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+  
+      assert.strictEqual(checkBody, null)
+      assert.notOk(stubCreateReadStream.called)
+      assert.strictEqual(ctx.headers['Etag'], assertEtag)
+      assert.strictEqual(ctx.headers['Last-Modified'], assertmTime.toUTCString())
+      assert.strictEqual(ctx.headers['Content-Length'], assertSize)
+      assert.strictEqual(ctx.type, 'image/png')
+      assert.notOk(ctx.headers['Content-Range'])
+      assert.strictEqual(ctx.status, 200)
+    })
+
+    const testStart = [0, 1000, 1999]
+    testStart.forEach(function(start) {
+      const stubCreateReadStream = stub()
+      let ctx = createCtx({
+        method: 'HEAD',
+      })
+      ctx.req.headers['range'] = 'bytes=' + start + '-'
+      ctx.body = new FileResponse('file.png', stat)
+      let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+      
+      assert.strictEqual(checkBody, null)
+      assert.notOk(stubCreateReadStream.called)
+      assert.strictEqual(ctx.headers['Content-Length'], assertSize - start)
+      assert.strictEqual(ctx.headers['Content-Range'], `${start}-${assertSize - 1}/${assertSize}`)
+      assert.strictEqual(ctx.status, 206)
+    })
+  })
+
  t.test('return fileReader with proper length with range and if-range passes', function() {
    const assertPath = '/some/path/here.jpg'
    const assertBody = { a: 1 }
--- a/test/flaska.api.test.mjs
+++ b/test/flaska.api.test.mjs
@ -50,7 +50,7 @@ t.describe('#constructor', function() {

    assert.strictEqual(ctx.headers['Server'], 'Flaska')
    assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
-    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; object-src 'none'; frame-ancestors 'none'`)
+    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'`)
    assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
    assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
    assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
@ -80,8 +80,7 @@ t.describe('#constructor', function() {
    flaska._before[0](ctx)
    
    let keys = Object.keys(defaultHeaders)
-    console.log(Object.keys(ctx.headers).sort())
-    console.log(keys.sort())
+
    assert.strictEqual(Object.keys(ctx.headers).length, keys.length + 1)
    for (let key of keys) {
      assert.strictEqual(ctx.headers[key], defaultHeaders[key])
@ -90,6 +89,38 @@ t.describe('#constructor', function() {

    assert.strictEqual(flaska._after.length, 0)
  })
+
+  t.test('should have before ready setting headers on context if appendHeaders is specified', function() {
+    const appendHeaders = {
+      'Server': 'nginx/1.16.1',
+      'Herp': 'Derp',
+    }
+    let flaska = new Flaska({
+      appendHeaders: appendHeaders,
+    }, faker)
+    assert.strictEqual(flaska._before.length, 1)
+
+    let ctx = {}
+
+    flaska._before[0](ctx)
+    
+    assert.deepEqual(
+      Object.keys(ctx.headers).sort(),
+      ['Server', 'Herp', 'X-Content-Type-Options','Content-Security-Policy','Cross-Origin-Opener-Policy','Cross-Origin-Resource-Policy','Cross-Origin-Embedder-Policy','Date'].sort()
+    )
+
+    assert.notStrictEqual(ctx.headers['Server'], 'Flaska')
+    assert.strictEqual(ctx.headers['Server'], appendHeaders.Server)
+    assert.strictEqual(ctx.headers['Herp'], 'Derp')
+    assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
+    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'`)
+    assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
+    assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
+    assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
+    assert.ok(new Date(ctx.headers['Date']).getDate())
+
+    assert.strictEqual(flaska._after.length, 0)
+  })
 })

 t.describe('#_nonce', function() {
@ -125,7 +156,7 @@ t.describe('#_nonce', function() {
    
    assert.strictEqual(ctx.headers['Server'], 'Flaska')
    assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
-    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline' 'nonce-${ctx.state.nonce}'; img-src * data: blob:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
+    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline' 'nonce-${ctx.state.nonce}'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
    assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
    assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
    assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
@ -143,7 +174,7 @@ t.describe('#_nonce', function() {
      let nextNonce = flaska._nonces[flaska._noncesIndex]
      flaska._before[0](ctx)
      assert.strictEqual(ctx.state.nonce, nextNonce)
-      assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
+      assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
    }

    assert.notOk(flaska._nonces[flaska._noncesIndex])
@ -157,7 +188,7 @@ t.describe('#_nonce', function() {
      assert.notStrictEqual(ctx.state.nonce, flaska._nonces[i])
    }

-    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
+    assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
  })

  t.test('should have after that regenerates lost hashes', function() {
@ -447,8 +478,8 @@ t.describe('_onreqerror', function() {
    let flaska = new Flaska({}, faker)
    let ctx = createCtx()
    flaska._onreqerror(assertError, ctx)
-    assert.strictEqual(ctx.log.info.callCount, 1)
-    assert.strictEqual(ctx.log.info.firstCall[0], assertError)
+    assert.strictEqual(ctx.log.info.callCount, 0)
+    assert.strictEqual(ctx.log.error.callCount, 0)
  })
 })

@ -914,6 +945,7 @@ t.describe('#listenAsync()', function() {
      checkIp = ip
      cb()
    })
+
    let flaska = new Flaska({}, testFaker)
    assert.ok(flaska.requestStart)
    flaska.requestStart = function() {
@ -925,7 +957,7 @@ t.describe('#listenAsync()', function() {
    assert.strictEqual(checkIp, assertIp)
  })

-  t.test('call http correctly if only port specified', async function() {
+  t.test('call http and listen correctly if only port specified', async function() {
    const assertPort = 325897235
    let checkPort = null
    let checkIp = null
@ -945,6 +977,55 @@ t.describe('#listenAsync()', function() {
    assert.strictEqual(checkPort, assertPort)
    assert.strictEqual(checkIp, '::')
  })
+  
+  t.test('call http and listenAsync correctly if supported', async function() {
+    const assertPort = 4632
+    const assertIp = 'asdf'
+    const assertReturns = { a: 1 }
+    const stubListenAsync = stub().resolves(assertReturns)
+
+    let flaska = new Flaska({}, {
+      createServer: function() {
+        return {
+          listenAsync: stubListenAsync,
+          on: stub(),
+        }
+      }
+    })
+    assert.ok(flaska.requestStart)
+    flaska.requestStart = function() {
+      checkInternalThis = this
+      checkIsTrue = true
+    }
+    let res = await flaska.listenAsync(assertPort, assertIp)
+    assert.strictEqual(res, assertReturns)
+    assert.strictEqual(stubListenAsync.firstCall[0], assertPort)
+    assert.strictEqual(stubListenAsync.firstCall[1], assertIp)
+  })
+  
+  t.test('call http and listenAsync correctly if supported and ip is null', async function() {
+    const assertPort = 325897235
+    const assertReturns = { a: 1 }
+    const stubListenAsync = stub().resolves(assertReturns)
+
+    let flaska = new Flaska({}, {
+      createServer: function() {
+        return {
+          listenAsync: stubListenAsync,
+          on: stub(),
+        }
+      }
+    })
+    assert.ok(flaska.requestStart)
+    flaska.requestStart = function() {
+      checkInternalThis = this
+      checkIsTrue = true
+    }
+    let res = await flaska.listenAsync(assertPort)
+    assert.strictEqual(res, assertReturns)
+    assert.strictEqual(stubListenAsync.firstCall[0], assertPort)
+    assert.strictEqual(stubListenAsync.firstCall[1], '::')
+  })

  t.test('register requestStart if no async', async function() {
    let checkIsTrue = false
--- a/test/flaska.in.test.mjs
+++ b/test/flaska.in.test.mjs
@ -19,42 +19,32 @@ t.describe('#requestStart()', function() {
    flaska.onreserror(onResError)
    flaska.requestEnded = onEnded

-    flaska.requestEnd = function(err, ctx) {
-      try {
-        assert.ok(err)
-        assert.strictEqual(assertReq.on.callCount, 2)
-        assert.strictEqual(assertRes.on.callCount, 2)
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.strictEqual(assertReq.on.callCount, 1)
+      assert.strictEqual(assertRes.on.callCount, 2)

+      assert.strictEqual(assertRes.on.firstCall[0], 'error')
+      assert.strictEqual(typeof(assertRes.on.firstCall[1]), 'function')
+      assertRes.on.firstCall[1](assertErrorTwo, ctx)
+      assert.strictEqual(onResError.callCount, 1)
+      assert.strictEqual(onResError.firstCall[0], assertErrorTwo)
+      assert.strictEqual(onResError.firstCall[1], ctx)
+      
+      assert.strictEqual(assertRes.on.secondCall[0], 'finish')
+      assert.strictEqual(typeof(assertRes.on.secondCall[1]), 'function')
+      assert.strictEqual(onEnded.callCount, 0)
+      assertRes.on.secondCall[1]()
+      assert.strictEqual(onEnded.callCount, 1)
+      assert.strictEqual(onEnded.firstCall[0], ctx)

-        assert.strictEqual(assertRes.on.firstCall[0], 'error')
-        assert.strictEqual(typeof(assertRes.on.firstCall[1]), 'function')
-        assertRes.on.firstCall[1](assertErrorTwo, ctx)
-        assert.strictEqual(onResError.callCount, 1)
-        assert.strictEqual(onResError.firstCall[0], assertErrorTwo)
-        assert.strictEqual(onResError.firstCall[1], ctx)
-        
-        assert.strictEqual(assertRes.on.secondCall[0], 'finish')
-        assert.strictEqual(typeof(assertRes.on.secondCall[1]), 'function')
-        assert.strictEqual(onEnded.callCount, 0)
-        assertRes.on.secondCall[1]()
-        assert.strictEqual(onEnded.callCount, 1)
-        assert.strictEqual(onEnded.firstCall[0], ctx)
-
-        assert.strictEqual(assertReq.on.firstCall[0], 'error')
-        assert.strictEqual(typeof(assertReq.on.firstCall[1]), 'function')
-        assertReq.on.firstCall[1](assertErrorOne, ctx)
-        assert.strictEqual(onReqError.callCount, 1)
-        assert.strictEqual(onReqError.firstCall[0], assertErrorOne)
-        assert.strictEqual(onReqError.firstCall[1], ctx)
-        
-        assert.strictEqual(assertReq.on.secondCall[0], 'close')
-        assert.strictEqual(typeof(assertReq.on.secondCall[1]), 'function')
-
-        // Test abort and close
-
-        cb()
-      } catch (err) { cb(err) }
-    }
+      assert.strictEqual(assertReq.on.firstCall[0], 'error')
+      assert.strictEqual(typeof(assertReq.on.firstCall[1]), 'function')
+      assertReq.on.firstCall[1](assertErrorOne, ctx)
+      assert.strictEqual(onReqError.callCount, 1)
+      assert.strictEqual(onReqError.firstCall[0], assertErrorOne)
+      assert.strictEqual(onReqError.firstCall[1], ctx)
+    })
    flaska._beforeCompiled = function(ctx) {
      throw new Error()
    }
@ -68,18 +58,13 @@ t.describe('#requestStart()', function() {
    const assertRes = createRes({ b: 2 })
    let flaska = new Flaska({}, faker)

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.strictEqual(err, assertError)
-        assert.deepStrictEqual(ctx.state, {})
-        assert.strictEqual(ctx.req, assertReq)
-        assert.strictEqual(ctx.res, assertRes)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.strictEqual(err, assertError)
+      assert.deepStrictEqual(ctx.state, {})
+      assert.strictEqual(ctx.req, assertReq)
+      assert.strictEqual(ctx.res, assertRes)
+    })
    flaska._beforeCompiled = function(ctx) {
      assert.strictEqual(ctx.req, assertReq)
      assert.strictEqual(ctx.res, assertRes)
@ -102,18 +87,13 @@ t.describe('#requestStart()', function() {
      return Promise.resolve().then(function() { return Promise.reject(assertError) })
    }

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.strictEqual(err, assertError)
-        assert.deepStrictEqual(ctx.state, {})
-        assert.strictEqual(ctx.req, assertReq)
-        assert.strictEqual(ctx.res, assertRes)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.strictEqual(err, assertError)
+      assert.deepStrictEqual(ctx.state, {})
+      assert.strictEqual(ctx.req, assertReq)
+      assert.strictEqual(ctx.res, assertRes)
+    })

    flaska.requestStart(assertReq, assertRes)
  })
@ -135,39 +115,35 @@ t.describe('#requestStart()', function() {
      }
    }

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
+    flaska.requestEnd = cb.finish(function(err, ctx) {

-      try {
-        assert.ok(err)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx.url, assertPath)
-        assert.strictEqual(ctx.search, assertSearch)
-        assert.strictEqual(ctx.method, assertMethod)
-        assert.strictEqual(ctx.status, 200)
-        assert.strictEqual(ctx.body, null)
-        assert.strictEqual(ctx.type, null)
-        assert.strictEqual(ctx.length, null)
-        assert.strictEqual(ctx.log, assertLog)
-        assert.ok(ctx.query)
-        assert.ok(ctx.query.get)
-        assert.ok(ctx.query.set)
-        assert.ok(ctx.query.delete)
-        assert.deepEqual(
-          Object.keys(ctx.headers).sort(),
-          ['Server','X-Content-Type-Options','Content-Security-Policy','Cross-Origin-Opener-Policy','Cross-Origin-Resource-Policy','Cross-Origin-Embedder-Policy','Date'].sort()
-        )
+      assert.ok(err)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx.url, assertPath)
+      assert.strictEqual(ctx.search, assertSearch)
+      assert.strictEqual(ctx.method, assertMethod)
+      assert.strictEqual(ctx.status, 200)
+      assert.strictEqual(ctx.body, null)
+      assert.strictEqual(ctx.type, null)
+      assert.strictEqual(ctx.length, null)
+      assert.strictEqual(ctx.log, assertLog)
+      assert.ok(ctx.query)
+      assert.ok(ctx.query.get)
+      assert.ok(ctx.query.set)
+      assert.ok(ctx.query.delete)
+      assert.deepEqual(
+        Object.keys(ctx.headers).sort(),
+        ['Server','X-Content-Type-Options','Content-Security-Policy','Cross-Origin-Opener-Policy','Cross-Origin-Resource-Policy','Cross-Origin-Embedder-Policy','Date'].sort()
+      )

-        assert.strictEqual(ctx.headers['Server'], 'Flaska')
-        assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
-        assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; object-src 'none'; frame-ancestors 'none'`)
-        assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
-        assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
-        assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
-        assert.ok(new Date(ctx.headers['Date']).getDate())
-        cb()
-      } catch (err) { cb(err) }
-    }
+      assert.strictEqual(ctx.headers['Server'], 'Flaska')
+      assert.strictEqual(ctx.headers['X-Content-Type-Options'], 'nosniff')
+      assert.strictEqual(ctx.headers['Content-Security-Policy'], `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src * data: blob:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'`)
+      assert.strictEqual(ctx.headers['Cross-Origin-Opener-Policy'], 'same-origin')
+      assert.strictEqual(ctx.headers['Cross-Origin-Resource-Policy'], 'same-origin')
+      assert.strictEqual(ctx.headers['Cross-Origin-Embedder-Policy'], 'require-corp')
+      assert.ok(new Date(ctx.headers['Date']).getDate())
+    })

    flaska.requestStart(createReq({
      url: assertPath + assertSearch,
@ -192,21 +168,16 @@ t.describe('#requestStart()', function() {
      }
    }

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.strictEqual(err, assertError)
-        let keys = Object.keys(defaultHeaders)
-        assert.strictEqual(Object.keys(ctx.headers).length, keys.length + 1)
-        for (let key of keys) {
-          assert.strictEqual(ctx.headers[key], defaultHeaders[key])
-        }
-        assert.ok(ctx.headers['Date'])
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.strictEqual(err, assertError)
+      let keys = Object.keys(defaultHeaders)
+      assert.strictEqual(Object.keys(ctx.headers).length, keys.length + 1)
+      for (let key of keys) {
+        assert.strictEqual(ctx.headers[key], defaultHeaders[key])
+      }
+      assert.ok(ctx.headers['Date'])
+    })

    flaska.requestStart(createReq({
      url: '/',
@ -219,9 +190,13 @@ t.describe('#requestStart()', function() {
    const assertMethod = 'test'
    const assertPath = '/test/me'
    const assertSearch = '?asdf=test'
+    let calledBefore = false
    let flaska = new Flaska({}, faker)
    flaska.compile()
-    flaska._beforeAsyncCompiled = function() { return Promise.resolve() }
+    flaska._beforeAsyncCompiled = function() {
+      calledBefore = true
+      return Promise.resolve()
+    }

    flaska.routers.test = {
      match: function(path) {
@ -230,18 +205,14 @@ t.describe('#requestStart()', function() {
      }
    }

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx.url, assertPath)
-        assert.strictEqual(ctx.search, assertSearch)
-        assert.strictEqual(ctx.method, assertMethod)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(calledBefore)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx.url, assertPath)
+      assert.strictEqual(ctx.search, assertSearch)
+      assert.strictEqual(ctx.method, assertMethod)
+    })

    flaska.requestStart(createReq({
      url: assertPath + assertSearch,
@ -272,18 +243,13 @@ t.describe('#requestStart()', function() {
      throw assertError
    }

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx, checkMiddleCtx)
-        assert.strictEqual(ctx.params, assertParams)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(ctx)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx, checkMiddleCtx)
+      assert.strictEqual(ctx.params, assertParams)
+    })

    flaska.requestStart(createReq({
      url: '',
@ -304,17 +270,12 @@ t.describe('#requestStart()', function() {
    flaska.get('/:id', handler)
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx, checkHandlerCtx)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(ctx)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx, checkHandlerCtx)
+    })

    flaska.requestStart(createReq({
      url: '/test',
@ -334,16 +295,12 @@ t.describe('#requestStart()', function() {
    flaska.get('/test', function() { throw new Error('should not be called') })
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err) return cb(err)
-
-      try {
-        assert.ok(ctx)
-        assert.strictEqual(on404Error.callCount, 1)
-        assert.strictEqual(on404Error.firstCall[0], ctx)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.notOk(err)
+      assert.ok(ctx)
+      assert.strictEqual(on404Error.callCount, 1)
+      assert.strictEqual(on404Error.firstCall[0], ctx)
+    })

    flaska.requestStart(createReq({
      url: '/nope',
@ -364,17 +321,11 @@ t.describe('#requestStart()', function() {
    flaska.get('/test', function() { throw new Error('should not be called') })
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(ctx, checkCtx)
-        assert.strictEqual(err, assertError)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.strictEqual(err, assertError)
+      assert.ok(ctx)
+      assert.strictEqual(ctx, checkCtx)
+    })

    flaska.requestStart(createReq({
      url: '/nope',
@ -394,17 +345,11 @@ t.describe('#requestStart()', function() {
    flaska.get('/test', function() { throw new Error('should not be called') })
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(ctx, checkCtx)
-        assert.strictEqual(err, assertError)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.strictEqual(err, assertError)
+      assert.ok(ctx)
+      assert.strictEqual(ctx, checkCtx)
+    })

    flaska.requestStart(createReq({
      url: '/nope',
@ -424,17 +369,11 @@ t.describe('#requestStart()', function() {
    flaska.get('/test', middles, function() { throw new Error('should not be called') })
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(ctx, checkCtx)
-        assert.strictEqual(err, assertError)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.strictEqual(err, assertError)
+      assert.ok(ctx)
+      assert.strictEqual(ctx, checkCtx)
+    })

    flaska.requestStart(createReq({
      url: '/test',
@ -456,14 +395,11 @@ t.describe('#requestStart()', function() {
      throw new Error('should not be called')
    }

-    flaska.requestEnd = function(err, ctx) {
-      try {
-        assert.notOk(err)
-        assert.ok(ctx)
-        assert.strictEqual(ctx.body, assertBody)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.notOk(err)
+      assert.ok(ctx)
+      assert.strictEqual(ctx.body, assertBody)
+    })

    flaska.requestStart(createReq({
      url: '/test/something/here',
@ -488,16 +424,11 @@ t.describe('#requestStart()', function() {
      return Promise.resolve().then(function() { return Promise.reject(assertError) })
    }

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(err, assertError)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(ctx)
+      assert.strictEqual(err, assertError)
+    })

    flaska.requestStart(createReq({
      url: '',
@ -518,17 +449,12 @@ t.describe('#requestStart()', function() {
    flaska.get('/:id', [function() { return Promise.resolve() }], handler)
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx, checkHandlerCtx)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(ctx)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx, checkHandlerCtx)
+    })

    flaska.requestStart(createReq({
      url: '/test',
@ -549,17 +475,12 @@ t.describe('#requestStart()', function() {
    flaska.get('/:id', [function() { return Promise.resolve() }], handler)
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx, checkHandlerCtx)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(ctx)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx, checkHandlerCtx)
+    })

    flaska.requestStart(createReq({
      url: '/test',
@ -588,15 +509,12 @@ t.describe('#requestStart()', function() {
    flaska.get('/::path', [middle], handler)
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      try {
+    flaska.requestEnd = cb.finish(function(err, ctx) {
        assert.notOk(err)
        assert.ok(ctx)
        assert.strictEqual(ctx.body, assertBody)
        assert.strictEqual(ctx.state, assertState)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    })

    flaska.requestStart(createReq({
      url: '/test/something/here',
@ -619,17 +537,12 @@ t.describe('#requestStart()', function() {
    flaska.get('/:id', handler)
    flaska.compile()

-    flaska.requestEnd = function(err, ctx) {
-      if (err && err !== assertError) return cb(err)
-
-      try {
-        assert.ok(err)
-        assert.ok(ctx)
-        assert.strictEqual(err, assertError)
-        assert.strictEqual(ctx, checkHandlerCtx)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.ok(err)
+      assert.ok(ctx)
+      assert.strictEqual(err, assertError)
+      assert.strictEqual(ctx, checkHandlerCtx)
+    })

    flaska.requestStart(createReq({
      url: '/test',
@ -654,14 +567,11 @@ t.describe('#requestStart()', function() {
      throw new Error('should not be called')
    }

-    flaska.requestEnd = function(err, ctx) {
-      try {
-        assert.notOk(err)
-        assert.ok(ctx)
-        assert.strictEqual(ctx.body, assertBody)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    flaska.requestEnd = cb.finish(function(err, ctx) {
+      assert.notOk(err)
+      assert.ok(ctx)
+      assert.strictEqual(ctx.body, assertBody)
+    })

    flaska.requestStart(createReq({
      url: '/test/something/here',
--- a/test/flaska.out.test.mjs
+++ b/test/flaska.out.test.mjs
@ -12,20 +12,17 @@ t.describe('#requestEnd()', function() {
    const assertStatus = 501
    // Calculated manually just in case
    const assertBodyLength = 7
-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.body, assertBody)
-        assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
-        assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, '{"a":1}')
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    let onFinish = cb.finish(function(body) {
+      assert.strictEqual(ctx.status, assertStatus)
+      assert.strictEqual(ctx.body, assertBody)
+      assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
+      assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
+      assert.ok(body)
+      assert.strictEqual(body, '{"a":1}')
+      assert.ok(ctx.res.writeHead.called)
+      assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+      assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+    })
    const ctx = createCtx({}, onFinish)

    let flaska = new Flaska({}, fakerHttp, fakeStream)
@ -43,14 +40,11 @@ t.describe('#requestEnd()', function() {
    const assertErrorNotSeen = new Error('should not be seen')
    const assertError = new Error('test')

-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, 500)
-        assert.strictEqual(ctx.body.status, 500)
-        assert.strictEqual(ctx.body.message, 'Internal Server Error')
-        cb()
-      } catch (err) { cb(err) }
-    }
+    let onFinish = cb.finish(function(body) {
+      assert.strictEqual(ctx.status, 500)
+      assert.strictEqual(ctx.body.status, 500)
+      assert.strictEqual(ctx.body.message, 'Internal Server Error')
+    })
    const ctx = createCtx({}, onFinish)

    let flaska = new Flaska({}, fakerHttp, fakeStream)
@ -61,110 +55,326 @@ t.describe('#requestEnd()', function() {
    flaska.requestEnd(assertErrorNotSeen, ctx)
  })

-  t.test('call res and end correctly when dealing with objects', function(cb) {
-    const assertStatus = 202
-    // Calculated manually just in case
-    const assertBodyLength = 7
-    const assertBody = { a: 1 }
-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.body, assertBody)
-        assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
-        assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, '{"a":1}')
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
-    const ctx = createCtx({
-      status: assertStatus,
-    }, onFinish)
-    ctx.body = assertBody
-
-    let flaska = new Flaska({}, fakerHttp, fakeStream)
-    flaska.requestEnd(null, ctx)
-  })
+  let testMethods = ['GET', 'HEAD']
  
-  t.test('call res and end correctly when dealing with strings', function(cb) {
-    const assertStatus = 206
-    // Calculated manually just in case
-    const assertBodyLength = 4
-    const assertBody = 'eða'
-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.body, assertBody)
-        assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
-        assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, assertBody)
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
-    const ctx = createCtx({
-      status: assertStatus,
-    }, onFinish)
-    ctx.body = assertBody
+  testMethods.forEach(function(method) {
+    t.describe(method, function() {
+      t.test('call res and end correctly when dealing with objects', function(cb) {
+        const assertStatus = 202
+        // Calculated manually just in case
+        const assertBodyLength = 7
+        const assertBody = { a: 1 }
+        let onFinish = cb.finish(function(body) {
+          assert.strictEqual(ctx.status, assertStatus)
+          assert.strictEqual(ctx.body, assertBody)
+          assert.strictEqual(ctx.headers['Content-Type'], 'application/json; charset=utf-8')
+          assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)

-    let flaska = new Flaska({}, fakerHttp, fakeStream)
-    flaska.requestEnd(null, ctx)
-  })
-  
-  t.test('call res and end correctly when dealing with numbers', function(cb) {
-    const assertStatus = 211
-    // Calculated manually just in case
-    const assertBodyLength = 7
-    const assertBody = 4214124
-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.body, assertBody)
-        assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
-        assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, assertBody.toString())
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
-    const ctx = createCtx({
-      status: assertStatus,
-    }, onFinish)
-    ctx.body = assertBody
+          if (method === 'GET') {
+            assert.ok(body)
+            assert.strictEqual(body, '{"a":1}')
+          } else {
+            assert.notOk(body)
+          }

-    let flaska = new Flaska({}, fakerHttp, fakeStream)
-    flaska.requestEnd(null, ctx)
-  })
+          assert.ok(ctx.res.writeHead.called)
+          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        })
+        const ctx = createCtx({
+          method: method,
+          status: assertStatus,
+        }, onFinish)
+        ctx.body = assertBody
+    
+        let flaska = new Flaska({}, fakerHttp, fakeStream)
+        flaska.requestEnd(null, ctx)
+      })

-  t.test('call handleRequest if body contains it', function() {
-    let body = new FileResponse()
-    let assertBody = { a : 1 }
-    const ctx = createCtx({
-      status: 204,
+      t.test('call res and end correctly when dealing with buffers', function(cb) {
+        const assertStatus = 202
+        // Calculated manually just in case
+        const assertBodyLength = 11
+        const assertBody = Buffer.from('hello world')
+        let onFinish = cb.finish(function(body) {
+          assert.strictEqual(ctx.status, assertStatus)
+          assert.strictEqual(ctx.body, assertBody)
+          assert.strictEqual(ctx.headers['Content-Type'], 'application/octet-stream')
+          assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
+
+          if (method === 'GET') {
+            assert.ok(body)
+            assert.strictEqual(body, assertBody)
+          } else {
+            assert.notOk(body)
+          }
+
+          assert.ok(ctx.res.writeHead.called)
+          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        })
+        const ctx = createCtx({
+          method: method,
+          status: assertStatus,
+        }, onFinish)
+        ctx.body = assertBody
+    
+        let flaska = new Flaska({}, fakerHttp, fakeStream)
+        flaska.requestEnd(null, ctx)
+      })
+
+      t.test('call res and end correctly when dealing with null and no status override', function(cb) {
+        // Calculated manually just in case
+        const assertBodyLength = 0
+        const assertBody = null
+        let onFinish = cb.finish(function(body) {
+          assert.strictEqual(ctx.status, 204)
+          assert.strictEqual(ctx.body, assertBody)
+          assert.notOk(ctx.headers['Content-Type'])
+          assert.notOk(ctx.headers['Content-Length'])
+
+          assert.strictEqual(body, undefined)
+
+          assert.ok(ctx.res.writeHead.called)
+          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        })
+        const ctx = createCtx({
+          method: method,
+          status: 200,
+        }, onFinish)
+        ctx.body = assertBody
+    
+        let flaska = new Flaska({}, fakerHttp, fakeStream)
+        flaska.requestEnd(null, ctx)
+      })
+      
+      t.test('call res and end correctly when dealing with null and status override', function(cb) {
+        const assertStatus = 202
+        // Calculated manually just in case
+        const assertBody = null
+        let onFinish = cb.finish(function(body) {
+          assert.strictEqual(ctx.status, assertStatus)
+          assert.strictEqual(ctx.body, assertBody)
+          assert.notOk(ctx.headers['Content-Type'])
+          assert.strictEqual(ctx.headers['Content-Length'], 0)
+
+          assert.strictEqual(body, undefined)
+
+          assert.ok(ctx.res.writeHead.called)
+          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        })
+        const ctx = createCtx({
+          method: method,
+          status: assertStatus,
+        }, onFinish)
+        ctx.body = assertBody
+    
+        let flaska = new Flaska({}, fakerHttp, fakeStream)
+        flaska.requestEnd(null, ctx)
+      })
+      
+      t.test('call res and end correctly when dealing with strings', function(cb) {
+        const assertStatus = 206
+        // Calculated manually just in case
+        const assertBodyLength = 4
+        const assertBody = 'eða'
+        let onFinish = cb.finish(function(body) {
+          assert.strictEqual(ctx.status, assertStatus)
+          assert.strictEqual(ctx.body, assertBody)
+          assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
+          assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
+
+          if (method === 'GET') {
+            assert.ok(body)
+            assert.strictEqual(body, assertBody)
+          } else {
+            assert.notOk(body)
+          }
+
+          assert.ok(ctx.res.writeHead.called)
+          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        })
+        const ctx = createCtx({
+          method: method,
+          status: assertStatus,
+        }, onFinish)
+        ctx.body = assertBody
+    
+        let flaska = new Flaska({}, fakerHttp, fakeStream)
+        flaska.requestEnd(null, ctx)
+      })
+      
+      t.test('call res and end correctly when dealing with numbers', function(cb) {
+        const assertStatus = 211
+        // Calculated manually just in case
+        const assertBodyLength = 7
+        const assertBody = 4214124
+        let onFinish = cb.finish(function(body) {
+          assert.strictEqual(ctx.status, assertStatus)
+          assert.strictEqual(ctx.body, assertBody)
+          assert.strictEqual(ctx.headers['Content-Type'], 'text/plain; charset=utf-8')
+          assert.strictEqual(ctx.headers['Content-Length'], assertBodyLength)
+
+          if (method === 'GET') {
+            assert.ok(body)
+            assert.strictEqual(body, assertBody.toString())
+          } else {
+            assert.notOk(body)
+          }
+          assert.ok(ctx.res.writeHead.called)
+          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        })
+        const ctx = createCtx({
+          method: method,
+          status: assertStatus,
+        }, onFinish)
+        ctx.body = assertBody
+    
+        let flaska = new Flaska({}, fakerHttp, fakeStream)
+        flaska.requestEnd(null, ctx)
+      })
+    
+      if (method === 'GET') {
+        t.test('call handleRequest if body contains it', function(cb) {
+          const assertContentType = 'test/test'
+          const assertContentLength = 1241241
+          const assertHandle = stub().returnWith(function(checkCtx, secondary) {
+            assert.notOk(secondary)
+            assert.strictEqual(checkCtx, ctx)
+            assert.notOk(ctx.res.writeHead.called)
+            ctx.type = assertContentType
+            ctx.headers['Content-Length'] = assertContentLength
+            return assertBody
+          })
+
+          let body = new FileResponse()
+          let assertBody = { pipe: function() {} }
+          let onFinish = cb.finish(function(source, target, callback) {
+            assert.ok(assertHandle.called)
+            assert.ok(ctx.res.writeHead)
+            assert.strictEqual(ctx.body, assertBody)
+            assert.strictEqual(source, assertBody)
+            assert.strictEqual(target, ctx.res)
+            assert.strictEqual(typeof(callback), 'function')
+            assert.ok(ctx.res.writeHead.called)
+            assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+            assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+            assert.strictEqual(ctx.headers['Content-Type'], assertContentType)
+            assert.strictEqual(ctx.headers['Content-Length'], assertContentLength)
+          })
+          const ctx = createCtx({
+          })
+          ctx.body = body
+          fakeStream.pipeline = onFinish
+          body.handleRequest = assertHandle
+      
+          let flaska = new Flaska({}, fakerHttp, fakeStream)
+
+          try {
+            flaska.requestEnd(null, ctx)
+          } catch (err) {
+            cb(err)
+          }
+        })
+
+        t.test('call pipeline correctly when dealing with pipe', function(cb) {
+          const assertStatus = 211
+          const assertType = 'herp/derp'
+          const assertBody = { pipe: function() {} }
+
+          let onFinish = cb.finish(function(source, target, callback) {
+            assert.strictEqual(ctx.status, assertStatus)
+            assert.strictEqual(ctx.headers['Content-Type'], assertType)
+            assert.strictEqual(source, assertBody)
+            assert.strictEqual(target, ctx.res)
+            assert.strictEqual(typeof(callback), 'function')
+            assert.ok(ctx.res.writeHead.called)
+            assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+            assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+          })
+          const ctx = createCtx({
+            status: assertStatus,
+          })
+          fakeStream.pipeline = onFinish
+
+          ctx.body = assertBody
+          ctx.type = assertType
+          let flaska = new Flaska({}, fakerHttp, fakeStream)
+          flaska.requestEnd(null, ctx)
+        })
+      } else {
+        t.test('call handleRequest if body contains it', function(cb) {
+          const assertContentType = 'test/test'
+          const assertContentLength = 1241241
+          const assertHandle = stub().returnWith(function(checkCtx, secondary) {
+            assert.notOk(secondary)
+            assert.strictEqual(checkCtx, ctx)
+            assert.notOk(ctx.res.writeHead.called)
+            ctx.type = assertContentType
+            ctx.headers['Content-Length'] = assertContentLength
+            return null
+          })
+
+          let body = new FileResponse()
+          let onFinish = cb.finish(function(body) {
+            assert.ok(assertHandle.called)
+            assert.ok(ctx.res.writeHead)
+            assert.strictEqual(ctx.body, null)
+            assert.notOk(body)
+            assert.ok(ctx.res.writeHead.called)
+            assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+            assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+            assert.strictEqual(ctx.headers['Content-Type'], assertContentType)
+            assert.strictEqual(ctx.headers['Content-Length'], assertContentLength)
+          })
+
+          const ctx = createCtx({
+            method: method,
+          }, onFinish)
+          ctx.body = body
+          body.handleRequest = assertHandle
+      
+          let flaska = new Flaska({}, fakerHttp, fakeStream)
+
+          try {
+            flaska.requestEnd(null, ctx)
+          } catch (err) {
+            cb(err)
+          }
+        })
+
+        t.test('call pipeline correctly when dealing with pipe', function(cb) {
+          const assertStatus = 211
+          const assertType = 'herp/derp'
+          const assertBody = { pipe: function() {}, destroy: stub() }
+
+          let onFinish = cb.finish(function(body) {
+            assert.strictEqual(ctx.status, assertStatus)
+            assert.strictEqual(ctx.headers['Content-Type'], assertType)
+            assert.notOk(ctx.headers['Content-Length'])
+            assert.notOk(body)
+            
+            assert.ok(assertBody.destroy.called)
+            assert.ok(ctx.res.writeHead.called)
+            assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+            assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+          })
+          const ctx = createCtx({
+            method: method,
+            status: assertStatus,
+          }, onFinish)
+
+          ctx.body = assertBody
+          ctx.type = assertType
+          let flaska = new Flaska({}, fakerHttp, fakeStream)
+          flaska.requestEnd(null, ctx)
+        })
+      }
    })
-    ctx.body = body
-    const assertHandle = stub().returnWith(function(checkCtx, secondary) {
-      assert.notOk(secondary)
-      assert.strictEqual(checkCtx, ctx)
-      assert.notOk(ctx.res.writeHead.called)
-      return assertBody
-    })
-    body.handleRequest = assertHandle
-
-    let flaska = new Flaska({}, fakerHttp, fakeStream)
-    flaska.requestEnd(null, ctx)
-    assert.ok(assertHandle.called)
-    assert.ok(ctx.res.writeHead)
-    assert.strictEqual(ctx.body, assertBody)
  })
  
  t.test('call _onerror with error if handleRequest throws error', function() {
@ -195,17 +405,14 @@ t.describe('#requestEnd()', function() {
    const assertStatus = 209
    const assertBody = 'test'
    const assertType = 'something/else'
-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.headers['Content-Type'], assertType)
-        assert.strictEqual(body, assertBody)
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    let onFinish = cb.finish(function(body) {
+      assert.strictEqual(ctx.status, assertStatus)
+      assert.strictEqual(ctx.headers['Content-Type'], assertType)
+      assert.strictEqual(body, assertBody)
+      assert.ok(ctx.res.writeHead.called)
+      assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+      assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+    })
    const ctx = createCtx({
      status: assertStatus,
      body: assertBody,
@ -216,48 +423,16 @@ t.describe('#requestEnd()', function() {
    flaska.requestEnd(null, ctx)
  })

-  t.test('call pipeline correctly when dealing with pipe', function(cb) {
-    const assertStatus = 211
-    const assertType = 'herp/derp'
-    const assertBody = { pipe: function() {} }
-
-    let onFinish = function(source, target, callback) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.headers['Content-Type'], assertType)
-        assert.strictEqual(source, assertBody)
-        assert.strictEqual(target, ctx.res)
-        assert.strictEqual(typeof(callback), 'function')
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
-    const ctx = createCtx({
-      status: assertStatus,
-    })
-    fakeStream.pipeline = onFinish
-
-    ctx.body = assertBody
-    ctx.type = assertType
-    let flaska = new Flaska({}, fakerHttp, fakeStream)
-    flaska.requestEnd(null, ctx)
-  })
-
  t.test('call pipe should have default type', function(cb) {
-    let onFinish = function(source, target) {
-      try {
-        assert.strictEqual(ctx.status, 200)
-        assert.strictEqual(ctx.headers['Content-Type'], 'application/octet-stream')
-        assert.strictEqual(source, ctx.body)
-        assert.strictEqual(target, ctx.res)
-        assert.ok(ctx.res.writeHead.called)
-        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-        cb()
-      } catch (err) { cb(err) }
-    }
+    let onFinish = cb.finish(function(source, target) {
+      assert.strictEqual(ctx.status, 200)
+      assert.strictEqual(ctx.headers['Content-Type'], 'application/octet-stream')
+      assert.strictEqual(source, ctx.body)
+      assert.strictEqual(target, ctx.res)
+      assert.ok(ctx.res.writeHead.called)
+      assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+      assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+    })
    const ctx = createCtx({})
    ctx.body = { pipe: function() {} }
    fakeStream.pipeline = onFinish
@ -275,18 +450,15 @@ t.describe('#requestEnd()', function() {

  tests.forEach(function(test) {
    t.test(`call pipe with file extension ${test[0]} should mimetype ${test[1]}`, function(cb) {
-      let onFinish = function(source, target) {
-        try {
-          assert.strictEqual(ctx.status, 200)
-          assert.strictEqual(ctx.headers['Content-Type'], test[1])
-          assert.strictEqual(source, ctx.body)
-          assert.strictEqual(target, ctx.res)
-          assert.ok(ctx.res.writeHead.called)
-          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-          cb()
-        } catch (err) { cb(err) }
-      }
+      let onFinish = cb.finish(function(source, target) {
+        assert.strictEqual(ctx.status, 200)
+        assert.strictEqual(ctx.headers['Content-Type'], test[1])
+        assert.strictEqual(source, ctx.body)
+        assert.strictEqual(target, ctx.res)
+        assert.ok(ctx.res.writeHead.called)
+        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+      })
      const ctx = createCtx({})
      ctx.body = { pipe: function() {}, path: './bla/test/temp.' + test[0] }
      fakeStream.pipeline = onFinish
@ -314,17 +486,14 @@ t.describe('#requestEnd()', function() {
      const assertStatus = status
      const assertNotBody = 'test'
      const assertNotType = 'something/else'
-      let onFinish = function(body) {
-        try {
-          assert.strictEqual(ctx.status, assertStatus)
-          assert.strictEqual(ctx.res.setHeader.callCount, 0)
-          assert.ok(ctx.res.writeHead.called)
-          assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
-          assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
-          assert.notOk(body)
-          cb()
-        } catch (err) { cb(err) }
-      }
+      let onFinish = cb.finish(function(body) {
+        assert.strictEqual(ctx.status, assertStatus)
+        assert.strictEqual(ctx.res.setHeader.callCount, 0)
+        assert.ok(ctx.res.writeHead.called)
+        assert.strictEqual(ctx.res.writeHead.firstCall[0], ctx.status)
+        assert.strictEqual(ctx.res.writeHead.firstCall[1], ctx.headers)
+        assert.notOk(body)
+      })
      const ctx = createCtx({
        status: assertStatus,
        body: assertNotBody,
--- a/test/helper.mjs
+++ b/test/helper.mjs
@ -6,7 +6,7 @@ const indexMap = [
  'thirdCall',
 ]

-export function fakeHttp(inj1, inj2) {
+export function fakeHttp(inj1, inj2, inj3) {
  let intermediate = {
    createServer: function(cb) {
      if (inj1) inj1(cb)
@ -15,6 +15,9 @@ export function fakeHttp(inj1, inj2) {
        listen: function(port, ip, cb) {
          if (inj2) inj2(port, ip, cb)
          else if (cb) cb()
+        },
+        on: function(name, handler) {
+          if (inj3) inj3(name, handler)
        }
      }
    }
--- a/test/http.test.mjs
+++ b/test/http.test.mjs
@ -24,6 +24,11 @@ let reqBody = null
 let file = null
 let uploaded = []

+flaska.after(function(ctx) {
+  if (ctx.aborted) return
+  ctx.log.info(ctx.status)
+})
+
 flaska.get('/', function(ctx) {
  ctx.body = { status: true }
 })
@ -31,6 +36,12 @@ flaska.post('/json', JsonHandler(), function(ctx) {
  ctx.body = { success: true }
  reqBody = ctx.req.body
 })
+flaska.post('/json/slow', JsonHandler(), async function(ctx) {
+  await setTimeout(300)
+  ctx.body = { success: true }
+  ctx.status = 201
+  reqBody = ctx.req.body
+})
 flaska.get('/timeout', function(ctx) {
  return new Promise(function() {})
 })
@ -49,6 +60,13 @@ flaska.post('/file/upload', FormidableHandler(formidable, {
  uploaded.push(ctx.req.file)
  ctx.body = ctx.req.file
 })
+flaska.post('/file/upload/many', FormidableHandler(formidable, {
+  uploadDir: './test/upload',
+}), function(ctx) {
+  uploaded.push(ctx.req.files.herp)
+  uploaded.push(ctx.req.files.derp)
+  ctx.body = ctx.req.files
+})
 flaska.get('/file/leak', function(ctx) {
  file = fsSync.createReadStream('./test/test.png')
  ctx.body = file
@ -79,6 +97,9 @@ t.describe('/', function() {
 })

 t.describe('/json', function() {
+  t.beforeEach(function() {
+    log.info.reset()
+  })
  t.test('should return success and store body', async function() {
    const assertBody = { a: '' }
    for (let i = 0; i < 1010; i++) {
@ -88,6 +109,21 @@ t.describe('/json', function() {
    let body = await client.post('/json', assertBody)
    assert.deepEqual(body, { success: true })
    assert.deepStrictEqual(reqBody, assertBody)
+    assert.strictEqual(log.info.callCount, 1)
+    assert.strictEqual(log.info.firstCall[0], 200)
+  })
+  
+  t.test('should return and log correctly', async function() {
+    const assertBody = { a: '' }
+    for (let i = 0; i < 1010; i++) {
+      assertBody.a += 'aaaaaaaaaa'
+    }
+    reqBody = null
+    let body = await client.post('/json/slow', assertBody)
+    assert.deepEqual(body, { success: true })
+    assert.deepStrictEqual(reqBody, assertBody)
+    assert.strictEqual(log.info.callCount, 1)
+    assert.strictEqual(log.info.firstCall[0], 201)
  })

  t.test('should fail if body is too big', async function() {
@ -109,15 +145,15 @@ t.describe('/json', function() {
  t.test('should fail if not a valid json', async function() {
    reset()

-    let err = await assert.isRejected(client.customRequest('POST', '/json', 'aaaa'))
+    let err = await assert.isRejected(client.customRequest('POST', '/json', 'XXXXX'))

    assert.strictEqual(err.body.status, 400)
    assert.match(err.body.message, /invalid json/i)
-    assert.match(err.body.message, /token a/i)
-    assert.strictEqual(err.body.request, 'aaaa')
+    assert.match(err.body.message, /token[^X]+X/i)
+    assert.strictEqual(err.body.request, 'XXXXX')
    assert.strictEqual(log.error.callCount, 1)
    assert.match(log.error.firstCall[0].message, /invalid json/i)
-    assert.match(log.error.firstCall[0].message, /token a/i)
+    assert.match(log.error.firstCall[0].message, /token[^X]+X/i)
  })

  t.test('should handle incomplete requests correctly', async function() {
@ -134,8 +170,8 @@ t.describe('/json', function() {
    await setTimeout(20)

    assert.strictEqual(log.error.callCount, 0)
-    assert.strictEqual(log.info.callCount, 1)
-    assert.strictEqual(log.info.firstCall[0].message, 'aborted')
+    assert.strictEqual(log.info.callCount, 0)
+    // assert.strictEqual(log.info.firstCall[0].message, 'aborted')
  })
 })

@ -145,14 +181,9 @@ t.describe('/timeout', function() {

    let err = await assert.isRejected(client.customRequest('GET', '/timeout', JSON.stringify({}), { timeout: 20 }))

-    while (!log.info.called) {
-      await setTimeout(10)
-    }
-
    assert.match(err.message, /timed out/)
    assert.notOk(log.error.called)
-    assert.ok(log.info.called)
-    assert.strictEqual(log.info.firstCall[0].message, 'aborted')
+    assert.notOk(log.info.called)
  })
 })

@ -201,8 +232,7 @@ t.describe('/file', function() {
    }
    
    assert.strictEqual(log.error.callCount, 0)
-    assert.strictEqual(log.info.callCount, 1)
-    assert.strictEqual(log.info.firstCall[0].message, 'aborted')
+    assert.strictEqual(log.info.callCount, 0)

    assert.ok(file.closed)
  })
@ -282,6 +312,195 @@ t.describe('/file/upload', function() {

    assert.strictEqual(statSource.size, statTarget.size)
    assert.strictEqual(statSource.size, res.size)
+    assert.strictEqual(res.type, 'image/png')
+  })
+  t.test('server should have correct type', async function() {
+    let res = await client.upload('/file/upload', './test/test.jpg')
+
+    let [statSource, statTarget] = await Promise.all([
+      fs.stat('./test/test.jpg'),
+      fs.stat(res.path),
+    ])
+
+    assert.strictEqual(statSource.size, statTarget.size)
+    assert.strictEqual(statSource.size, res.size)
+    assert.strictEqual(res.type, 'image/jpeg')
+  })
+  t.test('server should use type from user', async function() {
+    const assertType = 'some/test/here'
+    let res = await client.upload('/file/upload', './test/test.jpg', 'POST', {}, assertType)
+
+    let [statSource, statTarget] = await Promise.all([
+      fs.stat('./test/test.jpg'),
+      fs.stat(res.path),
+    ])
+
+    assert.strictEqual(statSource.size, statTarget.size)
+    assert.strictEqual(statSource.size, res.size)
+    assert.strictEqual(res.type, assertType)
+  })
+  t.test('server should attempt to correct type if type is application/octet-stream', async function() {
+    const assertNotType = 'application/octet-stream'
+    let res = await client.upload('/file/upload', './test/test.jpg', 'POST', {}, assertNotType)
+
+    let [statSource, statTarget] = await Promise.all([
+      fs.stat('./test/test.jpg'),
+      fs.stat(res.path),
+    ])
+
+    assert.strictEqual(statSource.size, statTarget.size)
+    assert.strictEqual(statSource.size, res.size)
+    assert.notStrictEqual(res.type, assertNotType)
+    assert.strictEqual(res.type, 'image/jpeg')
+  })
+  t.test('server fall back to type application/octet-stream if unknown', async function() {
+    let res = await client.upload('/file/upload', './test/test.gibberish')
+
+    let [statSource, statTarget] = await Promise.all([
+      fs.stat('./test/test.gibberish'),
+      fs.stat(res.path),
+    ])
+
+    assert.strictEqual(statSource.size, statTarget.size)
+    assert.strictEqual(statSource.size, res.size)
+    assert.strictEqual(res.type, 'application/octet-stream')
+
+    res = await client.upload('/file/upload', './test/test.gibberish', 'POST', {}, 'application/octet-stream')
+    assert.strictEqual(res.type, 'application/octet-stream')
+  })
+})
+
+t.describe('/file/upload/many', function() {
+  t.test('server should upload file', async function() {
+    let res = await client.upload('/file/upload/many', {
+      herp: './test/test.jpg',
+      derp: './test/test.png',
+    })
+
+    let [statSourcePng, statSourceJpg, statTargetHerp, statTargetDerp] = await Promise.all([
+      fs.stat('./test/test.png'),
+      fs.stat('./test/test.jpg'),
+      fs.stat(res.herp.path),
+      fs.stat(res.derp.path),
+    ])
+
+    assert.strictEqual(statSourceJpg.size, statTargetHerp.size)
+    assert.strictEqual(statSourceJpg.size, res.herp.size)
+    assert.strictEqual(statSourcePng.size, statTargetDerp.size)
+    assert.strictEqual(statSourcePng.size, res.derp.size)
+  })
+})
+
+t.describe('HEAD', function() {
+  const agent = new http.Agent({
+    keepAlive: true,
+    maxSockets: 1,
+    keepAliveMsecs: 3000,
+  })
+
+  t.describe('/file', function() {
+    t.test('server return HEAD for pipes', async function() {
+      log.error.reset()
+  
+      let res = await client.customRequest('HEAD', '/file', null, { getRaw: true, agent: agent })
+  
+      while (!file.closed) {
+        await setTimeout(10)
+      }
+
+      assert.ok(file.closed)
+      
+      let statSource = await fs.stat('./test/test.png')
+
+      assert.strictEqual(res.data, '')
+      assert.strictEqual(res.headers['content-type'], 'image/png')
+      assert.notOk(res.headers['content-length'])
+    })
+    t.test('server should autoclose body file handles on errors', async function() {
+      reset()
+  
+      file = null
+  
+      let req = await client.customRequest('HEAD', '/file/leak', null, { returnRequest: true })
+  
+      req.end()
+  
+      while (!file) {
+        await setTimeout(10)
+      }
+  
+      assert.ok(file)
+      assert.notOk(file.closed)
+  
+      req.destroy()
+      
+      while (!file.closed) {
+        await setTimeout(10)
+      }
+      
+      assert.strictEqual(log.error.callCount, 0)
+      assert.strictEqual(log.info.callCount, 0)
+  
+      assert.ok(file.closed)
+    })
+  })
+  
+  t.describe('/filehandle', function() {
+    t.test('server should send correctly', async function() {
+      log.error.reset()
+  
+      let res = await client.customRequest('HEAD', '/filehandle', null, { getRaw: true, agent: agent })
+      assert.strictEqual(res.status, 200)
+      assert.strictEqual(res.headers['content-length'], '11')
+      assert.strictEqual(res.headers['content-type'], 'text/plain')
+      assert.match(res.headers['etag'], /\"\d+-11-\d+"/)
+      assert.ok(res.headers['last-modified'])
+      let d = new Date(Date.parse(res.headers['last-modified']))
+      let etag = res.headers['etag']
+      assert.ok(d.getTime())
+      assert.strictEqual(res.data, '')
+  
+      res = await client.customRequest('HEAD', '/filehandle', null, { getRaw: true, agent: agent,
+        headers: {
+          'If-Modified-Since': d.toUTCString()
+        },
+      })
+      assert.strictEqual(res.status, 304)
+      assert.strictEqual(res.data, '')
+      assert.strictEqual(res.headers['etag'], etag)
+  
+      res = await client.customRequest('HEAD', '/filehandle', null, { getRaw: true, agent: agent,
+        headers: {
+          'If-None-Match': etag
+        },
+      })
+      assert.strictEqual(res.status, 304)
+      assert.strictEqual(res.data, '')
+      assert.strictEqual(res.headers['etag'], etag)
+  
+      res = await client.customRequest('HEAD', '/filehandle', null, { getRaw: true, agent: agent,
+        headers: {
+          'Range': 'bytes=2-5'
+        },
+      })
+      assert.strictEqual(res.status, 206)
+      assert.strictEqual(res.data, '')
+      assert.strictEqual(res.headers['content-length'], '4')
+  
+      
+      res = await client.customRequest('HEAD', '/filehandle', null, { getRaw: true, agent: agent,
+        headers: {
+          'Range': 'bytes=0-0'
+        },
+      })
+      assert.strictEqual(res.status, 206)
+      assert.strictEqual(res.data, '')
+      assert.strictEqual(res.headers['content-length'], '1')
+    })
+  
+    t.after(function() {
+      agent.destroy()
+    })
  })
 })

--- a/test/middlewares.test.mjs
+++ b/test/middlewares.test.mjs
@ -253,6 +253,27 @@ t.describe('#CorsHandler()', function() {
      assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
      assert.strictEqual(ctx.status, 204)
    })
+    
+    t.test('should set headers if allowedOrigins has a *', function() {
+      const assertOrigin = 'http://my.site.here'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: ['*'],
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+
+      assert.notOk(ctx.headers['Access-Control-Allow-Origin'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+
+      corsHandler(ctx)
+
+      assert.strictEqual(ctx.headers['Vary'], 'Origin')
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Origin'], assertOrigin)
+      assert.ok(ctx.headers['Access-Control-Allow-Methods'])
+      assert.strictEqual(ctx.status, 204)
+    })
  })

  t.describe('GET/POST/DELETE/PATCH/PUT', function() {
@ -498,8 +519,8 @@ t.describe('#JsonHandler()', function() {
      finished = true
    })

-    ctx.req.on.firstCall[1](Buffer.alloc(10, 'a'))
-    ctx.req.on.firstCall[1](Buffer.alloc(10, 'a'))
+    ctx.req.on.firstCall[1](Buffer.alloc(10, 'X'))
+    ctx.req.on.firstCall[1](Buffer.alloc(10, 'X'))
    ctx.req.on.secondCall[1]()
    
    await setTimeout(10)
@ -510,11 +531,11 @@ t.describe('#JsonHandler()', function() {
    assert.ok(err instanceof HttpError)
    assert.strictEqual(err.status, 400)
    assert.match(err.message, /JSON/)
-    assert.match(err.message, /Unexpected token a in/i)
+    assert.match(err.message, /Unexpected token[^X]+X/i)
    assert.strictEqual(err.body.status, 400)
    assert.match(err.body.message, /Invalid JSON/i)
-    assert.match(err.body.message, /Unexpected token a in/i)
-    assert.strictEqual(err.body.request, 'aaaaaaaaaaaaaaaaaaaa')
+    assert.match(err.body.message, /Unexpected token[^X]+X/i)
+    assert.strictEqual(err.body.request, 'XXXXXXXXXXXXXXXXXXXX')
  })

  t.test('should not throw if body is empty', async function() {
@ -615,7 +636,10 @@ t.describe('#FormidableHandler()', function() {

    let err = await assert.isRejected(handler(ctx))

-    assert.strictEqual(err, assertError)
+    assert.notStrictEqual(err, assertError)
+    assert.ok(err instanceof HttpError)
+    assert.strictEqual(err.message, assertError.message)
+    assert.strictEqual(err.status, 400)
  })

  t.test('should throw rename error if rename fails', async function() {
--- a/test/test.gibberish
+++ b/test/test.gibberish
--- a/test/test.jpg
+++ b/test/test.jpg
Author	SHA1	Message	Date
Jonatan Nilsson	d5459cbcb9	cors: Add specific support for supporting all origin continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-11-15 09:56:34 +00:00
Jonatan Nilsson	01a916eb2d	socket: Set time out and forcibly close timed out sockets. Fix tests for different node versions continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-11-03 22:52:09 +00:00
Jonatan Nilsson	598548d97b	random generator benchmark continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-10-07 11:49:41 +00:00
TheThing	8a49e38285	Update 'README.md' continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-09-28 10:39:12 +00:00
Jonatan Nilsson	6d4d62e79c	test: Add test for buffer support continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-05-11 11:12:23 +00:00
Jonatan Nilsson	7401b3bd2c	requestEnd: Add proper support for buffers in body continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-05-11 09:50:52 +00:00
Jonatan Nilsson	95e6c2dcac	Test: Update tests on formidable errors continuous-integration/appveyor/branch AppVeyor build succeeded Details	2023-01-26 09:26:12 +00:00
Jonatan Nilsson	74771d92cf	Formidable: Now return 400 BadRequest HttpError instead of generic error. continuous-integration/appveyor/branch AppVeyor build failed Details	2023-01-26 09:23:10 +00:00
Jonatan Nilsson	2b69013c04	remove .only() continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-08-10 14:29:51 +00:00
Jonatan Nilsson	8a56969015	Fix FormidableHandler so it detects filetype based on extension if type is unknown or application octet-stream. continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-08-10 14:13:14 +00:00
Jonatan Nilsson	5f916e97ea	Formidable: Better handling for file uploads. Now supports multiple keys continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-07-06 14:50:54 +00:00
Jonatan Nilsson	baf2d896c1	Update eltro, clean up a few tests continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-07-04 13:24:19 +00:00
Jonatan Nilsson	e9c600b869	Flaska: Add support for `appendHeaders` in constructor. continuous-integration/appveyor/branch AppVeyor build succeeded Details * Allows to append individual headers to the defaultHeaders without completely replacing the default values.	2022-06-16 09:59:30 +00:00
Jonatan Nilsson	568c620782	Flaska: Add support for appendHeaders to compliment default headers instead of completely replacing them	2022-06-16 09:58:11 +00:00
Jonatan Nilsson	0c22fe9577	Final fix unit tests continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-05-12 16:44:37 +00:00
Jonatan Nilsson	3a0064c563	Fix test for new default header continuous-integration/appveyor/branch AppVeyor build failed Details	2022-05-12 16:42:54 +00:00
Jonatan Nilsson	e7909cc84b	flaska: Add better default font-src with self and data: support. continuous-integration/appveyor/branch AppVeyor build failed Details	2022-05-12 16:40:14 +00:00
Jonatan Nilsson	4820347cfb	req: Fix bug where it would call requestEnded when request was closed. This behavior is normal during the middle of a request continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-04-07 11:27:44 +00:00
Jonatan Nilsson	cffca53eb6	test: Fix tests that were relying on aborted log message. These are spammy and normal and shouldn't be logged continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-04-02 19:47:39 +00:00
Jonatan Nilsson	3a454d44ce	onreqerror: Do not log aborted "errors" continuous-integration/appveyor/branch AppVeyor build failed Details	2022-04-02 19:40:46 +00:00
Jonatan Nilsson	975646d336	Flaska: If http server supports listenAsync (service-core for example) then use that instead of callback listen() continuous-integration/appveyor/branch AppVeyor build succeeded Details	2022-03-27 14:48:11 +00:00
Jonatan Nilsson	b97e34c1eb	Flaska: HEAD request support across the board. continuous-integration/appveyor/branch AppVeyor build succeeded Details Flaska: Set status to 204 if status is 200 and body is null Flaska: Fix implementation of how content-type is set FileResponse: Don't open file if running HEAD request	2022-03-27 00:30:56 +00:00