Update tests to use Promise syntax (#507)

* Use promises in tests

* Fix lint

* Update tests

* Update babelrc

* Update config

* Update engines

.babelrc

@@ -1,5 +1,10 @@
 {
   "presets": [
-    ["es2015", { "loose": true }]
+    ["env", {
+      "targets": {
+        "node": 4
+      },
+      "exclude": ["transform-regenerator"]
+    }]
   ]
 }

package.json

@@ -30,20 +30,20 @@
     "yargs": "^6.0.0"
   },
   "devDependencies": {
-    "babel-cli": "^6.10.1",
+    "babel-cli": "^6.24.0",
-    "babel-preset-es2015": "^6.16.0",
+    "babel-preset-env": "^1.3.2",
     "babel-register": "^6.16.3",
     "cross-env": "^2.0.1",
     "husky": "^0.13.0",
     "markdown-toc": "^0.13.0",
     "mkdirp": "^0.5.1",
-    "mocha": "^3.1.2",
+    "mocha": "^3.2.0",
     "os-tmpdir": "^1.0.1",
     "pkg-ok": "^1.0.1",
     "rimraf": "^2.5.2",
     "server-ready": "^0.3.1",
     "standard": "^8.3.0",
-    "supertest": "^2.0.0",
+    "supertest": "^3.0.0",
     "temp-write": "^2.1.0"
   },
   "scripts": {
@@ -51,7 +51,7 @@
     "test:cli": "npm run build && cross-env NODE_ENV=test mocha test/cli/*.js",
     "test:server": "cross-env NODE_ENV=test mocha test/server/*.js",
     "start": "babel-node src/cli/bin",
-    "prepush": "npm t",
+    "precommit": "npm test",
     "build": "babel src -d lib --copy-files",
     "toc": "markdown-toc -i README.md",
     "prepublish": "npm run build && pkg-ok"
@@ -89,6 +89,6 @@
     }
   },
   "engines": {
-    "node": ">= 0.12"
+    "node": ">= 4"
   }
 }

test/mocha.opts

@@ -1,3 +1,3 @@
---compilers js:babel-register
+--require babel-register
 --reporter spec
---timeout 5000
+--timeout 5000

test/server/plural.js

@@ -87,17 +87,17 @@ describe('Server', () => {
   })
 
   describe('GET /db', () => {
-    it('should respond with json and full database', (done) => {
+    it('should respond with json and full database', () => (
       request(server)
         .get('/db')
         .expect('Content-Type', /json/)
         .expect(db)
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource', () => {
-    it('should respond with json and corresponding resources', (done) => {
+    it('should respond with json and corresponding resources', () => (
       request(server)
         .get('/posts')
         .set('Origin', 'http://example.com')
@@ -105,207 +105,207 @@ describe('Server', () => {
         .expect('Access-Control-Allow-Credentials', 'true')
         .expect('Access-Control-Allow-Origin', 'http://example.com')
         .expect(db.posts)
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should respond with 404 if resource is not found', (done) => {
+    it('should respond with 404 if resource is not found', () => (
       request(server)
         .get('/undefined')
-        .expect(404, done)
+        .expect(404)
-    })
+    ))
   })
 
   describe('GET /:resource?attr=&attr=', () => {
-    it('should respond with json and filter resources', (done) => {
+    it('should respond with json and filter resources', () => (
       request(server)
         .get('/comments?postId=1&published=true')
         .expect('Content-Type', /json/)
         .expect([ db.comments[0] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should be strict', (done) => {
+    it('should be strict', () => (
       request(server)
         .get('/users?tel=123')
         .expect('Content-Type', /json/)
         .expect([ db.users[1] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should support multiple filters', (done) => {
+    it('should support multiple filters', () => (
       request(server)
         .get('/comments?id=1&id=2')
         .expect('Content-Type', /json/)
         .expect([ db.comments[0], db.comments[1] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should support deep filter', (done) => {
+    it('should support deep filter', () => (
       request(server)
         .get('/deep?a.b=1')
         .expect('Content-Type', /json/)
         .expect([ db.deep[0] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should ignore JSONP query parameters callback and _ ', (done) => {
+    it('should ignore JSONP query parameters callback and _ ', () => (
       request(server)
         .get('/comments?callback=1&_=1')
         .expect('Content-Type', /text/)
         .expect(new RegExp(db.comments[0].body)) // JSONP returns text
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should ignore unknown query parameters', (done) => {
+    it('should ignore unknown query parameters', () => (
       request(server)
         .get('/comments?foo=1&bar=2')
         .expect('Content-Type', /json/)
         .expect(db.comments)
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?q=', () => {
-    it('should respond with json and make a full-text search', (done) => {
+    it('should respond with json and make a full-text search', () => (
       request(server)
         .get('/tags?q=pho')
         .expect('Content-Type', /json/)
         .expect([ db.tags[1], db.tags[2] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should respond with json and make a deep full-text search', (done) => {
+    it('should respond with json and make a deep full-text search', () => (
       request(server)
         .get('/deep?q=1')
         .expect('Content-Type', /json/)
         .expect(db.deep)
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should return an empty array when nothing is matched', (done) => {
+    it('should return an empty array when nothing is matched', () => (
       request(server)
         .get('/tags?q=nope')
         .expect('Content-Type', /json/)
         .expect([ ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should support other query parameters', (done) => {
+    it('should support other query parameters', () => (
       request(server)
         .get('/comments?q=qu&published=true')
         .expect('Content-Type', /json/)
         .expect([ db.comments[3] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should ignore duplicate q query parameters', (done) => {
+    it('should ignore duplicate q query parameters', () => (
       request(server)
         .get('/comments?q=foo&q=bar')
         .expect('Content-Type', /json/)
         .expect([ db.comments[0] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should support filtering by boolean value false', (done) => {
+    it('should support filtering by boolean value false', () => (
       request(server)
         .get('/comments?published=false')
         .expect('Content-Type', /json/)
         .expect([ db.comments[1], db.comments[2], db.comments[4] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?_end=', () => {
-    it('should respond with a sliced array', (done) => {
+    it('should respond with a sliced array', () => (
       request(server)
         .get('/comments?_end=2')
         .expect('Content-Type', /json/)
         .expect('x-total-count', db.comments.length.toString())
         .expect('Access-Control-Expose-Headers', 'X-Total-Count')
         .expect(db.comments.slice(0, 2))
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?_sort=', () => {
-    it('should respond with json and sort on a field', (done) => {
+    it('should respond with json and sort on a field', () => (
       request(server)
         .get('/tags?_sort=body')
         .expect('Content-Type', /json/)
         .expect([ db.tags[1], db.tags[0], db.tags[2] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should reverse sorting with _order=DESC', (done) => {
+    it('should reverse sorting with _order=DESC', () => (
       request(server)
         .get('/tags?_sort=body&_order=DESC')
         .expect('Content-Type', /json/)
         .expect([ db.tags[2], db.tags[0], db.tags[1] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should sort on numerical field', (done) => {
+    it('should sort on numerical field', () => (
       request(server)
         .get('/posts?_sort=id&_order=DESC')
         .expect('Content-Type', /json/)
         .expect(db.posts.reverse())
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should sort on nested field', (done) => {
+    it('should sort on nested field', () => (
       request(server)
         .get('/nested?_sort=resource.name')
         .expect('Content-Type', /json/)
         .expect([ db.nested[1], db.nested[0], db.nested[2] ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?_start=&_end=', () => {
-    it('should respond with a sliced array', (done) => {
+    it('should respond with a sliced array', () => (
       request(server)
         .get('/comments?_start=1&_end=2')
         .expect('Content-Type', /json/)
         .expect('X-Total-Count', db.comments.length.toString())
         .expect('Access-Control-Expose-Headers', 'X-Total-Count')
         .expect(db.comments.slice(1, 2))
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?_start=&_limit=', () => {
-    it('should respond with a limited array', (done) => {
+    it('should respond with a limited array', () => (
       request(server)
         .get('/comments?_start=1&_limit=1')
         .expect('Content-Type', /json/)
         .expect('X-Total-Count', db.comments.length.toString())
         .expect('Access-Control-Expose-Headers', 'X-Total-Count')
         .expect(db.comments.slice(1, 2))
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?_page=', () => {
-    it('should paginate', (done) => {
+    it('should paginate', () => (
       request(server)
         .get('/list?_page=2')
         .expect('Content-Type', /json/)
         .expect('x-total-count', db.list.length.toString())
         .expect('Access-Control-Expose-Headers', 'X-Total-Count, Link')
         .expect(db.list.slice(10, 20))
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?_page=&_limit=', () => {
-    it('should paginate with a custom limit', (done) => {
+    it('should paginate with a custom limit', () => {
       const link = [
         '<http://localhost/list?_page=1&_limit=1>; rel="first"',
         '<http://localhost/list?_page=1&_limit=1>; rel="prev"',
         '<http://localhost/list?_page=3&_limit=1>; rel="next"',
         '<http://localhost/list?_page=15&_limit=1>; rel="last"'
       ].join(', ')
-      request(server)
+      return request(server)
         .get('/list?_page=2&_limit=1')
         .set('host', 'localhost')
         .expect('Content-Type', /json/)
@@ -313,32 +313,32 @@ describe('Server', () => {
         .expect('link', link)
         .expect('Access-Control-Expose-Headers', 'X-Total-Count, Link')
         .expect(db.list.slice(1, 2))
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource?attr_gte=&attr_lte=', () => {
-    it('should respond with a limited array', (done) => {
+    it('should respond with a limited array', () => (
       request(server)
         .get('/comments?id_gte=2&id_lte=3')
         .expect('Content-Type', /json/)
         .expect(db.comments.slice(1, 3))
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?attr_ne=', () => {
-    it('should respond with a limited array', (done) => {
+    it('should respond with a limited array', () => (
       request(server)
         .get('/comments?id_ne=1')
         .expect('Content-Type', /json/)
         .expect(db.comments.slice(1))
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource?attr_like=', () => {
-    it('should respond with an array that matches the like operator (case insensitive)', (done) => {
+    it('should respond with an array that matches the like operator (case insensitive)', () => (
       request(server)
         .get('/tags?body_like=photo')
         .expect('Content-Type', /json/)
@@ -346,12 +346,12 @@ describe('Server', () => {
           db.tags[1],
           db.tags[2]
         ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:parent/:parentId/:resource', () => {
-    it('should respond with json and corresponding nested resources', (done) => {
+    it('should respond with json and corresponding nested resources', () => (
       request(server)
         .get('/posts/1/comments')
         .expect('Content-Type', /json/)
@@ -359,214 +359,197 @@ describe('Server', () => {
           db.comments[0],
           db.comments[1]
         ])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
   describe('GET /:resource/:id', () => {
-    it('should respond with json and corresponding resource', (done) => {
+    it('should respond with json and corresponding resource', () => (
       request(server)
         .get('/posts/1')
         .expect('Content-Type', /json/)
         .expect(db.posts[0])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should support string id, respond with json and corresponding resource', (done) => {
+    it('should support string id, respond with json and corresponding resource', () => (
       request(server)
         .get('/refs/abcd-1234')
         .expect('Content-Type', /json/)
         .expect(db.refs[0])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should support integer id as string', (done) => {
+    it('should support integer id as string', () => (
       request(server)
         .get('/stringIds/1234')
         .expect('Content-Type', /json/)
         .expect(db.stringIds[0])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should respond with 404 if resource is not found', (done) => {
+    it('should respond with 404 if resource is not found', () => (
       request(server)
         .get('/posts/9001')
         .expect('Content-Type', /json/)
         .expect({})
-        .expect(404, done)
+        .expect(404)
-    })
+    ))
   })
 
   describe('GET /:resource?_embed=', () => {
-    it('should respond with corresponding resources and embedded resources', (done) => {
+    it('should respond with corresponding resources and embedded resources', () => {
       const posts = _.cloneDeep(db.posts)
       posts[0].comments = [ db.comments[0], db.comments[1] ]
       posts[1].comments = [ db.comments[2], db.comments[3], db.comments[4] ]
-      request(server)
+      return request(server)
         .get('/posts?_embed=comments')
         .expect('Content-Type', /json/)
         .expect(posts)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource?_embed&_embed=', () => {
-    it('should respond with corresponding resources and embedded resources', (done) => {
+    it('should respond with corresponding resources and embedded resources', () => {
       const posts = _.cloneDeep(db.posts)
       posts[0].comments = [ db.comments[0], db.comments[1] ]
       posts[0].refs = [ db.refs[0] ]
       posts[1].comments = [ db.comments[2], db.comments[3], db.comments[4] ]
       posts[1].refs = []
-      request(server)
+      return request(server)
         .get('/posts?_embed=comments&_embed=refs')
         .expect('Content-Type', /json/)
         .expect(posts)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource/:id?_embed=', () => {
-    it('should respond with corresponding resources and embedded resources', (done) => {
+    it('should respond with corresponding resources and embedded resources', () => {
       const post = _.cloneDeep(db.posts[0])
       post.comments = [ db.comments[0], db.comments[1] ]
-      request(server)
+      return request(server)
         .get('/posts/1?_embed=comments')
         .expect('Content-Type', /json/)
         .expect(post)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource/:id?_embed=&_embed=', () => {
-    it('should respond with corresponding resource and embedded resources', (done) => {
+    it('should respond with corresponding resource and embedded resources', () => {
       const post = _.cloneDeep(db.posts[0])
       post.comments = [ db.comments[0], db.comments[1] ]
       post.refs = [db.refs[0]]
-      request(server)
+      return request(server)
         .get('/posts/1?_embed=comments&_embed=refs')
         .expect('Content-Type', /json/)
         .expect(post)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource?_expand=', () => {
-    it('should respond with corresponding resource and expanded inner resources', (done) => {
+    it('should respond with corresponding resource and expanded inner resources', () => {
       const refs = _.cloneDeep(db.refs)
       refs[0].post = db.posts[0]
-      request(server)
+      return request(server)
         .get('/refs?_expand=post')
         .expect('Content-Type', /json/)
         .expect(refs)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource/:id?_expand=', () => {
-    it('should respond with corresponding resource and expanded inner resources', (done) => {
+    it('should respond with corresponding resource and expanded inner resources', () => {
       const comment = _.cloneDeep(db.comments[0])
       comment.post = db.posts[0]
-      request(server)
+      return request(server)
         .get('/comments/1?_expand=post')
         .expect('Content-Type', /json/)
         .expect(comment)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource?_expand=&_expand', () => {
-    it('should respond with corresponding resource and expanded inner resources', (done) => {
+    it('should respond with corresponding resource and expanded inner resources', () => {
       const refs = _.cloneDeep(db.refs)
       refs[0].post = db.posts[0]
       refs[0].user = db.users[0]
-      request(server)
+      return request(server)
         .get('/refs?_expand=post&_expand=user')
         .expect('Content-Type', /json/)
         .expect(refs)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('GET /:resource/:id?_expand=&_expand=', () => {
-    it('should respond with corresponding resource and expanded inner resources', (done) => {
+    it('should respond with corresponding resource and expanded inner resources', () => {
       const comments = db.comments[0]
       comments.post = db.posts[0]
       comments.user = db.users[0]
-      request(server)
+      return request(server)
         .get('/comments/1?_expand=post&_expand=user')
         .expect('Content-Type', /json/)
         .expect(comments)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
   describe('POST /:resource', () => {
-    it('should respond with json, create a resource and increment id',
+    it('should respond with json, create a resource and increment id', async () => {
-      (done) => {
+      await request(server)
-        request(server)
+        .post('/posts')
-          .post('/posts')
+        .send({body: 'foo', booleanValue: true, integerValue: 1})
-          .send({body: 'foo', booleanValue: true, integerValue: 1})
+        .expect('Access-Control-Expose-Headers', 'Location')
-          .expect('Access-Control-Expose-Headers', 'Location')
+        .expect('Location', /posts\/3$/)
-          .expect('Location', /posts\/3$/)
+        .expect('Content-Type', /json/)
-          .expect('Content-Type', /json/)
+        .expect({id: 3, body: 'foo', booleanValue: true, integerValue: 1})
-          .expect({id: 3, body: 'foo', booleanValue: true, integerValue: 1})
+        .expect(201)
-          .expect(201)
+      assert.equal(db.posts.length, 3)
-          .end((err, res) => {
+    })
-            if (err) return done(err)
-            assert.equal(db.posts.length, 3)
-            done()
-          })
-      }
-    )
 
-    it('should support x-www-form-urlencoded',
+    it('should support x-www-form-urlencoded', async () => {
-      (done) => {
+      await request(server)
-        request(server)
+        .post('/posts')
-          .post('/posts')
+        .type('form')
-          .type('form')
+        .send({body: 'foo', booleanValue: true, integerValue: 1})
-          .send({body: 'foo', booleanValue: true, integerValue: 1})
+        .expect('Content-Type', /json/)
-          .expect('Content-Type', /json/)
+        // x-www-form-urlencoded will convert to string
-          // x-www-form-urlencoded will convert to string
+        .expect({id: 3, body: 'foo', booleanValue: 'true', integerValue: '1'})
-          .expect({id: 3, body: 'foo', booleanValue: 'true', integerValue: '1'})
+        .expect(201)
-          .expect(201)
+      assert.equal(db.posts.length, 3)
-          .end((err, res) => {
+    })
-            if (err) return done(err)
-            assert.equal(db.posts.length, 3)
-            done()
-          })
-      }
-    )
 
-    it('should respond with json, create a resource and generate string id',
+    it('should respond with json, create a resource and generate string id', async () => {
-      (done) => {
+      await request(server)
-        request(server)
+        .post('/refs')
-          .post('/refs')
+        .send({url: 'http://foo.com', postId: '1'})
-          .send({url: 'http://foo.com', postId: '1'})
+        .expect('Content-Type', /json/)
-          .expect('Content-Type', /json/)
+        .expect(201)
-          .expect(201)
+      assert.equal(db.refs.length, 2)
-          .end((err, res) => {
+    })
-            if (err) return done(err)
-            assert.equal(db.refs.length, 2)
-            done()
-          })
-      })
   })
 
   describe('POST /:parent/:parentId/:resource', () => {
-    it('should respond with json and set parentId', (done) => {
+    it('should respond with json and set parentId', () => (
       request(server)
         .post('/posts/1/comments')
         .send({body: 'foo'})
         .expect('Content-Type', /json/)
         .expect({id: 6, postId: 1, body: 'foo'})
-        .expect(201, done)
+        .expect(201)
-    })
+    ))
   })
 
   describe('PUT /:resource/:id', () => {
-    it('should respond with json and replace resource', (done) => {
+    it('should respond with json and replace resource', async () => {
-      var post = {id: 1, booleanValue: true, integerValue: 1}
+      const post = {id: 1, booleanValue: true, integerValue: 1}
-      request(server)
+      const res = await request(server)
         .put('/posts/1')
         .set('Accept', 'application/json')
         // body property omitted to test that the resource is replaced
@@ -574,105 +557,93 @@ describe('Server', () => {
         .expect('Content-Type', /json/)
         .expect(post)
         .expect(200)
-        .end((err, res) => {
+      // TODO find a "supertest" way to test this
-          if (err) return done(err)
+      // https://github.com/typicode/json-server/issues/396
-          // TODO find a "supertest" way to test this
+      assert.deepStrictEqual(res.body, post)
-          // https://github.com/typicode/json-server/issues/396
+      // assert it was created in database too
-          assert.deepStrictEqual(res.body, post)
+      assert.deepStrictEqual(db.posts[0], post)
-          // assert it was created in database too
-          assert.deepStrictEqual(db.posts[0], post)
-          done()
-        })
     })
 
-    it('should respond with 404 if resource is not found', (done) => {
+    it('should respond with 404 if resource is not found', () => (
       request(server)
         .put('/posts/9001')
         .send({id: 1, body: 'bar'})
         .expect('Content-Type', /json/)
         .expect({})
-        .expect(404, done)
+        .expect(404)
-    })
+    ))
   })
 
   describe('PATCH /:resource/:id', () => {
-    it('should respond with json and update resource', (done) => {
+    it('should respond with json and update resource', async () => {
-      var partial = {body: 'bar'}
+      const partial = {body: 'bar'}
-      var post = {id: 1, body: 'bar'}
+      const post = {id: 1, body: 'bar'}
-      request(server)
+      const res = await request(server)
         .patch('/posts/1')
         .send(partial)
         .expect('Content-Type', /json/)
         .expect(post)
         .expect(200)
-        .end((err, res) => {
+      assert.deepStrictEqual(res.body, post)
-          if (err) return done(err)
+      // assert it was created in database too
-          assert.deepStrictEqual(res.body, post)
+      assert.deepStrictEqual(db.posts[0], post)
-          // assert it was created in database too
-          assert.deepStrictEqual(db.posts[0], post)
-          done()
-        })
     })
 
-    it('should respond with 404 if resource is not found', (done) => {
+    it('should respond with 404 if resource is not found', () => (
       request(server)
         .patch('/posts/9001')
         .send({body: 'bar'})
         .expect('Content-Type', /json/)
         .expect({})
-        .expect(404, done)
+        .expect(404)
-    })
+    ))
   })
 
   describe('DELETE /:resource/:id', () => {
-    it('should respond with empty data, destroy resource and dependent resources', (done) => {
+    it('should respond with empty data, destroy resource and dependent resources', async () => {
-      request(server)
+      await request(server)
         .del('/posts/1')
         .expect({})
         .expect(200)
-        .end((err, res) => {
+      assert.equal(db.posts.length, 1)
-          if (err) return done(err)
+      assert.equal(db.comments.length, 3)
-          assert.equal(db.posts.length, 1)
-          assert.equal(db.comments.length, 3)
-          done()
-        })
     })
 
-    it('should respond with 404 if resource is not found', (done) => {
+    it('should respond with 404 if resource is not found', () => (
       request(server)
         .del('/posts/9001')
         .expect('Content-Type', /json/)
         .expect({})
-        .expect(404, done)
+        .expect(404)
-    })
+    ))
   })
 
   describe('Static routes', () => {
     describe('GET /', () => {
-      it('should respond with html', (done) => {
+      it('should respond with html', () => (
         request(server)
           .get('/')
           .expect(/You're successfully running JSON Server/)
-          .expect(200, done)
+          .expect(200)
-      })
+      ))
     })
 
     describe('GET /main.js', () => {
-      it('should respond with js', (done) => {
+      it('should respond with js', () => (
         request(server)
           .get('/main.js')
           .expect('Content-Type', /javascript/)
-          .expect(200, done)
+          .expect(200)
-      })
+      ))
     })
 
     describe('GET /style.css', () => {
-      it('should respond with css', (done) => {
+      it('should respond with css', () => (
         request(server)
           .get('/style.css')
           .expect('Content-Type', /css/)
-          .expect(200, done)
+          .expect(200)
-      })
+      ))
     })
   })
 
@@ -683,82 +654,74 @@ describe('Server', () => {
   })
 
   describe('Responses', () => {
-    it('should have no cache headers (for IE)', (done) => {
+    it('should have no cache headers (for IE)', () => (
       request(server)
         .get('/db')
         .expect('Cache-Control', 'no-cache')
         .expect('Pragma', 'no-cache')
         .expect('Expires', '-1')
-        .end(done)
+    ))
-    })
   })
 
   describe('Rewriter', () => {
-    it('should rewrite using prefix', (done) => {
+    it('should rewrite using prefix', () => (
       request(server)
         .get('/api/posts/1')
         .expect(db.posts[0])
-        .end(done)
+    ))
-    })
 
-    it('should rewrite using params', (done) => {
+    it('should rewrite using params', () => (
       request(server)
         .get('/blog/posts/1/show')
         .expect(db.posts[0])
-        .end(done)
+    ))
-    })
 
-    it('should rewrite using query without params', (done) => {
+    it('should rewrite using query without params', () => {
       const expectedPost = _.cloneDeep(db.posts[0])
       expectedPost.comments = [ db.comments[0], db.comments[1] ]
-      request(server)
+      return request(server)
         .get('/firstpostwithcomments')
         .expect(expectedPost)
-        .end(done)
     })
 
-    it('should rewrite using params and query', (done) => {
+    it('should rewrite using params and query', () => (
       request(server)
         .get('/comments/special/1-quux')
         .expect([db.comments[4]])
-        .end(done)
+    ))
-    })
 
     // TODO
-    // it('should rewrite query params', (done) => {
+    // it('should rewrite query params', () => (
     //   request(server)
     //     .get('/articles?_id=1')
     //     .expect(db.posts[0])
     //     .end(done)
     // })
 
-    it('should expose routes', (done) => {
+    it('should expose routes', () => (
       request(server)
         .get('/__rules')
         .expect(rewriterRules)
-        .end(done)
+    ))
-    })
   })
 
-  describe('router.render', (done) => {
+  describe('router.render', () => {
     beforeEach(() => {
       router.render = (req, res) => {
-        res.jsonp({
+        res.jsonp({ data: res.locals.data })
-          data: res.locals.data
-        })
       }
     })
 
-    it('should be possible to wrap response', (done) => {
+    it('should be possible to wrap response', () => (
       request(server)
         .get('/posts/1')
         .expect('Content-Type', /json/)
         .expect({ data: db.posts[0] })
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
-  describe('router.db._.id', (done) => {
+  describe('router.db._.id', () => {
     beforeEach(() => {
       router.db.setState({
         posts: [
@@ -769,21 +732,21 @@ describe('Server', () => {
       router.db._.id = '_id'
     })
 
-    it('should be possible to GET using a different id property', (done) => {
+    it('should be possible to GET using a different id property', () => (
       request(server)
         .get('/posts/1')
         .expect('Content-Type', /json/)
         .expect(router.db.getState().posts[0])
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
 
-    it('should be possible to POST using a different id property', (done) => {
+    it('should be possible to POST using a different id property', () => (
       request(server)
         .post('/posts')
         .send({ body: 'hello' })
         .expect('Content-Type', /json/)
         .expect({ _id: 2, body: 'hello' })
-        .expect(201, done)
+        .expect(201)
-    })
+    ))
   })
 })

test/server/singular.js

@@ -1,12 +1,12 @@
 const request = require('supertest')
 const jsonServer = require('../../src/server')
 
-describe('Server', function () {
+describe('Server', () => {
   let server
   let router
   let db
 
-  beforeEach(function () {
+  beforeEach(() => {
     db = {}
 
     db.user = {
@@ -20,44 +20,44 @@ describe('Server', function () {
     server.use(router)
   })
 
-  describe('GET /:resource', function () {
+  describe('GET /:resource', () => {
-    it('should respond with corresponding resource', function (done) {
+    it('should respond with corresponding resource', () => (
       request(server)
         .get('/user')
         .expect(db.user)
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 
-  describe('POST /:resource', function () {
+  describe('POST /:resource', () => {
-    it('should create resource', function (done) {
+    it('should create resource', () => {
       const user = { name: 'bar' }
-      request(server)
+      return request(server)
         .post('/user')
         .send(user)
         .expect(user)
-        .expect(201, done)
+        .expect(201)
     })
   })
 
-  describe('PUT /:resource', function () {
+  describe('PUT /:resource', () => {
-    it('should update resource', function (done) {
+    it('should update resource', () => {
       const user = { name: 'bar' }
-      request(server)
+      return request(server)
         .put('/user')
         .send(user)
         .expect(user)
-        .expect(200, done)
+        .expect(200)
     })
   })
 
-  describe('PATCH /:resource', function () {
+  describe('PATCH /:resource', () => {
-    it('should update resource', function (done) {
+    it('should update resource', () => (
       request(server)
         .patch('/user')
         .send({ name: 'bar' })
         .expect({ name: 'bar', email: 'foo@example.com' })
-        .expect(200, done)
+        .expect(200)
-    })
+    ))
   })
 })

test/server/utils.js

@@ -1,12 +1,12 @@
 const assert = require('assert')
 const utils = require('../../src/server/utils')
 
-describe('utils', function () {
+describe('utils', () => {
-  describe('getPage', function () {
+  describe('getPage', () => {
     const array = [1, 2, 3, 4, 5]
     const perPage = 2
 
-    it('should return first page', function () {
+    it('should return first page', () => {
       assert.deepEqual(
         utils.getPage(array, 1, perPage),
         {
@@ -19,7 +19,7 @@ describe('utils', function () {
       )
     })
 
-    it('should return second page', function () {
+    it('should return second page', () => {
       assert.deepEqual(
         utils.getPage(array, 2, perPage),
         {
@@ -33,7 +33,7 @@ describe('utils', function () {
       )
     })
 
-    it('should return third page (last)', function () {
+    it('should return third page (last)', () => {
       assert.deepEqual(
         utils.getPage(array, 3, perPage),
         {
@@ -46,7 +46,7 @@ describe('utils', function () {
       )
     })
 
-    it('should return an empty array if page is greater than the last page', function () {
+    it('should return an empty array if page is greater than the last page', () => {
       assert.deepEqual(
         utils.getPage(array, 99, perPage),
         {
@@ -55,7 +55,7 @@ describe('utils', function () {
       )
     })
 
-    it('should return the array if perPage is greater than the array size', function () {
+    it('should return the array if perPage is greater than the array size', () => {
       assert.deepEqual(
         utils.getPage(array, 1, 99),
         {
@@ -64,7 +64,7 @@ describe('utils', function () {
       )
     })
 
-    it('should return an empty array if the array is empty', function () {
+    it('should return an empty array if the array is empty', () => {
       assert.deepEqual(
         utils.getPage([], 1, 1),
         {