basic support to test against official JSON-Schema-Test-Suite (#122)

This PR will add basic support to test against the official https://github.com/json-schema-org/JSON-Schema-Test-Suite. It contains only tests for the `required` feature.

Author: StarpTech

.gitignore

@@ -44,3 +44,6 @@ yarn.lock
 
 # vim swap files
 *.swp
+
+# vscode
+.vscode

.travis.yml

@@ -1,10 +1,8 @@
 language: node_js
 sudo: false
 node_js:
-- '4'
 - '6'
 - '8'
-- '9'
 - '10'
 
 notifications:

index.js

@@ -62,6 +62,10 @@ function build (schema, options) {
     `
   }
 
+  if (schema.type === undefined) {
+    schema.type = inferTypeByKeyword(schema)
+  }
+
   var hasSchemaSomeIf = hasIf(schema)
 
   var main
@@ -114,6 +118,59 @@ function build (schema, options) {
   return (Function.apply(null, dependenciesName).apply(null, dependencies))
 }
 
+const objectKeywords = [
+  'maxProperties',
+  'minProperties',
+  'required',
+  'properties',
+  'patternProperties',
+  'additionalProperties',
+  'dependencies'
+]
+
+const arrayKeywords = [
+  'items',
+  'additionalItems',
+  'maxItems',
+  'minItems',
+  'uniqueItems',
+  'contains'
+]
+
+const stringKeywords = [
+  'maxLength',
+  'minLength',
+  'pattern'
+]
+
+const numberKeywords = [
+  'multipleOf',
+  'maximum',
+  'exclusiveMaximum',
+  'minimum',
+  'exclusiveMinimum'
+]
+
+/**
+ * Infer type based on keyword in order to generate optimized code
+ * https://json-schema.org/latest/json-schema-validation.html#rfc.section.6
+ */
+function inferTypeByKeyword (schema) {
+  for (const keyword of objectKeywords) {
+    if (keyword in schema) return 'object'
+  }
+  for (const keyword of arrayKeywords) {
+    if (keyword in schema) return 'array'
+  }
+  for (const keyword of stringKeywords) {
+    if (keyword in schema) return 'string'
+  }
+  for (const keyword of numberKeywords) {
+    if (keyword in schema) return 'number'
+  }
+  return schema.type
+}
+
 function hasAnyOf (schema) {
   if ('anyOf' in schema) { return true }
 
@@ -694,7 +751,16 @@ function buildArrayTypeCondition (type, accessor) {
 function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKey) {
   var code = ''
   var funcName
+
+  if (schema.type === undefined) {
+    var inferedType = inferTypeByKeyword(schema)
+    if (inferedType) {
+      schema.type = inferedType
+    }
+  }
+
   var type = schema.type
+
   var accessor = key.indexOf('[') === 0 ? key : `['${key}']`
   switch (type) {
     case 'null':
@@ -754,7 +820,7 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKe
           json += JSON.stringify(obj${accessor})
         `
       } else {
-        throw new Error(`${schema} unsupported`)
+        throw new Error(`${schema.type} unsupported`)
       }
       break
     default:

package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "benchmark": "node bench.js",
     "lint": "standard",
-    "unit": "tap -j4 test/*.test.js",
+    "unit": "tap -j4 test/**/*.test.js",
     "test": "npm run lint && npm run unit"
   },
   "precommit": "test",

test/inferType.test.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const test = require('tap').test
+const validator = require('is-my-json-valid')
+const build = require('..')
+
+function buildTest (schema, toStringify) {
+  test(`render a ${schema.title} as JSON`, (t) => {
+    t.plan(5)
+
+    const validate = validator(schema)
+    const stringify = build(schema)
+    const stringifyUgly = build(schema, { uglify: true })
+    const output = stringify(toStringify)
+    const outputUglify = stringifyUgly(toStringify)
+
+    t.deepEqual(JSON.parse(output), toStringify)
+    t.deepEqual(JSON.parse(outputUglify), toStringify)
+    t.equal(output, JSON.stringify(toStringify))
+    t.equal(outputUglify, JSON.stringify(toStringify))
+    t.ok(validate(JSON.parse(output)), 'valid schema')
+  })
+}
+
+buildTest({
+  'title': 'infer type object by keyword',
+  // 'type': 'object',
+  'properties': {
+    'name': {
+      'type': 'string'
+    }
+  }
+}, {
+  name: 'foo'
+})
+
+buildTest({
+  'title': 'infer type of nested object by keyword',
+  // 'type': 'object',
+  'properties': {
+    'more': {
+      'description': 'more properties',
+      // 'type': 'object',
+      'properties': {
+        'something': {
+          'type': 'string'
+        }
+      }
+    }
+  }
+}, {
+  more: {
+    something: 'else'
+  }
+})
+
+buildTest({
+  'title': 'infer type array by keyword',
+  'type': 'object',
+  'properties': {
+    'ids': {
+      // 'type': 'array',
+      'items': {
+        'type': 'string'
+      }
+    }
+  }
+}, {
+  ids: ['test']
+})
+
+buildTest({
+  'title': 'infer type string by keyword',
+  'type': 'object',
+  'properties': {
+    'name': {
+      // 'type': 'string',
+      'maxLength': 3
+    }
+  }
+}, {
+  name: 'foo'
+})
+
+buildTest({
+  'title': 'infer type number by keyword',
+  'type': 'object',
+  'properties': {
+    'age': {
+      // 'type': 'number',
+      'maximum': 18
+    }
+  }
+}, {
+  age: 18
+})

test/json-schema-test-suite/README.md

@@ -0,0 +1,10 @@
+# JSON-Schema-Test-Suite
+
+You can find all test cases [here](https://github.com/json-schema-org/JSON-Schema-Test-Suite).
+It contains a set of JSON objects that implementors of JSON Schema validation libraries can use to test their validators.
+
+# How to add another test case?
+
+1. Navigate to [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/master/tests)
+2. Choose a draft `draft4`, `draft6` or `draft7`
+3. Copy & paste the `test-case.json` to the project and add a test like in the `draft4.test.js`

test/json-schema-test-suite/draft4.test.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const test = require('tap').test
+const { counTests, runTests } = require('./util')
+
+const requiredTestSuite = require('./draft4/required.json')
+
+test('required', (t) => {
+  const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
+  t.plan(counTests(requiredTestSuite, skippedTests))
+  runTests(t, requiredTestSuite, skippedTests)
+})

test/json-schema-test-suite/draft4/required.json

@@ -0,0 +1,54 @@
+[
+    {
+        "description": "required validation",
+        "schema": {
+            "properties": {
+                "foo": {},
+                "bar": {}
+            },
+            "required": ["foo"]
+        },
+        "tests": [
+            {
+                "description": "present required property is valid",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "non-present required property is invalid",
+                "data": {"bar": 1},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required default validation",
+        "schema": {
+            "properties": {
+                "foo": {}
+            }
+        },
+        "tests": [
+            {
+                "description": "not required by default",
+                "data": {},
+                "valid": true
+            }
+        ]
+    }
+]

test/json-schema-test-suite/draft6.test.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const test = require('tap').test
+const { counTests, runTests } = require('./util')
+
+const requiredTestSuite = require('./draft6/required.json')
+
+test('required', (t) => {
+  const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
+  t.plan(counTests(requiredTestSuite, skippedTests))
+  runTests(t, requiredTestSuite, skippedTests)
+})

test/json-schema-test-suite/draft6/required.json

@@ -0,0 +1,70 @@
+[
+    {
+        "description": "required validation",
+        "schema": {
+            "properties": {
+                "foo": {},
+                "bar": {}
+            },
+            "required": ["foo"]
+        },
+        "tests": [
+            {
+                "description": "present required property is valid",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "non-present required property is invalid",
+                "data": {"bar": 1},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required default validation",
+        "schema": {
+            "properties": {
+                "foo": {}
+            }
+        },
+        "tests": [
+            {
+                "description": "not required by default",
+                "data": {},
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required with empty array",
+        "schema": {
+            "properties": {
+                "foo": {}
+            },
+            "required": []
+        },
+        "tests": [
+            {
+                "description": "property not required",
+                "data": {},
+                "valid": true
+            }
+        ]
+    }
+]