@wirenboard/json-editor 2.5.3-wb13

package/tests/unit/editors/table.spec.js

@@ -0,0 +1,91 @@
+import { JSONEditor } from '../../../src/core'
+
+const fixture = [
+  {
+    title: 'Table Editor Test',
+    schema: {
+      type: 'array',
+      format: 'table',
+      items: {
+        type: ['boolean', 'string', 'null', 'number']
+      }
+    },
+    value: [false]
+  },
+  {
+    title: 'Table Editor Test',
+    schema: {
+      type: 'array',
+      format: 'table',
+      items: {
+        type: ['boolean', 'string', 'null', 'number']
+      }
+    },
+    value: ['']
+  },
+  {
+    title: 'Table Editor Test',
+    schema: {
+      type: 'array',
+      format: 'table',
+      items: {
+        type: ['boolean', 'string', 'null', 'number']
+      }
+    },
+    value: [0]
+  },
+  {
+    title: 'Table Editor Test',
+    schema: {
+      type: 'array',
+      format: 'table',
+      items: {
+        type: 'string'
+      }
+    },
+    options: {
+      use_default_values: false
+    },
+    value: ['']
+  },
+  {
+    title: 'Table Editor Test',
+    schema: {
+      type: 'array',
+      format: 'table',
+      items: {
+        type: 'number'
+      }
+    },
+    options: {
+      use_default_values: false
+    },
+    value: [0]
+  }
+]
+
+describe('Table Editor', () => {
+  let element
+  let editor
+
+  beforeEach(() => {
+    document.body.insertAdjacentHTML(
+      'afterbegin',
+      '<div id="fixture"></div>')
+    element = document.getElementById('fixture')
+  })
+
+  afterEach(() => {
+    editor.destroy()
+  })
+
+  fixture.forEach(spec => {
+    it(spec.title, () => {
+      editor = new JSONEditor(element, {
+        schema: spec.schema
+      })
+      editor.setValue(spec.value);
+      expect(editor.getValue()).toEqual(spec.value)
+    })
+  })
+})

package/tests/unit/readme.md

@@ -0,0 +1,35 @@
+# Unit Tests
+
+## Introduction
+
+Unit tests are implemented using the [Jasmine](https://jasmine.github.io/) framework.
+
+## Karma Test Runner
+
+### Running
+
+You can continuously watch and debug unit tests using:
+
+```bash
+npm run test
+```
+
+The browser will start and run each unit test in a random sequence, showing the result. If tests are target code is edited, the code will be recompiled and the tests re-run.
+
+### Debugging
+
+To debug tests click the debug button in the browser - this will allow you to select each test to run in debug mode. 
+
+You can set breakpoints on the original code by:
+
+1. Opening Chrome developer tools
+2. Opening the Sources tab
+3. Expanding the Webpack://./tests/unit/ hierarchy to display your test file
+4. Clicking on the line number to place the breakpoint
+
+## File hierarchy
+
+Test files should have the same name as their target files but ending with `.spec.js` instead of `.js` and their subpath relative to this directory should be the same as the target file's relative to the `./src/` directory.
+
+So a file testing `/src/editors/validator.js` should have the path `./tests/unit/editors/validator.spec.js`
+

package/tests/unit/schemaloader.spec.js

@@ -0,0 +1,498 @@
+/* global describe beforeEach it expect */
+
+import { SchemaLoader } from '../../src/schemaloader'
+import { createFakeServer } from 'sinon'
+
+describe('SchemaLoader', () => {
+  let loader
+  let fileBase
+  let fetchUrl
+
+  describe('when no external ref', () => {
+    beforeEach(() => {
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader()
+      fileBase = loader._getFileBase(document.location.toString())
+    })
+
+    it('should create a loader', () => {
+      expect(loader).toBeTruthy()
+    })
+
+    it('load schema without $ref', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' }
+        }
+      }
+      loader.load(schema, schema => {}, fetchUrl, fileBase)
+      const urls = Object.keys(loader.refs)
+      expect(urls.length).toEqual(0)
+    })
+
+    it('load schema with $ref', () => {
+      const schema = {
+        definitions: {
+          name: {
+            type: 'string',
+            minLength: 4
+          }
+        },
+        type: 'object',
+        properties: {
+          fname: { $ref: '#/definitions/name' },
+          lname: { $ref: '#/definitions/name' }
+        }
+      }
+      loader.load(schema, schema => {}, fetchUrl, fileBase)
+      const urls = Object.keys(loader.refs)
+      expect(urls.length).toEqual(1)
+    })
+
+    it('load schema with urn: $ref', () => {
+      const schema = {
+        definitions: {
+          fname: {
+            id: 'urn:fname',
+            type: 'string',
+            default: 'John',
+            minLength: 4
+          },
+          lname: {
+            $id: 'urn:lname',
+            type: 'string',
+            default: 'Doe',
+            minLength: 4
+          }
+        },
+        type: 'object',
+        properties: {
+          fname: { $ref: 'urn:fname' },
+          lname: { $ref: 'urn:lname' }
+        }
+      }
+      loader.load(schema, schema => {}, fetchUrl, fileBase)
+      const urls = Object.keys(loader.refs)
+      expect(urls.length).toEqual(4)
+    })
+  })
+
+  describe('when external absolute ref exists', () => {
+    it('should set oprion { ajax: true }', done => {
+      const response = {
+        type: 'string',
+        minLength: 4
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith('/string.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(response)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+
+      const schema = {
+        type: 'object',
+        properties: {
+          fname: { $ref: '/string.json' },
+          lname: { $ref: '/string.json' }
+        }
+      }
+      loader.load(
+        schema,
+        schema => {
+          const urls = Object.keys(loader.refs)
+          expect(urls.length).toEqual(1)
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when external relative $ref exists', () => {
+    it('should set oprion { ajax: true }', done => {
+      const response = {
+        type: 'string',
+        minLength: 4
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith('/string.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(response)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+
+      const schema = {
+        type: 'object',
+        properties: {
+          fname: { $ref: 'string.json' },
+          lname: { $ref: 'string.json' }
+        }
+      }
+      loader.load(
+        schema,
+        schema => {
+          const urls = Object.keys(loader.refs)
+          expect(urls.length).toEqual(1)
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when external absolute-to-relative $ref exists', () => {
+    it('can get refs recursively', done => {
+      const schema1 = {
+        type: 'object',
+        properties: {
+          fname: { $ref: '/schema/main.json' },
+          lname: { $ref: '/schema/main.json' }
+        }
+      }
+      const schema2 = {
+        $ref: 'registry/sub.json'
+      }
+      const schema3 = {
+        type: 'string',
+        minLength: 4
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith('/schema/main.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(schema2)
+      ])
+      server.respondWith('/schema/registry/sub.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(schema3)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+      loader.load(
+        schema1,
+        schema => {
+          expect(Object.keys(loader.refs).length).toBe(2)
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when external relative-to-relative $ref exists', () => {
+    it('can get refs recursively', done => {
+      const schema1 = {
+        type: 'object',
+        properties: {
+          fname: { $ref: 'schema/main.json' },
+          lname: { $ref: 'schema/main.json' }
+        }
+      }
+      const schema2 = {
+        $ref: 'registry/sub.json'
+      }
+      const schema3 = {
+        type: 'string',
+        minLength: 4
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith('/schema/main.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(schema2)
+      ])
+      server.respondWith('/schema/registry/sub.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(schema3)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+      loader.load(
+        schema1,
+        schema => {
+          console.log(loader.refs)
+          expect(Object.keys(loader.refs).length).toBe(2)
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when external absolute $ref with json pointer exists', () => {
+    it('can get refs', done => {
+      const schema1 = {
+        type: 'object',
+        properties: {
+          'test-1': { $ref: '/common.schema.json#' },
+          'test-2': { $ref: '/common.schema.json#/definitions/known-product' },
+          'test-3': {
+            type: 'object',
+            properties: {
+              Product: { $ref: '/common.schema.json#/definitions/known-product' }
+            }
+          }
+        }
+      }
+      const schema2 = {
+        definitions: {
+          'known-product': {
+            title: 'product',
+            type: 'string',
+            enum: [ 'power', 'hydrogen', 'heat' ]
+          }
+        },
+        title: 'test',
+        properties: {
+          customer: { type: 'string' },
+          product: { $ref: '#/definitions/known-product' }
+        }
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith('/common.schema.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(schema2)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+      loader.load(
+        schema1,
+        schema => {
+          console.log(loader.refs)
+          expect(Object.keys(loader.refs).length).toBe(2)
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when external relative $ref with json pointer exists', () => {
+    it('can get refs', done => {
+      const schema1 = {
+        type: 'object',
+        properties: {
+          'test-1': { $ref: 'common.schema.json#' },
+          'test-2': { $ref: 'common.schema.json#/definitions/known-product' },
+          'test-3': {
+            type: 'object',
+            properties: {
+              Product: { $ref: 'common.schema.json#/definitions/known-product' }
+            }
+          }
+        }
+      }
+      const schema2 = {
+        definitions: {
+          'known-product': {
+            title: 'product',
+            type: 'string',
+            enum: [ 'power', 'hydrogen', 'heat' ]
+          }
+        },
+        title: 'test',
+        properties: {
+          customer: { type: 'string' },
+          product: { $ref: '#/definitions/known-product' }
+        }
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith('/common.schema.json', [
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(schema2)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+      loader.load(
+        schema1,
+        schema => {
+          console.log(loader.refs)
+          expect(Object.keys(loader.refs).length).toBe(2)
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when external ref exists with json pointer', () => {
+    it('should get ref and resolve json pointer', done => {
+      const response = {
+        definitions: {
+          fruits: {
+            enum: [
+              'apple',
+              'banana',
+              'cherry'
+            ]
+          }
+        }
+      }
+      const server = createFakeServer()
+      server.autoRespond = true
+      window.XMLHttpRequest = server.xhr
+      server.respondWith([
+        200,
+        { 'Content-Type': 'application/json' },
+        JSON.stringify(response)
+      ])
+      fetchUrl =
+        document.location.origin + document.location.pathname.toString()
+      loader = new SchemaLoader({ ajax: true })
+      fileBase = loader._getFileBase(document.location.toString())
+
+      const schema = {
+        type: 'object',
+        properties: {
+          fruits: { $ref: '/fruits.json#/definitions/fruits' }
+        }
+      }
+      loader.load(
+        schema,
+        schema => {
+          const urls = Object.keys(loader.refs)
+          expect(urls.length).toEqual(1)
+          expect(urls[0]).toEqual('/fruits.json#/definitions/fruits')
+          expect(loader.refs['/fruits.json#/definitions/fruits']).toEqual({ enum: ['apple', 'banana', 'cherry'] })
+          done()
+          server.restore()
+        },
+        fetchUrl,
+        fileBase
+      )
+    })
+  })
+
+  describe('when resolving undeclared URN $ref', () => {
+    it('can get refs recursively', done => {
+      const schema1 = {
+        type: 'object',
+        properties: {
+          fname: { $ref: 'urn:main' },
+          lname: { $ref: 'urn:sub' }
+        }
+      }
+      const schema2 = {
+        definitions: {
+           name: {
+             id: 'urn:main',
+             $ref: 'urn:sub'
+          }
+        }
+      }
+      const schema3 = {
+        definitions: {
+          name: {
+            $id: 'urn:sub',
+            type: 'string',
+            default: 'Waldo',
+            minLength: 4
+          }
+        }
+      }
+      loader = new SchemaLoader({ urn_resolver: (urn, callback) => {
+        if (urn === 'urn:main') {
+          callback(JSON.stringify(schema2))
+          return true
+        }
+        if (urn === 'urn:sub') {
+          callback(JSON.stringify(schema3))
+          return true
+        }
+        return false
+      }})
+      loader.load(
+        schema1,
+        schema => {
+          console.log(loader.refs_with_info)
+          expect(Object.keys(loader.refs).length).toBe(4)
+          done()
+        }
+      )
+    })
+  })
+
+  describe('when resolving undeclared URN $ref with fragment', () => {
+    it('can get refs recursively', done => {
+      const schema1 = {
+        type: 'object',
+        properties: {
+          fname: { $ref: 'urn:main#/definitions/name' },
+          lname: { $ref: 'urn:main#/definitions/name' }
+        }
+      }
+      const schema2 = {
+        definitions: {
+          name: {
+            $id: 'urn:main',
+            type: 'string',
+            default: 'Waldo',
+            minLength: 4
+          }
+        }
+      }
+      loader = new SchemaLoader({ urn_resolver: (urn, callback) => {
+        if (urn === 'urn:main') {
+          callback(JSON.stringify(schema2))
+          return true
+        }
+        return false
+      }})
+      loader.load(
+        schema1,
+        schema => {
+          console.log(loader.refs_with_info)
+          expect(Object.keys(loader.refs).length).toBe(2)
+          done()
+        }
+      )
+    })
+  })
+})

package/tests/unit/validator.spec.js

@@ -0,0 +1,94 @@
+/* global describe beforeAll beforeEach afterEach afterAll it expect */
+
+import { JSONEditor } from '../../src/core'
+import { Validator } from '../../src/validator'
+import { defaults } from '../../src/defaults'
+import fixture from '../fixtures/validation.json'
+import fixtureString from '../fixtures/string.json'
+import fixtureRecursive from '../fixtures/recursive.json'
+import * as math from 'mathjs'
+import { createFakeServer } from 'sinon'
+
+describe('Validator', () => {
+  it('mathjs test', () => {
+    window.math = math
+    expect(window.math.mod(window.math.bignumber(1), window.math.bignumber(0.01))).toEqual(window.math.bignumber(0))
+  })
+  it('should exist', () => {
+    expect(Validator).toBeTruthy()
+  })
+
+  describe('Constructor()', () => {
+    it('should create a new object', () => {
+      const jsonEditor = {}
+      const schema = {}
+      const options = {}
+      const instance = new Validator(jsonEditor, schema, options, defaults)
+      expect(instance).toBeTruthy()
+    })
+  })
+})
+
+describe('Validation Test', () => {
+  let element
+  let server
+
+  beforeAll(() => {
+    server = createFakeServer()
+    server.autoRespond = true
+    window.XMLHttpRequest = server.xhr
+    const response = {
+      string: fixtureString,
+      recursive: fixtureRecursive
+    }
+    server.respondWith(/(\w+)\.json/, (xhr, name) => {
+      xhr.respond(200, { 'Content-Type': 'application/json' }, JSON.stringify(response[name]))
+    })
+  })
+
+  afterAll(() => {
+    server.restore()
+  })
+
+  beforeEach(() => {
+    window.math = math
+    document.body.insertAdjacentHTML(
+      'afterbegin',
+      '<div id="fixture"></div>')
+    element = document.getElementById('fixture')
+  })
+
+  Object.entries(fixture).forEach(([subject, spec]) => {
+    describe(subject, () => {
+      let editor
+      beforeEach(() => {
+        editor = new JSONEditor(element, {
+          schema: spec.schema,
+          ajax: true
+        })
+      })
+
+      afterEach(() => {
+        editor.destroy()
+      })
+      spec.valid.forEach((v, i) => {
+        it(`valid data ${i + 1}`, (done) => {
+          editor.on('ready', () => {
+            const result = editor.validate(v)
+            expect(result.length).toBe(0)
+            done()
+          })
+        })
+      })
+      spec.invalid.forEach((v, i) => {
+        it(`invalid data ${i + 1}`, (done) => {
+          editor.on('ready', () => {
+            const result = editor.validate(v)
+            expect(result.length).toBeGreaterThan(0)
+            done()
+          })
+        })
+      })
+    })
+  })
+})