cors: Add specific support for supporting all origin

* Allows to append individual headers to the defaultHeaders without completely
  replacing the default values.

.circleci/config.yml

@@ -1,23 +0,0 @@
-version: 2
-jobs:
-  run_tester:
-    docker:
-      - image: circleci/node:latest
-    working_directory: ~/flaska
-    steps:
-      - checkout
-      - run:
-          name: Install dependencies
-          command: |
-            npm install
-            npm list --all
-      - run:
-          name: Run tests
-          command: |
-            npm test
-
-workflows:
-  version: 2
-  build_deploy:
-    jobs:
-      - run_tester

.npmrc

@@ -0,0 +1 @@
+package-lock=false

README.md

@@ -1,2 +1,194 @@
-# bottle-node
-Bottle 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.
+# Flaska
+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.
+
+Heavily inspired by koa and koa-router it takes liberties of implementing most of the common functionality required for most sites without sacrificing anything. And the fact that the footprint for this is much smaller than koa while also being more powerful and faster shows the testament that is flaska.
+
+## Installation
+
+```
+$ npm install flaska
+```
+
+## Hello Flaska
+
+```js
+import { Flaska } from '../flaska.mjs'
+const flaska = new Flaska()
+
+flaska.get('/', function(ctx) {
+  ctx.body = 'Hello Flaska';
+})
+
+// flaska.listen(3000);
+flaska.listenAsync(3000).then(function() {
+  console.log('listening on port 3000')
+}, function(err) {
+  console.error('Error listening:', err)
+})
+```
+
+## Router/Handlers
+
+Flaska supports all the common verbs out of the box:
+
+* `flaska.get(url, [middlewares], handler)`
+* `flaska.post(url, [middlewares], handler)`
+* `flaska.put(url, [middlewares], handler)`
+* `flaska.delete(url, [middlewares], handler)`
+* `flaska.options(url, [middlewares], handler)`
+* `flaska.patch(url, [middlewares], handler)`
+
+Example:
+
+```
+flaska.get('/path/to/url', async function(ctx) {
+  // Perform action
+})
+```
+
+In addition, each route can have none, one or many middlewares:
+
+```
+flaska.get('/handlequery', QueryHandler(), async function(ctx) {
+  // Perform action
+})
+
+flaska.get('/query/and/json', [QueryHandler(), JsonHandler()], async function(ctx) {
+  // Perform action
+})
+```
+
+You can also run global middlewares at the start or end of every request:
+
+```
+import { Flaska, QueryHandler, JsonHandler } from '../flaska.mjs'
+const flaska = new Flaska()
+
+flaska.before(QueryHandler())
+flaska.before(JsonHandler())
+flaska.beforeAsync(MyLoadDatabase())
+
+flaska.after(function(ctx) {
+  ctx.log.info('Request finished.')
+})
+```
+
+## Context, Request and Response
+
+Each handler receives a Flaska `Context` object that encapsulates an incoming
+http message and the corresponding response to that message. For those familiar
+with koa will be famililar with this concept. `ctx` is often used as the parameter
+name for the context object.
+
+```js
+app.before(function(ctx) {
+  ctx.log.info('Got request')
+})
+app.beforeAsync(async function(ctx) {
+  // Do some database fetching maybe
+})
+```
+
+The context `ctx` that gets generated includes the following properties for the incoming request:
+
+* `log`: Log handler.
+* `req`: The Request's [IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage).
+* `res`: The Response's [ServerResponse](https://nodejs.org/api/http.html#http_class_http_serverresponse).
+* `method`: The HTTP method ('GET', 'POST', etc.).
+* `url`: The full URL path.
+* `search`: The URL search.
+* `state`: Anonymous object for user-defined data.
+* `query`: Map containing the key/value for the url search.
+
+The following context specific variables can be specified by you the user to instruct Flaska on what to return in response:
+* `status`: The status code to return in response (default 200).
+* `body`: The body contents to return in response (default null).
+* `type`: The content-type for the header (default null).
+* `length`: The length of the body in bytes (default null).
+
+More on this next.
+
+## `ctx.body`
+
+At the end of each request, flaska will read `ctx.body` and determine the best course of action based on the type of content is being sent.
+
+### Javascript object
+
+In cases where the response body is a normal object, Flaska will automatically `JSON.stringify` it,
+set the `Content-Type` to `application/json` and set the total length in `Content-Length`. This
+is provided for you at no expense on your behalf so you don't have to worry about it:
+
+```
+flaska.get('/api/test', function(ctx) {
+  ctx.body = {
+    message: 'Hello world',
+  }
+})
+```
+
+### pipe
+
+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) {
+  ctx.body = fs.createReadStream('./test/test.png')
+})
+```
+
+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.
+
+```
+flaska.get('/file.html', function(ctx) {
+  ctx.body = `
+<!doctype html>
+<html lang="en">
+<body>
+  <h1>Hello world</h1>
+</body>
+</html>
+`
+  ctx.type = 'text/html; charset=utf-8'
+})
+```
+
+The `Context` object also provides shortcuts for methods on its `request` and `response`.  In the prior
+examples,  `ctx.type` can be used instead of `ctx.response.type` and `ctx.accepts` can be used
+instead of `ctx.request.accepts`.
+
+
+## Built-in middlewares and handlers
+
+Flaska comes with a few middlewares out of the box.
+
+* `QueryHandler()`
+
+Parse the search query and create a map with key->value in `ctx.query`.
+
+* `JsonHandler()`
+
+Parse incoming request body as json and store it in `ctx.req.body`.
+
+* `FormidableHandler()`
+
+Provides a wrapper to handle an incoming file upload using `Formidable@1`.

appveyor.yml

@@ -0,0 +1,64 @@
+# version format
+version: '{build}'
+deploy: on
+
+# branches to build
+branches:
+  # whitelist
+  only:
+    - master
+
+# Do not build on tags (GitHub, Bitbucket, GitLab, Gitea)
+skip_tags: true
+
+# Maximum number of concurrent jobs for the project
+max_jobs: 1
+clone_depth: 1
+
+# Build worker image (VM template)
+build_cloud: Docker
+
+environment:
+  docker_image: node:17-alpine
+
+test_script:
+  - sh: |
+      mkdir /lib64
+      ln -s /lib/libc.musl-x86_64.so.1 /lib64/ld-linux-x86-64.so.2
+      chmod -R 777 /appveyor/projects
+      npm install
+      npm run test -- --ignore-only
+      if [ $? -ne 0 ]; then
+        exit 1
+      fi
+
+artifacts:
+  - path: ./*_sc-core.7z
+
+# on successful build
+on_success:
+  - sh: |
+      apk add curl jq
+      if [ $? -eq 0 ]; then
+        echo "Finished installling curl and jq"
+      else
+        exit 1
+      fi
+      CURR_VER=$(cat package.json | jq -r .version)
+      echo "Checking https://git.nfp.is/api/v1/repos/$APPVEYOR_REPO_NAME/releases for version v${CURR_VER}"
+      curl -s -X GET -H "Authorization: token $deploytoken" https://git.nfp.is/api/v1/repos/$APPVEYOR_REPO_NAME/releases | grep -o "\"name\"\:\"v${CURR_VER}\"" > /dev/null
+
+      if [ $? -eq 0 ] ; then
+        echo "Release already exists, nothing to do.";
+      else
+        echo "Creating release on gitea"
+        curl \
+          -X POST \
+          -H "Authorization: token $deploytoken" \
+          -H "Content-Type: application/json" \
+          https://git.nfp.is/api/v1/repos/$APPVEYOR_REPO_NAME/releases \
+          -d "{\"tag_name\":\"v${CURR_VER}\",\"name\":\"v${CURR_VER}\",\"body\":\"Automatic release from Appveyor from ${APPVEYOR_REPO_COMMIT} :\n\n${APPVEYOR_REPO_COMMIT_MESSAGE}\"}"
+        echo '//registry.npmjs.org/:_authToken=${npmtoken}' > ~/.npmrc
+        echo "Publishing new version to npm"
+        npm publish
+      fi

benchmark/index.bat

@@ -1,2 +1 @@
-start /B /WAIT /REALTIME node index.js
-pause
+start /B /WAIT /REALTIME node index.js

benchmark/index.js

@@ -1,3 +1,4 @@
+import crypto from 'crypto'
 import assert from 'assert'
 import Benchmark from 'benchmarkjs-pretty'
 import { koaRouter1, koaRouter2 } from './router_koa.js'
@@ -176,7 +177,89 @@ function TestObjectAssign() {
     ctx.router2 = flaskaRouter2
   }
 
+  function registerHeader(ctx) {
+    ctx.headers['Server'] = 'nginx/1.16.1'
+    ctx.headers['Date'] = 'Mon, 21 Mar 2022 07:26:01 GMT'
+    ctx.headers['Content-Type'] = 'application/json; charset=utf-8'
+    ctx.headers['Content-Length'] = '1646'
+    ctx.headers['Connection'] = 'keep-alive'
+    ctx.headers['vary'] = 'Origin'
+    ctx.headers['Link'] = '<http://kisildalur.is/api/categories?perPage=1250>; rel="current"; title="Page 1"'
+    ctx.headers['pagination_total'] = '7'
+    ctx.headers['X-Frame-Options'] = 'DENY'
+    ctx.headers['X-Content-Type-Options'] = 'nosniff'
+  }
+
+  function registerHeaderAlt(ctx) {
+    ctx.headers = {
+      'Server': 'nginx/1.16.1',
+      'Date': 'Mon, 21 Mar 2022 07:26:01 GMT',
+      'Content-Type': 'application/json; charset=utf-8',
+      'Content-Length': '1646',
+      'Connection': 'keep-alive',
+      'vary': 'Origin',
+      'Link': '<http://kisildalur.is/api/categories?perPage=1250>; rel="current"; title="Page 1"',
+      'pagination_total': '7',
+      'X-Frame-Options': 'DENY',
+      'X-Content-Type-Options': 'nosniff',
+    }
+  }
+
+  let baseHeaders = {
+    'Server': 'nginx/1.16.1',
+    'Date': 'Mon, 21 Mar 2022 07:26:01 GMT',
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': '1646',
+    'Connection': 'keep-alive',
+    'vary': 'Origin',
+    'Link': '<http://kisildalur.is/api/categories?perPage=1250>; rel="current"; title="Page 1"',
+    'pagination_total': '7',
+    'X-Frame-Options': 'DENY',
+    'X-Content-Type-Options': 'nosniff',
+  }
+  let keys = Object.keys(baseHeaders)
+  
+
   return new Benchmark.default('test different method to initialize objects)')
+    .add('[HEADERS] Object.assign()', function() {
+      let ctx = {
+        headers: {}
+      }
+      Object.assign(ctx.headers, baseHeaders)
+      // assert.notStrictEqual(ctx.headers, baseHeaders)
+    })
+    .add('[HEADERS] ecmascript spread', function() {
+      let ctx = {
+        headers: {
+          ...baseHeaders
+        }
+      }
+      // assert.notStrictEqual(ctx.headers, baseHeaders)
+    })
+    .add('[HEADERS] Basic clone lol', function() {
+      let ctx = {
+        headers: {}
+      }
+      for (let key of keys) {
+        ctx.headers[key] = baseHeaders[key]
+      }
+      // assert.notStrictEqual(ctx.headers, baseHeaders)
+    })
+    .add('[HEADERS] Use register function', function() {
+      let ctx = {
+        headers: {}
+      }
+      registerHeader(ctx)
+      // assert.notStrictEqual(ctx.headers, baseHeaders)
+    })
+    .add('[HEADERS] Use register function ALT', function() {
+      let ctx = {
+        headers: {}
+      }
+      registerHeaderAlt(ctx)
+      // assert.notStrictEqual(ctx.headers, baseHeaders)
+    })
+    /*
     .add('Object.assign()', function() {
       let ctx = {
         req: req,
@@ -196,7 +279,7 @@ function TestObjectAssign() {
       register3(ctx)
       ctx.log.info()
     })
-    /*.add('Object.create() all props', function() {
+    .add('Object.create() all props', function() {
       let ctx = Object.create({}, propMakerAlt)
       ctx.log.info()
     })
@@ -212,7 +295,100 @@ function TestObjectAssign() {
       let ctx = { }
       Object.defineProperties(ctx, propMakerAlt)
       ctx.log.info()
-    })*/
+    })
+    */
+    .run()
+    .then(function() {}, function(e) {
+      console.error('error:', e)
+      process.exit(1)
+    })
+}
+
+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 (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)
+    })
+}
+
+function TestArrayReduce() {
+  return new Benchmark.default('test different method to reduce array)')
+    .add('currIndex', function() {
+      const arr1 = new Array(100)
+
+      for (let i = 0; i < arr1.length; i++) {
+        arr1[i] = 'a'
+      }
+      
+      let currIndex = arr1.length - 1
+
+      let out = ''
+      while (currIndex >= 0) {
+        out += arr1[currIndex]
+        currIndex--
+      }
+    })
+    .add('crypto.randomBytes(32)', function() {
+      const arr1 = new Array(100)
+
+      for (let i = 0; i < arr1.length; i++) {
+        arr1[i] = 'a'
+      }
+
+      let out = ''
+      while (arr1.length > 0) {
+        out += arr1.splice(0, 1)[0]
+      }
+    })
+    .run()
+    .then(function() {}, function(e) {
+      console.error('error:', e)
+      process.exit(1)
+    })
+}
+
+function TestStringCombination() {
+  let val1 = 'some'
+  let val2 = 'text'
+  let val3 = 'gose'
+  let val4 = 'here'
+
+  return new Benchmark.default('test different method to combine string)')
+    .add('ES6 with variable', function() {
+      let out = `Hello my friend ${val1} this goes to ${val2} all my homies ${val3} over at my ${val4} house`
+      return out
+    })
+    .add('String concatenation', function() {
+      let out = 'Hello my friend ' + val1 + ' this goes to ' + val2 + ' all my homies ' + val3 + ' over at my ' + val4 + ' house'
+      return out
+    })
     .run()
     .then(function() {}, function(e) {
       console.error('error:', e)
@@ -345,8 +521,8 @@ function TestLargeParamLargeUrlRoute() {
     })
 }
 
+/*
 TestSmallStaticRoute()
-// TestObjectAssign()
 // TestPromiseCreators()
   .then(function() {
     return TestSmallParamRoute()
@@ -362,4 +538,12 @@ TestSmallStaticRoute()
   })
   .then(function() {
     process.exit(0)
-  })
+  })*/
+
+// TestObjectAssign()
+// TestGenerateRandomString()
+// TestArrayReduce()
+TestStringCombination()
+.then(function() {
+  process.exit(0)
+})

benchmark/package-lock.json

@@ -1,8 +1,731 @@
 {
   "name": "benchmark",
   "version": "1.0.0",
-  "lockfileVersion": 1,
+  "lockfileVersion": 2,
   "requires": true,
+  "packages": {
+    "": {
+      "name": "benchmark",
+      "version": "1.0.0",
+      "license": "WTFPL",
+      "dependencies": {
+        "benchmarkjs-pretty": "^2.0.0",
+        "express": "^4.17.1",
+        "koa-router": "^8.0.8"
+      }
+    },
+    "node_modules/@types/benchmark": {
+      "version": "1.0.31",
+      "resolved": "https://registry.npmjs.org/@types/benchmark/-/benchmark-1.0.31.tgz",
+      "integrity": "sha512-F6fVNOkGEkSdo/19yWYOwVKGvzbTeWkR/XQYBKtGBQ9oGRjBN9f/L4aJI4sDcVPJO58Y1CJZN8va9V2BhrZapA=="
+    },
+    "node_modules/@types/chalk": {
+      "version": "0.4.31",
+      "resolved": "https://registry.npmjs.org/@types/chalk/-/chalk-0.4.31.tgz",
+      "integrity": "sha1-ox10JBprHtu5c8822XooloNKUfk="
+    },
+    "node_modules/accepts": {
+      "version": "1.3.7",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz",
+      "integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==",
+      "dependencies": {
+        "mime-types": "~2.1.24",
+        "negotiator": "0.6.2"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI="
+    },
+    "node_modules/benchmark": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/benchmark/-/benchmark-2.1.4.tgz",
+      "integrity": "sha1-CfPeMckWQl1JjMLuVloOvzwqVik=",
+      "dependencies": {
+        "lodash": "^4.17.4",
+        "platform": "^1.3.3"
+      }
+    },
+    "node_modules/benchmarkjs-pretty": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/benchmarkjs-pretty/-/benchmarkjs-pretty-2.0.0.tgz",
+      "integrity": "sha512-t5a+ztdAuim1HPEbQwBELN9ugqe5WCSbjwPh79olqS+zgw44Bi/3qPz472LNPIfXlTernAo+meL8KULaXuWAeQ==",
+      "dependencies": {
+        "@types/benchmark": "^1.0.30",
+        "@types/chalk": "^0.4.31",
+        "benchmark": "^2.1.4",
+        "chalk": "^2.0.1"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.19.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.19.0.tgz",
+      "integrity": "sha512-dhEPs72UPbDnAQJ9ZKMNTP6ptJaionhP5cBb541nXPlW60Jepo9RV/a4fX4XWW9CuFNK22krhrj1+rgzifNCsw==",
+      "dependencies": {
+        "bytes": "3.1.0",
+        "content-type": "~1.0.4",
+        "debug": "2.6.9",
+        "depd": "~1.1.2",
+        "http-errors": "1.7.2",
+        "iconv-lite": "0.4.24",
+        "on-finished": "~2.3.0",
+        "qs": "6.7.0",
+        "raw-body": "2.4.0",
+        "type-is": "~1.6.17"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/body-parser/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/body-parser/node_modules/http-errors": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz",
+      "integrity": "sha512-uUQBt3H/cSIVfch6i1EuPNy/YsRSOUBXTVfZ+yR7Zjez3qjBz6i9+i4zjNaoqcoFVI4lQJ5plg63TvGfRSDCRg==",
+      "dependencies": {
+        "depd": "~1.1.2",
+        "inherits": "2.0.3",
+        "setprototypeof": "1.1.1",
+        "statuses": ">= 1.5.0 < 2",
+        "toidentifier": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/body-parser/node_modules/inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+    },
+    "node_modules/body-parser/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+    },
+    "node_modules/bytes": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.0.tgz",
+      "integrity": "sha512-zauLjrfCG+xvoyaqLoV8bLVXXNGC4JqlxFCutSDWA6fJrTo2ZuvLYTqZ7aHBLZSMOopbzwv8f+wZcVzfVTI2Dg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dependencies": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU="
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.3.tgz",
+      "integrity": "sha512-ExO0774ikEObIAEV9kDo50o+79VCUdEB6n6lzKgGwupcVeRlhrj3qGAfwq8G6uBJjkqLrhT0qEYFcWng8z1z0g==",
+      "dependencies": {
+        "safe-buffer": "5.1.2"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz",
+      "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.0.tgz",
+      "integrity": "sha512-+Hp8fLp57wnUSt0tY0tHEXh4voZRDnoIrZPqlo3DPiI4y9lwg/jqx+1Om94/W6ZaPDOUbnjOt/99w66zk+l1Xg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw="
+    },
+    "node_modules/debug": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
+      "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
+      "deprecated": "Debug versions >=3.2.0 <3.2.7 || >=4 <4.3.1 have a low-severity ReDos regression when used in a Node.js environment. It is recommended you upgrade to 3.2.7 or 4.3.1. (https://github.com/visionmedia/debug/issues/797)",
+      "dependencies": {
+        "ms": "^2.1.1"
+      }
+    },
+    "node_modules/depd": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
+      "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz",
+      "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA="
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0="
+    },
+    "node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg="
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.17.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.17.1.tgz",
+      "integrity": "sha512-mHJ9O79RqluphRrcw2X/GTh3k9tVv8YcoyY4Kkh4WDMUYKRZUq0h1o0w2rrrxBqM7VoeUVqgb27xlEMXTnYt4g==",
+      "dependencies": {
+        "accepts": "~1.3.7",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.19.0",
+        "content-disposition": "0.5.3",
+        "content-type": "~1.0.4",
+        "cookie": "0.4.0",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "~1.1.2",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.1.2",
+        "fresh": "0.5.2",
+        "merge-descriptors": "1.0.1",
+        "methods": "~1.1.2",
+        "on-finished": "~2.3.0",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.7",
+        "proxy-addr": "~2.0.5",
+        "qs": "6.7.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.1.2",
+        "send": "0.17.1",
+        "serve-static": "1.14.1",
+        "setprototypeof": "1.1.1",
+        "statuses": "~1.5.0",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    },
+    "node_modules/express/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/express/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+    },
+    "node_modules/finalhandler": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.2.tgz",
+      "integrity": "sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.3.0",
+        "parseurl": "~1.3.3",
+        "statuses": "~1.5.0",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/finalhandler/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/finalhandler/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+    },
+    "node_modules/forwarded": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz",
+      "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "1.7.3",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.3.tgz",
+      "integrity": "sha512-ZTTX0MWrsQ2ZAhA1cejAwDLycFsd7I7nVtnkT3Ol0aqodaKW+0CTZDQ1uBv5whptCnc8e8HeRRJxRs0kmm/Qfw==",
+      "dependencies": {
+        "depd": "~1.1.2",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.1.1",
+        "statuses": ">= 1.5.0 < 2",
+        "toidentifier": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
+      "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8="
+    },
+    "node_modules/koa-compose": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/koa-compose/-/koa-compose-4.1.0.tgz",
+      "integrity": "sha512-8ODW8TrDuMYvXRwra/Kh7/rJo9BtOfPc6qO8eAfC80CnCvSjSl0bkRM24X6/XBBEyj0v1nRUQ1LyOy3dbqOWXw=="
+    },
+    "node_modules/koa-router": {
+      "version": "8.0.8",
+      "resolved": "https://registry.npmjs.org/koa-router/-/koa-router-8.0.8.tgz",
+      "integrity": "sha512-2rNF2cgu/EWi/NV8GlBE5+H/QBoaof83X6Z0dULmalkbt7W610/lyP2EOLVqVrUUFfjsVWL/Ju5TVBcGJDY9XQ==",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "http-errors": "^1.7.3",
+        "koa-compose": "^4.1.0",
+        "methods": "^1.1.2",
+        "path-to-regexp": "1.x",
+        "urijs": "^1.19.2"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      }
+    },
+    "node_modules/koa-router/node_modules/path-to-regexp": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.8.0.tgz",
+      "integrity": "sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==",
+      "dependencies": {
+        "isarray": "0.0.1"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.15",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz",
+      "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A=="
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
+      "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E="
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.43.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.43.0.tgz",
+      "integrity": "sha512-+5dsGEEovYbT8UY9yD7eE4XTc4UwJ1jBYlgaQQF38ENsKR3wj/8q8RFZrF9WIZpB2V1ArTVFUva8sAul1NzRzQ==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.26",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.26.tgz",
+      "integrity": "sha512-01paPWYgLrkqAyrlDorC1uDwl2p3qZT7yl806vW7DvDoxwXi46jsjFbg+WdwotBIk6/MbEhO/dh5aZ5sNj/dWQ==",
+      "dependencies": {
+        "mime-db": "1.43.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.2.tgz",
+      "integrity": "sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
+      "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
+      "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w="
+    },
+    "node_modules/platform": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/platform/-/platform-1.3.5.tgz",
+      "integrity": "sha512-TuvHS8AOIZNAlE77WUDiR4rySV/VMptyMfcfeoMgs4P8apaZM3JrnbzBiixKUv+XR6i+BXrQh8WAnjaSPFO65Q=="
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.6.tgz",
+      "integrity": "sha512-dh/frvCBVmSsDYzw6n926jv974gddhkFPfiN8hPOi30Wax25QZyZEGveluCgliBnqmuM+UJmBErbAUFIoDbjOw==",
+      "dependencies": {
+        "forwarded": "~0.1.2",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.7.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.7.0.tgz",
+      "integrity": "sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.4.0.tgz",
+      "integrity": "sha512-4Oz8DUIwdvoa5qMJelxipzi/iJIi40O5cGV1wNYp5hvZP8ZN0T+jiNkL0QepXs+EsQ9XJ8ipEDoiH70ySUJP3Q==",
+      "dependencies": {
+        "bytes": "3.1.0",
+        "http-errors": "1.7.2",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/raw-body/node_modules/http-errors": {
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz",
+      "integrity": "sha512-uUQBt3H/cSIVfch6i1EuPNy/YsRSOUBXTVfZ+yR7Zjez3qjBz6i9+i4zjNaoqcoFVI4lQJ5plg63TvGfRSDCRg==",
+      "dependencies": {
+        "depd": "~1.1.2",
+        "inherits": "2.0.3",
+        "setprototypeof": "1.1.1",
+        "statuses": ">= 1.5.0 < 2",
+        "toidentifier": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body/node_modules/inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "node_modules/send": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.17.1.tgz",
+      "integrity": "sha512-BsVKsiGcQMFwT8UxypobUKyv7irCNRHk1T0G680vk88yf6LBByGcZJOTJCrTP2xVN6yI+XjPJcNuE3V4fT9sAg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "~1.1.2",
+        "destroy": "~1.0.4",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "~1.7.2",
+        "mime": "1.6.0",
+        "ms": "2.1.1",
+        "on-finished": "~2.3.0",
+        "range-parser": "~1.2.1",
+        "statuses": "~1.5.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/send/node_modules/debug/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
+      "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg=="
+    },
+    "node_modules/serve-static": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.14.1.tgz",
+      "integrity": "sha512-JMrvUwE54emCYWlTI+hGrGv5I8dEwmco/00EvkzIIsR7MqrHonbD9pO2MOfFnpFntl7ecpZs+3mW+XbQZu9QCg==",
+      "dependencies": {
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.17.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.1.tgz",
+      "integrity": "sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw=="
+    },
+    "node_modules/statuses": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz",
+      "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.0.tgz",
+      "integrity": "sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/urijs": {
+      "version": "1.19.2",
+      "resolved": "https://registry.npmjs.org/urijs/-/urijs-1.19.2.tgz",
+      "integrity": "sha512-s/UIq9ap4JPZ7H1EB5ULo/aOUbWqfDi7FKzMC2Nz+0Si8GiT1rIEaprt8hy3Vy2Ex2aJPpOQv4P4DuOZ+K1c6w=="
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    }
+  },
   "dependencies": {
     "@types/benchmark": {
       "version": "1.0.31",

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)
+})

package.json

@@ -1,15 +1,27 @@
 {
   "name": "flaska",
-  "version": "0.9.8",
+  "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": {
-    "test": "eltro"
+    "test": "eltro",
+    "test:watch": "npm-watch test"
+  },
+  "watch": {
+    "test": {
+      "patterns": [
+        "test/*",
+        "flaska.mjs"
+      ],
+      "extensions": "mjs",
+      "quiet": true,
+      "inherit": true
+    }
   },
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nfp-projects/bottle-node.git"
+    "url": "git+https://git.nfp.is/TheThing/flaska.git"
   },
   "keywords": [
     "web",
@@ -23,11 +35,12 @@
   "author": "Jonatan Nilsson",
   "license": "WTFPL",
   "bugs": {
-    "url": "https://github.com/nfp-projects/bottle-node/issues"
+    "url": "https://git.nfp.is/TheThing/flaska/issues"
   },
-  "homepage": "https://github.com/nfp-projects/bottle-node#readme",
+  "homepage": "https://git.nfp.is/TheThing/flaska/#readme",
   "devDependencies": {
-    "eltro": "^1.1.0"
+    "eltro": "^1.3.2",
+    "formidable": "^1.2.2"
   },
   "files": [
     "flaska.mjs",

test/client.mjs

@@ -1,4 +1,7 @@
+import fs from 'fs/promises'
+import path from 'path'
 import http from 'http'
+import stream from 'stream'
 import { URL } from 'url'
 import { defaults } from './helper.mjs'
 
@@ -7,7 +10,7 @@ export default function Client(port, opts) {
   this.prefix = `http://localhost:${port}`
 }
 
-Client.prototype.customRequest = function(method = 'GET', path, body, options) {
+Client.prototype.customRequest = function(method = 'GET', path, body, options = {}) {
   if (path.slice(0, 4) !== 'http') {
     path = this.prefix + path
   }
@@ -15,7 +18,6 @@ Client.prototype.customRequest = function(method = 'GET', path, body, options) {
 
   return new Promise((resolve, reject) => {
     const opts = defaults(defaults(options, {
-      agent: false,
       method: method,
       timeout: 500,
       protocol: urlObj.protocol,
@@ -24,33 +26,57 @@ Client.prototype.customRequest = function(method = 'GET', path, body, options) {
       host: urlObj.hostname,
       port: Number(urlObj.port),
       path: urlObj.pathname + urlObj.search,
+      headers: {},
     }))
 
-    const req = http.request(opts)
-    if (body) {
-      req.write(body)
+    if (options.agent) {
+      opts.agent = options.agent
     }
 
-    req.on('error', reject)
+    // opts.agent = agent
+
+    const req = http.request(opts)
+
+    req.on('error', (err) => {
+      reject(err)
+    })
     req.on('timeout', function() {
-      console.log(req.destroy())
+      req.destroy()
       reject(new Error(`Request ${method} ${path} timed out`))
     })
     req.on('response', res => {
-      res.setEncoding('utf8')
       let output = ''
+      if (options.toPipe) {
+        return stream.pipeline(res, options.toPipe, function(err) {
+          if (err) {
+            return reject(err)
+          }
+          resolve()
+        })
+      } else {
+        res.setEncoding('utf8')
 
-      res.on('data', function (chunk) {
-        output += chunk.toString()
-      })
+        res.on('data', function (chunk) {
+          output += chunk.toString()
+        })
+      }
 
       res.on('end', function () {
-        try {
-          output = JSON.parse(output)
-        } catch (e) {
-          return reject(new Error(`${e.message} while decoding: ${output}`))
+        if (options.getRaw) {
+          output = {
+            status: res.statusCode,
+            data: output,
+            headers: res.headers,
+          }
+        } else {
+          if (!output) return resolve(null)
+          try {
+            output = JSON.parse(output)
+          } catch (e) {
+            return reject(new Error(`${e.message} while decoding: ${output}`))
+          }
         }
-        if (output.status && typeof(output.status) === 'number') {
+        if (!options.getRaw && output.status && typeof(output.status) === 'number') {
           let err = new Error(`Request failed [${output.status}]: ${output.message}`)
           err.body = output
           return reject(err)
@@ -58,11 +84,96 @@ Client.prototype.customRequest = function(method = 'GET', path, body, options) {
         resolve(output)
       })
     })
+
+    if (opts.returnRequest) {
+      return resolve(req)
+    }
+    
+    if (body) {
+      req.write(body)
+    }
     req.end()
     return req
   })
 }
 
-Client.prototype.get = function(path = '/') {
-  return this.customRequest('GET', path, null)
-}
+Client.prototype.get = function(url = '/') {
+  return this.customRequest('GET', url, null)
+}
+
+Client.prototype.post = function(url = '/', body = {}) {
+  let parsed = JSON.stringify(body)
+  return this.customRequest('POST', url, parsed, {
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': parsed.length,
+    },
+  })
+}
+
+Client.prototype.del = function(url = '/', body = {}) {
+  return this.customRequest('DELETE', url, JSON.stringify(body))
+}
+
+const random = (length = 8) => {
+  // Declare all characters
+  let chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  // Pick characers randomly
+  let str = '';
+  for (let i = 0; i < length; i++) {
+      str += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return str;
+}
+
+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)
+
+      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}--`))
+
+    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,
+      },
+    })
+  })
+}

test/fileResponse.test.mjs

@@ -0,0 +1,498 @@
+import { Eltro as t, assert, stub } from 'eltro'
+import { FileResponse } from '../flaska.mjs'
+import { createCtx } from './helper.mjs'
+
+t.test('should add path and stat', function() {
+  const assertPath = 'some/path/here'
+  const assertStat = { a: 1 }
+
+  let fileRes = new FileResponse(assertPath, assertStat)
+
+  assert.strictEqual(fileRes.filepath, assertPath)
+  assert.strictEqual(fileRes.stat, assertStat)
+})
+
+t.describe('CreateReader()', function() {
+  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'
+        }
+      ],
+    ]
+  
+    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 }
+    const assertSize = 2000
+    const assertmTime = new Date('2021-04-03T11:22:33.777')
+    const assertIno = 3569723027
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    const stubCreateReadStream = stub().returns(assertBody)
+    let ctx = createCtx()
+    ctx.req.headers['range'] = 'bytes=0-1023'
+    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.strictEqual(stubCreateReadStream.firstCall[1].start, 0)
+    assert.strictEqual(stubCreateReadStream.firstCall[1].end, 1023)
+    assert.strictEqual(ctx.headers['Etag'], `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`)
+    assert.strictEqual(ctx.headers['Last-Modified'], assertmTime.toUTCString())
+    assert.strictEqual(ctx.headers['Content-Length'], 1024)
+    assert.strictEqual(ctx.type, 'image/jpeg')
+    assert.strictEqual(ctx.headers['Content-Range'], `0-1023/${assertSize}`)
+    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 }
+    const assertSize = 2000
+    const assertmTime = new Date('2021-04-03T11:22:33.777')
+    const roundedModified = new Date('2021-04-03T11:22:33')
+    const assertIno = 3569723027
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
+    let tests = [
+      function(headers) { headers['if-range'] = roundedModified.toUTCString() },
+      function(headers) { headers['if-range'] = assertEtag },
+    ]
+    tests.forEach(function(check, i) {
+      const stubCreateReadStream = stub().returns(assertBody)
+      let ctx = createCtx()
+      ctx.req.headers['range'] = 'bytes=0-1023'
+      check(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.strictEqual(stubCreateReadStream.firstCall[1].start, 0, `start missing in test ${i + 1}`)
+      assert.strictEqual(stubCreateReadStream.firstCall[1].end, 1023)
+      assert.strictEqual(ctx.headers['Etag'], `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`)
+      assert.strictEqual(ctx.headers['Last-Modified'], assertmTime.toUTCString())
+      assert.strictEqual(ctx.headers['Content-Length'], 1024)
+      assert.strictEqual(ctx.type, 'image/jpeg')
+      assert.strictEqual(ctx.headers['Content-Range'], `0-1023/${assertSize}`)
+      assert.strictEqual(ctx.status, 206)
+    })
+  })
+
+  t.test('return fileReader with proper start if only start is specified', function() {
+    const assertSize = 2000
+    const stat = {
+      size: assertSize,
+      mtime: new Date('2021-04-03T11:22:33.777'),
+      ino: 111,
+    }
+
+    const testStart = [0, 1000, 1999]
+    testStart.forEach(function(start) {
+      const stubCreateReadStream = stub()
+      let ctx = createCtx()
+      ctx.req.headers['range'] = 'bytes=' + start + '-'
+      ctx.body = new FileResponse('file.png', stat)
+      ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+      
+      assert.strictEqual(stubCreateReadStream.firstCall[1].start, start)
+      assert.strictEqual(stubCreateReadStream.firstCall[1].end, assertSize - 1)
+      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('should default to end if end overflows but start is valid', function() {
+    const assertSize = 2000
+    const stat = {
+      size: assertSize,
+      mtime: new Date('2021-04-03T11:22:33.777'),
+      ino: 111,
+    }
+
+    const testEnd = [2000, 3000, 99999]
+    testEnd.forEach(function(end) {
+      const stubCreateReadStream = stub()
+      let ctx = createCtx()
+      ctx.req.headers['range'] = 'bytes=1000-' + end
+      ctx.body = new FileResponse('file.png', stat)
+      ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+      
+      assert.strictEqual(stubCreateReadStream.firstCall[1].start, 1000)
+      assert.strictEqual(stubCreateReadStream.firstCall[1].end, 1999)
+      assert.strictEqual(ctx.headers['Content-Length'], 1000)
+      assert.strictEqual(ctx.headers['Content-Range'], `1000-${assertSize - 1}/${assertSize}`)
+      assert.strictEqual(ctx.status, 206)
+    })
+  })
+
+  t.test('should throw 416 if start is out of range', function() {
+    const stubCreateReadStream = stub()
+    let tests = [1000, 2000, 9999]
+
+    tests.forEach(function(start) {
+      let ctx = createCtx()
+      ctx.body = new FileResponse('file.png', {
+        size: 1000,
+        mtime: new Date('2021-04-03T11:22:33.777'),
+        ino: 111,
+      })
+      ctx.req.headers['range'] = `bytes=${start}-`
+
+      assert.throws(function() {
+        ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+      }, function(err) {
+        assert.strictEqual(err.status, 416)
+        assert.match(err.message, new RegExp(1000))
+        assert.match(err.message, new RegExp(start))
+        
+        assert.ok(ctx.headers['Etag'])
+        assert.notOk(stubCreateReadStream.called)
+        assert.notOk(ctx.headers['Last-Modified'])
+        assert.notOk(ctx.headers['Content-Length'])
+        assert.notOk(ctx.type)
+        assert.notOk(ctx.headers['Content-Range'])
+        return true
+      })
+    })
+  })
+  
+  t.test('should return 304 if etag is found', 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 assertIno = 3569723027
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
+
+    let tests = [
+      assertEtag,
+      `"asdf", "herp", ${assertEtag}`,
+      `"asdf", ${assertEtag}, "bla"`,
+      `${assertEtag}, "hello world"`,
+      `"asdf","herp",${assertEtag}`,
+      `"asdf",${assertEtag},"bla"`,
+      `${assertEtag},"hello world"`,
+    ]
+    tests.forEach(function(check) {
+      const stubCreateReadStream = stub().returns(assertNotBody)
+      let ctx = createCtx()
+      ctx.req.headers['if-none-match'] = check
+      ctx.body = new FileResponse(assertPath, stat)
+      let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+
+      assert.strictEqual(checkBody, null)
+      assert.strictEqual(ctx.status, 304)
+      assert.strictEqual(ctx.headers['Etag'], `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`)
+
+      assert.notOk(stubCreateReadStream.called)
+      
+      assert.notOk(ctx.headers['Last-Modified'])
+      assert.notOk(ctx.headers['Content-Length'])
+      assert.notOk(ctx.type)
+      assert.notOk(ctx.headers['Content-Range'])
+    })
+  })
+  
+  t.test('should return 304 if-last-modified is found', 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 assertIno = 3569723027
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+
+    let tests = [
+      assertmTime.toUTCString(),
+      'Fri, 02 Apr 2021 11:22:33 GMT',
+      'Fri, 02 Apr 2021 11:22:34 GMT',
+      'Fri, 02 Apr 2022 11:22:32 GMT',
+    ]
+
+    tests.forEach(function(check) {
+      const stubCreateReadStream = stub().returns(assertNotBody)
+      let ctx = createCtx()
+      ctx.body = new FileResponse(assertPath, stat)
+      ctx.req.headers['if-modified-since'] = assertmTime.toUTCString()
+      let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+
+      assert.strictEqual(checkBody, null)
+      assert.strictEqual(ctx.status, 304)
+      assert.strictEqual(ctx.headers['Etag'], `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`)
+
+      assert.notOk(stubCreateReadStream.called)
+      assert.notOk(ctx.headers['Last-Modified'])
+      assert.notOk(ctx.headers['Content-Length'])
+      assert.notOk(ctx.type)
+      assert.notOk(ctx.headers['Content-Range'])
+    })
+  })
+
+  t.test('should return 200 if etag or modified-by is not found', 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 assertIno = 3569723027
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
+    const roundedModified = new Date('2021-04-02T11:22:33')
+
+    let tests = [
+      function(headers) { headers['if-none-match'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() + 1}"`; },
+      function(headers) { headers['if-none-match'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() - 1}"`; },
+      function(headers) { headers['if-none-match'] = `"asdf"`; },
+      function(headers) { headers['if-none-match'] = `"asdf"`; headers['if-modified-since'] = roundedModified.toUTCString(); },
+      function(headers) { headers['if-modified-since'] = new Date(roundedModified.getTime() - 1).toUTCString(); },
+      function(headers) { headers['if-modified-since'] = 'asdfs' },
+    ]
+    tests.forEach(function(check, i) {
+      const stubCreateReadStream = stub().returns(assertBody)
+      let ctx = createCtx()
+      check(ctx.req.headers)
+      ctx.body = new FileResponse(assertPath, stat)
+      let checkBody = ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+
+      assert.strictEqual(checkBody, assertBody, 'missing body in test ' + (i + 1))
+      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('should return 412 if precondition fails', function() {
+    const stubCreateReadStream = stub()
+    const assertmTime = new Date('2021-04-02T11:22:33.777')
+    const roundedModified = new Date('2021-04-02T11:22:33')
+    const assertIno = 3569723027
+    const assertSize = 12498
+    const assertEtag = `"${assertIno}-${assertSize}-${assertmTime.getTime()}"`
+    const stat = {
+      size: assertSize,
+      mtime: assertmTime,
+      ino: assertIno,
+    }
+    let tests = [
+      function(headers) { headers['if-match'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() + 1}"` },
+      function(headers) { headers['if-match'] = `"${assertIno}-${assertSize}-${assertmTime.getTime() - 1}"` },
+      function(headers) { headers['if-match'] = `asdf` },
+      function(headers) { headers['if-unmodified-since'] = new Date(roundedModified.getTime() - 1).toUTCString(); },
+      function(headers) { headers['if-unmodified-since'] = 'asdf'; },
+      function(headers) { headers['if-match'] = assertEtag; headers['if-unmodified-since'] = 'asdf'; },
+      function(headers) { headers['if-match'] = assertEtag; headers['if-unmodified-since'] = new Date(roundedModified.getTime() - 1000).toUTCString(); },
+      function(headers) { headers['if-match'] = '"bla"'; headers['if-unmodified-since'] = roundedModified.toUTCString(); },
+    ]
+    tests.forEach(function(check) {
+      let ctx = createCtx()
+      ctx.body = new FileResponse('file.png', stat)
+      check(ctx.req.headers)
+
+      assert.throws(function() {
+        ctx.body.handleRequest(ctx, { createReadStream: stubCreateReadStream })
+      }, function(err) {
+        assert.strictEqual(err.status, 412)
+        assert.notOk(stubCreateReadStream.called)
+        assert.notOk(ctx.headers['Last-Modified'])
+        assert.notOk(ctx.headers['Content-Length'])
+        assert.notOk(ctx.type)
+        assert.notOk(ctx.headers['Content-Range'])
+        return true
+      })
+    })
+  })
+})

test/flaska.api.test.mjs

@@ -1,28 +1,295 @@
-import { Eltro as t, assert} from 'eltro'
-import { Flaska } from '../flaska.mjs'
-import { spy, createCtx, fakeHttp } from './helper.mjs'
+import { Eltro as t, assert, stub, spy } from 'eltro'
+import { Flaska, HttpError } from '../flaska.mjs'
+import { createCtx, fakeHttp } from './helper.mjs'
 
 const faker = fakeHttp()
 
-t.test('should be able to override the http', function() {    
-  let flaska = new Flaska({}, faker)
-  assert.strictEqual(flaska.http, faker)
+t.describe('#constructor', function() {
+  t.test('should be able to override the http', function() {    
+    let flaska = new Flaska({}, faker)
+    assert.strictEqual(flaska.http, faker)
+  })
+  
+  t.test('it should have all the common verbs', function() {
+    let flaska = new Flaska({}, faker)
+    assert.ok(flaska.get)
+    assert.strictEqual(typeof(flaska.get), 'function')
+    assert.ok(flaska.post)
+    assert.strictEqual(typeof(flaska.post), 'function')
+    assert.ok(flaska.put)
+    assert.strictEqual(typeof(flaska.put), 'function')
+    assert.ok(flaska.delete)
+    assert.strictEqual(typeof(flaska.delete), 'function')
+    assert.ok(flaska.options)
+    assert.strictEqual(typeof(flaska.options), 'function')
+    assert.ok(flaska.patch)
+    assert.strictEqual(typeof(flaska.patch), 'function')
+  })
+  
+  t.test('the verbs GET and HEAD should be identical', function() {
+    let flaska = new Flaska({}, faker)
+    assert.ok(flaska.get)
+    assert.strictEqual(typeof(flaska.get), 'function')
+    assert.notOk(flaska.head)
+    assert.ok(flaska.routers['HEAD'])
+    assert.strictEqual(flaska.routers['GET'], flaska.routers['HEAD'])
+  })
+
+  t.test('should have before default header generator', function() {
+    let flaska = new Flaska({}, faker)
+    assert.strictEqual(flaska._before.length, 1)
+    
+    let ctx = {}
+
+    flaska._before[0](ctx)
+
+    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:; 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.test('should have before ready setting headers on context if defaultHeaders is specified', function() {
+    const defaultHeaders = {
+      'Server': 'nginx/1.16.1',
+      'Content-Type': 'applicat"ion/json; charset=utf-8',
+      'Content-Length': '1646',
+      'Connection': 'keep-alive',
+      'vary': 'Origin',
+      'Link': 'Link goes here',
+      'X-Frame-Options': 'DENY',
+      'X-Content-Type-Options': 'nosniff',
+    }
+    let flaska = new Flaska({
+      defaultHeaders: defaultHeaders,
+    }, faker)
+    assert.strictEqual(flaska._before.length, 1)
+
+    let ctx = {}
+
+    flaska._before[0](ctx)
+    
+    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'])
+
+    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.test('it should have all the common verbs', function() {
-  let flaska = new Flaska({}, faker)
-  assert.ok(flaska.get)
-  assert.strictEqual(typeof(flaska.get), 'function')
-  assert.ok(flaska.post)
-  assert.strictEqual(typeof(flaska.post), 'function')
-  assert.ok(flaska.put)
-  assert.strictEqual(typeof(flaska.put), 'function')
-  assert.ok(flaska.delete)
-  assert.strictEqual(typeof(flaska.delete), 'function')
-  assert.ok(flaska.options)
-  assert.strictEqual(typeof(flaska.options), 'function')
-  assert.ok(flaska.patch)
-  assert.strictEqual(typeof(flaska.patch), 'function')
+t.describe('#_nonce', function() {
+  t.test('should support nonce parameter with cached pre-filled entries', function() {
+    let flaska = new Flaska({
+      nonce: ['script-src', 'style-src'],
+    }, faker)
+
+    assert.ok(flaska._nonces)
+    assert.strictEqual(flaska._noncesIndex + 1, flaska._nonces.length)
+    assert.strictEqual(flaska._nonces.length, 25)
+    assert.ok(flaska._nonces[flaska._noncesIndex])
+
+    //Check they're all unique
+    let set = new Set()
+    flaska._nonces.forEach(function(entry) {
+      set.add(entry)
+    })
+    assert.strictEqual(set.size, flaska._nonces.length)
+    
+    let ctx = createCtx()
+
+    assert.notOk(ctx.state.nonce)
+
+    let oldIndex = flaska._noncesIndex
+
+    flaska._before[0](ctx)
+    
+    assert.ok(ctx.state.nonce)
+    assert.strictEqual(flaska._noncesIndex, oldIndex - 1)
+    assert.strictEqual(flaska._nonces[oldIndex], ctx.state.nonce)
+
+    
+    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:; 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')
+    assert.ok(new Date(ctx.headers['Date']).getDate())
+  })
+  
+  t.test('should always return nonce values even if it runs out in cache', function() {
+    let flaska = new Flaska({
+      nonce: ['script-src'],
+      nonceCacheLength: 5,
+    }, faker)
+    let ctx = createCtx()
+
+    for (let i = 0; i < 5; i++) {
+      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:; font-src 'self' data:; object-src 'none'; frame-ancestors 'none'; script-src 'nonce-${ctx.state.nonce}'`)
+    }
+
+    assert.notOk(flaska._nonces[flaska._noncesIndex])
+    
+    flaska._before[0](ctx)
+    
+    assert.notOk(flaska._nonces[flaska._noncesIndex])
+    assert.ok(ctx.state.nonce)
+
+    for (let i = 0; i < flaska._nonces.length; i++) {
+      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:; 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() {
+    let flaska = new Flaska({
+      nonce: ['script-src'],
+      nonceCacheLength: 5,
+    }, faker)
+    let ctx = createCtx()
+
+    assert.strictEqual(flaska._after.length, 1)
+
+    //Check they're all unique
+    let set = new Set()
+    flaska._nonces.forEach(function(entry) {
+      set.add(entry)
+    })
+    assert.strictEqual(set.size, 5)
+    
+    flaska._before[0](ctx)
+    flaska._before[0](ctx)
+    flaska._before[0](ctx)
+
+    assert.strictEqual(flaska._noncesIndex, 1)
+    
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 2)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 6)
+
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 3)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 7)
+
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 4)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 8)
+    
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 4)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 8)
+  })
+
+  t.test('after should not generate keys outside range', function() {
+    let flaska = new Flaska({
+      nonce: ['script-src'],
+      nonceCacheLength: 2,
+    }, faker)
+    let ctx = createCtx()
+
+    assert.strictEqual(flaska._after.length, 1)
+
+    //Check they're all unique
+    let set = new Set()
+    flaska._nonces.forEach(function(entry) {
+      set.add(entry)
+    })
+    assert.strictEqual(set.size, 2)
+    
+    flaska._before[0](ctx)
+    flaska._before[0](ctx)
+
+    assert.strictEqual(flaska._noncesIndex, -1)
+    
+    flaska._before[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, -2)
+    set.add(ctx.state.nonce)
+    assert.strictEqual(set.size, 3)
+
+    flaska._before[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, -3)
+    set.add(ctx.state.nonce)
+    assert.strictEqual(set.size, 4)
+
+    flaska._before[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, -4)
+    set.add(ctx.state.nonce)
+    assert.strictEqual(set.size, 5)
+
+    assert.strictEqual(Object.keys(flaska._nonces).length, 2)
+    
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 0)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 6)
+    assert.strictEqual(Object.keys(flaska._nonces).length, 2)
+    
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 1)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 7)
+    assert.strictEqual(Object.keys(flaska._nonces).length, 2)
+    
+    flaska._after[0](ctx)
+    assert.strictEqual(flaska._noncesIndex, 1)
+    set.add(flaska._nonces[flaska._noncesIndex])
+    assert.strictEqual(set.size, 7)
+    assert.strictEqual(Object.keys(flaska._nonces).length, 2)
+  })
 })
 
 t.describe('#log', function() {
@@ -99,11 +366,6 @@ specialHandlers.forEach(function(type) {
 })
 
 t.describe('_on404', function() {
-  t.test('a valid function', function() {
-    let flaska = new Flaska({}, faker)
-    assert.strictEqual(typeof(flaska._on404), 'function')
-  })
-
   t.test('default valid handling of context', function() {
     let ctx = createCtx()
     let flaska = new Flaska({}, faker)
@@ -114,6 +376,28 @@ t.describe('_on404', function() {
       message: 'Not Found',
     })
   })
+
+  t.test('should do nothing if body is not null', function() {
+    const assertBody = { a: 1 }
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+
+    ctx.body = assertBody
+    flaska._on404(ctx)
+    assert.strictEqual(ctx.status, 200)
+    assert.strictEqual(ctx.body, assertBody)
+  })
+
+  t.test('should do nothing if body is null but status is 204', function() {
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+
+    ctx.status = 204
+    ctx.body = null
+    flaska._on404(ctx)
+    assert.strictEqual(ctx.status, 204)
+    assert.strictEqual(ctx.body, null)
+  })
 })
 
 t.describe('_onerror', function() {
@@ -135,6 +419,68 @@ t.describe('_onerror', function() {
       message: 'Internal Server Error',
     })
   })
+
+  t.test('default valid handling of HttpError', function() {
+    const assertStatus = 431
+    const assertBody = { a: 1 }
+    const assertError = new HttpError(assertStatus, 'should not be seen', assertBody)
+    
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+    flaska._onerror(assertError, ctx)
+    assert.strictEqual(ctx.log.error.callCount, 1)
+    assert.strictEqual(ctx.log.error.firstCall[0], assertError)
+    assert.strictEqual(ctx.status, assertStatus)
+    assert.strictEqual(ctx.body, assertBody)
+  })
+
+  t.test('default valid handling of HttpError with no body', function() {
+    const assertStatus = 413
+    const assertError = new HttpError(assertStatus, 'should not be seen')
+    
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+    flaska._onerror(assertError, ctx)
+    assert.strictEqual(ctx.log.error.callCount, 1)
+    assert.strictEqual(ctx.log.error.firstCall[0], assertError)
+    assert.strictEqual(ctx.status, assertStatus)
+    assert.deepStrictEqual(ctx.body, {
+      status: assertStatus,
+      message: 'Payload Too Large',
+    })
+  })
+
+  t.test('default valid handling of HttpError with missing status message', function() {
+    const assertStatus = 432
+    const assertError = new HttpError(assertStatus, 'should not be seen')
+    
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+    flaska._onerror(assertError, ctx)
+    assert.strictEqual(ctx.log.error.callCount, 1)
+    assert.strictEqual(ctx.log.error.firstCall[0], assertError)
+    assert.strictEqual(ctx.status, assertStatus)
+    assert.deepStrictEqual(ctx.body, {
+      status: assertStatus,
+      message: 'Internal Server Error',
+    })
+  })
+})
+
+t.describe('_onreqerror', function() {
+  t.test('a valid function', function() {
+    let flaska = new Flaska({}, faker)
+    assert.strictEqual(typeof(flaska._onreqerror), 'function')
+  })
+
+  t.test('default valid handling of aborted', function() {
+    const assertError = new Error('aborted')
+    let flaska = new Flaska({}, faker)
+    let ctx = createCtx()
+    flaska._onreqerror(assertError, ctx)
+    assert.strictEqual(ctx.log.info.callCount, 0)
+    assert.strictEqual(ctx.log.error.callCount, 0)
+  })
 })
 
 t.describe('#devMode()', function() {
@@ -180,6 +526,54 @@ t.describe('#devMode()', function() {
     assert.match(ctx.body.message, new RegExp(assertErrorMessage))
     assert.ok(ctx.body.stack)
   })
+
+  t.test('default valid handling of HttpError', function() {
+    const assertStatus = 431
+    const assertBody = { a: 1 }
+    const assertError = new HttpError(assertStatus, 'should not be seen', assertBody)
+    
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+    flaska.devMode()
+    flaska._onerror(assertError, ctx)
+    assert.strictEqual(ctx.log.error.callCount, 1)
+    assert.strictEqual(ctx.log.error.firstCall[0], assertError)
+    assert.strictEqual(ctx.status, assertStatus)
+    assert.strictEqual(ctx.body, assertBody)
+  })
+
+  t.test('default valid handling of HttpError with no body', function() {
+    const assertStatus = 413
+    const assertErrorMessage = 'A day'
+    const assertError = new HttpError(assertStatus, assertErrorMessage)
+    
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+    flaska.devMode()
+    flaska._onerror(assertError, ctx)
+    assert.strictEqual(ctx.log.error.callCount, 1)
+    assert.strictEqual(ctx.log.error.firstCall[0], assertError)
+    assert.strictEqual(ctx.status, assertStatus)
+    assert.strictEqual(ctx.body.status, assertStatus)
+    assert.match(ctx.body.message, /Payload Too Large/)
+    assert.match(ctx.body.message, new RegExp(assertErrorMessage))
+  })
+
+  t.test('default valid handling of HttpError with missing status message', function() {
+    const assertStatus = 432
+    const assertErrorMessage = 'Jet Coaster Ride'
+    const assertError = new HttpError(assertStatus, assertErrorMessage)
+    
+    let ctx = createCtx()
+    let flaska = new Flaska({}, faker)
+    flaska.devMode()
+    flaska._onerror(assertError, ctx)
+    assert.strictEqual(ctx.log.error.callCount, 1)
+    assert.strictEqual(ctx.log.error.firstCall[0], assertError)
+    assert.strictEqual(ctx.status, assertStatus)
+    assert.strictEqual(ctx.body.status, assertStatus)
+    assert.match(ctx.body.message, /Internal Server Error/)
+  })
 })
 
 t.describe('#before()', function() {
@@ -198,8 +592,8 @@ t.describe('#before()', function() {
     let flaska = new Flaska({}, faker)
     assert.ok(flaska._before)
     flaska.before(assertFunction)
-    assert.strictEqual(flaska._before.length, 1)
-    assert.strictEqual(flaska._before[0], assertFunction)
+    assert.strictEqual(flaska._before.length, 2)
+    assert.strictEqual(flaska._before[1], assertFunction)
   })
 })
 
@@ -441,12 +835,39 @@ t.describe('#listen()', function() {
 
   t.test('call http correctly', function() {
     const assertPort = 325897235
+    const assertIp = 'asdga'
     const assertCb = function() { }
     let checkPort = null
+    let checkIp = null
     let checkListenCb = null
 
-    let testFaker = fakeHttp(null, function(port, cb) {
+    let testFaker = fakeHttp(null, function(port, ip, cb) {
       checkPort = port
+      checkIp = ip
+      checkListenCb = cb
+    })
+    let flaska = new Flaska({}, testFaker)
+    assert.ok(flaska.requestStart)
+    flaska.requestStart = function() {
+      checkInternalThis = this
+      checkIsTrue = true
+    }
+    flaska.listen(assertPort, assertIp, assertCb)
+    assert.strictEqual(checkPort, assertPort)
+    assert.strictEqual(checkIp, assertIp)
+    assert.strictEqual(checkListenCb, assertCb)
+  })
+
+  t.test('call http correctly if only port is specified', function() {
+    const assertPort = 325897235
+    const assertCb = function() { }
+    let checkPort = null
+    let checkIp = null
+    let checkListenCb = null
+
+    let testFaker = fakeHttp(null, function(port, ip, cb) {
+      checkPort = port
+      checkIp = ip
       checkListenCb = cb
     })
     let flaska = new Flaska({}, testFaker)
@@ -457,6 +878,7 @@ t.describe('#listen()', function() {
     }
     flaska.listen(assertPort, assertCb)
     assert.strictEqual(checkPort, assertPort)
+    assert.strictEqual(checkIp, '::')
     assert.strictEqual(checkListenCb, assertCb)
   })
 
@@ -484,3 +906,181 @@ t.describe('#listen()', function() {
     assert.strictEqual(checkInternalThis, flaska)
   })
 })
+
+t.describe('#listenAsync()', function() {
+  t.test('it should throw if missing port', async function() {
+    let flaska = new Flaska({}, faker)
+
+    let tests = [
+      undefined,
+      'asdf',
+      '123',
+      [],
+      {},
+      function() {},
+    ]
+    let errors = await Promise.all(tests.map(x => assert.isRejected(flaska.listenAsync(x))))
+    assert.strictEqual(errors.length, tests.length)
+    for (let i = 0; i < errors.length; i++) {
+      assert.match(errors[i].message, /[Pp]ort/)
+    }
+  })
+
+  t.test('it should automatically call compile', async function() {
+    let assertCalled = false
+    let flaska = new Flaska({}, faker)
+    flaska.compile = function() { assertCalled = true }
+    await flaska.listenAsync(404)
+    assert.strictEqual(assertCalled, true)
+  })
+
+  t.test('call http correctly', async function() {
+    const assertPort = 325897235
+    const assertIp = 'asdf'
+    let checkPort = null
+    let checkIp = null
+
+    let testFaker = fakeHttp(null, function(port, ip, cb) {
+      checkPort = port
+      checkIp = ip
+      cb()
+    })
+
+    let flaska = new Flaska({}, testFaker)
+    assert.ok(flaska.requestStart)
+    flaska.requestStart = function() {
+      checkInternalThis = this
+      checkIsTrue = true
+    }
+    await flaska.listenAsync(assertPort, assertIp)
+    assert.strictEqual(checkPort, assertPort)
+    assert.strictEqual(checkIp, assertIp)
+  })
+
+  t.test('call http and listen correctly if only port specified', async function() {
+    const assertPort = 325897235
+    let checkPort = null
+    let checkIp = null
+
+    let testFaker = fakeHttp(null, function(port, ip, cb) {
+      checkPort = port
+      checkIp = ip
+      cb()
+    })
+    let flaska = new Flaska({}, testFaker)
+    assert.ok(flaska.requestStart)
+    flaska.requestStart = function() {
+      checkInternalThis = this
+      checkIsTrue = true
+    }
+    await flaska.listenAsync(assertPort)
+    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
+    let checkInternalThis = null
+    let checkHandler = null
+
+    let testFaker = fakeHttp(function(cb) {
+      checkHandler = cb
+    })
+    let flaska = new Flaska({}, testFaker)
+    assert.ok(flaska.requestStart)
+    flaska.requestStart = function() {
+      checkInternalThis = this
+      checkIsTrue = true
+    }
+    await flaska.listenAsync(404)
+    assert.strictEqual(typeof(checkHandler), 'function')
+    assert.notStrictEqual(checkHandler, flaska.requestStart)
+    assert.notStrictEqual(checkIsTrue, true)
+    assert.notStrictEqual(checkInternalThis, flaska)
+    checkHandler()
+    assert.strictEqual(checkIsTrue, true)
+    assert.strictEqual(checkInternalThis, flaska)
+  })
+})
+
+t.describe('#closeAsync()', function() {
+  t.test('it return if server is null', function() {
+    let flaska = new Flaska()
+    flaska.server = null
+    return flaska.closeAsync()
+  })
+
+  t.test('it should call close on server correctly', async function() {
+    const assertError = new Error('Pirate Fight')
+    let flaska = new Flaska()
+    flaska.server = {
+      close: stub()
+    }
+    flaska.server.close.returnWith(function(cb) {
+      cb(assertError)
+    })
+    let err = await assert.isRejected(flaska.closeAsync())
+    assert.strictEqual(err, assertError)
+  })
+
+  t.test('should otherwise work', async function() {
+    let flaska = new Flaska()
+    flaska.server = {
+      close: stub()
+    }
+    flaska.server.close.returnWith(function(cb) {
+      cb(null, { a: 1 })
+    })
+    let res = await flaska.closeAsync()
+    assert.notOk(res)
+  })
+})

test/flaska.in.test.mjs

@@ -1,6 +1,6 @@
-import { Eltro as t, assert} from 'eltro'
+import { Eltro as t, spy, assert} from 'eltro'
 import { Flaska } from '../flaska.mjs'
-import { fakeHttp, createReq, spy, createRes } from './helper.mjs'
+import { fakeHttp, createReq, createRes } from './helper.mjs'
 
 const faker = fakeHttp()
 
@@ -19,45 +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], 'aborted')
-        assert.strictEqual(typeof(assertReq.on.secondCall[1]), 'function')
-        assert.notStrictEqual(ctx.aborted, false)
-        assertReq.on.secondCall[1]()
-        assert.strictEqual(ctx.aborted, true)
-
-        // 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()
     }
@@ -71,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)
@@ -105,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)
   })
@@ -138,27 +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)
-        cb()
-      } catch (err) { cb(err) }
-    }
+      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:; 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,
@@ -166,14 +151,52 @@ t.describe('#requestStart()', function() {
     }), createRes())
   })
 
+  t.test('correctly adds default headers', function(cb) {
+    const assertError = new Error('test')
+    const defaultHeaders = {
+      'Test': 'Asdf',
+      'Herp': 'Derp',
+    }
+    let flaska = new Flaska({
+      defaultHeaders: defaultHeaders,
+    }, faker)
+    flaska.compile()
+
+    flaska.routers.test = {
+      match: function(path) {
+        throw assertError
+      }
+    }
+
+    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: '/',
+      method: 'test',
+    }), createRes())
+  })
+
   t.test('calls correct router with correct url and context if beforeAsync', function(cb) {
     const assertError = new Error('test')
     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) {
@@ -182,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,
@@ -224,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: '',
@@ -256,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',
@@ -286,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',
@@ -316,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',
@@ -346,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',
@@ -376,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',
@@ -408,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',
@@ -440,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: '',
@@ -470,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',
@@ -501,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',
@@ -540,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',
@@ -571,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',
@@ -606,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',

test/flaska.out.test.mjs

@@ -1,6 +1,6 @@
-import { Eltro as t, assert} from 'eltro'
-import { Flaska, FlaskaRouter } from '../flaska.mjs'
-import { fakeHttp, createCtx, spy } from './helper.mjs'
+import { Eltro as t, spy, assert, stub} from 'eltro'
+import { FileResponse, Flaska, FlaskaRouter } from '../flaska.mjs'
+import { fakeHttp, createCtx } from './helper.mjs'
 
 const fakerHttp = fakeHttp()
 const fakeStream = { pipeline: spy() }
@@ -12,21 +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.res.statusCode, assertStatus)
-        assert.strictEqual(ctx.res.setHeader.callCount, 2)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], 'application/json; charset=utf-8')
-        assert.strictEqual(ctx.res.setHeader.secondCall[0], 'Content-Length')
-        assert.strictEqual(ctx.res.setHeader.secondCall[1], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, '{"a":1}')
-        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)
@@ -44,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)
@@ -62,107 +55,364 @@ 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.res.statusCode, assertStatus)
-        assert.strictEqual(ctx.res.setHeader.callCount, 2)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], 'application/json; charset=utf-8')
-        assert.strictEqual(ctx.res.setHeader.secondCall[0], 'Content-Length')
-        assert.strictEqual(ctx.res.setHeader.secondCall[1], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, '{"a":1}')
-        cb()
-      } catch (err) { cb(err) }
-    }
-    const ctx = createCtx({
-      status: assertStatus,
-    }, onFinish)
-    ctx.body = assertBody
+  let testMethods = ['GET', 'HEAD']
+  
+  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)
+          if (method === 'GET') {
+            assert.ok(body)
+            assert.strictEqual(body, '{"a":1}')
+          } 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 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)
+        })
+      }
+    })
   })
   
-  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.res.statusCode, assertStatus)
-        assert.strictEqual(ctx.res.setHeader.callCount, 2)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], 'text/plain; charset=utf-8')
-        assert.strictEqual(ctx.res.setHeader.secondCall[0], 'Content-Length')
-        assert.strictEqual(ctx.res.setHeader.secondCall[1], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, assertBody)
-        cb()
-      } catch (err) { cb(err) }
-    }
+  t.test('call _onerror with error if handleRequest throws error', function() {
+    let body = new FileResponse()
+    const assertError = new Error('Secrets of the Goddess')
+    let assertBody = { a : 1 }
     const ctx = createCtx({
-      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 = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.body, assertBody)
-        assert.strictEqual(ctx.res.statusCode, assertStatus)
-        assert.strictEqual(ctx.res.setHeader.callCount, 2)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], 'text/plain; charset=utf-8')
-        assert.strictEqual(ctx.res.setHeader.secondCall[0], 'Content-Length')
-        assert.strictEqual(ctx.res.setHeader.secondCall[1], assertBodyLength)
-        assert.ok(body)
-        assert.strictEqual(body, assertBody.toString())
-        cb()
-      } catch (err) { cb(err) }
-    }
-    const ctx = createCtx({
-      status: assertStatus,
-    }, onFinish)
-    ctx.body = assertBody
+      status: 204,
+    })
+    ctx.body = body
+    const assertHandle = stub().throws(assertError)
+    body.handleRequest = assertHandle
 
     let flaska = new Flaska({}, fakerHttp, fakeStream)
+    flaska._onerror = stub().returnWith(function(err, checkCtx) {
+      assert.strictEqual(err, assertError)
+      checkCtx.body = assertBody
+    })
     flaska.requestEnd(null, ctx)
+    assert.ok(assertHandle.called)
+    assert.ok(flaska._onerror.called)
+    assert.strictEqual(flaska._onerror.firstCall[0], assertError)
+    assert.ok(ctx.res.writeHead)
+    assert.strictEqual(ctx.body, assertBody)
   })
 
   t.test('call res and end correctly when dealing with custom type', function(cb) {
     const assertStatus = 209
     const assertBody = 'test'
     const assertType = 'something/else'
-    let onFinish = function(body) {
-      try {
-        assert.strictEqual(ctx.status, assertStatus)
-        assert.strictEqual(ctx.res.statusCode, assertStatus)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], assertType)
-        assert.strictEqual(body, assertBody)
-        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,
@@ -173,45 +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.res.statusCode, assertStatus)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], assertType)
-        assert.strictEqual(source, assertBody)
-        assert.strictEqual(target, ctx.res)
-        assert.strictEqual(typeof(callback), 'function')
-        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.res.statusCode, 200)
-        assert.strictEqual(ctx.res.setHeader.firstCall[0], 'Content-Type')
-        assert.strictEqual(ctx.res.setHeader.firstCall[1], 'application/octet-stream')
-        assert.strictEqual(source, ctx.body)
-        assert.strictEqual(target, ctx.res)
-        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
@@ -219,6 +440,33 @@ t.describe('#requestEnd()', function() {
     let flaska = new Flaska({}, fakerHttp, fakeStream)
     flaska.requestEnd(null, ctx)
   })
+
+  let tests = [
+    ['png', 'image/png'],
+    ['jpg', 'image/jpeg'],
+    ['bmp', 'image/bmp'],
+    ['js', 'text/javascript'],
+  ]
+
+  tests.forEach(function(test) {
+    t.test(`call pipe with file extension ${test[0]} should mimetype ${test[1]}`, function(cb) {
+      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
+  
+      let flaska = new Flaska({}, fakerHttp, fakeStream)
+      flaska.requestEnd(null, ctx)
+    })
+  })
   
   t.test('should return immediately if req is finished', function() {
     let onFinish = function() {
@@ -238,15 +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.statusCode, assertStatus)
-          assert.strictEqual(ctx.res.setHeader.callCount, 0)
-          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,
@@ -260,6 +507,38 @@ t.describe('#requestEnd()', function() {
 })
 
 t.describe('#requestEnded()', function() {
+  t.test('calls destroy if body is pipe and is not closed', function() {
+    const ctx = createCtx({
+      body: {
+        pipe: {},
+        closed: false,
+        destroy: spy(),
+      },
+    })
+    let flaska = new Flaska({}, fakerHttp)
+    flaska._afterCompiled = function() {}
+
+    flaska.requestEnded(ctx)
+
+    assert.ok(ctx.body.destroy.called)
+  })
+
+  t.test('not call destroy if body is pipe but is closed', function() {
+    const ctx = createCtx({
+      body: {
+        pipe: {},
+        closed: true,
+        destroy: spy(),
+      }
+    })
+    let flaska = new Flaska({}, fakerHttp)
+    flaska._afterCompiled = function() {}
+
+    flaska.requestEnded(ctx)
+
+    assert.notOk(ctx.body.destroy.called)
+  })
+
   t.test('calls afterCompiled correctly', function() {
     const assertError = new Error('test')
     const assertCtx = createCtx()

test/helper.mjs

@@ -1,41 +1,23 @@
+import { spy } from 'eltro'
+
 const indexMap = [
   'firstCall',
   'secondCall',
   'thirdCall',
 ]
 
-export function spy() {
-  let calls = []
-  let called = 0
-  let func = function(...args) {
-    func.called = true
-    calls.push(args)
-    if (called < indexMap.length) {
-      func[indexMap[called]] = args
-    }
-    called++
-    func.callCount = called
-  }
-  func.called = false
-  func.callCount = called
-  func.onCall = function(i) {
-    return calls[i]
-  }
-  for (let i = 0; i < indexMap.length; i++) {
-    func[indexMap] = null
-  }
-  return func
-}
-
-export function fakeHttp(inj1, inj2) {
+export function fakeHttp(inj1, inj2, inj3) {
   let intermediate = {
     createServer: function(cb) {
       if (inj1) inj1(cb)
       intermediate.fakeRequest = cb
       return {
-        listen: function(port, cb) {
-          if (inj2) inj2(port, cb)
+        listen: function(port, ip, cb) {
+          if (inj2) inj2(port, ip, cb)
           else if (cb) cb()
+        },
+        on: function(name, handler) {
+          if (inj3) inj3(name, handler)
         }
       }
     }
@@ -45,6 +27,7 @@ export function fakeHttp(inj1, inj2) {
 
 export function createReq(def) {
   return defaults(def, {
+    headers: {},
     on: spy(),
   })
 }
@@ -61,7 +44,7 @@ export function createRes(def) {
   })
 }
 
-export function createCtx(def, endHandler) {
+export function createCtx(def = {}, endHandler = null) {
   return defaults(def, {
     req: createReq(),
     res: createRes({ end: endHandler || spy() }),
@@ -74,6 +57,7 @@ export function createCtx(def, endHandler) {
     body: null,
     type: null,
     length: null,
+    headers: {},
     log: {
       error: spy(),
       info: spy(),

test/http.test.mjs

@@ -1,29 +1,513 @@
-import { Eltro as t, assert} from 'eltro'
-import { Flaska } from '../flaska.mjs'
+import fsSync from 'fs'
+import http from 'http'
+import fs from 'fs/promises'
+import formidable from 'formidable'
+import { Eltro as t, assert, stub } from 'eltro'
+import { setTimeout } from 'timers/promises'
+import { Flaska, JsonHandler, FormidableHandler, FileResponse } from '../flaska.mjs'
 import Client from './client.mjs'
 
 const port = 51024
-const flaska = new Flaska({})
+const log = {
+  fatal: stub(),
+  error: stub(),
+  warn: stub(),
+  info: stub(),
+  debug: stub(),
+  trace: stub(),
+  log: stub(),
+}
+const flaska = new Flaska({ log })
 const client = new Client(port)
 
+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 }
 })
+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() {})
+})
+flaska.get('/file', function(ctx) {
+  file = fsSync.createReadStream('./test/test.png')
+  ctx.body = file
+})
+flaska.get('/filehandle', function(ctx) {
+  return fs.stat('./test/test.txt').then(function(stat) {
+    ctx.body = new FileResponse('./test/test.txt', stat)
+  })
+})
+flaska.post('/file/upload', FormidableHandler(formidable, {
+  uploadDir: './test/upload'
+}), function(ctx) {
+  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
 
-t.before(function(cb) {
-  flaska.listen(port, cb)
+  return new Promise(function() {})
 })
 
-t.describe('', function() {
-  t.test('/ should return status true', function() {
-    return client.get().then(function(body) {
+function reset() {
+  log.fatal.reset()
+  log.error.reset()
+  log.warn.reset()
+  log.info.reset()
+  log.debug.reset()
+  log.trace.reset()
+  log.log.reset()
+}
+
+t.before(function() {
+  return flaska.listenAsync(port)
+})
+
+t.describe('/', function() {
+  t.test('should return status true', function() {
+    return client.get('/').then(function(body) {
       assert.deepEqual(body, { status: true })
     })
   })
 })
 
-t.after(function(cb) {
-  setTimeout(function() {
-    flaska.server.close(cb)
-  }, 1000)
+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++) {
+      assertBody.a += 'aaaaaaaaaa'
+    }
+    reqBody = null
+    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() {
+    reset()
+
+    const assertBody = { a: '' }
+    for (let i = 0; i < 10300; i++) {
+      assertBody.a += 'aaaaaaaaaa'
+    }
+
+    let err = await assert.isRejected(client.post('/json', assertBody))
+
+    assert.strictEqual(err.body.status, 413)
+    assert.ok(log.error.called)
+    assert.match(log.error.firstCall[0].message, /10240/)
+    assert.strictEqual(log.error.firstCall[0].status, 413)
+  })
+
+  t.test('should fail if not a valid json', async function() {
+    reset()
+
+    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[^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[^X]+X/i)
+  })
+
+  t.test('should handle incomplete requests correctly', async function() {
+    reset()
+
+    let req = await client.customRequest('POST', '/json', 'aaaa', { returnRequest: true })
+
+    req.write('part1')
+
+    await setTimeout(20)
+
+    req.destroy()
+
+    await setTimeout(20)
+
+    assert.strictEqual(log.error.callCount, 0)
+    assert.strictEqual(log.info.callCount, 0)
+    // assert.strictEqual(log.info.firstCall[0].message, 'aborted')
+  })
+})
+
+t.describe('/timeout', function() {
+  t.test('server should handle timeout', async function() {
+    reset()
+
+    let err = await assert.isRejected(client.customRequest('GET', '/timeout', JSON.stringify({}), { timeout: 20 }))
+
+    assert.match(err.message, /timed out/)
+    assert.notOk(log.error.called)
+    assert.notOk(log.info.called)
+  })
+})
+
+t.describe('/file', function() {
+  t.test('server should pipe', async function() {
+    log.error.reset()
+
+    let target = fsSync.createWriteStream('./test_tmp.png')
+
+    await client.customRequest('GET', '/file', null, { toPipe: target })
+
+    while (!target.closed && !file.closed) {
+      await setTimeout(10)
+    }
+
+    assert.ok(target.closed)
+    assert.ok(file.closed)
+    
+    let [statSource, statTarget] = await Promise.all([
+      fs.stat('./test/test.png'),
+      fs.stat('./test_tmp.png'),
+    ])
+
+    assert.strictEqual(statSource.size, statTarget.size)
+  })
+  t.test('server should autoclose body file handles on errors', async function() {
+    reset()
+
+    file = null
+
+    let req = await client.customRequest('GET', '/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() {
+  const agent = new http.Agent({
+    keepAlive: true,
+    maxSockets: 1,
+    keepAliveMsecs: 3000,
+  })
+
+  t.test('server should send correctly', async function() {
+    log.error.reset()
+
+    let res = await client.customRequest('GET', '/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())
+
+    res = await client.customRequest('GET', '/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('GET', '/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('GET', '/filehandle', null, { getRaw: true, agent: agent,
+      headers: {
+        'Range': 'bytes=2-5'
+      },
+    })
+    assert.strictEqual(res.status, 206)
+    assert.strictEqual(res.data, 'llo ')
+    assert.strictEqual(res.headers['content-length'], '4')
+
+    
+    res = await client.customRequest('GET', '/filehandle', null, { getRaw: true, agent: agent,
+      headers: {
+        'Range': 'bytes=0-0'
+      },
+    })
+    assert.strictEqual(res.status, 206)
+    assert.strictEqual(res.data, 'H')
+    assert.strictEqual(res.headers['content-length'], '1')
+  })
+
+  t.after(function() {
+    agent.destroy()
+  })
+})
+
+t.describe('/file/upload', function() {
+  t.test('server should upload file', async function() {
+    let res = await client.upload('/file/upload', './test/test.png')
+
+    let [statSource, statTarget] = await Promise.all([
+      fs.stat('./test/test.png'),
+      fs.stat(res.path),
+    ])
+
+    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()
+    })
+  })
+})
+
+t.after(function() {
+  return Promise.all([
+    fs.rm('./test_tmp.png', { force: true }),
+    Promise.all(uploaded.map(file => fs.rm(file.path, { force: true }))),
+    flaska.closeAsync(),
+  ])
 })

test/middlewares.test.mjs

@@ -1,5 +1,11 @@
-import { Eltro as t, assert} from 'eltro'
-import { QueryHandler } from '../flaska.mjs'
+import os from 'os'
+import path from 'path'
+import { Buffer } from 'buffer'
+import { Eltro as t, assert, stub} from 'eltro'
+import { QueryHandler, JsonHandler, FormidableHandler, HttpError, CorsHandler } from '../flaska.mjs'
+import { createCtx } from './helper.mjs'
+import { finished } from 'stream'
+import { setTimeout } from 'timers/promises'
 
 t.describe('#QueryHandler()', function() {
   let queryHandler = QueryHandler()
@@ -22,3 +28,722 @@ t.describe('#QueryHandler()', function() {
     assert.strictEqual(ctx.query.get('ITEM2'), 'hello world')
   })
 })
+
+
+t.describe('#CorsHandler()', function() {
+  let corsHandler
+  let ctx
+  
+  t.test('should return a handler', function() {
+    corsHandler = CorsHandler()
+    assert.strictEqual(typeof(corsHandler), 'function')
+  })
+
+  t.describe('OPTIONS', function() {
+    t.beforeEach(function() {
+      ctx = createCtx()
+      ctx.method = 'OPTIONS'
+    })
+
+    t.test('should set status and headers', function() {
+      const assertOrigin = 'http://my.site.here'
+      const assertRequestHeaders = 'asdf,foobar'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: [assertOrigin],
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = assertRequestHeaders
+
+      assert.notOk(ctx.headers['Vary'])
+      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.strictEqual(ctx.headers['Access-Control-Allow-Methods'], 'GET,HEAD,PUT,POST,DELETE,PATCH')
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Headers'], assertRequestHeaders)
+      assert.notOk(ctx.headers['Access-Control-Allow-Credentials'])
+      assert.notOk(ctx.headers['Access-Control-Max-Age'])
+      assert.strictEqual(ctx.status, 204)
+    })
+
+    t.test('should set Allow-Credentials if credentials is specified', function() {
+      const assertOrigin = 'http://my.site.here'
+      const assertRequestHeaders = 'asdf,foobar'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: [assertOrigin],
+        credentials: true,
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = assertRequestHeaders
+
+      assert.notOk(ctx.headers['Vary'])
+      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-Credentials'], 'true')
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Origin'], assertOrigin)
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Methods'], 'GET,HEAD,PUT,POST,DELETE,PATCH')
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Headers'], assertRequestHeaders)
+      assert.notOk(ctx.headers['Access-Control-Max-Age'])
+      assert.strictEqual(ctx.status, 204)
+    })
+
+    t.test('should set Max-Age if maxAge is specified', function() {
+      const assertOrigin = 'http://my.site.here'
+      const assertRequestHeaders = 'asdf,foobar'
+      const assertMaxAge = '600'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: [assertOrigin],
+        maxAge: assertMaxAge,
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = assertRequestHeaders
+
+      assert.notOk(ctx.headers['Vary'])
+      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.strictEqual(ctx.headers['Access-Control-Max-Age'], assertMaxAge)
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Methods'], 'GET,HEAD,PUT,POST,DELETE,PATCH')
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Headers'], assertRequestHeaders)
+      assert.notOk(ctx.headers['Access-Control-Allow-Credentials'])
+      assert.strictEqual(ctx.status, 204)
+    })
+
+    t.test('should support custom allowed methods and headers', function() {
+      const assertOrigin = 'http://my.site.here'
+      const assertAllowedMethods = 'GET,HEAD'
+      const assertAllowedHeaders = 'test1,test2'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: [assertOrigin],
+        allowedMethods: assertAllowedMethods,
+        allowedHeaders: assertAllowedHeaders,
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = 'asdfasdfasdfsfad'
+
+      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.notOk(ctx.headers['Access-Control-Allow-Credentials'])
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Origin'], assertOrigin)
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Methods'], assertAllowedMethods)
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Headers'], assertAllowedHeaders)
+      assert.strictEqual(ctx.status, 204)
+    })
+
+    t.test('should not set any allowed headers if allowedHeaders is explicitly false', function() {
+      const assertOrigin = 'http://my.site.here'
+      const assertAllowedMethods = 'GET,HEAD'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: [assertOrigin],
+        allowedMethods: assertAllowedMethods,
+        allowedHeaders: false,
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = 'asdfasdfasdfsfad'
+
+      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.notOk(ctx.headers['Access-Control-Allow-Credentials'])
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Origin'], assertOrigin)
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Methods'], assertAllowedMethods)
+      assert.strictEqual(ctx.headers['Access-Control-Allow-Headers'], undefined)
+      assert.strictEqual(ctx.status, 204)
+    })
+    
+    t.test('should not add any headers if origin missing', function() {
+      corsHandler = CorsHandler({
+        allowedOrigins: ['https://test.com'],
+      })
+      ctx.req.headers['origin'] = null
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = 'asdfasdfasdfsfad'
+
+      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.notOk(ctx.headers['Access-Control-Allow-Origin'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+      assert.strictEqual(ctx.status, 204)
+    })
+
+    t.test('should not add any headers if origin not found', function() {
+      const assertOrigin = 'http://my.site.here'
+      const assertAllowedMethods = 'GET,HEAD'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: ['https://my.site.here'],
+        allowedMethods: assertAllowedMethods,
+        allowedHeaders: false,
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      ctx.req.headers['access-control-request-method'] = 'GET'
+      ctx.req.headers['access-control-request-headers'] = 'asdfasdfasdfsfad'
+
+      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.notOk(ctx.headers['Access-Control-Allow-Origin'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+      assert.strictEqual(ctx.status, 204)
+    })
+
+    t.test('should not add any headers if request-method is missing', function() {
+      const assertOrigin = 'http://my.site.here'
+
+      corsHandler = CorsHandler({
+        allowedOrigins: ['http://my.site.here'],
+      })
+      ctx.req.headers['origin'] = assertOrigin
+      delete ctx.req.headers['access-control-request-method']
+      ctx.req.headers['access-control-request-headers'] = 'asdfasdfasdfsfad'
+
+      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.notOk(ctx.headers['Access-Control-Allow-Origin'])
+      assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+      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() {
+    let testMethods = ['GET', 'POST', 'DELETE', 'PATCH', 'PUT']
+
+    t.test('should set header but no status', function() {
+      testMethods.forEach(function(method) {
+        ctx = createCtx()
+        ctx.method = method
+        ctx.status = method
+
+        const assertOrigin = 'http://my.site.here'
+
+        corsHandler = CorsHandler({
+          allowedOrigins: [assertOrigin],
+        })
+        ctx.req.headers['origin'] = assertOrigin
+        ctx.req.headers['access-control-request-headers'] = 'asdfasdfasdfsfad'
+
+        assert.notOk(ctx.headers['Vary'])
+        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.notOk(ctx.headers['Access-Control-Allow-Credentials'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+        assert.notOk(ctx.headers['Access-Control-Expose-Headers'])
+        assert.strictEqual(ctx.status, method)
+      })
+    })
+
+    t.test('should set credential header if specifed', function() {
+      testMethods.forEach(function(method) {
+        ctx = createCtx()
+        ctx.method = method
+        ctx.status = method
+
+        const assertOrigin = 'http://my.site.here'
+
+        corsHandler = CorsHandler({
+          allowedOrigins: [assertOrigin],
+          credentials: true,
+        })
+        ctx.req.headers['origin'] = assertOrigin
+
+        assert.notOk(ctx.headers['Vary'])
+        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-Credentials'], 'true')
+        assert.strictEqual(ctx.headers['Access-Control-Allow-Origin'], assertOrigin)
+        assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+        assert.notOk(ctx.headers['Access-Control-Expose-Headers'])
+        assert.strictEqual(ctx.status, method)
+      })
+    })
+
+    t.test('should set expose headers if specifed', function() {
+      testMethods.forEach(function(method) {
+        const assertExposeHeaders = 'Some, Test, Here'
+        ctx = createCtx()
+        ctx.method = method
+        ctx.status = method
+
+        const assertOrigin = 'http://my.site.here'
+
+        corsHandler = CorsHandler({
+          allowedOrigins: [assertOrigin],
+          exposeHeaders: assertExposeHeaders,
+        })
+        ctx.req.headers['origin'] = assertOrigin
+
+        assert.notOk(ctx.headers['Vary'])
+        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.notOk(ctx.headers['Access-Control-Allow-Credentials'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+        assert.strictEqual(ctx.headers['Access-Control-Expose-Headers'], assertExposeHeaders)
+        assert.strictEqual(ctx.status, method)
+      })
+    })
+    
+    t.test('should not add any headers if origin missing', function() {
+      testMethods.forEach(function(method) {
+        ctx = createCtx()
+        ctx.method = method
+        ctx.status = method
+
+        corsHandler = CorsHandler({
+          allowedOrigins: ['https://test.com'],
+        })
+        ctx.req.headers['origin'] = null
+
+        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.notOk(ctx.headers['Access-Control-Allow-Origin'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+        assert.notOk(ctx.headers['Access-Control-Expose-Headers'])
+        assert.strictEqual(ctx.status, method)
+      })
+    })
+
+    t.test('should not add any headers if origin not found', function() {
+      testMethods.forEach(function(method) {
+        ctx = createCtx()
+        ctx.method = method
+        ctx.status = method
+
+        const assertOrigin = 'http://my.site.here'
+        const assertAllowedMethods = 'GET,HEAD'
+
+        corsHandler = CorsHandler({
+          allowedOrigins: ['https://my.site.here'],
+          allowedMethods: assertAllowedMethods,
+          allowedHeaders: false,
+        })
+        ctx.req.headers['origin'] = assertOrigin
+
+        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.notOk(ctx.headers['Access-Control-Allow-Origin'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Methods'])
+        assert.notOk(ctx.headers['Access-Control-Allow-Headers'])
+        assert.notOk(ctx.headers['Access-Control-Expose-Headers'])
+        assert.strictEqual(ctx.status, method)
+      })
+    })
+  })
+})
+
+t.describe('#JsonHandler()', function() {
+  let jsonHandler = JsonHandler()
+  let ctx
+
+  t.beforeEach(function() {
+    ctx = createCtx()
+  })
+
+  t.test('should return a handler', function() {
+    assert.strictEqual(typeof(jsonHandler), 'function')
+  })
+
+  t.test('should support fetching body from request', async function() {
+    const assertBody = { a: 1, temp: 'test', hello: 'world'}
+    let parsed = JSON.stringify(assertBody)
+    let finished = false
+    let err = null
+
+    jsonHandler(ctx).catch(function(error) {
+      err = error
+    }).then(function() {
+      finished = true
+    })
+
+    assert.ok(ctx.req.on.called)
+    assert.strictEqual(ctx.req.on.firstCall[0], 'data')
+    assert.strictEqual(ctx.req.on.secondCall[0], 'end')
+
+    assert.strictEqual(finished, false)
+
+    ctx.req.on.firstCall[1](Buffer.from(parsed.slice(0, parsed.length / 2)))
+    
+    assert.strictEqual(finished, false)
+
+    ctx.req.on.firstCall[1](Buffer.from(parsed.slice(parsed.length / 2)))
+    
+    assert.strictEqual(finished, false)
+
+    ctx.req.on.secondCall[1]()
+
+    await setTimeout(10)
+    
+    assert.strictEqual(finished, true)
+    assert.strictEqual(err, null)
+
+    assert.notStrictEqual(ctx.req.body, assertBody)
+    assert.deepStrictEqual(ctx.req.body, assertBody)
+  })
+
+  t.test('should throw if buffer grows too large', async function() {
+    let defaultLimit = 10 * 1024
+    let segmentSize = 100
+    
+    let finished = false
+    let err = null
+
+    jsonHandler(ctx).catch(function(error) {
+      err = error
+    }).then(function() {
+      finished = true
+    })
+
+    for (let i = 0; i < defaultLimit; i += segmentSize) {
+      ctx.req.on.firstCall[1](Buffer.alloc(segmentSize, 'a'))
+    }
+    
+    await setTimeout(10)
+
+    assert.strictEqual(finished, true)
+    assert.notStrictEqual(err, null)
+
+    assert.ok(err instanceof HttpError)
+    assert.strictEqual(err.status, 413)
+    assert.match(err.message, new RegExp(100 * 103))
+    assert.match(err.message, new RegExp(defaultLimit))
+  })
+
+  t.test('should throw if buffer is not valid json', async function() {
+    let finished = false
+    let err = null
+
+    jsonHandler(ctx).catch(function(error) {
+      err = error
+    }).then(function() {
+      finished = true
+    })
+
+    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)
+
+    assert.strictEqual(finished, true)
+    assert.notStrictEqual(err, null)
+
+    assert.ok(err instanceof HttpError)
+    assert.strictEqual(err.status, 400)
+    assert.match(err.message, /JSON/)
+    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[^X]+X/i)
+    assert.strictEqual(err.body.request, 'XXXXXXXXXXXXXXXXXXXX')
+  })
+
+  t.test('should not throw if body is empty', async function() {
+    let finished = false
+    let err = null
+
+    jsonHandler(ctx).catch(function(error) {
+      err = error
+    }).then(function() {
+      finished = true
+    })
+
+    assert.ok(ctx.req.on.called)
+    assert.strictEqual(ctx.req.on.firstCall[0], 'data')
+    assert.strictEqual(ctx.req.on.secondCall[0], 'end')
+
+    assert.strictEqual(finished, false)
+
+    ctx.req.on.secondCall[1]()
+
+    await setTimeout(10)
+    
+    assert.strictEqual(finished, true)
+    assert.strictEqual(err, null)
+
+    assert.deepStrictEqual(ctx.req.body, {})
+  })
+})
+
+t.describe('#FormidableHandler()', function() {
+  let formidable
+  let incomingForm
+  let ctx
+
+  t.beforeEach(function() {
+    ctx = createCtx()
+    formidable = {
+      IncomingForm: stub(),
+      fsRename: stub().resolves(),
+    }
+
+    incomingForm = {
+      parse: stub().returnWith(function(req, cb) {
+        cb(null, {}, { file: { name: 'asdf.png' } })
+      })
+    }
+
+    formidable.IncomingForm.returns(incomingForm)
+  })
+
+  t.test('should call formidable with correct defaults', async function() {
+    let handler = FormidableHandler(formidable)
+    await handler(ctx)
+
+    assert.strictEqual(incomingForm.uploadDir, os.tmpdir())
+    assert.strictEqual(incomingForm.maxFileSize, 8 * 1024 * 1024)
+    assert.strictEqual(incomingForm.maxFieldsSize, 10 * 1024)
+    assert.strictEqual(incomingForm.maxFields, 50)
+    assert.strictEqual(incomingForm.parse.firstCall[0], ctx.req)
+  })
+
+  t.test('should apply fields and rename file before returning', async function() {
+    const assertFilename = 'Lets love.png'
+    const assertOriginalPath = 'Hitoshi/Fujima/Yuigi.png'
+    const assertFile = { a: 1, name: assertFilename, path: assertOriginalPath }
+    const assertFields = { b: 2, c: 3 }
+    let handler = FormidableHandler(formidable)
+
+    incomingForm.parse.returnWith(function(req, cb) {
+      cb(null, assertFields, { file: assertFile })
+    })
+
+    assert.notOk(ctx.req.body)
+    assert.notOk(ctx.req.file)
+    let prefix = new Date().toISOString().replace(/-/g, '').replace('T', '_').replace(/:/g, '').split('.')[0]
+    await handler(ctx)
+
+    assert.strictEqual(ctx.req.body, assertFields)
+    assert.strictEqual(ctx.req.file, assertFile)
+    assert.strictEqual(ctx.req.file.path, path.join(os.tmpdir(), ctx.req.file.filename))
+    assert.match(ctx.req.file.filename, new RegExp(prefix))
+    assert.match(ctx.req.file.filename, new RegExp(assertFilename))
+
+    assert.ok(formidable.fsRename.called)
+    assert.strictEqual(formidable.fsRename.firstCall[0], assertOriginalPath)
+    assert.strictEqual(formidable.fsRename.firstCall[1], ctx.req.file.path)
+  })
+
+  t.test('should throw parse error if parse fails', async function() {
+    const assertError = new Error('Aozora')
+
+    
+    let handler = FormidableHandler(formidable)
+
+    incomingForm.parse.returnWith(function(req, cb) {
+      cb(assertError)
+    })
+
+    let err = await assert.isRejected(handler(ctx))
+
+    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() {
+    const assertError = new Error('Aozora')
+    formidable.fsRename.rejects(assertError)
+    
+    let handler = FormidableHandler(formidable)
+    let err = await assert.isRejected(handler(ctx))
+
+    assert.strictEqual(err, assertError)
+  })
+
+  t.test('should not call rename if no file is present', async function() {
+    const assertNotError = new Error('Aozora')
+    const assertFields = { a: 1 }
+    formidable.fsRename.rejects(assertNotError)
+    
+    let handler = FormidableHandler(formidable)
+
+    incomingForm.parse.returnWith(function(req, cb) {
+      cb(null, assertFields, null)
+    })
+
+    await handler(ctx)
+    
+    assert.strictEqual(ctx.req.body, assertFields)
+    assert.strictEqual(ctx.req.file, null)
+
+    incomingForm.parse.returnWith(function(req, cb) {
+      cb(null, assertFields, { file: null })
+    })
+    
+    await handler(ctx)
+    
+    assert.strictEqual(ctx.req.body, assertFields)
+    assert.strictEqual(ctx.req.file, null)
+  })
+  
+  t.test('should throw filename error if filename fails', async function() {
+    const assertError = new Error('Dallaglio Piano')
+
+    let handler = FormidableHandler(formidable, {
+      filename: function() {
+        throw assertError
+      }
+    })
+
+    let err = await assert.isRejected(handler(ctx))
+
+    assert.strictEqual(err, assertError)
+  })
+  
+  t.test('should default to original name of filename returns null', async function() {
+    const assertFilename = 'Herrscher.png'
+
+    let handler = FormidableHandler(formidable, {
+      filename: function() {
+        return null
+      }
+    })
+
+    incomingForm.parse.returnWith(function(req, cb) {
+      cb(null, { }, { file: { name: assertFilename } })
+    })
+
+    await handler(ctx)
+
+    assert.strictEqual(ctx.req.file.filename, assertFilename)
+  })
+  
+  t.test('should support multiple filename calls in same second', async function() {
+    const assertFilename = 'Herrscher.png'
+
+    let handler = FormidableHandler(formidable)
+
+    await handler(ctx)
+
+    let file1 = ctx.req.file
+    
+    await handler(ctx)
+
+    let file2 = ctx.req.file
+
+    assert.notStrictEqual(file1, file2)
+    assert.notStrictEqual(file1.filename, file2.filename)
+  })
+
+  
+  t.test('should support parsing fields as json', async function() {
+    const assertFields = { b: '2', c: '3', e: 'asdf', f: '{"a": 1}' }
+    let handler = FormidableHandler(formidable, {
+      parseFields: true,
+    })
+
+    incomingForm.parse.returnWith(function(req, cb) {
+      cb(null, assertFields, { file: { name: 'test.png' } })
+    })
+
+    await handler(ctx)
+
+    assert.strictEqual(ctx.req.body, assertFields)
+    assert.strictEqual(ctx.req.body.b, 2)
+    assert.strictEqual(ctx.req.body.c, 3)
+    assert.strictEqual(ctx.req.body.e, 'asdf')
+    assert.deepStrictEqual(ctx.req.body.f, {a: 1})
+  })
+})

test/test.txt

@@ -0,0 +1 @@
+Hello World