fast-json-stringify 6.0.0 → 6.0.1

package/test/array.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const validator = require('is-my-json-valid')
 const build = require('..')
 const Ajv = require('ajv')
@@ -8,7 +8,7 @@ const Ajv = require('ajv')
 test('error on invalid largeArrayMechanism', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {
@@ -31,9 +31,9 @@ function buildTest (schema, toStringify, options) {
     const stringify = build(schema, options)
     const output = stringify(toStringify)
 
-    t.same(JSON.parse(output), JSON.parse(JSON.stringify(toStringify)))
-    t.equal(output, JSON.stringify(toStringify))
-    t.ok(validate(JSON.parse(output)), 'valid schema')
+    t.assert.deepStrictEqual(JSON.parse(output), JSON.parse(JSON.stringify(toStringify)))
+    t.assert.equal(output, JSON.stringify(toStringify))
+    t.assert.ok(validate(JSON.parse(output)), 'valid schema')
   })
 }
 
@@ -216,7 +216,7 @@ test('invalid items throw', (t) => {
     }
   }
   const stringify = build(schema)
-  t.throws(() => stringify({ args: ['invalid'] }))
+  t.assert.throws(() => stringify({ args: ['invalid'] }))
 })
 
 buildTest({
@@ -258,7 +258,7 @@ test('array items is a list of schema and additionalItems is true, just the desc
     ]
   })
 
-  t.equal(result, '{"foo":["foo","bar",1]}')
+  t.assert.equal(result, '{"foo":["foo","bar",1]}')
 })
 
 test('array items is a list of schema and additionalItems is true, just the described item is validated', (t) => {
@@ -287,7 +287,7 @@ test('array items is a list of schema and additionalItems is true, just the desc
     foo: ['foo']
   })
 
-  t.equal(result, '{"foo":["foo"]}')
+  t.assert.equal(result, '{"foo":["foo"]}')
 })
 
 test('array items is a list of schema and additionalItems is false /1', (t) => {
@@ -307,7 +307,7 @@ test('array items is a list of schema and additionalItems is false /1', (t) => {
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: ['foo', 'bar'] }), new Error('Item at 1 does not match schema definition.'))
 })
 
 test('array items is a list of schema and additionalItems is false /2', (t) => {
@@ -329,9 +329,9 @@ test('array items is a list of schema and additionalItems is false /2', (t) => {
 
   const stringify = build(schema)
 
-  t.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.'))
-  t.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.'))
-  t.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: [1, 'bar'] }), new Error('Item at 0 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: ['foo', 1] }), new Error('Item at 1 does not match schema definition.'))
+  t.assert.throws(() => stringify({ foo: ['foo', 'bar', 'baz'] }), new Error('Item at 2 does not match schema definition.'))
 })
 
 test('array items is a schema and additionalItems is false', (t) => {
@@ -354,8 +354,8 @@ test('array items is a schema and additionalItems is false', (t) => {
   const ajv = new Ajv({ allErrors: true, strict: false })
 
   const validate = ajv.compile(schema)
-  t.same(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}')
-  t.equal(validate({ foo: ['foo', 'bar'] }), true)
+  t.assert.equal(stringify({ foo: ['foo', 'bar'] }), '{"foo":["foo","bar"]}')
+  t.assert.equal(validate({ foo: ['foo', 'bar'] }), true)
 })
 
 // https://github.com/fastify/fast-json-stringify/issues/279
@@ -402,7 +402,7 @@ test('object array with anyOf and symbol', (t) => {
     { name: 'name-0', option: 'Foo' },
     { name: 'name-1', option: 'Bar' }
   ])
-  t.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
+  t.assert.equal(value, '[{"name":"name-0","option":"Foo"},{"name":"name-1","option":"Bar"}]')
 })
 
 test('different arrays with same item schemas', (t) => {
@@ -427,7 +427,7 @@ test('different arrays with same item schemas', (t) => {
   const stringify = build(schema)
   const data = { array1: ['bar'], array2: ['foo', 'bar'] }
 
-  t.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}')
+  t.assert.equal(stringify(data), '{"array1":["bar"],"array2":["foo","bar"]}')
 })
 
 const largeArray = new Array(2e4).fill({ a: 'test', b: 1 })
@@ -557,7 +557,7 @@ buildTest({
 test('error on invalid value for largeArraySize /1', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {
@@ -574,7 +574,7 @@ test('error on invalid value for largeArraySize /1', (t) => {
 test('error on invalid value for largeArraySize /2', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {
@@ -591,7 +591,7 @@ test('error on invalid value for largeArraySize /2', (t) => {
 test('error on invalid value for largeArraySize /3', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'large array of null values with default mechanism',
     type: 'object',
     properties: {

package/test/asNumber.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 
 test('asNumber should convert BigInt', (t) => {
   t.plan(1)
@@ -9,5 +9,5 @@ test('asNumber should convert BigInt', (t) => {
 
   const number = serializer.asNumber(11753021440n)
 
-  t.equal(number, '11753021440')
+  t.assert.equal(number, '11753021440')
 })

package/test/basic.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const validator = require('is-my-json-valid')
 const build = require('..')
 
@@ -12,9 +12,9 @@ function buildTest (schema, toStringify) {
     const stringify = build(schema)
     const output = stringify(toStringify)
 
-    t.same(JSON.parse(output), toStringify)
-    t.equal(output, JSON.stringify(toStringify))
-    t.ok(validate(JSON.parse(output)), 'valid schema')
+    t.assert.deepStrictEqual(JSON.parse(output), toStringify)
+    t.assert.equal(output, JSON.stringify(toStringify))
+    t.assert.ok(validate(JSON.parse(output)), 'valid schema')
   })
 }
 
@@ -281,41 +281,34 @@ test('throw an error or coerce numbers and integers that are not numbers', (t) =
     }
   })
 
-  try {
+  t.assert.throws(() => {
     stringify({ age: 'hello  ', distance: 'long' })
-    t.fail('should throw an error')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'The value "hello  " cannot be converted to a number.' })
 
   const result = stringify({
     age: '42',
     distance: true
   })
 
-  t.same(JSON.parse(result), { age: 42, distance: 1 })
-  t.end()
+  t.assert.deepStrictEqual(JSON.parse(result), { age: 42, distance: 1 })
 })
 
 test('Should throw on invalid schema', t => {
   t.plan(1)
-  try {
+  t.assert.throws(() => {
     build({
       type: 'Dinosaur',
       properties: {
         claws: { type: 'sharp' }
       }
     })
-    t.fail('should be an invalid schema')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'schema is invalid: data/properties/claws/type must be equal to one of the allowed values' })
 })
 
 test('additionalProperties - throw on unknown type', (t) => {
   t.plan(1)
 
-  try {
+  t.assert.throws(() => {
     build({
       title: 'check array coerce',
       type: 'object',
@@ -325,15 +318,13 @@ test('additionalProperties - throw on unknown type', (t) => {
       }
     })
     t.fail('should be an invalid schema')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'schema is invalid: data/additionalProperties/type must be equal to one of the allowed values' })
 })
 
 test('patternProperties - throw on unknown type', (t) => {
   t.plan(1)
 
-  try {
+  t.assert.throws(() => {
     build({
       title: 'check array coerce',
       type: 'object',
@@ -344,10 +335,7 @@ test('patternProperties - throw on unknown type', (t) => {
         }
       }
     })
-    t.fail('should be an invalid schema')
-  } catch (err) {
-    t.ok(err)
-  }
+  }, { message: 'schema is invalid: data/patternProperties/foo/type must be equal to one of the allowed values' })
 })
 
 test('render a double quote as JSON /1', (t) => {
@@ -362,8 +350,8 @@ test('render a double quote as JSON /1', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render a double quote as JSON /2', (t) => {
@@ -378,8 +366,8 @@ test('render a double quote as JSON /2', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render a long string', (t) => {
@@ -394,8 +382,8 @@ test('render a long string', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('returns JSON.stringify if schema type is boolean', t => {
@@ -408,5 +396,5 @@ test('returns JSON.stringify if schema type is boolean', t => {
 
   const array = [1, true, 'test']
   const stringify = build(schema)
-  t.equal(stringify(array), JSON.stringify(array))
+  t.assert.equal(stringify(array), JSON.stringify(array))
 })

package/test/bigint.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
+
 const build = require('..')
 
 test('render a bigint as JSON', (t) => {
@@ -15,7 +15,7 @@ test('render a bigint as JSON', (t) => {
   const stringify = build(schema)
   const output = stringify(1615n)
 
-  t.equal(output, '1615')
+  t.assert.equal(output, '1615')
 })
 
 test('render an object with a bigint as JSON', (t) => {
@@ -36,7 +36,7 @@ test('render an object with a bigint as JSON', (t) => {
     id: 1615n
   })
 
-  t.equal(output, '{"id":1615}')
+  t.assert.equal(output, '{"id":1615}')
 })
 
 test('render an array with a bigint as JSON', (t) => {
@@ -53,7 +53,7 @@ test('render an array with a bigint as JSON', (t) => {
   const stringify = build(schema)
   const output = stringify([1615n])
 
-  t.equal(output, '[1615]')
+  t.assert.equal(output, '[1615]')
 })
 
 test('render an object with an additionalProperty of type bigint as JSON', (t) => {
@@ -72,5 +72,5 @@ test('render an object with an additionalProperty of type bigint as JSON', (t) =
     num: 1615n
   })
 
-  t.equal(output, '{"num":1615}')
+  t.assert.equal(output, '{"num":1615}')
 })

package/test/clean-cache.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('Should clean the cache', (t) => {
@@ -11,9 +11,10 @@ test('Should clean the cache', (t) => {
     type: 'string'
   }
 
-  build(schema)
-  build(schema)
-  t.pass()
+  t.assert.doesNotThrow(() => {
+    build(schema)
+    build(schema)
+  })
 })
 
 test('Should clean the cache with external schemas', (t) => {
@@ -39,7 +40,8 @@ test('Should clean the cache with external schemas', (t) => {
     }
   }
 
-  build(schema)
-  build(schema)
-  t.pass()
+  t.assert.doesNotThrow(() => {
+    build(schema)
+    build(schema)
+  })
 })

package/test/const.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const validator = require('is-my-json-valid')
 const build = require('..')
 
@@ -20,8 +20,8 @@ test('schema with const string', (t) => {
     foo: 'bar'
   })
 
-  t.equal(output, '{"foo":"bar"}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":"bar"}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const string and different input', (t) => {
@@ -40,8 +40,8 @@ test('schema with const string and different input', (t) => {
     foo: 'baz'
   })
 
-  t.equal(output, '{"foo":"bar"}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":"bar"}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const string and different type input', (t) => {
@@ -60,8 +60,8 @@ test('schema with const string and different type input', (t) => {
     foo: 1
   })
 
-  t.equal(output, '{"foo":"bar"}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":"bar"}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const string and no input', (t) => {
@@ -78,8 +78,8 @@ test('schema with const string and no input', (t) => {
   const stringify = build(schema)
   const output = stringify({})
 
-  t.equal(output, '{}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const string that contains \'', (t) => {
@@ -98,8 +98,8 @@ test('schema with const string that contains \'', (t) => {
     foo: "'bar'"
   })
 
-  t.equal(output, '{"foo":"\'bar\'"}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":"\'bar\'"}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const number', (t) => {
@@ -118,8 +118,8 @@ test('schema with const number', (t) => {
     foo: 1
   })
 
-  t.equal(output, '{"foo":1}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":1}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const number and different input', (t) => {
@@ -138,8 +138,8 @@ test('schema with const number and different input', (t) => {
     foo: 2
   })
 
-  t.equal(output, '{"foo":1}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":1}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const bool', (t) => {
@@ -158,8 +158,8 @@ test('schema with const bool', (t) => {
     foo: true
   })
 
-  t.equal(output, '{"foo":true}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":true}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const number', (t) => {
@@ -178,8 +178,8 @@ test('schema with const number', (t) => {
     foo: 1
   })
 
-  t.equal(output, '{"foo":1}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":1}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const null', (t) => {
@@ -198,8 +198,8 @@ test('schema with const null', (t) => {
     foo: null
   })
 
-  t.equal(output, '{"foo":null}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":null}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const array', (t) => {
@@ -218,8 +218,8 @@ test('schema with const array', (t) => {
     foo: [1, 2, 3]
   })
 
-  t.equal(output, '{"foo":[1,2,3]}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":[1,2,3]}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const object', (t) => {
@@ -238,8 +238,8 @@ test('schema with const object', (t) => {
     foo: { bar: 'baz' }
   })
 
-  t.equal(output, '{"foo":{"bar":"baz"}}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":{"bar":"baz"}}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('schema with const and null as type', (t) => {
@@ -258,12 +258,12 @@ test('schema with const and null as type', (t) => {
     foo: null
   })
 
-  t.equal(output, '{"foo":null}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":null}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 
   const output2 = stringify({ foo: 'baz' })
-  t.equal(output2, '{"foo":"baz"}')
-  t.ok(validate(JSON.parse(output2)), 'valid schema')
+  t.assert.equal(output2, '{"foo":"baz"}')
+  t.assert.ok(validate(JSON.parse(output2)), 'valid schema')
 })
 
 test('schema with const as nullable', (t) => {
@@ -282,14 +282,14 @@ test('schema with const as nullable', (t) => {
     foo: null
   })
 
-  t.equal(output, '{"foo":null}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"foo":null}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 
   const output2 = stringify({
     foo: 'baz'
   })
-  t.equal(output2, '{"foo":"baz"}')
-  t.ok(validate(JSON.parse(output2)), 'valid schema')
+  t.assert.equal(output2, '{"foo":"baz"}')
+  t.assert.ok(validate(JSON.parse(output2)), 'valid schema')
 })
 
 test('schema with const and invalid object', (t) => {
@@ -309,6 +309,6 @@ test('schema with const and invalid object', (t) => {
     foo: { foo: 'baz' }
   })
 
-  t.equal(result, '{"foo":{"foo":"bar"}}')
-  t.ok(validate(JSON.parse(result)), 'valid schema')
+  t.assert.equal(result, '{"foo":{"foo":"bar"}}')
+  t.assert.ok(validate(JSON.parse(result)), 'valid schema')
 })