Make integer/number handling consistent for type arrays (#146)

* Make integer handling consistent, add tests

* Add note about null and coercion

Author: cemremengu

README.md

@@ -481,6 +481,13 @@ console.log(stringify({product: null})) // "{"product":null}"
 console.log(stringify(null)) // null
 ```
 
+Otherwise, instead of raising an error, null values will be coerced as follows:
+
+- `integer` -> `0`
+- `number` -> `0`
+- `string` -> `""`
+- `boolean` -> `false`
+
 <a name="acknowledgements"></a>
 ## Acknowledgements
 

index.js

@@ -879,7 +879,12 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
             `
           } else if (type === 'integer') {
             code += `
-              ${index === 0 ? 'if' : 'else if'}(Number.isInteger(obj${accessor}))
+              ${index === 0 ? 'if' : 'else if'}(Number.isInteger(obj${accessor}) || obj${accessor} === null)
+              ${nestedResult.code}
+            `
+          } else if (type === 'number') {
+            code += `
+              ${index === 0 ? 'if' : 'else if'}(isNaN(obj${accessor}) === false)
               ${nestedResult.code}
             `
           } else {

test/missing-values.test.js

@@ -41,3 +41,48 @@ test('handle null when value should be string', (t) => {
 
   t.equal('{"str":""}', stringify({ str: null }))
 })
+
+test('handle null when value should be integer', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      int: {
+        type: 'integer'
+      }
+    }
+  })
+
+  t.equal('{"int":0}', stringify({ int: null }))
+})
+
+test('handle null when value should be number', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      num: {
+        type: 'number'
+      }
+    }
+  })
+
+  t.equal('{"num":0}', stringify({ num: null }))
+})
+
+test('handle null when value should be boolean', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      bool: {
+        type: 'boolean'
+      }
+    }
+  })
+
+  t.equal('{"bool":false}', stringify({ bool: null }))
+})

test/typesArray.test.js

@@ -3,7 +3,7 @@
 const test = require('tap').test
 const build = require('..')
 
-test('possibly nullable primitive alternative', (t) => {
+test('possibly nullable integer primitive alternative', (t) => {
   t.plan(1)
 
   const schema = {
@@ -28,7 +28,32 @@ test('possibly nullable primitive alternative', (t) => {
   }
 })
 
-test('possibly nullable primitive alternative with null value', (t) => {
+test('possibly nullable number primitive alternative', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'simple object with multi-type nullable primitive',
+    type: 'object',
+    properties: {
+      data: {
+        type: ['number']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      data: 4
+    })
+    t.is(value, '{"data":4}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('possibly nullable integer primitive alternative with null value', (t) => {
   t.plan(1)
 
   const schema = {
@@ -47,13 +72,38 @@ test('possibly nullable primitive alternative with null value', (t) => {
     const value = stringify({
       data: null
     })
-    t.is(value, '{"data":null}')
+    t.is(value, '{"data":0}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('possibly nullable number primitive alternative with null value', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'simple object with multi-type nullable primitive',
+    type: 'object',
+    properties: {
+      data: {
+        type: ['number']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      data: null
+    })
+    t.is(value, '{"data":0}')
   } catch (e) {
     t.fail()
   }
 })
 
-test('nullable primitive', (t) => {
+test('nullable integer primitive', (t) => {
   t.plan(1)
 
   const schema = {
@@ -78,6 +128,31 @@ test('nullable primitive', (t) => {
   }
 })
 
+test('nullable number primitive', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'simple object with nullable primitive',
+    type: 'object',
+    properties: {
+      data: {
+        type: ['number', 'null']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      data: 4
+    })
+    t.is(value, '{"data":4}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
 test('nullable primitive with null value', (t) => {
   t.plan(1)
 
@@ -103,6 +178,31 @@ test('nullable primitive with null value', (t) => {
   }
 })
 
+test('nullable number primitive with null value', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'simple object with nullable primitive',
+    type: 'object',
+    properties: {
+      data: {
+        type: ['number', 'null']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  try {
+    const value = stringify({
+      data: null
+    })
+    t.is(value, '{"data":null}')
+  } catch (e) {
+    t.fail()
+  }
+})
+
 test('possibly null object with multi-type property', (t) => {
   t.plan(3)