fast-json-stringify 3.2.0 → 4.0.0

package/test/date.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const test = require('tap').test
-const moment = require('moment')
+const { DateTime } = require('luxon')
 const validator = require('is-my-json-valid')
 const build = require('..')
 
@@ -40,13 +40,14 @@ test('render a date in a string when format is date-format as ISOString', (t) =>
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
+test('render a nullable date in a string when format is date-format as ISOString', (t) => {
   t.plan(2)
 
   const schema = {
     title: 'a date in a string',
     type: 'string',
-    format: 'date'
+    format: 'date-time',
+    nullable: true
   }
   const toStringify = new Date()
 
@@ -54,11 +55,11 @@ test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${moment(toStringify).format('YYYY-MM-DD')}"`)
+  t.equal(output, JSON.stringify(toStringify))
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('verify padding for rendered date in a string when format is date', (t) => {
+test('render a date in a string when format is date as YYYY-MM-DD', (t) => {
   t.plan(2)
 
   const schema = {
@@ -66,23 +67,24 @@ test('verify padding for rendered date in a string when format is date', (t) =>
     type: 'string',
     format: 'date'
   }
-  const toStringify = new Date(2020, 0, 1, 0, 0, 0, 0)
+  const toStringify = new Date()
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${moment(toStringify).format('YYYY-MM-DD')}"`)
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a date in a string when format is time as kk:mm:ss', (t) => {
-  t.plan(3)
+test('render a nullable date in a string when format is date as YYYY-MM-DD', (t) => {
+  t.plan(2)
 
   const schema = {
     title: 'a date in a string',
     type: 'string',
-    format: 'time'
+    format: 'date',
+    nullable: true
   }
   const toStringify = new Date()
 
@@ -90,14 +92,29 @@ test('render a date in a string when format is time as kk:mm:ss', (t) => {
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  validate(JSON.parse(output))
-  t.equal(validate.errors, null)
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
 
-  t.equal(output, `"${moment(toStringify).format('HH:mm:ss')}"`)
+test('verify padding for rendered date in a string when format is date', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'a date in a string',
+    type: 'string',
+    format: 'date'
+  }
+  const toStringify = new Date(2020, 0, 1, 0, 0, 0, 0)
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toISODate()}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('verify padding for rendered date in a string when format is time', (t) => {
+test('render a date in a string when format is time as kk:mm:ss', (t) => {
   t.plan(3)
 
   const schema = {
@@ -105,7 +122,7 @@ test('verify padding for rendered date in a string when format is time', (t) =>
     type: 'string',
     format: 'time'
   }
-  const toStringify = new Date(2020, 0, 1, 1, 1, 1, 1)
+  const toStringify = new Date()
 
   const validate = validator(schema)
   const stringify = build(schema)
@@ -114,61 +131,71 @@ test('verify padding for rendered date in a string when format is time', (t) =>
   validate(JSON.parse(output))
   t.equal(validate.errors, null)
 
-  t.equal(output, `"${moment(toStringify).format('HH:mm:ss')}"`)
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a moment.js instance in a string when format is date-time as ISOString', (t) => {
-  t.plan(2)
+test('render a nullable date in a string when format is time as kk:mm:ss', (t) => {
+  t.plan(3)
 
   const schema = {
-    title: 'a moment.js object in a string',
+    title: 'a date in a string',
     type: 'string',
-    format: 'date-time'
+    format: 'time',
+    nullable: true
   }
-  const toStringify = moment()
+  const toStringify = new Date()
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, JSON.stringify(toStringify))
+  validate(JSON.parse(output))
+  t.equal(validate.errors, null)
+
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a moment.js instance in a string when format is date as YYYY-MM-DD', (t) => {
-  t.plan(2)
+test('render a midnight time', (t) => {
+  t.plan(3)
 
   const schema = {
-    title: 'a moment.js object in a string',
+    title: 'a date in a string',
     type: 'string',
-    format: 'date'
+    format: 'time'
   }
-  const toStringify = moment()
+  const midnight = new Date(new Date().setHours(24))
 
   const validate = validator(schema)
   const stringify = build(schema)
-  const output = stringify(toStringify)
+  const output = stringify(midnight)
 
-  t.equal(output, `"${toStringify.format('YYYY-MM-DD')}"`)
+  validate(JSON.parse(output))
+  t.equal(validate.errors, null)
+
+  t.equal(output, `"${DateTime.fromJSDate(midnight).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
-test('render a moment.js instance in a string when format is time as HH:mm:ss', (t) => {
-  t.plan(2)
+test('verify padding for rendered date in a string when format is time', (t) => {
+  t.plan(3)
 
   const schema = {
-    title: 'a moment.js object in a string',
+    title: 'a date in a string',
     type: 'string',
     format: 'time'
   }
-  const toStringify = moment()
+  const toStringify = new Date(2020, 0, 1, 1, 1, 1, 1)
 
   const validate = validator(schema)
   const stringify = build(schema)
   const output = stringify(toStringify)
 
-  t.equal(output, `"${toStringify.format('HH:mm:ss')}"`)
+  validate(JSON.parse(output))
+  t.equal(validate.errors, null)
+
+  t.equal(output, `"${DateTime.fromJSDate(toStringify).toFormat('HH:mm:ss')}"`)
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
@@ -185,7 +212,7 @@ test('render a nested object in a string when type is date-format as ISOString',
       }
     }
   }
-  const toStringify = { date: moment() }
+  const toStringify = { date: new Date() }
 
   const validate = validator(schema)
   const stringify = build(schema)

package/test/debug-mode.test.js

@@ -98,5 +98,5 @@ test('to string auto-consistent with ajv-formats', t => {
   const compiled = fjs.restore(debugMode)
   const tobe = JSON.stringify({ str: 'foo@bar.com' })
   t.same(compiled({ str: 'foo@bar.com' }), tobe)
-  t.same(compiled({ str: 'foo' }), JSON.stringify({ str: null }), 'invalid format is ignored')
+  t.throws(() => compiled({ str: 'foo' }))
 })

package/test/nestedObjects.test.js

@@ -30,3 +30,34 @@ test('nested objects with same properties', (t) => {
   })
   t.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
 })
+
+test('names collision', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'nested objects with same properties',
+    type: 'object',
+    properties: {
+      test: {
+        type: 'object',
+        properties: {
+          a: { type: 'string' }
+        }
+      },
+      tes: {
+        type: 'object',
+        properties: {
+          b: { type: 'string' },
+          t: { type: 'object' }
+        }
+      }
+    }
+  }
+  const stringify = build(schema)
+  const data = {
+    test: { a: 'a' },
+    tes: { b: 'b', t: {} }
+  }
+
+  t.equal(stringify(data), JSON.stringify(data))
+})

package/test/nullable.test.js

@@ -116,3 +116,331 @@ Object.keys(testSet).forEach(key => {
     t.same(JSON.parse(result), expected)
   })
 })
+
+test('handle nullable number correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'number',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable integer correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'integer',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable boolean correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'boolean',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable string correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable date-time correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'date-time',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable date correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'date',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('handle nullable time correctly', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'time',
+    nullable: true
+  }
+  const stringify = build(schema)
+
+  const data = null
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable date-time strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          format: 'date-time',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable date-time strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          format: 'date',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable date-time strings with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'string',
+          format: 'time',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable numbers with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'number',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable integers with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'integer',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})
+
+test('large array of nullable booleans with default mechanism', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      ids: {
+        type: 'array',
+        items: {
+          type: 'boolean',
+          nullable: true
+        }
+      }
+    }
+  }
+
+  const options = {
+    largeArraySize: 2e4,
+    largeArrayMechanism: 'default'
+  }
+
+  const stringify = build(schema, options)
+
+  const data = { ids: new Array(2e4).fill(null) }
+  const result = stringify(data)
+
+  t.same(result, JSON.stringify(data))
+  t.same(JSON.parse(result), data)
+})

package/test/oneof.test.js

@@ -104,11 +104,7 @@ test('object with field of type string and coercion disable ', (t) => {
     }
   }
   const stringify = build(schema)
-
-  const value = stringify({
-    str: 1
-  })
-  t.equal(value, '{"str":null}')
+  t.throws(() => stringify({ str: 1 }))
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -403,7 +399,7 @@ test('oneOf object with field of type string with format or null', (t) => {
 })
 
 test('one array item match oneOf types', (t) => {
-  t.plan(1)
+  t.plan(3)
 
   const schema = {
     type: 'object',
@@ -429,15 +425,13 @@ test('one array item match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  const responseWithMappedType = stringify({
-    data: [false, 'foo']
-  })
-
-  t.equal('{"data":["foo"]}', responseWithMappedType)
+  t.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}')
+  t.equal(stringify({ data: [1] }), '{"data":[1]}')
+  t.throws(() => stringify({ data: [false, 'foo'] }))
 })
 
 test('some array items match oneOf types', (t) => {
-  t.plan(1)
+  t.plan(2)
 
   const schema = {
     type: 'object',
@@ -463,11 +457,8 @@ test('some array items match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  const responseWithMappedTypes = stringify({
-    data: [false, 'foo', true, 5]
-  })
-
-  t.equal('{"data":["foo",5]}', responseWithMappedTypes)
+  t.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}')
+  t.throws(() => stringify({ data: [false, 'foo', true, 5] }))
 })
 
 test('all array items does not match oneOf types', (t) => {
@@ -497,9 +488,5 @@ test('all array items does not match oneOf types', (t) => {
 
   const stringify = build(schema)
 
-  const emptyResponse = stringify({
-    data: [null, false, true, undefined, [], {}]
-  })
-
-  t.equal('{"data":[]}', emptyResponse)
+  t.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
 })

package/test/patternProperties.test.js

@@ -63,7 +63,7 @@ test('patternProperties - string coerce', (t) => {
 })
 
 test('patternProperties - number coerce', (t) => {
-  t.plan(1)
+  t.plan(2)
   const stringify = build({
     title: 'check number coerce',
     type: 'object',
@@ -75,8 +75,16 @@ test('patternProperties - number coerce', (t) => {
     }
   })
 
-  const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
-  t.equal(stringify(obj), '{"foo":1,"ofoo":42,"xfoo":null,"arrfoo":null,"objfoo":null}')
+  const coercibleValues = { foo: true, ofoo: '42' }
+  t.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)
+  }
 })
 
 test('patternProperties - boolean coerce', (t) => {
@@ -119,7 +127,7 @@ test('patternProperties - object coerce', (t) => {
 })
 
 test('patternProperties - array coerce', (t) => {
-  t.plan(1)
+  t.plan(2)
   const stringify = build({
     title: 'check array coerce',
     type: 'object',
@@ -134,6 +142,9 @@ test('patternProperties - array coerce', (t) => {
     }
   })
 
-  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { tyrion: 'lannister' } }
-  t.equal(stringify(obj), '{"foo":["t","r","u","e"],"ofoo":[],"arrfoo":["1","2"],"objfoo":[]}')
+  const coercibleValues = { arrfoo: [1, 2] }
+  t.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}')
+
+  const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } }
+  t.throws(() => stringify(incoercibleValues))
 })