fast-json-stringify 6.0.0 → 6.0.1

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/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 }))
 })

package/test/multi-type-serializer.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('should throw a TypeError with the path to the key of the invalid value', (t) => {
@@ -15,5 +15,5 @@ test('should throw a TypeError with the path to the key of the invalid value', (
   }
 
   const stringify = build(schema)
-  t.throws(() => stringify({ num: { bla: 123 } }), new TypeError('The value of \'#/properties/num\' does not match schema definition.'))
+  t.assert.throws(() => stringify({ num: { bla: 123 } }), new TypeError('The value of \'#/properties/num\' does not match schema definition.'))
 })

package/test/nestedObjects.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('nested objects with same properties', (t) => {
@@ -28,7 +28,7 @@ test('nested objects with same properties', (t) => {
       numberProperty: 42
     }
   })
-  t.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
+  t.assert.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
 })
 
 test('names collision', (t) => {
@@ -59,5 +59,5 @@ test('names collision', (t) => {
     tes: { b: 'b', t: {} }
   }
 
-  t.equal(stringify(data), JSON.stringify(data))
+  t.assert.equal(stringify(data), JSON.stringify(data))
 })