fast-json-stringify 1.17.0 → 1.20.1

package/test/oneof.test.js

@@ -0,0 +1,399 @@
+'use strict'
+
+const { test } = require('tap')
+const build = require('..')
+
+test('object with multiple types field', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with multiple types field',
+    type: 'object',
+    properties: {
+      str: {
+        oneOf: [{
+          type: 'string'
+        }, {
+          type: 'boolean'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      str: 'string'
+    })
+    t.is(value, '{"str":"string"}')
+  } catch (e) {
+    t.fail(e.message)
+  }
+
+  try {
+    const value = stringify({
+      str: true
+    })
+    t.is(value, '{"str":true}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with field of type object or null', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with field of type object or null',
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: [{
+          type: 'object',
+          properties: {
+            str: {
+              type: 'string'
+            }
+          }
+        }, {
+          type: 'null'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      prop: null
+    })
+    t.is(value, '{"prop":null}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      prop: {
+        str: 'string',
+        remove: 'this'
+      }
+    })
+    t.is(value, '{"prop":{"str":"string"}}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with field of type object or array', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with field of type object or array',
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: [{
+          type: 'object',
+          properties: {},
+          additionalProperties: true
+        }, {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      prop: {
+        str: 'string'
+      }
+    })
+    t.is(value, '{"prop":{"str":"string"}}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      prop: ['string']
+    })
+    t.is(value, '{"prop":["string"]}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with field of type string and coercion disable ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with field of type string',
+    type: 'object',
+    properties: {
+      str: {
+        oneOf: [{
+          type: 'string'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      str: 1
+    })
+    t.is(value, '{"str":null}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with field of type string and coercion enable ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with field of type string',
+    type: 'object',
+    properties: {
+      str: {
+        oneOf: [{
+          type: 'string'
+        }]
+      }
+    }
+  }
+
+  const options = {
+    ajv: {
+      coerceTypes: true
+    }
+  }
+  const stringify = build(schema, options)
+
+  try {
+    const value = stringify({
+      str: 1
+    })
+    t.is(value, '{"str":"1"}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('object with field with type union of multiple objects', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with oneOf property value containing objects',
+    type: 'object',
+    properties: {
+      oneOfSchema: {
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              baz: { type: 'number' }
+            },
+            required: ['baz']
+          },
+          {
+            type: 'object',
+            properties: {
+              bar: { type: 'string' }
+            },
+            required: ['bar']
+          }
+        ]
+      }
+    },
+    required: ['oneOfSchema']
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({ oneOfSchema: { baz: 5 } })
+    t.is(value, '{"oneOfSchema":{"baz":5}}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({ oneOfSchema: { bar: 'foo' } })
+    t.is(value, '{"oneOfSchema":{"bar":"foo"}}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('null value in schema', (t) => {
+  t.plan(0)
+
+  const schema = {
+    title: 'schema with null child',
+    type: 'string',
+    nullable: true,
+    enum: [null]
+  }
+
+  try {
+    build(schema)
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('oneOf and $ref together', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        type: 'string'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      cs: 'franco'
+    })
+    t.is(value, '{"cs":"franco"}')
+  } catch (e) {
+    t.fail()
+  }
+
+  try {
+    const value = stringify({
+      cs: true
+    })
+    t.is(value, '{"cs":true}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('oneOf and $ref: 2 levels are fine', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        oneOf: [
+          {
+            type: 'number'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  try {
+    const value = stringify({
+      cs: 3
+    })
+    t.is(value, '{"cs":3}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('oneOf and $ref: multiple levels should throw at build.', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option2'
+          },
+          {
+            type: 'string'
+          }
+        ]
+      },
+      Option2: {
+        type: 'number'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  try {
+    const value = stringify({
+      cs: 3
+    })
+    t.is(value, '{"cs":3}')
+  } catch (e) {
+    t.fail(e)
+  }
+  try {
+    const value = stringify({
+      cs: true
+    })
+    t.is(value, '{"cs":true}')
+  } catch (e) {
+    t.fail(e)
+  }
+  try {
+    const value = stringify({
+      cs: 'pippo'
+    })
+    t.is(value, '{"cs":"pippo"}')
+  } catch (e) {
+    t.fail(e)
+  }
+})

package/test/typesArray.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const test = require('tap').test
+const moment = require('moment')
 const build = require('..')
 
 test('possibly nullable integer primitive alternative', (t) => {
@@ -423,15 +424,17 @@ test('string type array can handle dates', (t) => {
   const schema = {
     type: 'object',
     properties: {
-      date: { type: ['string'] }
+      date: { type: ['string'] },
+      dateObject: { type: ['string'], format: 'date-time' }
     }
   }
   const stringify = build(schema)
   try {
     const value = stringify({
-      date: new Date('2018-04-20T07:52:31.017Z')
+      date: new Date('2018-04-20T07:52:31.017Z'),
+      dateObject: moment('2018-04-21T07:52:31.017Z')
     })
-    t.is(value, '{"date":"2018-04-20T07:52:31.017Z"}')
+    t.is(value, '{"date":"2018-04-20T07:52:31.017Z","dateObject":"2018-04-21T07:52:31.017Z"}')
   } catch (e) {
     t.fail()
   }

package/.travis.yml

@@ -1,14 +0,0 @@
-language: node_js
-sudo: false
-os:
-  - windows
-  - linux
-node_js:
-- '6'
-- '8'
-- '10'
-
-notifications:
-  email:
-    on_success: never
-    on_failure: always

package/azure-pipelines.yml

@@ -1,35 +0,0 @@
-pool:
-  vmImage: 'ubuntu-16.04'
-
-strategy:
-  matrix:
-    node_6_x:
-      node_version: 6.x
-    node_8_x:
-      node_version: 8.x
-    node_10_x:
-      node_version: 10.x
-    node_11_x:
-      node_version: 11.x
-
-steps:
-  - task: NodeTool@0
-    inputs:
-      versionSpec: $(node_version)
-    displayName: Install Node.js
-
-  - bash: npm install
-    displayName: Install dependencies
-
-  - bash: npm run test:lint
-    displayName: Linter
-
-  - bash: npm run test:report && npm run test:reporter
-    displayName: Test
-
-  - task: PublishTestResults@2
-    displayName: "Publish Test Results"
-    condition: succeededOrFailed()
-    inputs:
-      testResultsFiles: "**test/junit-testresults.xml"
-      testRunTitle: TestRun $(node_version)