fast-json-stringify 6.0.0 → 6.1.0

package/test/debug-mode.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const fjs = require('..')
 
 const Ajv = require('ajv').default
@@ -24,11 +24,11 @@ test('activate debug mode', t => {
   t.plan(5)
   const debugMode = build({ debugMode: true })
 
-  t.type(debugMode, 'object')
-  t.ok(debugMode.ajv instanceof Ajv)
-  t.ok(debugMode.validator instanceof Validator)
-  t.ok(debugMode.serializer instanceof Serializer)
-  t.type(debugMode.code, 'string')
+  t.assert.ok(typeof debugMode === 'object')
+  t.assert.ok(debugMode.ajv instanceof Ajv)
+  t.assert.ok(debugMode.validator instanceof Validator)
+  t.assert.ok(debugMode.serializer instanceof Serializer)
+  t.assert.ok(typeof debugMode.code === 'string')
 })
 
 test('activate debug mode truthy', t => {
@@ -36,26 +36,26 @@ test('activate debug mode truthy', t => {
 
   const debugMode = build({ debugMode: 'yes' })
 
-  t.type(debugMode, 'object')
-  t.type(debugMode.code, 'string')
-  t.ok(debugMode.ajv instanceof Ajv)
-  t.ok(debugMode.validator instanceof Validator)
-  t.ok(debugMode.serializer instanceof Serializer)
+  t.assert.ok(typeof debugMode === 'object')
+  t.assert.ok(typeof debugMode.code === 'string')
+  t.assert.ok(debugMode.ajv instanceof Ajv)
+  t.assert.ok(debugMode.validator instanceof Validator)
+  t.assert.ok(debugMode.serializer instanceof Serializer)
 })
 
 test('to string auto-consistent', t => {
   t.plan(6)
   const debugMode = build({ debugMode: 1 })
 
-  t.type(debugMode, 'object')
-  t.type(debugMode.code, 'string')
-  t.ok(debugMode.ajv instanceof Ajv)
-  t.ok(debugMode.serializer instanceof Serializer)
-  t.ok(debugMode.validator instanceof Validator)
+  t.assert.ok(typeof debugMode === 'object')
+  t.assert.ok(typeof debugMode.code === 'string')
+  t.assert.ok(debugMode.ajv instanceof Ajv)
+  t.assert.ok(debugMode.serializer instanceof Serializer)
+  t.assert.ok(debugMode.validator instanceof Validator)
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ firstName: 'Foo' })
-  t.same(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted')
+  t.assert.equal(compiled({ firstName: 'Foo', surname: 'bar' }), tobe, 'surname evicted')
 })
 
 test('to string auto-consistent with ajv', t => {
@@ -75,15 +75,15 @@ test('to string auto-consistent with ajv', t => {
     }
   }, { debugMode: 1 })
 
-  t.type(debugMode, 'object')
-  t.type(debugMode.code, 'string')
-  t.ok(debugMode.ajv instanceof Ajv)
-  t.ok(debugMode.validator instanceof Validator)
-  t.ok(debugMode.serializer instanceof Serializer)
+  t.assert.ok(typeof debugMode === 'object')
+  t.assert.ok(typeof debugMode.code === 'string')
+  t.assert.ok(debugMode.ajv instanceof Ajv)
+  t.assert.ok(debugMode.validator instanceof Validator)
+  t.assert.ok(debugMode.serializer instanceof Serializer)
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'Foo' })
-  t.same(compiled({ str: 'Foo', void: 'me' }), tobe)
+  t.assert.equal(compiled({ str: 'Foo', void: 'me' }), tobe)
 })
 
 test('to string auto-consistent with ajv-formats', t => {
@@ -104,12 +104,12 @@ test('to string auto-consistent with ajv-formats', t => {
     }
   }, { debugMode: 1 })
 
-  t.type(debugMode, 'object')
+  t.assert.ok(typeof debugMode === 'object')
 
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'foo@bar.com' })
-  t.same(compiled({ str: 'foo@bar.com' }), tobe)
-  t.throws(() => compiled({ str: 'foo' }))
+  t.assert.equal(compiled({ str: 'foo@bar.com' }), tobe)
+  t.assert.throws(() => compiled({ str: 'foo' }))
 })
 
 test('debug should restore the same serializer instance', t => {
@@ -117,5 +117,5 @@ test('debug should restore the same serializer instance', t => {
 
   const debugMode = fjs({ type: 'integer' }, { debugMode: 1, rounding: 'ceil' })
   const compiled = fjs.restore(debugMode)
-  t.same(compiled(3.95), 4)
+  t.assert.equal(compiled(3.95), 4)
 })

package/test/defaults.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 function buildTest (schema, toStringify, expected) {
@@ -11,7 +11,7 @@ function buildTest (schema, toStringify, expected) {
 
     const output = stringify(toStringify)
 
-    t.equal(output, JSON.stringify(expected))
+    t.assert.equal(output, JSON.stringify(expected))
   })
 }
 

package/test/enum.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('use enum without type', (t) => {
@@ -17,7 +17,7 @@ test('use enum without type', (t) => {
   })
 
   const obj = { order: 'asc' }
-  t.equal('{"order":"asc"}', stringify(obj))
+  t.assert.equal('{"order":"asc"}', stringify(obj))
 })
 
 test('use enum without type', (t) => {
@@ -33,5 +33,5 @@ test('use enum without type', (t) => {
   })
 
   const obj = { order: 'asc' }
-  t.equal('{"order":"asc"}', stringify(obj))
+  t.assert.equal('{"order":"asc"}', stringify(obj))
 })

package/test/fix-604.test.js

@@ -1,24 +1,25 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const fjs = require('..')
-const schema = {
-  type: 'object',
-  properties: {
-    fullName: { type: 'string' },
-    phone: { type: 'number' }
+
+test('fix-604', t => {
+  const schema = {
+    type: 'object',
+    properties: {
+      fullName: { type: 'string' },
+      phone: { type: 'number' }
+    }
   }
-}
 
-const input = {
-  fullName: 'Jone',
-  phone: 'phone'
-}
+  const input = {
+    fullName: 'Jone',
+    phone: 'phone'
+  }
 
-const render = fjs(schema)
+  const render = fjs(schema)
 
-try {
-  render(input)
-} catch (err) {
-  t.equal(err.message, 'The value "phone" cannot be converted to a number.')
-}
+  t.assert.throws(() => {
+    render(input)
+  }, { message: 'The value "phone" cannot be converted to a number.' })
+})

package/test/if-then-else.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
 process.env.TZ = 'UTC'
@@ -251,7 +251,7 @@ const deepFoobarOutput = JSON.stringify({
 })
 const noElseGreetingOutput = JSON.stringify({})
 
-t.test('if-then-else', t => {
+test('if-then-else', async t => {
   const tests = [
     {
       name: 'foobar',
@@ -315,20 +315,18 @@ t.test('if-then-else', t => {
     }
   ]
 
-  tests.forEach(test => {
-    t.test(test.name + ' - normal', t => {
+  for (const { name, schema, input, expected } of tests) {
+    await t.test(name + ' - normal', async t => {
       t.plan(1)
 
-      const stringify = build(JSON.parse(JSON.stringify(test.schema)), { ajv: { strictTypes: false } })
-      const serialized = stringify(test.input)
-      t.equal(serialized, test.expected)
+      const stringify = build(JSON.parse(JSON.stringify(schema)), { ajv: { strictTypes: false } })
+      const serialized = stringify(input)
+      t.assert.equal(serialized, expected)
     })
-  })
-
-  t.end()
+  }
 })
 
-t.test('nested if/then', t => {
+test('nested if/then', t => {
   t.plan(2)
 
   const schema = {
@@ -352,18 +350,18 @@ t.test('nested if/then', t => {
 
   const stringify = build(schema)
 
-  t.equal(
+  t.assert.equal(
     stringify({ a: 'A', foo: 'foo', bar: 'bar' }),
     JSON.stringify({ a: 'A', bar: 'bar' })
   )
 
-  t.equal(
+  t.assert.equal(
     stringify({ a: 'A', foo: 'foo', bar: 'bar', foo1: 'foo1', bar1: 'bar1' }),
     JSON.stringify({ a: 'A', bar: 'bar', bar1: 'bar1' })
   )
 })
 
-t.test('if/else with string format', (t) => {
+test('if/else with string format', (t) => {
   t.plan(2)
 
   const schema = {
@@ -376,11 +374,11 @@ t.test('if/else with string format', (t) => {
 
   const date = new Date(1674263005800)
 
-  t.equal(stringify(date), '"2023-01-21"')
-  t.equal(stringify('Invalid'), '"Invalid"')
+  t.assert.equal(stringify(date), '"2023-01-21"')
+  t.assert.equal(stringify('Invalid'), '"Invalid"')
 })
 
-t.test('if/else with const integers', (t) => {
+test('if/else with const integers', (t) => {
   t.plan(2)
 
   const schema = {
@@ -392,11 +390,11 @@ t.test('if/else with const integers', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify(100.32), '66')
-  t.equal(stringify(10.12), '33')
+  t.assert.equal(stringify(100.32), '66')
+  t.assert.equal(stringify(10.12), '33')
 })
 
-t.test('if/else with array', (t) => {
+test('if/else with array', (t) => {
   t.plan(2)
 
   const schema = {
@@ -408,11 +406,11 @@ t.test('if/else with array', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(stringify(['1']), JSON.stringify(['1']))
-  t.equal(stringify(['1', '2']), JSON.stringify([1, 2]))
+  t.assert.equal(stringify(['1']), JSON.stringify(['1']))
+  t.assert.equal(stringify(['1', '2']), JSON.stringify([1, 2]))
 })
 
-t.test('external recursive if/then/else', (t) => {
+test('external recursive if/then/else', (t) => {
   t.plan(1)
 
   const externalSchema = {
@@ -466,5 +464,5 @@ t.test('external recursive if/then/else', (t) => {
     }
   }
   const stringify = build(schema, { schema: { externalSchema } })
-  t.equal(stringify(data), '{"a":{"base":"a","bar":"42"},"b":{"base":"b","baz":"43"}}')
+  t.assert.equal(stringify(data), '{"a":{"base":"a","bar":"42"},"b":{"base":"b","baz":"43"}}')
 })

package/test/inferType.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')
   })
 }
 

package/test/infinity.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('Finite numbers', t => {
@@ -17,7 +17,7 @@ test('Finite numbers', t => {
 
   const stringify = build(schema)
 
-  values.forEach(v => t.equal(stringify(v), JSON.stringify(v)))
+  values.forEach(v => t.assert.equal(stringify(v), JSON.stringify(v)))
 })
 
 test('Infinite integers', t => {
@@ -35,7 +35,7 @@ test('Infinite integers', t => {
     try {
       stringify(v)
     } catch (err) {
-      t.equal(err.message, `The value "${v}" cannot be converted to an integer.`)
+      t.assert.equal(err.message, `The value "${v}" cannot be converted to an integer.`)
     }
   })
 })
@@ -51,5 +51,5 @@ test('Infinite numbers', t => {
 
   const stringify = build(schema)
 
-  values.forEach(v => t.equal(stringify(v), JSON.stringify(v)))
+  values.forEach(v => t.assert.equal(stringify(v), JSON.stringify(v)))
 })

package/test/integer.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
+
 const validator = require('is-my-json-valid')
 const build = require('..')
 const ROUNDING_TYPES = ['ceil', 'floor', 'round']
@@ -18,8 +18,8 @@ test('render an integer as JSON', (t) => {
   const stringify = build(schema)
   const output = stringify(1615)
 
-  t.equal(output, '1615')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '1615')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render a float as an integer', (t) => {
@@ -30,8 +30,8 @@ test('render a float as an integer', (t) => {
       type: 'integer'
     }, { rounding: 'foobar' })
   } catch (error) {
-    t.ok(error)
-    t.equal(error.message, 'Unsupported integer rounding method foobar')
+    t.assert.ok(error)
+    t.assert.equal(error.message, 'Unsupported integer rounding method foobar')
   }
 })
 
@@ -44,7 +44,7 @@ test('throws on NaN', (t) => {
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify(NaN), new Error('The value "NaN" cannot be converted to an integer.'))
+  t.assert.throws(() => stringify(NaN), new Error('The value "NaN" cannot be converted to an integer.'))
 })
 
 test('render a float as an integer', (t) => {
@@ -87,8 +87,8 @@ test('render a float as an integer', (t) => {
     const stringify = build(schema, { rounding })
     const str = stringify(input)
 
-    t.equal(str, output)
-    t.ok(validate(JSON.parse(str)), 'valid schema')
+    t.assert.equal(str, output)
+    t.assert.ok(validate(JSON.parse(str)), 'valid schema')
   }
 })
 
@@ -111,8 +111,8 @@ test('render an object with an integer as JSON', (t) => {
     id: 1615
   })
 
-  t.equal(output, '{"id":1615}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"id":1615}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render an array with an integer as JSON', (t) => {
@@ -130,8 +130,8 @@ test('render an array with an integer as JSON', (t) => {
   const stringify = build(schema)
   const output = stringify([1615])
 
-  t.equal(output, '[1615]')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '[1615]')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('render an object with an additionalProperty of type integer as JSON', (t) => {
@@ -151,8 +151,8 @@ test('render an object with an additionalProperty of type integer as JSON', (t)
     num: 1615
   })
 
-  t.equal(output, '{"num":1615}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"num":1615}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('should round integer object parameter', t => {
@@ -163,8 +163,8 @@ test('should round integer object parameter', t => {
   const stringify = build(schema, { rounding: 'ceil' })
   const output = stringify({ magic: 4.2 })
 
-  t.equal(output, '{"magic":5}')
-  t.ok(validate(JSON.parse(output)), 'valid schema')
+  t.assert.equal(output, '{"magic":5}')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
 test('should not stringify a property if it does not exist', t => {
@@ -175,8 +175,8 @@ test('should not stringify a property if it does not exist', 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')
 })
 
 ROUNDING_TYPES.forEach((rounding) => {
@@ -188,7 +188,7 @@ ROUNDING_TYPES.forEach((rounding) => {
     const stringify = build(schema, { rounding })
     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')
   })
 })

package/test/invalidSchema.test.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 // Covers issue #139
 test('Should throw on invalid schema', t => {
-  t.plan(2)
-  try {
+  t.plan(1)
+  t.assert.throws(() => {
     build({}, {
       schema: {
         invalid: {
@@ -14,9 +14,5 @@ test('Should throw on invalid schema', t => {
         }
       }
     })
-    t.fail('should be an invalid schema')
-  } catch (err) {
-    t.match(err.message, /^"invalid" schema is invalid:.*/, 'Schema contains invalid key')
-    t.ok(err)
-  }
+  }, { message: /^"invalid" schema is invalid:.*/ })
 })

package/test/issue-479.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
 test('should validate anyOf after allOf merge', (t) => {
@@ -51,7 +51,7 @@ test('should validate anyOf after allOf merge', (t) => {
 
   const stringify = build(schema)
 
-  t.equal(
+  t.assert.equal(
     stringify({ name: 'foo', union: 'a8f1cc50-5530-5c62-9109-5ba9589a6ae1' }),
     '{"name":"foo","union":"a8f1cc50-5530-5c62-9109-5ba9589a6ae1"}')
 })

package/test/json-schema-test-suite/README.md

@@ -5,6 +5,6 @@ It contains a set of JSON objects that implementors of JSON Schema validation li
 
 # How to add another test case?
 
-1. Navigate to [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/master/tests)
+1. Navigate to [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests)
 2. Choose a draft `draft4`, `draft6` or `draft7`
 3. Copy & paste the `test-case.json` to the project and add a test like in the `draft4.test.js`

package/test/json-schema-test-suite/draft4.test.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const { counTests, runTests } = require('./util')
 
 const requiredTestSuite = require('./draft4/required.json')
 
-test('required', (t) => {
+test('required', async (t) => {
   const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
   t.plan(counTests(requiredTestSuite, skippedTests))
-  runTests(t, requiredTestSuite, skippedTests)
+  await runTests(t, requiredTestSuite, skippedTests)
 })

package/test/json-schema-test-suite/draft6.test.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const { counTests, runTests } = require('./util')
 
 const requiredTestSuite = require('./draft6/required.json')
 
-test('required', (t) => {
+test('required', async (t) => {
   const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
   t.plan(counTests(requiredTestSuite, skippedTests))
-  runTests(t, requiredTestSuite, skippedTests)
+  await runTests(t, requiredTestSuite, skippedTests)
 })

package/test/json-schema-test-suite/draft7.test.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const { counTests, runTests } = require('./util')
 
 const requiredTestSuite = require('./draft7/required.json')
 
-test('required', (t) => {
+test('required', async (t) => {
   const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
   t.plan(counTests(requiredTestSuite, skippedTests))
-  runTests(t, requiredTestSuite, skippedTests)
+  await runTests(t, requiredTestSuite, skippedTests)
 })

package/test/json-schema-test-suite/util.js

@@ -2,25 +2,22 @@
 
 const build = require('../..')
 
-function runTests (t, testsuite, skippedTests) {
+async function runTests (t, testsuite, skippedTests) {
   for (const scenario of testsuite) {
     const stringify = build(scenario.schema)
     for (const test of scenario.tests) {
       if (skippedTests.indexOf(test.description) !== -1) {
-        t.comment('skip %s', test.description)
+        console.log(`skip ${test.description}`)
         continue
       }
-      t.test(test.description, (t) => {
+
+      await t.test(test.description, (t) => {
         t.plan(1)
         try {
           const output = stringify(test.data)
-          t.equal(output, JSON.stringify(test.data), 'compare payloads')
+          t.assert.equal(output, JSON.stringify(test.data), 'compare payloads')
         } catch (err) {
-          if (test.valid === false) {
-            t.pass('payload is invalid')
-          } else {
-            t.fail('payload should be valid: ' + err.message)
-          }
+          t.assert.ok(test.valid === false, 'payload should be valid: ' + err.message)
         }
       })
     }

package/test/missing-values.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('missing values', (t) => {
@@ -22,9 +22,9 @@ test('missing values', (t) => {
     }
   })
 
-  t.equal('{"val":"value"}', stringify({ val: 'value' }))
-  t.equal('{"str":"string","val":"value"}', stringify({ str: 'string', val: 'value' }))
-  t.equal('{"str":"string","num":42,"val":"value"}', stringify({ str: 'string', num: 42, val: 'value' }))
+  t.assert.equal('{"val":"value"}', stringify({ val: 'value' }))
+  t.assert.equal('{"str":"string","val":"value"}', stringify({ str: 'string', val: 'value' }))
+  t.assert.equal('{"str":"string","num":42,"val":"value"}', stringify({ str: 'string', num: 42, val: 'value' }))
 })
 
 test('handle null when value should be string', (t) => {
@@ -39,7 +39,7 @@ test('handle null when value should be string', (t) => {
     }
   })
 
-  t.equal('{"str":""}', stringify({ str: null }))
+  t.assert.equal('{"str":""}', stringify({ str: null }))
 })
 
 test('handle null when value should be integer', (t) => {
@@ -54,7 +54,7 @@ test('handle null when value should be integer', (t) => {
     }
   })
 
-  t.equal('{"int":0}', stringify({ int: null }))
+  t.assert.equal('{"int":0}', stringify({ int: null }))
 })
 
 test('handle null when value should be number', (t) => {
@@ -69,7 +69,7 @@ test('handle null when value should be number', (t) => {
     }
   })
 
-  t.equal('{"num":0}', stringify({ num: null }))
+  t.assert.equal('{"num":0}', stringify({ num: null }))
 })
 
 test('handle null when value should be boolean', (t) => {
@@ -84,5 +84,5 @@ test('handle null when value should be boolean', (t) => {
     }
   })
 
-  t.equal('{"bool":false}', stringify({ bool: null }))
+  t.assert.equal('{"bool":false}', stringify({ bool: null }))
 })