fast-json-stringify 6.0.0 → 6.1.0

package/test/standalone-mode.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test, after } = require('node:test')
 const fjs = require('..')
 const fs = require('fs')
 const path = require('path')
@@ -22,23 +22,29 @@ const tmpDir = 'test/fixtures'
 
 test('activate standalone mode', async (t) => {
   t.plan(3)
-  const code = build({ mode: 'standalone' })
-  t.type(code, 'string')
-  t.equal(code.indexOf('ajv'), -1)
-
-  const destination = path.resolve(tmpDir, 'standalone.js')
 
-  t.teardown(async () => {
+  after(async () => {
     await fs.promises.rm(destination, { force: true })
   })
 
+  const code = build({ mode: 'standalone' })
+  t.assert.ok(typeof code === 'string')
+  t.assert.equal(code.indexOf('ajv'), -1)
+
+  const destination = path.resolve(tmpDir, 'standalone.js')
+
   await fs.promises.writeFile(destination, code)
   const standalone = require(destination)
-  t.same(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted')
+  t.assert.equal(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted')
 })
 
 test('test ajv schema', async (t) => {
   t.plan(3)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
   const code = build({ mode: 'standalone' }, {
     type: 'object',
     properties: {
@@ -86,18 +92,14 @@ test('test ajv schema', async (t) => {
       }
     }
   })
-  t.type(code, 'string')
-  t.equal(code.indexOf('ajv') > 0, true)
+  t.assert.ok(typeof code === 'string')
+  t.assert.equal(code.indexOf('ajv') > 0, true)
 
   const destination = path.resolve(tmpDir, 'standalone2.js')
 
-  t.teardown(async () => {
-    await fs.promises.rm(destination, { force: true })
-  })
-
   await fs.promises.writeFile(destination, code)
   const standalone = require(destination)
-  t.same(standalone({
+  t.assert.equal(standalone({
     kind: 'foobar',
     foo: 'FOO',
     list: [{
@@ -122,6 +124,11 @@ test('test ajv schema', async (t) => {
 
 test('no need to keep external schemas once compiled', async (t) => {
   t.plan(1)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
   const externalSchema = {
     first: {
       definitions: {
@@ -145,19 +152,19 @@ test('no need to keep external schemas once compiled', async (t) => {
 
   const destination = path.resolve(tmpDir, 'standalone3.js')
 
-  t.teardown(async () => {
-    await fs.promises.rm(destination, { force: true })
-  })
-
   await fs.promises.writeFile(destination, code)
   const standalone = require(destination)
 
-  t.same(standalone({ id1: 5 }), JSON.stringify({ id1: 5 }), 'serialization works with external schemas')
+  t.assert.equal(standalone({ id1: 5 }), JSON.stringify({ id1: 5 }), 'serialization works with external schemas')
 })
 
 test('no need to keep external schemas once compiled - with oneOf validator', async (t) => {
   t.plan(2)
 
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
   const externalSchema = {
     ext: {
       definitions: {
@@ -204,13 +211,9 @@ test('no need to keep external schemas once compiled - with oneOf validator', as
 
   const destination = path.resolve(tmpDir, 'standalone-oneOf-ref.js')
 
-  t.teardown(async () => {
-    await fs.promises.rm(destination, { force: true })
-  })
-
   await fs.promises.writeFile(destination, code)
   const stringify = require(destination)
 
-  t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
-  t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+  t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+  t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
 })

package/test/string.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('serialize short string', (t) => {
@@ -15,8 +15,8 @@ test('serialize short string', (t) => {
   const stringify = build(schema)
   const output = stringify(input)
 
-  t.equal(output, '"abcd"')
-  t.equal(JSON.parse(output), input)
+  t.assert.equal(output, '"abcd"')
+  t.assert.equal(JSON.parse(output), input)
 })
 
 test('serialize short string', (t) => {
@@ -30,8 +30,8 @@ test('serialize short string', (t) => {
   const stringify = build(schema)
   const output = stringify(input)
 
-  t.equal(output, '"\\u0000"')
-  t.equal(JSON.parse(output), input)
+  t.assert.equal(output, '"\\u0000"')
+  t.assert.equal(JSON.parse(output), input)
 })
 
 test('serialize long string', (t) => {
@@ -45,8 +45,8 @@ test('serialize long string', (t) => {
   const stringify = build(schema)
   const output = stringify(input)
 
-  t.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`)
-  t.equal(JSON.parse(output), input)
+  t.assert.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`)
+  t.assert.equal(JSON.parse(output), input)
 })
 
 test('unsafe string', (t) => {
@@ -61,8 +61,8 @@ test('unsafe string', (t) => {
   const stringify = build(schema)
   const output = stringify(input)
 
-  t.equal(output, `"${input}"`)
-  t.equal(JSON.parse(output), input)
+  t.assert.equal(output, `"${input}"`)
+  t.assert.equal(JSON.parse(output), input)
 })
 
 test('unsafe unescaped string', (t) => {
@@ -77,8 +77,8 @@ test('unsafe unescaped string', (t) => {
   const stringify = build(schema)
   const output = stringify(input)
 
-  t.equal(output, `"${input}"`)
-  t.throws(function () {
+  t.assert.equal(output, `"${input}"`)
+  t.assert.throws(function () {
     JSON.parse(output)
   })
 })

package/test/surrogate.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('..')
 
@@ -16,8 +16,8 @@ test('render a string with surrogate pairs as JSON:test 1', (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('render a string with surrogate pairs as JSON: test 2', (t) => {
@@ -32,8 +32,8 @@ test('render a string with surrogate pairs as JSON: test 2', (t) => {
   const stringify = build(schema)
   const output = stringify('\uD834\uDF06')
 
-  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('render a string with Unpaired surrogate code as JSON', (t) => {
@@ -47,8 +47,8 @@ test('render a string with Unpaired surrogate code as JSON', (t) => {
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify('\uDF06\uD834')
-  t.equal(output, JSON.stringify('\uDF06\uD834'))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify('\uDF06\uD834'))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render a string with lone surrogate code as JSON', (t) => {
@@ -62,6 +62,6 @@ test('render a string with lone surrogate code as JSON', (t) => {
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify('\uDEAD')
-  t.equal(output, JSON.stringify('\uDEAD'))
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, JSON.stringify('\uDEAD'))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })

package/test/toJSON.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('use toJSON method on object types', (t) => {
@@ -22,7 +22,7 @@ test('use toJSON method on object types', (t) => {
     }
   }
 
-  t.equal('{"productName":"cola"}', stringify(object))
+  t.assert.equal('{"productName":"cola"}', stringify(object))
 })
 
 test('use toJSON method on nested object types', (t) => {
@@ -55,7 +55,7 @@ test('use toJSON method on nested object types', (t) => {
     }
   ]
 
-  t.equal('[{"productName":"cola"},{"productName":"sprite"}]', stringify(array))
+  t.assert.equal('[{"productName":"cola"},{"productName":"sprite"}]', stringify(array))
 })
 
 test('not use toJSON if does not exist', (t) => {
@@ -79,7 +79,7 @@ test('not use toJSON if does not exist', (t) => {
     product: { name: 'cola' }
   }
 
-  t.equal('{"product":{"name":"cola"}}', stringify(object))
+  t.assert.equal('{"product":{"name":"cola"}}', stringify(object))
 })
 
 test('not fail on null object declared nullable', (t) => {
@@ -100,7 +100,7 @@ test('not fail on null object declared nullable', (t) => {
       }
     }
   })
-  t.equal('null', stringify(null))
+  t.assert.equal('null', stringify(null))
 })
 
 test('not fail on null sub-object declared nullable', (t) => {
@@ -124,7 +124,7 @@ test('not fail on null sub-object declared nullable', (t) => {
   const object = {
     product: null
   }
-  t.equal('{"product":null}', stringify(object))
+  t.assert.equal('{"product":null}', stringify(object))
 })
 
 test('on non nullable null sub-object it should coerce to {}', (t) => {
@@ -150,7 +150,7 @@ test('on non nullable null sub-object it should coerce to {}', (t) => {
   }
 
   const result = stringify(object)
-  t.equal(result, JSON.stringify({ product: {} }))
+  t.assert.equal(result, JSON.stringify({ product: {} }))
 })
 
 test('on non nullable null object it should coerce to {}', (t) => {
@@ -174,7 +174,7 @@ test('on non nullable null object it should coerce to {}', (t) => {
   })
 
   const result = stringify(null)
-  t.equal(result, '{}')
+  t.assert.equal(result, '{}')
 })
 
 test('on non-nullable null object it should skip rendering, skipping required fields checks', (t) => {
@@ -199,5 +199,5 @@ test('on non-nullable null object it should skip rendering, skipping required fi
   })
 
   const result = stringify(null)
-  t.equal(result, '{}')
+  t.assert.equal(result, '{}')
 })

package/test/typebox.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('nested object in pattern properties for typebox', (t) => {
@@ -32,5 +32,5 @@ test('nested object in pattern properties for typebox', (t) => {
       }
     }
   })
-  t.equal(value, '{"key1":{"nestedKey":{"nestedKey1":"value1"}},"key2":{"nestedKey":{"nestedKey1":"value2"}}}')
+  t.assert.equal(value, '{"key1":{"nestedKey":{"nestedKey1":"value1"}},"key2":{"nestedKey":{"nestedKey1":"value2"}}}')
 })

package/test/typesArray.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('possibly nullable integer primitive alternative', (t) => {
@@ -21,7 +21,7 @@ test('possibly nullable integer primitive alternative', (t) => {
   const value = stringify({
     data: 4
   })
-  t.equal(value, '{"data":4}')
+  t.assert.equal(value, '{"data":4}')
 })
 
 test('possibly nullable number primitive alternative', (t) => {
@@ -42,7 +42,7 @@ test('possibly nullable number primitive alternative', (t) => {
   const value = stringify({
     data: 4
   })
-  t.equal(value, '{"data":4}')
+  t.assert.equal(value, '{"data":4}')
 })
 
 test('possibly nullable integer primitive alternative with null value', (t) => {
@@ -63,7 +63,7 @@ test('possibly nullable integer primitive alternative with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.equal(value, '{"data":0}')
+  t.assert.equal(value, '{"data":0}')
 })
 
 test('possibly nullable number primitive alternative with null value', (t) => {
@@ -84,7 +84,7 @@ test('possibly nullable number primitive alternative with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.equal(value, '{"data":0}')
+  t.assert.equal(value, '{"data":0}')
 })
 
 test('possibly nullable number primitive alternative with null value', (t) => {
@@ -105,7 +105,7 @@ test('possibly nullable number primitive alternative with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.equal(value, '{"data":false}')
+  t.assert.equal(value, '{"data":false}')
 })
 
 test('nullable integer primitive', (t) => {
@@ -126,7 +126,7 @@ test('nullable integer primitive', (t) => {
   const value = stringify({
     data: 4
   })
-  t.equal(value, '{"data":4}')
+  t.assert.equal(value, '{"data":4}')
 })
 
 test('nullable number primitive', (t) => {
@@ -147,7 +147,7 @@ test('nullable number primitive', (t) => {
   const value = stringify({
     data: 4
   })
-  t.equal(value, '{"data":4}')
+  t.assert.equal(value, '{"data":4}')
 })
 
 test('nullable primitive with null value', (t) => {
@@ -168,7 +168,7 @@ test('nullable primitive with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.equal(value, '{"data":null}')
+  t.assert.equal(value, '{"data":null}')
 })
 
 test('nullable number primitive with null value', (t) => {
@@ -189,7 +189,7 @@ test('nullable number primitive with null value', (t) => {
   const value = stringify({
     data: null
   })
-  t.equal(value, '{"data":null}')
+  t.assert.equal(value, '{"data":null}')
 })
 
 test('possibly null object with multi-type property', (t) => {
@@ -211,19 +211,19 @@ test('possibly null object with multi-type property', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     objectOrNull: {
       stringOrNumber: 'string'
     }
   }), '{"objectOrNull":{"stringOrNumber":"string"}}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     objectOrNull: {
       stringOrNumber: 42
     }
   }), '{"objectOrNull":{"stringOrNumber":42}}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     objectOrNull: null
   }), '{"objectOrNull":null}')
 })
@@ -249,7 +249,7 @@ test('object with possibly null array of multiple types', (t) => {
     const value = stringify({
       arrayOfStringsAndNumbers: null
     })
-    t.equal(value, '{"arrayOfStringsAndNumbers":null}')
+    t.assert.equal(value, '{"arrayOfStringsAndNumbers":null}')
   } catch (e) {
     console.log(e)
     t.fail()
@@ -259,21 +259,21 @@ test('object with possibly null array of multiple types', (t) => {
     const value = stringify({
       arrayOfStringsAndNumbers: ['string1', 'string2']
     })
-    t.equal(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}')
+    t.assert.equal(value, '{"arrayOfStringsAndNumbers":["string1","string2"]}')
   } catch (e) {
     console.log(e)
     t.fail()
   }
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     arrayOfStringsAndNumbers: [42, 7]
   }), '{"arrayOfStringsAndNumbers":[42,7]}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     arrayOfStringsAndNumbers: ['string1', 42, 7, 'string2']
   }), '{"arrayOfStringsAndNumbers":["string1",42,7,"string2"]}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     arrayOfStringsAndNumbers: ['string1', null, 42, 7, 'string2', null]
   }), '{"arrayOfStringsAndNumbers":["string1",null,42,7,"string2",null]}')
 })
@@ -307,7 +307,7 @@ test('object with tuple of multiple types', (t) => {
     const value = stringify({
       fixedTupleOfStringsAndNumbers: ['string1', 42, 7]
     })
-    t.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}')
+    t.assert.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,7]}')
   } catch (e) {
     console.log(e)
     t.fail()
@@ -317,7 +317,7 @@ test('object with tuple of multiple types', (t) => {
     const value = stringify({
       fixedTupleOfStringsAndNumbers: ['string1', 42, 'string2']
     })
-    t.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}')
+    t.assert.equal(value, '{"fixedTupleOfStringsAndNumbers":["string1",42,"string2"]}')
   } catch (e) {
     console.log(e)
     t.fail()
@@ -354,17 +354,17 @@ test('object with anyOf and multiple types', (t) => {
     const value = stringify({
       objectOrBoolean: { stringOrNumber: 'string' }
     })
-    t.equal(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}')
+    t.assert.equal(value, '{"objectOrBoolean":{"stringOrNumber":"string"}}')
   } catch (e) {
     console.log(e)
     t.fail()
   }
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     objectOrBoolean: { stringOrNumber: 42 }
   }), '{"objectOrBoolean":{"stringOrNumber":42}}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     objectOrBoolean: true
   }), '{"objectOrBoolean":true}')
 })
@@ -383,7 +383,7 @@ test('string type array can handle dates', (t) => {
     date: new Date('2018-04-20T07:52:31.017Z'),
     dateObject: new Date('2018-04-21T07:52:31.017Z')
   })
-  t.equal(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}')
+  t.assert.equal(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}')
 })
 
 test('object that is simultaneously a string and a json', (t) => {
@@ -406,10 +406,10 @@ test('object that is simultaneously a string and a json', (t) => {
 
   const stringify = build(schema)
   const valueStr = stringify({ simultaneously: likeObjectId })
-  t.equal(valueStr, '{"simultaneously":"hello"}')
+  t.assert.equal(valueStr, '{"simultaneously":"hello"}')
 
   const valueObj = stringify({ simultaneously: { foo: likeObjectId } })
-  t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
+  t.assert.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
 })
 
 test('object that is simultaneously a string and a json switched', (t) => {
@@ -432,10 +432,10 @@ test('object that is simultaneously a string and a json switched', (t) => {
 
   const stringify = build(schema)
   const valueStr = stringify({ simultaneously: likeObjectId })
-  t.equal(valueStr, '{"simultaneously":{}}')
+  t.assert.equal(valueStr, '{"simultaneously":{}}')
 
   const valueObj = stringify({ simultaneously: { foo: likeObjectId } })
-  t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
+  t.assert.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
 })
 
 test('class instance that is simultaneously a string and a json', (t) => {
@@ -461,10 +461,10 @@ test('class instance that is simultaneously a string and a json', (t) => {
 
   const stringify = build(schema)
   const valueStr = stringify({ simultaneously: likeObjectId })
-  t.equal(valueStr, '{"simultaneously":"hello"}')
+  t.assert.equal(valueStr, '{"simultaneously":"hello"}')
 
   const valueObj = stringify({ simultaneously: { foo: likeObjectId } })
-  t.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
+  t.assert.equal(valueObj, '{"simultaneously":{"foo":"hello"}}')
 })
 
 test('should not throw an error when type is array and object is null, it should instead coerce to []', (t) => {
@@ -483,7 +483,7 @@ test('should not throw an error when type is array and object is null, it should
 
   const stringify = build(schema)
   const result = stringify({ arr: null })
-  t.equal(result, JSON.stringify({ arr: [] }))
+  t.assert.equal(result, JSON.stringify({ arr: [] }))
 })
 
 test('should throw an error when type is array and object is not an array', (t) => {
@@ -501,7 +501,7 @@ test('should throw an error when type is array and object is not an array', (t)
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'#/properties/arr\' does not match schema definition.'))
+  t.assert.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'#/properties/arr\' does not match schema definition.'))
 })
 
 test('should throw an error when type is array and object is not an array with external schema', (t) => {
@@ -529,7 +529,7 @@ test('should throw an error when type is array and object is not an array with e
   }
 
   const stringify = build(schema, { schema: externalSchema })
-  t.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'arrayOfNumbers#/definitions/arr\' does not match schema definition.'))
+  t.assert.throws(() => stringify({ arr: { foo: 'hello' } }), new TypeError('The value of \'arrayOfNumbers#/definitions/arr\' does not match schema definition.'))
 })
 
 test('throw an error if none of types matches', (t) => {
@@ -546,5 +546,5 @@ test('throw an error if none of types matches', (t) => {
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify({ data: 'string' }), 'The value "string" does not match schema definition.')
+  t.assert.throws(() => stringify({ data: 'string' }), 'The value "string" does not match schema definition.')
 })

package/test/unknownFormats.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('object with custom format field', (t) => {
@@ -19,9 +19,9 @@ test('object with custom format field', (t) => {
 
   const stringify = build(schema)
 
-  stringify({
-    str: 'string'
+  t.assert.doesNotThrow(() => {
+    stringify({
+      str: 'string'
+    })
   })
-
-  t.pass()
 })

package/test/webpack.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const webpack = require('webpack')
 const path = require('path')
 
@@ -46,5 +46,5 @@ test('the library should work with webpack', async (t) => {
   })
 
   const obj = { foo: '42', bar: true }
-  t.equal(stringify(obj), '{"foo":"42","bar":true}')
+  t.assert.equal(stringify(obj), '{"foo":"42","bar":true}')
 })