harperdb 3.1.3 → 3.1.4

package/node_modules/fast-json-stringify/test/integer.test.js

@@ -6,6 +6,7 @@ const semver = require('semver')
 const validator = require('is-my-json-valid')
 const proxyquire = require('proxyquire')
 const build = proxyquire('..', { long: null })
+const ROUNDING_TYPES = ['ceil', 'floor', 'round']
 
 test('render an integer as JSON', (t) => {
   t.plan(2)
@@ -32,7 +33,7 @@ test('render a float as an integer', (t) => {
     }, { rounding: 'foobar' })
   } catch (error) {
     t.ok(error)
-    t.equals(error.message, 'Unsupported integer rounding method foobar')
+    t.equal(error.message, 'Unsupported integer rounding method foobar')
   }
 })
 
@@ -40,6 +41,10 @@ test('render a float as an integer', (t) => {
   const cases = [
     { input: Math.PI, output: '3' },
     { input: 5.0, output: '5' },
+    { input: null, output: '0' },
+    { input: 0, output: '0' },
+    { input: 0.0, output: '0' },
+    { input: 42, output: '42' },
     { input: 1.99999, output: '1' },
     { input: -45.05, output: '-45' },
     { input: 0.95, output: '1', rounding: 'ceil' },
@@ -137,3 +142,41 @@ if (semver.gt(process.versions.node, '10.3.0')) {
   t.pass('Skip because Node version < 10.4')
   t.end()
 }
+
+test('should round integer object parameter', t => {
+  t.plan(2)
+
+  const schema = { type: 'object', properties: { magic: { type: 'integer' } } }
+  const validate = validator(schema)
+  const stringify = build(schema, { rounding: 'ceil' })
+  const output = stringify({ magic: 4.2 })
+
+  t.equal(output, '{"magic":5}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('should not stringify a property if it does not exist', t => {
+  t.plan(2)
+
+  const schema = { title: 'Example Schema', type: 'object', properties: { age: { type: 'integer' } } }
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({})
+
+  t.equal(output, '{}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+ROUNDING_TYPES.forEach((rounding) => {
+  test(`should not stringify a property if it does not exist (rounding: ${rounding})`, t => {
+    t.plan(2)
+
+    const schema = { type: 'object', properties: { magic: { type: 'integer' } } }
+    const validate = validator(schema)
+    const stringify = build(schema, { rounding })
+    const output = stringify({})
+
+    t.equal(output, '{}')
+    t.ok(validate(JSON.parse(output)), 'valid schema')
+  })
+})

package/node_modules/fast-json-stringify/test/nestedObjects.test.js

@@ -28,5 +28,5 @@ test('nested objects with same properties', (t) => {
       numberProperty: 42
     }
   })
-  t.is(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
+  t.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
 })

package/node_modules/fast-json-stringify/test/nullable.test.js

@@ -108,6 +108,6 @@ Object.keys(testSet).forEach(key => {
     const data = testSet[key][1]
     const expected = testSet[key][2]
     const result = stringifier(data)
-    t.deepEqual(JSON.parse(result), expected)
+    t.same(JSON.parse(result), expected)
   })
 })

package/node_modules/fast-json-stringify/test/oneof.test.js

@@ -21,8 +21,8 @@ test('object with multiple types field', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({ str: 'string' }), '{"str":"string"}')
-  t.is(stringify({ str: true }), '{"str":true}')
+  t.equal(stringify({ str: 'string' }), '{"str":"string"}')
+  t.equal(stringify({ str: true }), '{"str":true}')
 })
 
 test('object with field of type object or null', (t) => {
@@ -48,9 +48,9 @@ test('object with field of type object or null', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({ prop: null }), '{"prop":null}')
+  t.equal(stringify({ prop: null }), '{"prop":null}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: {
       str: 'string', remove: 'this'
     }
@@ -80,11 +80,11 @@ test('object with field of type object or array', (t) => {
   }
   const stringify = build(schema)
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: { str: 'string' }
   }), '{"prop":{"str":"string"}}')
 
-  t.is(stringify({
+  t.equal(stringify({
     prop: ['string']
   }), '{"prop":["string"]}')
 })
@@ -108,7 +108,7 @@ test('object with field of type string and coercion disable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":null}')
+  t.equal(value, '{"str":null}')
 })
 
 test('object with field of type string and coercion enable ', (t) => {
@@ -136,7 +136,7 @@ test('object with field of type string and coercion enable ', (t) => {
   const value = stringify({
     str: 1
   })
-  t.is(value, '{"str":"1"}')
+  t.equal(value, '{"str":"1"}')
 })
 
 test('object with field with type union of multiple objects', (t) => {
@@ -170,9 +170,9 @@ test('object with field with type union of multiple objects', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+  t.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
 
-  t.is(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+  t.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
 })
 
 test('null value in schema', (t) => {
@@ -214,9 +214,9 @@ test('oneOf and $ref together', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+  t.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
 
-  t.is(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
 })
 
 test('oneOf and $ref: 2 levels are fine', (t) => {
@@ -254,7 +254,7 @@ test('oneOf and $ref: 2 levels are fine', (t) => {
   const value = stringify({
     cs: 3
   })
-  t.is(value, '{"cs":3}')
+  t.equal(value, '{"cs":3}')
 })
 
 test('oneOf and $ref: multiple levels should throw at build.', (t) => {
@@ -293,9 +293,9 @@ test('oneOf and $ref: multiple levels should throw at build.', (t) => {
 
   const stringify = build(schema)
 
-  t.is(stringify({ cs: 3 }), '{"cs":3}')
-  t.is(stringify({ cs: true }), '{"cs":true}')
-  t.is(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+  t.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.equal(stringify({ cs: true }), '{"cs":true}')
+  t.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
 })
 
 test('oneOf and $ref - multiple external $ref', (t) => {
@@ -373,5 +373,133 @@ test('oneOf with enum with more than 100 entries', (t) => {
   const stringify = build(schema)
 
   const value = stringify(['EUR', 'USD', null])
-  t.is(value, '["EUR","USD",null]')
+  t.equal(value, '["EUR","USD",null]')
+})
+
+test('oneOf object with field of type string with format or null', (t) => {
+  t.plan(1)
+
+  const toStringify = new Date()
+
+  const withOneOfSchema = {
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: [{
+          type: 'string',
+          format: 'date-time'
+        }, {
+          type: 'null'
+        }]
+      }
+    }
+  }
+
+  const withOneOfStringify = build(withOneOfSchema)
+
+  t.equal(withOneOfStringify({
+    prop: toStringify
+  }), `{"prop":"${toStringify.toISOString()}"}`)
+})
+
+test('one array item match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const responseWithMappedType = stringify({
+    data: [false, 'foo']
+  })
+
+  t.equal('{"data":["foo"]}', responseWithMappedType)
+})
+
+test('some array items match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const responseWithMappedTypes = stringify({
+    data: [false, 'foo', true, 5]
+  })
+
+  t.equal('{"data":["foo",5]}', responseWithMappedTypes)
+})
+
+test('all array items does not match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  const emptyResponse = stringify({
+    data: [null, false, true, undefined, [], {}]
+  })
+
+  t.equal('{"data":[]}', emptyResponse)
 })

package/node_modules/fast-json-stringify/test/recursion.test.js

@@ -0,0 +1,180 @@
+'use strict'
+
+const test = require('tap').test
+const build = require('..')
+
+test('can stringify recursive directory tree (issue #181)', (t) => {
+  t.plan(1)
+
+  const schema = {
+    definitions: {
+      directory: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          subDirectories: {
+            type: 'array',
+            items: { $ref: '#/definitions/directory' },
+            default: []
+          }
+        }
+      }
+    },
+    type: 'array',
+    items: { $ref: '#/definitions/directory' }
+  }
+  const stringify = build(schema)
+
+  t.equal(stringify([
+    { name: 'directory 1', subDirectories: [] },
+    {
+      name: 'directory 2',
+      subDirectories: [
+        { name: 'directory 2.1', subDirectories: [] },
+        { name: 'directory 2.2', subDirectories: [] }
+      ]
+    }
+  ]), '[{"name":"directory 1","subDirectories":[]},{"name":"directory 2","subDirectories":[{"name":"directory 2.1","subDirectories":[]},{"name":"directory 2.2","subDirectories":[]}]}]')
+})
+
+test('can stringify when recursion in external schema', t => {
+  t.plan(1)
+
+  const referenceSchema = {
+    $id: 'person',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      children: {
+        type: 'array',
+        items: { $ref: '#' }
+      }
+    }
+  }
+
+  const schema = {
+    $id: 'mainSchema',
+    type: 'object',
+    properties: {
+      people: {
+        $ref: 'person'
+      }
+    }
+  }
+  const stringify = build(schema, {
+    schema: {
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const value = stringify({ people: { name: 'Elizabeth', children: [{ name: 'Charles' }] } })
+  t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles"}]}}')
+})
+
+test('use proper serialize function', t => {
+  t.plan(1)
+
+  const personSchema = {
+    $id: 'person',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      children: {
+        type: 'array',
+        items: { $ref: '#' }
+      }
+    }
+  }
+
+  const directorySchema = {
+    $id: 'directory',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      subDirectories: {
+        type: 'array',
+        items: { $ref: '#' },
+        default: []
+      }
+    }
+  }
+
+  const schema = {
+    $id: 'mainSchema',
+    type: 'object',
+    properties: {
+      people: { $ref: 'person' },
+      directory: { $ref: 'directory' }
+    }
+  }
+  const stringify = build(schema, {
+    schema: {
+      [personSchema.$id]: personSchema,
+      [directorySchema.$id]: directorySchema
+    }
+  })
+
+  const value = stringify({
+    people: {
+      name: 'Elizabeth',
+      children: [{
+        name: 'Charles',
+        children: [{ name: 'William', children: [{ name: 'George' }, { name: 'Charlotte' }] }, { name: 'Harry' }]
+      }]
+    },
+    directory: {
+      name: 'directory 1',
+      subDirectories: [
+        { name: 'directory 1.1', subDirectories: [] },
+        {
+          name: 'directory 1.2',
+          subDirectories: [{ name: 'directory 1.2.1' }, { name: 'directory 1.2.2' }]
+        }
+      ]
+    }
+  })
+  t.equal(value, '{"people":{"name":"Elizabeth","children":[{"name":"Charles","children":[{"name":"William","children":[{"name":"George"},{"name":"Charlotte"}]},{"name":"Harry"}]}]},"directory":{"name":"directory 1","subDirectories":[{"name":"directory 1.1","subDirectories":[]},{"name":"directory 1.2","subDirectories":[{"name":"directory 1.2.1","subDirectories":[]},{"name":"directory 1.2.2","subDirectories":[]}]}]}}')
+})
+
+test('can stringify recursive references in object types (issue #365)', t => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    definitions: {
+      parentCategory: {
+        type: 'object',
+        properties: {
+          parent: {
+            $ref: '#/definitions/parentCategory'
+          }
+        }
+      }
+    },
+    properties: {
+      category: {
+        type: 'object',
+        properties: {
+          parent: {
+            $ref: '#/definitions/parentCategory'
+          }
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const data = {
+    category: {
+      parent: {
+        parent: {
+          parent: {
+            parent: {}
+          }
+        }
+      }
+    }
+  }
+  const value = stringify(data)
+  t.equal(value, '{"category":{"parent":{"parent":{"parent":{"parent":{}}}}}}')
+})

package/node_modules/fast-json-stringify/test/ref.test.js

@@ -1026,7 +1026,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
+      t.equal(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
     }
   })
 
@@ -1051,7 +1051,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "foobar"')
+      t.equal(err.message, 'Cannot find reference "foobar"')
     }
   })
 
@@ -1081,7 +1081,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
+      t.equal(err.message, 'Cannot find reference "porjectId", did you mean "projectId"?')
     }
   })
 
@@ -1111,7 +1111,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "foobar"')
+      t.equal(err.message, 'Cannot find reference "foobar"')
     }
   })
 
@@ -1141,7 +1141,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
+      t.equal(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
     }
   })
 
@@ -1166,7 +1166,7 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
+      t.equal(err.message, 'Cannot find reference "deifnitions", did you mean "definitions"?')
     }
   })
 
@@ -1196,9 +1196,56 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.is(err.message, 'Cannot find reference "extrenal", did you mean "external"?')
+      t.equal(err.message, 'Cannot find reference "extrenal", did you mean "external"?')
     }
   })
 
   t.end()
 })
+
+test('Regression 2.5.2', t => {
+  t.plan(1)
+
+  const externalSchema = {
+    '/models/Bar': {
+      $id: '/models/Bar',
+      $schema: 'http://json-schema.org/schema#',
+      definitions: {
+        entity: {
+          type: 'object',
+          properties: { field: { type: 'string' } }
+        }
+      }
+    },
+    '/models/Foo': {
+      $id: '/models/Foo',
+      $schema: 'http://json-schema.org/schema#',
+      definitions: {
+        entity: {
+          type: 'object',
+          properties: {
+            field: { type: 'string' },
+            sub: {
+              oneOf: [
+                { $ref: '/models/Bar#/definitions/entity' },
+                { type: 'null' }
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const schema = {
+    type: 'array',
+    items: {
+      $ref: '/models/Foo#/definitions/entity'
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify([{ field: 'parent', sub: { field: 'joined' } }])
+
+  t.equal(output, '[{"field":"parent","sub":{"field":"joined"}}]')
+})

package/node_modules/fast-json-stringify/test/required.test.js

@@ -32,7 +32,7 @@ test('object with required field', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 })
@@ -56,7 +56,7 @@ test('object with required field not in properties schema', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 
@@ -66,7 +66,7 @@ test('object with required field not in properties schema', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 })
@@ -91,7 +91,7 @@ test('object with required field not in properties schema with additional proper
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 
@@ -101,7 +101,7 @@ test('object with required field not in properties schema with additional proper
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"str" is required!')
+    t.equal(e.message, '"str" is required!')
     t.pass()
   }
 })
@@ -126,7 +126,7 @@ test('object with multiple required field not in properties schema', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"num" is required!')
+    t.equal(e.message, '"num" is required!')
     t.pass()
   }
 
@@ -136,7 +136,7 @@ test('object with multiple required field not in properties schema', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"key1" is required!')
+    t.equal(e.message, '"key1" is required!')
     t.pass()
   }
 
@@ -147,7 +147,7 @@ test('object with multiple required field not in properties schema', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"key2" is required!')
+    t.equal(e.message, '"key2" is required!')
     t.pass()
   }
 })
@@ -172,7 +172,7 @@ test('object with required bool', (t) => {
     stringify({})
     t.fail()
   } catch (e) {
-    t.is(e.message, '"bool" is required!')
+    t.equal(e.message, '"bool" is required!')
     t.pass()
   }
 
@@ -232,7 +232,7 @@ test('required numbers', (t) => {
     })
     t.fail()
   } catch (e) {
-    t.is(e.message, '"num" is required!')
+    t.equal(e.message, '"num" is required!')
     t.pass()
   }
 })