fastify 5.0.0 → 5.2.0

package/test/http-methods/propfind.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('../../')()
 fastify.addHttpMethod('PROPFIND', { hasBody: true })
@@ -62,45 +61,48 @@ test('can be created - propfind', t => {
           )
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
-fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => {
+test('propfind test', async t => {
+  await fastify.listen({ port: 0 })
+
+  t.after(() => {
     fastify.close()
   })
 
-  test('request - propfind', t => {
+  await t.test('request - propfind', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/`,
       method: 'PROPFIND'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 207)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 207)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 
-  test('request with other path - propfind', t => {
+  await t.test('request with other path - propfind', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test`,
       method: 'PROPFIND'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 207)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 207)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 
   // the body test uses a text/plain content type instead of application/xml because it requires
   // a specific content type parser
-  test('request with body - propfind', t => {
+  await t.test('request with body - propfind', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test`,
@@ -108,34 +110,37 @@ fastify.listen({ port: 0 }, err => {
       body: bodySample,
       method: 'PROPFIND'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 207)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 207)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 
-  test('request with body and no content type (415 error) - propfind', t => {
+  await t.test('request with body and no content type (415 error) - propfind', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test`,
       body: bodySample,
       method: 'PROPFIND'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 415)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 415)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 
-  test('request without body - propfind', t => {
+  await t.test('request without body - propfind', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test`,
       method: 'PROPFIND'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 207)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 207)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 })

package/test/http-methods/proppatch.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('../../')()
 fastify.addHttpMethod('PROPPATCH', { hasBody: true })
@@ -56,19 +55,19 @@ test('shorthand - proppatch', t => {
           )
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
-fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => { fastify.close() })
+test('proppatch test', async t => {
+  await fastify.listen({ port: 0 })
 
+  t.after(() => { fastify.close() })
   // the body test uses a text/plain content type instead of application/xml because it requires
   // a specific content type parser
-  test('request with body - proppatch', t => {
+  await t.test('request with body - proppatch', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
@@ -76,34 +75,37 @@ fastify.listen({ port: 0 }, err => {
       body: bodySample,
       method: 'PROPPATCH'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 207)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 207)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 
-  test('request with body and no content type (415 error) - proppatch', t => {
+  await t.test('request with body and no content type (415 error) - proppatch', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
       body: bodySample,
       method: 'PROPPATCH'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 415)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 415)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 
-  test('request without body - proppatch', t => {
+  await t.test('request without body - proppatch', (t, done) => {
     t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
       method: 'PROPPATCH'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 207)
-      t.equal(response.headers['content-length'], '' + body.length)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 207)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      done()
     })
   })
 })

package/test/http-methods/report.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('REPORT', { hasBody: true })
@@ -68,19 +67,20 @@ test('can be created - report', (t) => {
             </D:multistatus>`)
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
-fastify.listen({ port: 0 }, (err) => {
-  t.error(err)
-  t.teardown(() => {
+test('report test', async t => {
+  await fastify.listen({ port: 0 })
+
+  t.after(() => {
     fastify.close()
   })
 
-  test('request - report', (t) => {
+  await t.test('request - report', (t, done) => {
     t.plan(3)
     sget(
       {
@@ -88,14 +88,15 @@ fastify.listen({ port: 0 }, (err) => {
         method: 'REPORT'
       },
       (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 207)
-        t.equal(response.headers['content-length'], '' + body.length)
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 207)
+        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+        done()
       }
     )
   })
 
-  test('request with other path - report', (t) => {
+  await t.test('request with other path - report', (t, done) => {
     t.plan(3)
     sget(
       {
@@ -103,16 +104,17 @@ fastify.listen({ port: 0 }, (err) => {
         method: 'REPORT'
       },
       (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 207)
-        t.equal(response.headers['content-length'], '' + body.length)
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 207)
+        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+        done()
       }
     )
   })
 
   // the body test uses a text/plain content type instead of application/xml because it requires
   // a specific content type parser
-  test('request with body - report', (t) => {
+  await t.test('request with body - report', (t, done) => {
     t.plan(3)
     sget(
       {
@@ -122,14 +124,15 @@ fastify.listen({ port: 0 }, (err) => {
         method: 'REPORT'
       },
       (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 207)
-        t.equal(response.headers['content-length'], '' + body.length)
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 207)
+        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+        done()
       }
     )
   })
 
-  test('request with body and no content type (415 error) - report', (t) => {
+  await t.test('request with body and no content type (415 error) - report', (t, done) => {
     t.plan(3)
     sget(
       {
@@ -138,14 +141,15 @@ fastify.listen({ port: 0 }, (err) => {
         method: 'REPORT'
       },
       (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 415)
-        t.equal(response.headers['content-length'], '' + body.length)
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 415)
+        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+        done()
       }
     )
   })
 
-  test('request without body - report', (t) => {
+  await t.test('request without body - report', (t, done) => {
     t.plan(3)
     sget(
       {
@@ -153,9 +157,10 @@ fastify.listen({ port: 0 }, (err) => {
         method: 'REPORT'
       },
       (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 207)
-        t.equal(response.headers['content-length'], '' + body.length)
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 207)
+        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+        done()
       }
     )
   })

package/test/http-methods/search.test.js

@@ -1,8 +1,7 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const sget = require('simple-get').concat
-const test = t.test
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('SEARCH', { hasBody: true })
 
@@ -69,9 +68,9 @@ test('search', t => {
         reply.code(200).send({ hello: 'world' })
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -86,9 +85,9 @@ test('search, params schema', t => {
         reply.code(200).send(request.params)
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -103,9 +102,9 @@ test('search, querystring schema', t => {
         reply.code(200).send(request.query)
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -120,92 +119,96 @@ test('search, body schema', t => {
         reply.code(200).send(request.body)
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
-fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => { fastify.close() })
-
+test('search test', async t => {
+  await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
   const url = `http://localhost:${fastify.server.address().port}`
 
-  test('request - search', t => {
+  await t.test('request - search', (t, done) => {
     t.plan(4)
     sget({
       method: 'SEARCH',
       url
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      done()
     })
   })
 
-  test('request search params schema', t => {
+  await t.test('request search params schema', (t, done) => {
     t.plan(4)
     sget({
       method: 'SEARCH',
       url: `${url}/params/world/123`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { foo: 'world', test: 123 })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { foo: 'world', test: 123 })
+      done()
     })
   })
 
-  test('request search params schema error', t => {
+  await t.test('request search params schema error', (t, done) => {
     t.plan(3)
     sget({
       method: 'SEARCH',
       url: `${url}/params/world/string`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         error: 'Bad Request',
         code: 'FST_ERR_VALIDATION',
         message: 'params/test must be integer',
         statusCode: 400
       })
+      done()
     })
   })
 
-  test('request search querystring schema', t => {
+  await t.test('request search querystring schema', (t, done) => {
     t.plan(4)
     sget({
       method: 'SEARCH',
       url: `${url}/query?hello=123`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 123 })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 123 })
+      done()
     })
   })
 
-  test('request search querystring schema error', t => {
+  await t.test('request search querystring schema error', (t, done) => {
     t.plan(3)
     sget({
       method: 'SEARCH',
       url: `${url}/query?hello=world`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         error: 'Bad Request',
         code: 'FST_ERR_VALIDATION',
         message: 'querystring/hello must be integer',
         statusCode: 400
       })
+      done()
     })
   })
 
-  test('request search body schema', t => {
+  await t.test('request search body schema', (t, done) => {
     t.plan(4)
     const replyBody = { foo: 'bar', test: 5 }
     sget({
@@ -214,14 +217,15 @@ fastify.listen({ port: 0 }, err => {
       body: JSON.stringify(replyBody),
       headers: { 'content-type': 'application/json' }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), replyBody)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), replyBody)
+      done()
     })
   })
 
-  test('request search body schema error', t => {
+  await t.test('request search body schema error', (t, done) => {
     t.plan(4)
     sget({
       method: 'SEARCH',
@@ -229,15 +233,16 @@ fastify.listen({ port: 0 }, err => {
       body: JSON.stringify({ foo: 'bar', test: 'test' }),
       headers: { 'content-type': 'application/json' }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         error: 'Bad Request',
         code: 'FST_ERR_VALIDATION',
         message: 'body/test must be integer',
         statusCode: 400
       })
+      done()
     })
   })
 })

package/test/http-methods/trace.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('TRACE')
 
@@ -15,8 +14,8 @@ test('shorthand - trace', t => {
         reply.code(200).send('TRACE OK')
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })

package/test/http-methods/unlock.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('UNLOCK')
@@ -16,17 +15,17 @@ test('can be created - unlock', t => {
         reply.code(204).send()
       }
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
-fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => { fastify.close() })
+test('unlock test', async t => {
+  await fastify.listen({ port: 0 })
 
-  test('request - unlock', t => {
+  t.after(() => { fastify.close() })
+  await t.test('request - unlock', (t, done) => {
     t.plan(2)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
@@ -35,8 +34,9 @@ fastify.listen({ port: 0 }, err => {
         'Lock-Token': 'urn:uuid:a515cfa4-5da4-22e1-f5b5-00a0451e6bf7'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 204)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 204)
+      done()
     })
   })
 })