fast-json-stringify 6.0.0 → 6.0.1

package/test/required.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('object with required field', (t) => {
-  t.plan(3)
+  t.plan(2)
 
   const schema = {
     title: 'object with required field',
@@ -21,24 +21,21 @@ test('object with required field', (t) => {
   }
   const stringify = build(schema)
 
-  stringify({
-    str: 'string'
+  t.assert.doesNotThrow(() => {
+    stringify({
+      str: 'string'
+    })
   })
-  t.pass()
 
-  try {
+  t.assert.throws(() => {
     stringify({
       num: 42
     })
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"str" is required!')
-    t.pass()
-  }
+  }, { message: '"str" is required!' })
 })
 
 test('object with required field not in properties schema', (t) => {
-  t.plan(4)
+  t.plan(2)
 
   const schema = {
     title: 'object with required field',
@@ -52,27 +49,19 @@ test('object with required field not in properties schema', (t) => {
   }
   const stringify = build(schema)
 
-  try {
+  t.assert.throws(() => {
     stringify({})
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"str" is required!')
-    t.pass()
-  }
+  }, { message: '"str" is required!' })
 
-  try {
+  t.assert.throws(() => {
     stringify({
       num: 42
     })
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"str" is required!')
-    t.pass()
-  }
+  }, { message: '"str" is required!' })
 })
 
 test('object with required field not in properties schema with additional properties true', (t) => {
-  t.plan(4)
+  t.plan(2)
 
   const schema = {
     title: 'object with required field',
@@ -87,27 +76,19 @@ test('object with required field not in properties schema with additional proper
   }
   const stringify = build(schema)
 
-  try {
+  t.assert.throws(() => {
     stringify({})
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"str" is required!')
-    t.pass()
-  }
+  }, { message: '"str" is required!' })
 
-  try {
+  t.assert.throws(() => {
     stringify({
       num: 42
     })
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"str" is required!')
-    t.pass()
-  }
+  }, { message: '"str" is required!' })
 })
 
 test('object with multiple required field not in properties schema', (t) => {
-  t.plan(6)
+  t.plan(3)
 
   const schema = {
     title: 'object with required field',
@@ -122,35 +103,23 @@ test('object with multiple required field not in properties schema', (t) => {
   }
   const stringify = build(schema)
 
-  try {
+  t.assert.throws(() => {
     stringify({})
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"key1" is required!')
-    t.pass()
-  }
+  }, { message: '"key1" is required!' })
 
-  try {
+  t.assert.throws(() => {
     stringify({
       key1: 42,
       key2: 42
     })
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"num" is required!')
-    t.pass()
-  }
+  }, { message: '"num" is required!' })
 
-  try {
+  t.assert.throws(() => {
     stringify({
       num: 42,
       key1: 'some'
     })
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"key2" is required!')
-    t.pass()
-  }
+  }, { message: '"key2" is required!' })
 })
 
 test('object with required bool', (t) => {
@@ -169,16 +138,14 @@ test('object with required bool', (t) => {
   }
   const stringify = build(schema)
 
-  try {
+  t.assert.throws(() => {
     stringify({})
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, '"bool" is required!')
-    t.pass()
-  }
+  }, { message: '"bool" is required!' })
 
-  stringify({
-    bool: false
+  t.assert.doesNotThrow(() => {
+    stringify({
+      bool: false
+    })
   })
 })
 
@@ -198,14 +165,15 @@ test('required nullable', (t) => {
   }
   const stringify = build(schema)
 
-  stringify({
-    null: null
+  t.assert.doesNotThrow(() => {
+    stringify({
+      null: null
+    })
   })
-  t.pass()
 })
 
 test('required numbers', (t) => {
-  t.plan(3)
+  t.plan(2)
 
   const schema = {
     title: 'object with required field',
@@ -222,18 +190,15 @@ test('required numbers', (t) => {
   }
   const stringify = build(schema)
 
-  stringify({
-    num: 42
+  t.assert.doesNotThrow(() => {
+    stringify({
+      num: 42
+    })
   })
-  t.pass()
 
-  try {
+  t.assert.throws(() => {
     stringify({
       num: 'aaa'
     })
-    t.fail()
-  } catch (e) {
-    t.equal(e.message, 'The value "aaa" cannot be converted to an integer.')
-    t.pass()
-  }
+  }, { message: 'The value "aaa" cannot be converted to an integer.' })
 })

package/test/requiresAjv.test.js

@@ -1,48 +1,50 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
-t.test('nested ref requires ajv', async t => {
-  const schemaA = {
-    $id: 'urn:schema:a',
-    definitions: {
-      foo: { anyOf: [{ type: 'string' }, { type: 'null' }] }
+test('nested ref requires ajv', async t => {
+  t.test('nested ref requires ajv', async t => {
+    const schemaA = {
+      $id: 'urn:schema:a',
+      definitions: {
+        foo: { anyOf: [{ type: 'string' }, { type: 'null' }] }
+      }
     }
-  }
 
-  const schemaB = {
-    $id: 'urn:schema:b',
-    type: 'object',
-    properties: {
-      results: {
-        type: 'object',
-        properties: {
-          items: {
-            type: 'object',
-            properties: {
-              bar: {
-                type: 'array',
-                items: { $ref: 'urn:schema:a#/definitions/foo' }
+    const schemaB = {
+      $id: 'urn:schema:b',
+      type: 'object',
+      properties: {
+        results: {
+          type: 'object',
+          properties: {
+            items: {
+              type: 'object',
+              properties: {
+                bar: {
+                  type: 'array',
+                  items: { $ref: 'urn:schema:a#/definitions/foo' }
+                }
               }
             }
           }
         }
       }
     }
-  }
 
-  const stringify = build(schemaB, {
-    schema: {
-      [schemaA.$id]: schemaA
-    }
-  })
-  const result = stringify({
-    results: {
-      items: {
-        bar: ['baz']
+    const stringify = build(schemaB, {
+      schema: {
+        [schemaA.$id]: schemaA
       }
-    }
+    })
+    const result = stringify({
+      results: {
+        items: {
+          bar: ['baz']
+        }
+      }
+    })
+    t.assert.equal(result, '{"results":{"items":{"bar":["baz"]}}}')
   })
-  t.same(result, '{"results":{"items":{"bar":["baz"]}}}')
 })

package/test/sanitize.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
 const stringify = build({
@@ -91,52 +91,51 @@ const obj = {
   notmatchnum: 42
 }
 
-// pass if it does not crash
-const json = stringify(obj)
-JSON.parse(json)
+test('sanitize', t => {
+  const json = stringify(obj)
+  t.assert.doesNotThrow(() => JSON.parse(json))
 
-const stringify2 = build({
-  title: 'Example Schema',
-  type: 'object',
-  patternProperties: {
-    '"\'w00t.*////': {
-      type: 'number'
+  const stringify2 = build({
+    title: 'Example Schema',
+    type: 'object',
+    patternProperties: {
+      '"\'w00t.*////': {
+        type: 'number'
+      }
     }
-  }
-})
+  })
 
-t.same(JSON.parse(stringify2({
-  '"\'phra////': 42,
-  asd: 42
-})), {
-})
+  t.assert.deepStrictEqual(JSON.parse(stringify2({
+    '"\'phra////': 42,
+    asd: 42
+  })), {
+  })
 
-const stringify3 = build({
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    "\"phra\\'&&(console.log(42))//||'phra": {}
-  }
-})
+  const stringify3 = build({
+    title: 'Example Schema',
+    type: 'object',
+    properties: {
+      "\"phra\\'&&(console.log(42))//||'phra": {}
+    }
+  })
 
-// this verifies the escaping
-JSON.parse(stringify3({
-  '"phra\'&&(console.log(42))//||\'phra': 42
-}))
+  // this verifies the escaping
+  JSON.parse(stringify3({
+    '"phra\'&&(console.log(42))//||\'phra': 42
+  }))
 
-const stringify4 = build({
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    '"\\\\\\\\\'w00t': {
-      type: 'string',
-      default: '"\'w00t'
+  const stringify4 = build({
+    title: 'Example Schema',
+    type: 'object',
+    properties: {
+      '"\\\\\\\\\'w00t': {
+        type: 'string',
+        default: '"\'w00t'
+      }
     }
-  }
-})
+  })
 
-t.same(JSON.parse(stringify4({})), {
-  '"\\\\\\\\\'w00t': '"\'w00t'
+  t.assert.deepStrictEqual(JSON.parse(stringify4({})), {
+    '"\\\\\\\\\'w00t': '"\'w00t'
+  })
 })
-
-t.pass('no crashes')

package/test/sanitize2.test.js

@@ -1,18 +1,18 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
-const payload = '(throw "pwoned")'
+test('sanitize 2', t => {
+  const payload = '(throw "pwoned")'
 
-const stringify = build({
-  properties: {
-    [`*///\\\\\\']);${payload};{/*`]: {
-      type: 'number'
+  const stringify = build({
+    properties: {
+      [`*///\\\\\\']);${payload};{/*`]: {
+        type: 'number'
+      }
     }
-  }
-})
-
-stringify({})
+  })
 
-t.pass('no crashes')
+  t.assert.doesNotThrow(() => stringify({}))
+})

package/test/sanitize3.test.js

@@ -1,15 +1,17 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
-t.throws(() => {
-  build({
-    $defs: {
-      type: 'foooo"bar'
-    },
-    patternProperties: {
-      x: { $ref: '#/$defs' }
-    }
-  })
-}, 'foooo"bar unsupported')
+test('sanitize 3', t => {
+  t.assert.throws(() => {
+    build({
+      $defs: {
+        type: 'foooo"bar'
+      },
+      patternProperties: {
+        x: { $ref: '#/$defs' }
+      }
+    })
+  }, { message: 'foooo"bar unsupported' })
+})

package/test/sanitize4.test.js

@@ -1,14 +1,16 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
-const payload = '(throw "pwoned")'
+test('sanitize 4', t => {
+  const payload = '(throw "pwoned")'
 
-const stringify = build({
-  required: [`"];${payload}//`]
-})
+  const stringify = build({
+    required: [`"];${payload}//`]
+  })
 
-t.throws(() => {
-  stringify({})
-}, 'Error: ""];(throw "pwoned")//" is required!')
+  t.assert.throws(() => {
+    stringify({})
+  }, { message: '""];(throw "pwoned")//" is required!' })
+})

package/test/sanitize5.test.js

@@ -1,16 +1,16 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
-const payload = '(throw "pwoned")'
+test('sanitize 5', t => {
+  const payload = '(throw "pwoned")'
 
-const expected = 'Error: Invalid regular expression: /*/: Nothing to repeat. Found at * matching {"type":"*/(throw \\"pwoned\\")){//"}'
-
-t.throws(() => {
-  build({
-    patternProperties: {
-      '*': { type: `*/${payload}){//` }
-    }
-  })
-}, expected)
+  t.assert.throws(() => {
+    build({
+      patternProperties: {
+        '*': { type: `*/${payload}){//` }
+      }
+    })
+  }, { message: 'schema is invalid: data/patternProperties must match format "regex"' })
+})

package/test/sanitize6.test.js

@@ -1,22 +1,22 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const build = require('..')
 
-const payload = '(throw "pwoned")'
+test('sanitize 6', t => {
+  const payload = '(throw "pwoned")'
 
-const stringify = build({
-  type: 'object',
-  properties: {
-    '/*': { type: 'object' },
-    x: {
-      type: 'object',
-      properties: {
-        a: { type: 'string', default: `*/}${payload};{//` }
+  const stringify = build({
+    type: 'object',
+    properties: {
+      '/*': { type: 'object' },
+      x: {
+        type: 'object',
+        properties: {
+          a: { type: 'string', default: `*/}${payload};{//` }
+        }
       }
     }
-  }
+  })
+  t.assert.doesNotThrow(() => { stringify({}) })
 })
-stringify({})
-
-t.pass('no crashes')

package/test/sanitize7.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const build = require('..')
 
 test('required property containing single quote, contains property', (t) => {
@@ -16,7 +16,7 @@ test('required property containing single quote, contains property', (t) => {
     ]
   })
 
-  t.throws(() => stringify({}), new Error('"\'" is required!'))
+  t.assert.throws(() => stringify({}), new Error('"\'" is required!'))
 })
 
 test('required property containing double quote, contains property', (t) => {
@@ -32,7 +32,7 @@ test('required property containing double quote, contains property', (t) => {
     ]
   })
 
-  t.throws(() => stringify({}), new Error('""" is required!'))
+  t.assert.throws(() => stringify({}), new Error('""" is required!'))
 })
 
 test('required property containing single quote, does not contain property', (t) => {
@@ -48,7 +48,7 @@ test('required property containing single quote, does not contain property', (t)
     ]
   })
 
-  t.throws(() => stringify({}), new Error('"\'" is required!'))
+  t.assert.throws(() => stringify({}), new Error('"\'" is required!'))
 })
 
 test('required property containing double quote, does not contain property', (t) => {
@@ -64,5 +64,5 @@ test('required property containing double quote, does not contain property', (t)
     ]
   })
 
-  t.throws(() => stringify({}), new Error('""" is required!'))
+  t.assert.throws(() => stringify({}), new Error('""" is required!'))
 })

package/test/side-effect.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const clone = require('rfdc/default')
 const build = require('..')
 
@@ -32,8 +32,8 @@ test('oneOf with $ref should not change the input schema', t => {
   })
 
   const value = stringify({ people: { name: 'hello', foo: 'bar' } })
-  t.equal(value, '{"people":{"name":"hello"}}')
-  t.same(schema, clonedSchema)
+  t.assert.equal(value, '{"people":{"name":"hello"}}')
+  t.assert.deepStrictEqual(schema, clonedSchema)
 })
 
 test('oneOf and anyOf with $ref should not change the input schema', t => {
@@ -75,9 +75,9 @@ test('oneOf and anyOf with $ref should not change the input schema', t => {
   const valueAny1 = stringify({ people: { name: 'hello', foo: 'bar' }, love: 'music' })
   const valueAny2 = stringify({ people: { name: 'hello', foo: 'bar' }, love: true })
 
-  t.equal(valueAny1, '{"people":{"name":"hello"},"love":"music"}')
-  t.equal(valueAny2, '{"people":{"name":"hello"},"love":true}')
-  t.same(schema, clonedSchema)
+  t.assert.equal(valueAny1, '{"people":{"name":"hello"},"love":"music"}')
+  t.assert.equal(valueAny2, '{"people":{"name":"hello"},"love":true}')
+  t.assert.deepStrictEqual(schema, clonedSchema)
 })
 
 test('multiple $ref tree', t => {
@@ -118,8 +118,8 @@ test('multiple $ref tree', t => {
   })
 
   const value = stringify({ people: { name: 'hello', foo: 'bar', age: 42 } })
-  t.equal(value, '{"people":{"name":"hello","age":42}}')
-  t.same(schema, clonedSchema)
+  t.assert.equal(value, '{"people":{"name":"hello","age":42}}')
+  t.assert.deepStrictEqual(schema, clonedSchema)
 })
 
 test('must not mutate items $ref', t => {
@@ -152,8 +152,8 @@ test('must not mutate items $ref', t => {
   })
 
   const value = stringify([{ name: 'foo' }])
-  t.equal(value, '[{"name":"foo"}]')
-  t.same(schema, clonedSchema)
+  t.assert.equal(value, '[{"name":"foo"}]')
+  t.assert.deepStrictEqual(schema, clonedSchema)
 })
 
 test('must not mutate items referred by $ref', t => {
@@ -191,6 +191,6 @@ test('must not mutate items referred by $ref', t => {
   })
 
   const value = stringify({ name: { name: 'foo' } })
-  t.equal(value, '{"name":{"name":"foo"}}')
-  t.same(firstSchema, clonedSchema)
+  t.assert.equal(value, '{"name":{"name":"foo"}}')
+  t.assert.deepStrictEqual(firstSchema, clonedSchema)
 })