Server is not closed when close() is used
Hello,
I'm trying to write integration test for my first Koa application (I come from Rubyland originally).

I noticed with every new import of my server in my integration tests, the number of request calls inside koa router is increasing. What that means? When I make one call, inside Koa server generates the request multiple times how many times the server is listened. 

```js
import app from '../../app'
import tokenSchema from '../../app/schemas/token'
import errorSchema from '../../app/schemas/error'
import {
  createUser,
  truncate,
} from '../helpers'

describe('Authentication API', () => {
  let server

  before(async () => {
    await createUser('tester@email.com')
  })

  beforeEach(() => {
    server = app.listen()
  })

  afterEach(() => {
    server.close()
  })

  after(async () => {
    await truncate('users')
  })

  describe('POST /auth', () => {
    context('when an user uses valid credentials', () => {
      it('returns authentication token response', async () => {
        const response = await request(server)
          .post('/api/v1/auth')
          .set('Content-Type', 'application/json')
          .send({ email: 'tester@email.com', password: 'password' })

        expect(response.status).to.equal(201)
        expect(response.type).to.equal('application/json')
        expect(response.body).to.be.jsonSchema(tokenSchema)
        expect(response.body.token).to.be.a('string').that.is.not.empty
      })
    })

    context('when an user uses invalid credentials', () => {
      it('returns invalid authentication error', async () => {
        const response = await request(server)
          .post('/api/v1/auth')
          .set('Content-Type', 'application/json')
          .send({ email: 'tester@email.com', password: 'passwrd' })

        expect(response.status).to.equal(401)
        expect(response.type).to.equal('application/json')
        expect(response.body).to.be.jsonSchema(errorSchema)
        expect(response.body).to.deep.equal({
          error: {
            type: 'invalidAuthentication',
            description: 'The credentials are incorrect.',
          },
        })
      })
    })
  })
})
```

```js
// import server from '../../app/server'
import app from '../../app'
import errorSchema from '../../app/schemas/error'
import {
  createUser,
  truncate,
} from '../helpers'

describe('Users API', () => {
  let server

  beforeEach(() => {
    server = app.listen()
  })

  afterEach(async () => {
    server.close()
    await truncate('users')
  })

  describe('POST /users', () => {
    context('when a given user is not registreted yet', () => {
      it('returns the user response', async () => {
        const response = await request(server)
          .post('/api/v1/users')
          .set('Content-Type', 'application/json')
          .send({ email: 'tester@email.com', password: 'password' })

        expect(response.status).to.equal(201)
        expect(response.type).to.equal('application/json')
        expect(response.body).to.exist
      })
    })
  })
})
```

When the second spec is called. The request inside Koa route is called twice.

These tests pass but there are other which depends on number of data in DB. I don't know what's wrong.

My app looks 

```js
import Koa from 'koa'
import koaBody from 'koa-body'
import logger from 'koa-logger'
import { ENVIRONMENT } from '../config'
import { unprotectedRouter, protectedRouter } from './routes'
import validationErrorsMiddleware from './middlewares/validationErrors'
import internalErrorsMiddleware from './middlewares/internalErrors'
import exceptionsMiddleware from './middlewares/exceptions'
import authorizedErrorsMiddleware from './middlewares/unauthorizedErrors'
import jwtMiddleware from './middlewares/jwt'

const app = new Koa()

if (ENVIRONMENT !== 'test') {
  app.use(logger())
}

app.use(koaBody({
  urlencoded: false,
  text: false,
}))

// Error middlewares
app.use(exceptionsMiddleware)
app.use(internalErrorsMiddleware)
app.use(authorizedErrorsMiddleware)
app.use(validationErrorsMiddleware)

app.use(unprotectedRouter.routes())
app.use(unprotectedRouter.allowedMethods())

app.use(jwtMiddleware)

app.use(protectedRouter.routes())
app.use(protectedRouter.allowedMethods())

export default app
```

I use the latest `koa`, `mocha`, `chai`, `supertest` including `esm` for enabling ES module support. I tried multiple options and this is the latest iteration of that. It looks the server doesn't close after calling `close()`. In this case, there is no connection made during server initialization so the closing would be fine.

My dependencies:

```json
  "dependencies": {
    "ajv": "^6.5.2",
    "bcrypt": "^3.0.0",
    "camelcase": "^5.0.0",
    "esm": "^3.0.72",
    "firebase-admin": "^5.13.0",
    "jsonwebtoken": "^8.3.0",
    "knex": "^0.15.2",
    "koa": "^2.5.2",
    "koa-body": "^4.0.4",
    "koa-jwt": "^3.3.2",
    "koa-logger": "^3.2.0",
    "koa-router": "^7.4.0",
    "objection": "^1.2.0",
    "objection-db-errors": "^1.0.0",
    "pg": "^7.4.3"
  },
  "devDependencies": {
    "chai": "^4.1.2",
    "chai-as-promised": "^7.1.1",
    "chai-http": "^4.0.0",
    "chai-json-schema-ajv": "^3.0.0",
    "dotenv": "^6.0.0",
    "dotenv-flow": "^0.1.0-beta.3",
    "mocha": "^5.2.0",
    "nodemon": "^1.18.2",
    "sinon": "^6.1.4",
    "sinon-chai": "^3.2.0",
    "supertest": "^3.1.0"
  }
```