fast-json-stringify 3.1.0 → 4.1.0

package/test/array.test.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const moment = require('moment')
 const test = require('tap').test
 const validator = require('is-my-json-valid')
 const build = require('..')
@@ -177,27 +176,6 @@ test('invalid items throw', (t) => {
   t.throws(() => stringify({ args: ['invalid'] }))
 })
 
-test('moment array', (t) => {
-  t.plan(1)
-  const schema = {
-    type: 'object',
-    properties: {
-      times: {
-        type: 'array',
-        items: {
-          type: 'string',
-          format: 'date-time'
-        }
-      }
-    }
-  }
-  const stringify = build(schema)
-  const value = stringify({
-    times: [moment('2018-04-21T07:52:31.017Z')]
-  })
-  t.equal(value, '{"times":["2018-04-21T07:52:31.017Z"]}')
-})
-
 buildTest({
   title: 'item types in array default to any',
   type: 'object',
@@ -240,6 +218,35 @@ test('array items is a list of schema and additionalItems is true, just the desc
   t.equal(result, '{"foo":["foo","bar",1]}')
 })
 
+test('array items is a list of schema and additionalItems is true, just the described item is validated', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: [
+          {
+            type: 'string'
+          },
+          {
+            type: 'number'
+          }
+        ],
+        additionalItems: true
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const result = stringify({
+    foo: ['foo']
+  })
+
+  t.equal(result, '{"foo":["foo"]}')
+})
+
 test('array items is a list of schema and additionalItems is false', (t) => {
   t.plan(1)
 
@@ -344,7 +351,7 @@ buildTest({
 })
 
 buildTest({
-  title: 'large array with json-stringify mechanism',
+  title: 'large array of objects with json-stringify mechanism',
   type: 'object',
   properties: {
     ids: {
@@ -363,3 +370,83 @@ buildTest({
 }, {
   largeArrayMechanism: 'json-stringify'
 })
+
+buildTest({
+  title: 'large array of strings with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'string' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill('string')
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of numbers with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'number' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(42)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of integers with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'integer' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(42)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of booleans with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'boolean' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(true)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})
+
+buildTest({
+  title: 'large array of null values with default mechanism',
+  type: 'object',
+  properties: {
+    ids: {
+      type: 'array',
+      items: { type: 'null' }
+    }
+  }
+}, {
+  ids: new Array(2e4).fill(null)
+}, {
+  largeArraySize: 2e4,
+  largeArrayMechanism: 'default'
+})

package/test/basic.test.js

@@ -261,7 +261,7 @@ buildTest({
   readonly: true
 })
 
-test('skip or coerce numbers and integers that are not numbers', (t) => {
+test('throw an error or coerce numbers and integers that are not numbers', (t) => {
   const stringify = build({
     title: 'basic',
     type: 'object',
@@ -275,14 +275,14 @@ test('skip or coerce numbers and integers that are not numbers', (t) => {
     }
   })
 
-  let result = stringify({
-    age: 'hello  ',
-    distance: 'long'
-  })
-
-  t.same(JSON.parse(result), {})
+  try {
+    stringify({ age: 'hello  ', distance: 'long' })
+    t.fail('should throw an error')
+  } catch (err) {
+    t.ok(err)
+  }
 
-  result = stringify({
+  const result = stringify({
     age: '42',
     distance: true
   })

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/if-then-else.test.js

@@ -261,13 +261,13 @@ t.test('if-then-else', t => {
   const tests = [
     {
       name: 'foobar',
-      schema: schema,
+      schema,
       input: fooBarInput,
       expected: foobarOutput
     },
     {
       name: 'greeting',
-      schema: schema,
+      schema,
       input: greetingInput,
       expected: greetingOutput
     },

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