fast-json-stringify 6.0.0 → 6.0.1

package/test/nullable.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 
 const build = require('..')
 
@@ -113,7 +113,7 @@ Object.keys(testSet).forEach(key => {
 
     const stringifier = build(schema, extraOptions)
     const result = stringifier(data)
-    t.same(JSON.parse(result), expected)
+    t.assert.deepStrictEqual(JSON.parse(result), expected)
   })
 })
 
@@ -129,8 +129,8 @@ test('handle nullable number correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('handle nullable integer correctly', (t) => {
@@ -145,8 +145,8 @@ test('handle nullable integer correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('handle nullable boolean correctly', (t) => {
@@ -161,8 +161,8 @@ test('handle nullable boolean correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('handle nullable string correctly', (t) => {
@@ -177,8 +177,8 @@ test('handle nullable string correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('handle nullable date-time correctly', (t) => {
@@ -194,8 +194,8 @@ test('handle nullable date-time correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('handle nullable date correctly', (t) => {
@@ -211,8 +211,8 @@ test('handle nullable date correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('handle nullable time correctly', (t) => {
@@ -228,8 +228,8 @@ test('handle nullable time correctly', (t) => {
   const data = null
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.equal(JSON.parse(result), data)
 })
 
 test('large array of nullable strings with default mechanism', (t) => {
@@ -258,8 +258,8 @@ test('large array of nullable strings with default mechanism', (t) => {
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('large array of nullable date-time strings with default mechanism', (t) => {
@@ -289,8 +289,8 @@ test('large array of nullable date-time strings with default mechanism', (t) =>
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('large array of nullable date-time strings with default mechanism', (t) => {
@@ -320,8 +320,8 @@ test('large array of nullable date-time strings with default mechanism', (t) =>
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('large array of nullable date-time strings with default mechanism', (t) => {
@@ -351,8 +351,8 @@ test('large array of nullable date-time strings with default mechanism', (t) =>
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('large array of nullable numbers with default mechanism', (t) => {
@@ -381,8 +381,8 @@ test('large array of nullable numbers with default mechanism', (t) => {
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('large array of nullable integers with default mechanism', (t) => {
@@ -411,8 +411,8 @@ test('large array of nullable integers with default mechanism', (t) => {
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('large array of nullable booleans with default mechanism', (t) => {
@@ -441,8 +441,8 @@ test('large array of nullable booleans with default mechanism', (t) => {
   const data = { ids: new Array(2e4).fill(null) }
   const result = stringify(data)
 
-  t.same(result, JSON.stringify(data))
-  t.same(JSON.parse(result), data)
+  t.assert.equal(result, JSON.stringify(data))
+  t.assert.deepStrictEqual(JSON.parse(result), data)
 })
 
 test('nullable type in the schema', (t) => {
@@ -461,8 +461,8 @@ test('nullable type in the schema', (t) => {
 
   const data = { foo: 'bar' }
 
-  t.same(stringify(data), JSON.stringify(data))
-  t.same(stringify(null), JSON.stringify(null))
+  t.assert.equal(stringify(data), JSON.stringify(data))
+  t.assert.equal(stringify(null), JSON.stringify(null))
 })
 
 test('throw an error if the value doesn\'t match the type', (t) => {
@@ -493,10 +493,10 @@ test('throw an error if the value doesn\'t match the type', (t) => {
   const stringify = build(schema)
 
   const validData = { data: [1, 'testing'] }
-  t.equal(stringify(validData), JSON.stringify(validData))
+  t.assert.equal(stringify(validData), JSON.stringify(validData))
 
   const invalidData = { data: [false, 'testing'] }
-  t.throws(() => stringify(invalidData))
+  t.assert.throws(() => stringify(invalidData))
 })
 
 test('nullable value in oneOf', (t) => {
@@ -539,5 +539,5 @@ test('nullable value in oneOf', (t) => {
   const stringify = build(schema)
 
   const data = { data: [{ job: null }] }
-  t.equal(stringify(data), JSON.stringify(data))
+  t.assert.equal(stringify(data), JSON.stringify(data))
 })

package/test/oneof.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
 test('object with multiple types field', (t) => {
@@ -21,8 +21,8 @@ test('object with multiple types field', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({ str: 'string' }), '{"str":"string"}')
-  t.equal(stringify({ str: true }), '{"str":true}')
+  t.assert.equal(stringify({ str: 'string' }), '{"str":"string"}')
+  t.assert.equal(stringify({ str: true }), '{"str":true}')
 })
 
 test('object with field of type object or null', (t) => {
@@ -48,9 +48,9 @@ test('object with field of type object or null', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({ prop: null }), '{"prop":null}')
+  t.assert.equal(stringify({ prop: null }), '{"prop":null}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: {
       str: 'string', remove: 'this'
     }
@@ -80,11 +80,11 @@ test('object with field of type object or array', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: { str: 'string' }
   }), '{"prop":{"str":"string"}}')
 
-  t.equal(stringify({
+  t.assert.equal(stringify({
     prop: ['string']
   }), '{"prop":["string"]}')
 })
@@ -104,7 +104,7 @@ test('object with field of type string and coercion disable ', (t) => {
     }
   }
   const stringify = build(schema)
-  t.throws(() => stringify({ str: 1 }))
+  t.assert.throws(() => stringify({ str: 1 }))
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -132,7 +132,7 @@ test('object with field of type string and coercion enable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.equal(value, '{"str":"1"}')
+  t.assert.equal(value, '{"str":"1"}')
 })
 
 test('object with field with type union of multiple objects', (t) => {
@@ -166,9 +166,9 @@ test('object with field with type union of multiple objects', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+  t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
 
-  t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+  t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
 })
 
 test('null value in schema', (t) => {
@@ -210,9 +210,9 @@ test('oneOf and $ref together', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+  t.assert.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
 
-  t.equal(stringify({ cs: true }), '{"cs":true}')
+  t.assert.equal(stringify({ cs: true }), '{"cs":true}')
 })
 
 test('oneOf and $ref: 2 levels are fine', (t) => {
@@ -250,7 +250,7 @@ test('oneOf and $ref: 2 levels are fine', (t) => {
   const value = stringify({
     cs: 3
   })
-  t.equal(value, '{"cs":3}')
+  t.assert.equal(value, '{"cs":3}')
 })
 
 test('oneOf and $ref: multiple levels should throw at build.', (t) => {
@@ -289,9 +289,9 @@ test('oneOf and $ref: multiple levels should throw at build.', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ cs: 3 }), '{"cs":3}')
-  t.equal(stringify({ cs: true }), '{"cs":true}')
-  t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+  t.assert.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.assert.equal(stringify({ cs: true }), '{"cs":true}')
+  t.assert.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
 })
 
 test('oneOf and $ref - multiple external $ref', (t) => {
@@ -344,10 +344,8 @@ test('oneOf and $ref - multiple external $ref', (t) => {
   const stringify = build(schema, { schema: externalSchema })
   const output = stringify(object)
 
-  JSON.parse(output)
-  t.pass()
-
-  t.equal(output, '{"obj":{"prop":{"prop2":"test"}}}')
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"obj":{"prop":{"prop2":"test"}}}')
 })
 
 test('oneOf with enum with more than 100 entries', (t) => {
@@ -369,7 +367,7 @@ test('oneOf with enum with more than 100 entries', (t) => {
   const stringify = build(schema)
 
   const value = stringify(['EUR', 'USD', null])
-  t.equal(value, '["EUR","USD",null]')
+  t.assert.equal(value, '["EUR","USD",null]')
 })
 
 test('oneOf object with field of type string with format or null', (t) => {
@@ -393,7 +391,7 @@ test('oneOf object with field of type string with format or null', (t) => {
 
   const withOneOfStringify = build(withOneOfSchema)
 
-  t.equal(withOneOfStringify({
+  t.assert.equal(withOneOfStringify({
     prop: toStringify
   }), `{"prop":"${toStringify.toISOString()}"}`)
 })
@@ -425,9 +423,9 @@ test('one array item match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}')
-  t.equal(stringify({ data: [1] }), '{"data":[1]}')
-  t.throws(() => stringify({ data: [false, 'foo'] }))
+  t.assert.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}')
+  t.assert.equal(stringify({ data: [1] }), '{"data":[1]}')
+  t.assert.throws(() => stringify({ data: [false, 'foo'] }))
 })
 
 test('some array items match oneOf types', (t) => {
@@ -457,8 +455,8 @@ test('some array items match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}')
-  t.throws(() => stringify({ data: [false, 'foo', true, 5] }))
+  t.assert.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}')
+  t.assert.throws(() => stringify({ data: [false, 'foo', true, 5] }))
 })
 
 test('all array items does not match oneOf types', (t) => {
@@ -488,5 +486,5 @@ test('all array items does not match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  t.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
+  t.assert.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
 })

package/test/patternProperties.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('patternProperties', (t) => {
@@ -21,7 +21,7 @@ test('patternProperties', (t) => {
   })
 
   const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true }, notMe: false }
-  t.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}')
+  t.assert.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}')
 })
 
 test('patternProperties should not change properties', (t) => {
@@ -42,7 +42,7 @@ test('patternProperties should not change properties', (t) => {
   })
 
   const obj = { foo: '42', ofoo: 42 }
-  t.equal(stringify(obj), '{"foo":"42","ofoo":42}')
+  t.assert.equal(stringify(obj), '{"foo":"42","ofoo":42}')
 })
 
 test('patternProperties - string coerce', (t) => {
@@ -59,7 +59,7 @@ test('patternProperties - string coerce', (t) => {
   })
 
   const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } }
-  t.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}')
+  t.assert.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}')
 })
 
 test('patternProperties - number coerce', (t) => {
@@ -76,14 +76,14 @@ test('patternProperties - number coerce', (t) => {
   })
 
   const coercibleValues = { foo: true, ofoo: '42' }
-  t.equal(stringify(coercibleValues), '{"foo":1,"ofoo":42}')
+  t.assert.equal(stringify(coercibleValues), '{"foo":1,"ofoo":42}')
 
   const incoercibleValues = { xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
   try {
     stringify(incoercibleValues)
     t.fail('should throw an error')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 })
 
@@ -101,7 +101,7 @@ test('patternProperties - boolean coerce', (t) => {
   })
 
   const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { a: true } }
-  t.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}')
+  t.assert.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}')
 })
 
 test('patternProperties - object coerce', (t) => {
@@ -123,7 +123,7 @@ test('patternProperties - object coerce', (t) => {
   })
 
   const obj = { objfoo: { answer: 42 } }
-  t.equal(stringify(obj), '{"objfoo":{"answer":42}}')
+  t.assert.equal(stringify(obj), '{"objfoo":{"answer":42}}')
 })
 
 test('patternProperties - array coerce', (t) => {
@@ -143,16 +143,16 @@ test('patternProperties - array coerce', (t) => {
   })
 
   const coercibleValues = { arrfoo: [1, 2] }
-  t.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}')
+  t.assert.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}')
 
   const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } }
-  t.throws(() => stringify(incoercibleValues))
+  t.assert.throws(() => stringify(incoercibleValues))
 })
 
 test('patternProperties - fail on invalid regex, handled by ajv', (t) => {
   t.plan(1)
 
-  t.throws(() => build({
+  t.assert.throws(() => build({
     title: 'check array coerce',
     type: 'object',
     properties: {},

package/test/recursion.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('can stringify recursive directory tree (issue #181)', (t) => {
@@ -25,7 +25,7 @@ test('can stringify recursive directory tree (issue #181)', (t) => {
   }
   const stringify = build(schema)
 
-  t.equal(stringify([
+  t.assert.equal(stringify([
     { name: 'directory 1', subDirectories: [] },
     {
       name: 'directory 2',
@@ -68,7 +68,7 @@ test('can stringify when recursion in external schema', t => {
   })
 
   const value = stringify({ people: { name: 'Elizabeth', children: [{ name: 'Charles' }] } })
-  t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles"}]}}')
+  t.assert.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles"}]}}')
 })
 
 test('use proper serialize function', t => {
@@ -133,7 +133,7 @@ test('use proper serialize function', t => {
       ]
     }
   })
-  t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}')
+  t.assert.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}')
 })
 
 test('can stringify recursive references in object types (issue #365)', t => {
@@ -176,7 +176,7 @@ test('can stringify recursive references in object types (issue #365)', t => {
     }
   }
   const value = stringify(data)
-  t.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}')
+  t.assert.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}')
 })
 
 test('can stringify recursive inline $id references (issue #410)', t => {
@@ -241,5 +241,5 @@ test('can stringify recursive inline $id references (issue #410)', t => {
     ]
   }
   const value = stringify(data)
-  t.equal(value, '{"id":"0","nodes":[{"id":"1","nodes":[{"id":"2","nodes":[{"id":"3","nodes":[]},{"id":"4","nodes":[]},{"id":"5","nodes":[]}]}]},{"id":"6","nodes":[{"id":"7","nodes":[{"id":"8","nodes":[]},{"id":"9","nodes":[]},{"id":"10","nodes":[]}]}]},{"id":"11","nodes":[{"id":"12","nodes":[{"id":"13","nodes":[]},{"id":"14","nodes":[]},{"id":"15","nodes":[]}]}]}]}')
+  t.assert.equal(value, '{"id":"0","nodes":[{"id":"1","nodes":[{"id":"2","nodes":[{"id":"3","nodes":[]},{"id":"4","nodes":[]},{"id":"5","nodes":[]}]}]},{"id":"6","nodes":[{"id":"7","nodes":[{"id":"8","nodes":[]},{"id":"9","nodes":[]},{"id":"10","nodes":[]}]}]},{"id":"11","nodes":[{"id":"12","nodes":[{"id":"13","nodes":[]},{"id":"14","nodes":[]},{"id":"15","nodes":[]}]}]}]}')
 })