functional-models 1.1.23 → 1.2.0

package/test/src/utils.test.js

@@ -0,0 +1,54 @@
+const assert = require('chai').assert
+const sinon = require('sinon')
+const proxyquire = require('proxyquire')
+const { loweredTitleCase, createUuid } = require('../../src/utils')
+
+describe('/src/utils.js', () => {
+  describe('#loweredTitleCase()', () => {
+    it('should turn TitleCase into titleCase', () => {
+      const actual = loweredTitleCase('TitleCase')
+      const expected = 'titleCase'
+      assert.equal(actual, expected)
+    })
+  })
+  describe('#createUuid()', () => {
+    before(() => {
+      window = undefined
+    })
+    after(() => {
+      window = undefined
+    })
+    describe('when not having access to "window"', () => {
+      it('should call get-random-values 31 times with hello-crypto', () => {
+        const getRandomValues = sinon.stub().returns('hello-crypto')
+        const utils = proxyquire('../../src/utils', {
+          'get-random-values': getRandomValues,
+        })
+        const actual = utils.createUuid()
+        sinon.assert.callCount(getRandomValues, 31)
+      })
+    })
+    describe('when in a browser with "window"', () => {
+      it('should call window.crypto when it exists 31 times with hello-crypto', () => {
+        const getRandomValues = sinon.stub().returns('hello-crypto')
+        window = {
+          crypto: {
+            getRandomValues,
+          },
+        }
+        const actual = createUuid()
+        sinon.assert.callCount(getRandomValues, 31)
+      })
+      it('should call window.myCrypto when it exists 31 times with hello-crypto', () => {
+        const getRandomValues = sinon.stub().returns('hello-crypto')
+        window = {
+          msCrypto: {
+            getRandomValues,
+          },
+        }
+        const actual = createUuid()
+        sinon.assert.callCount(getRandomValues, 31)
+      })
+    })
+  })
+})

package/test/src/validation.test.js

@@ -0,0 +1,614 @@
+const chai = require('chai')
+const assert = chai.assert
+const chaiAsPromised = require('chai-as-promised')
+chai.use(chaiAsPromised)
+const sinon = require('sinon')
+const { Model } = require('../../src/models')
+const { UniqueId, TextProperty } = require('../../src/properties')
+const {
+  isNumber,
+  isBoolean,
+  isInteger,
+  isString,
+  isArray,
+  isDate,
+  arrayType,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  referenceTypeMatch,
+  emptyValidator,
+  createModelValidator,
+  createPropertyValidator,
+  TYPE_PRIMATIVES,
+} = require('../../src/validation')
+
+const TestModel1 = Model('TestModel1', {
+  id: UniqueId(),
+})
+
+const TestModel2 = Model('TestModel2', {
+  id: UniqueId(),
+})
+
+const createTestModel3 = modelValidators =>
+  Model(
+    'TestModel3',
+    {
+      id: UniqueId(),
+      name: TextProperty(),
+    },
+    {
+      modelValidators,
+    }
+  )
+
+describe('/src/validation.js', () => {
+  describe('#isDate()', () => {
+    it('should return an error if value is null', () => {
+      const actual = isDate(null)
+      assert.isOk(actual)
+    })
+    it('should return an error if value is undefined', () => {
+      const actual = isDate(undefined)
+      assert.isOk(actual)
+    })
+    it('should return an error object does not have toISOString', () => {
+      const actual = isDate({})
+      assert.isOk(actual)
+    })
+    it('should return undefined if a date', () => {
+      const actual = isDate(new Date())
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#referenceTypeMatch()', () => {
+    it('should allow a function for a model', () => {
+      const myModel = TestModel1.create()
+      const actual = referenceTypeMatch(() => TestModel1)(myModel)
+      const expected = undefined
+      assert.equal(actual, expected)
+    })
+    it('should validate when the correct object matches the model', () => {
+      const myModel = TestModel1.create()
+      const actual = referenceTypeMatch(TestModel1)(myModel)
+      const expected = undefined
+      assert.equal(actual, expected)
+    })
+    it('should return an error when the input does not match the model', () => {
+      const myModel = TestModel2.create()
+      const actual = referenceTypeMatch(TestModel1)(myModel)
+      assert.isOk(actual)
+    })
+  })
+  describe('#isNumber()', () => {
+    it('should return an error when empty is passed', () => {
+      const actual = isNumber(null)
+      assert.isOk(actual)
+    })
+    it('should return an error when "asdf" is passed', () => {
+      const actual = isNumber('asdf')
+      assert.isOk(actual)
+    })
+    it('should return undefined when 1 is passed', () => {
+      const actual = isNumber(1)
+      assert.isUndefined(actual)
+    })
+    it('should return error when "1" is passed', () => {
+      const actual = isNumber('1')
+      assert.isOk(actual)
+    })
+  })
+  describe('#isString()', () => {
+    it('should return undefined when "1" is passed', () => {
+      const actual = isString('1')
+      assert.isUndefined(actual)
+    })
+    it('should return error when 1 is passed', () => {
+      const actual = isString(1)
+      assert.isOk(actual)
+    })
+  })
+  describe('#isRequired()', () => {
+    it('should return undefined when 1 is passed', () => {
+      const actual = isRequired(1)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when a date is passed', () => {
+      const actual = isRequired(new Date())
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when 0 is passed', () => {
+      const actual = isRequired(0)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when "something" is passed', () => {
+      const actual = isRequired('something')
+      assert.isUndefined(actual)
+    })
+    it('should return error when null is passed', () => {
+      const actual = isRequired(null)
+      assert.isOk(actual)
+    })
+    it('should return error when undefined is passed', () => {
+      const actual = isRequired(undefined)
+      assert.isOk(actual)
+    })
+    it('should return undefined when false is passed', () => {
+      const actual = isRequired(false)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when true is passed', () => {
+      const actual = isRequired(true)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#isBoolean()', () => {
+    it('should return error when "true" is passed"', () => {
+      const actual = isBoolean('true')
+      assert.isOk(actual)
+    })
+    it('should return an error when "false" is passed', () => {
+      const actual = isBoolean('false')
+      assert.isOk(actual)
+    })
+    it('should return undefined when true is passed"', () => {
+      const actual = isBoolean(true)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined when false is passed', () => {
+      const actual = isBoolean(false)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#maxNumber()', () => {
+    it('should return error if max=5 and value="hello world"', () => {
+      const actual = maxNumber(5)('hello world')
+      assert.isOk(actual)
+    })
+    it('should return error if max=5 and value=6', () => {
+      const actual = maxNumber(5)(6)
+      assert.isOk(actual)
+    })
+    it('should return undefined if max=5 and value=5', () => {
+      const actual = maxNumber(5)(5)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if max=5 and value=4', () => {
+      const actual = maxNumber(5)(4)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#minNumber()', () => {
+    it('should return error if min=5 and value="hello world"', () => {
+      const actual = minNumber(5)('hello world')
+      assert.isOk(actual)
+    })
+    it('should return error if min=5 and value=4', () => {
+      const actual = minNumber(5)(4)
+      assert.isOk(actual)
+    })
+    it('should return undefined if min=5 and value=4', () => {
+      const actual = minNumber(5)(5)
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if min=5 and value=6', () => {
+      const actual = minNumber(5)(6)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#choices()', () => {
+    it('should return an error if choices are [1,2,3] and value is 4', () => {
+      const actual = choices([1, 2, 3])(4)
+      assert.isOk(actual)
+    })
+    it('should return undefined if choices are [1,2,3] and value is 1', () => {
+      const actual = choices([1, 2, 3])(1)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#minTextLength()', () => {
+    it('should return error if min=5 and value=5', () => {
+      const actual = minTextLength(5)(5)
+      assert.isOk(actual)
+    })
+    it('should return error if length=5 and value="asdf"', () => {
+      const actual = minTextLength(5)('asdf')
+      assert.isOk(actual)
+    })
+    it('should return undefined if length=5 and value="hello"', () => {
+      const actual = minTextLength(5)('hello')
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if length=5 and value="hello world"', () => {
+      const actual = minTextLength(5)('hello world')
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#maxTextLength()', () => {
+    it('should return error if max=5 and value=5', () => {
+      const actual = maxTextLength(5)(5)
+      assert.isOk(actual)
+    })
+    it('should return error if length=5 and value="hello world"', () => {
+      const actual = maxTextLength(5)('hello world')
+      assert.isOk(actual)
+    })
+    it('should return undefined if length=5 and value="hello"', () => {
+      const actual = maxTextLength(5)('hello')
+      assert.isUndefined(actual)
+    })
+    it('should return undefined if length=5 and value="asdf"', () => {
+      const actual = maxTextLength(5)('asdf')
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#meetsRegex()', () => {
+    it('should return an error with regex=/asdf/ flags="g" and value="hello world"', () => {
+      const actual = meetsRegex(/asdf/, 'g')('hello world')
+      assert.isOk(actual)
+    })
+    it('should return undefined with regex=/asdf/ flags="g" and value="hello asdf world"', () => {
+      const actual = meetsRegex(/asdf/, 'g')('asdf')
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#aggregateValidator()', () => {
+    it('should return two errors when two validators are passed, and the value fails both', async () => {
+      const validators = [minTextLength(10), isNumber]
+      const value = 'asdf'
+      const actual = (await aggregateValidator(validators)('asdf')).length
+      const expected = 2
+      assert.equal(actual, expected)
+    })
+    it('should return one error when one validator is passed, and the value fails', async () => {
+      const validators = minTextLength(10)
+      const value = 'asdf'
+      const actual = (await aggregateValidator(validators)('asdf')).length
+      const expected = 1
+      assert.equal(actual, expected)
+    })
+  })
+  describe('#emptyValidator()', () => {
+    it('should return an empty array with a value of 1', () => {
+      const actual = emptyValidator(1).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of "1"', () => {
+      const actual = emptyValidator('1').length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of true', () => {
+      const actual = emptyValidator(true).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of false', () => {
+      const actual = emptyValidator(false).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should return an empty array with a value of undefined', () => {
+      const actual = emptyValidator(undefined).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+  })
+  describe('#isInteger()', () => {
+    it('should return an error with a value of "1"', () => {
+      const actual = isInteger('1')
+      assert.isOk(actual)
+    })
+    it('should return undefined with a value of 1', () => {
+      const actual = isInteger(1)
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#createModelValidator()', () => {
+    it('should throw an exception if instance is null', () => {
+      const modelValidator = sinon.stub().returns(undefined)
+      const properties = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            name: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(properties, [modelValidator])
+      assert.isRejected(validator())
+    })
+    it('should call the model validator passed in', async () => {
+      const modelValidator = sinon.stub().returns(undefined)
+      const testModel3 = createTestModel3([modelValidator])
+      const properties = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            name: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(properties, [modelValidator])
+      await validator(
+        testModel3.create({
+          id: 'test-id',
+          name: 'my-name',
+        })
+      )
+      sinon.assert.calledOnce(modelValidator)
+    })
+    it('should pass the instance into the validator as the first argument', async () => {
+      const modelValidator = sinon.stub().returns(undefined)
+      const testModel3 = createTestModel3([modelValidator])
+      const properties = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            name: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(properties, [modelValidator])
+      const instance = testModel3.create({
+        id: 'test-id',
+        name: 'my-name',
+      })
+      await validator(instance)
+
+      const actual = modelValidator.getCall(0).args[0]
+      const expected = instance
+      assert.deepEqual(actual, expected)
+    })
+    it('should pass the instance data into the validator as the second argument', async () => {
+      const modelValidator = sinon.stub().returns(undefined)
+      const testModel3 = createTestModel3([modelValidator])
+      const properties = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            name: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(properties, [modelValidator])
+      const instance = testModel3.create({
+        id: 'test-id',
+        name: 'my-name',
+      })
+      const expected = await instance.functions.toObj()
+      await validator(instance)
+
+      const actual = modelValidator.getCall(0).args[1]
+      assert.deepEqual(actual, expected)
+    })
+    it('should return a overall: ["my-validation-error"] when the model validator returns "my-validation-error"', async () => {
+      const modelValidator = sinon.stub().returns('my-validation-error')
+      const testModel3 = createTestModel3([modelValidator])
+      const properties = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            name: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(properties, [modelValidator])
+      const instance = testModel3.create({
+        id: 'test-id',
+        name: 'my-name',
+      })
+      const actual = await validator(instance)
+      const expected = {
+        overall: ['my-validation-error'],
+      }
+      assert.deepEqual(actual, expected)
+    })
+    it('should return no errors when two model validators return undefined', async () => {
+      const modelValidator1 = sinon.stub().resolves(undefined)
+      const modelValidator2 = sinon.stub().resolves(undefined)
+      const testModel3 = createTestModel3([modelValidator1, modelValidator2])
+      const properties = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            name: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(properties, [
+        modelValidator1,
+        modelValidator2,
+      ])
+      const instance = testModel3.create({
+        id: 'test-id',
+        name: 'my-name',
+      })
+      const actual = await validator(instance)
+      const expected = {}
+      assert.deepEqual(actual, expected)
+    })
+    it('should use both functions.validate for two objects', async () => {
+      const propertys = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            type: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(propertys)
+      const testModel3 = Model('Model', {})
+      const instance = testModel3.create({
+        id: 'test-id',
+        name: 'my-name',
+      })
+      await validator(instance)
+      sinon.assert.calledOnce(propertys.functions.validators.id)
+      sinon.assert.calledOnce(propertys.functions.validators.type)
+    })
+    it('should run a validators.model() function', async () => {
+      const propertys = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            type: sinon.stub().returns(undefined),
+            model: sinon.stub().returns(undefined),
+          },
+        },
+      }
+      const validator = createModelValidator(propertys)
+      const testModel3 = Model('Model', {})
+      const instance = testModel3.create({
+        id: 'test-id',
+        name: 'my-name',
+      })
+      await validator(instance)
+      sinon.assert.called(propertys.functions.validators.model)
+    })
+    it('should combine results for both functions.validators for two objects that error', async () => {
+      const propertys = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns('error1'),
+            type: sinon.stub().returns('error2'),
+          },
+        },
+      }
+      const validator = createModelValidator(propertys)
+      const testModel3 = Model('Model', {})
+      const instance = testModel3.create({
+        id: 'test-id',
+        type: 'my-name',
+      })
+      const actual = await validator(instance)
+      const expected = {
+        id: 'error1',
+        type: 'error2',
+      }
+      assert.deepEqual(actual, expected)
+    })
+    it('should take the error of the one of two functions', async () => {
+      const propertys = {
+        functions: {
+          validators: {
+            id: sinon.stub().returns(undefined),
+            type: sinon.stub().returns('error2'),
+          },
+        },
+      }
+      const validator = createModelValidator(propertys)
+      const testModel3 = Model('Model', {})
+      const instance = testModel3.create({
+        id: 'test-id',
+        type: 'my-name',
+      })
+      const actual = await validator(instance)
+      const expected = {
+        type: 'error2',
+      }
+      assert.deepEqual(actual, expected)
+    })
+  })
+  describe('#createPropertyValidator()', () => {
+    it('should not include isRequired if required=false, returning []', async () => {
+      const validator = createPropertyValidator({ required: false })
+      const actual = await validator(null)
+      const expected = []
+      assert.deepEqual(actual, expected)
+    })
+    it('should return [] if no configs are provided', async () => {
+      const validator = createPropertyValidator({})
+      const actual = await validator(null)
+      const expected = []
+      assert.deepEqual(actual, expected)
+    })
+    it('should use isRequired if required=false, returning one error', async () => {
+      const validator = createPropertyValidator({ required: true })
+      const actual = await validator(null)
+      const expected = 1
+      assert.equal(actual.length, expected)
+    })
+    it('should use validators.isRequired returning one error', async () => {
+      const validator = createPropertyValidator({ validators: [isRequired] })
+      const actual = await validator(null)
+      const expected = 1
+      assert.equal(actual.length, expected)
+    })
+  })
+  describe('#isArray()', () => {
+    it('should return an error for null', () => {
+      const actual = isArray(null)
+      assert.isOk(actual)
+    })
+    it('should return an error for undefined', () => {
+      const actual = isArray(undefined)
+      assert.isOk(actual)
+    })
+    it('should return an error for 1', () => {
+      const actual = isArray(1)
+      assert.isOk(actual)
+    })
+    it('should return an error for "1"', () => {
+      const actual = isArray('1')
+      assert.isOk(actual)
+    })
+    it('should return undefined for [1,2,3]', () => {
+      const actual = isArray([1, 2, 3])
+      assert.isUndefined(actual)
+    })
+    it('should return undefined for []', () => {
+      const actual = isArray([])
+      assert.isUndefined(actual)
+    })
+  })
+  describe('#arrayType()', () => {
+    describe('#(object)()', () => {
+      it('should return an error for null, even though its an object, its not an array', () => {
+        const actual = arrayType('object')(null)
+        assert.isOk(actual)
+      })
+      it('should return an error for 1', () => {
+        const actual = arrayType('object')(1)
+        assert.isOk(actual)
+      })
+      it('should return undefined for [{}]', () => {
+        const actual = arrayType('object')([{}])
+        assert.isUndefined(actual)
+      })
+    })
+    describe('#(integer)()', () => {
+      it('should return an error for null', () => {
+        const actual = arrayType(TYPE_PRIMATIVES.integer)(null)
+        assert.isOk(actual)
+      })
+      it('should return an error for undefined', () => {
+        const actual = arrayType(TYPE_PRIMATIVES.integer)(undefined)
+        assert.isOk(actual)
+      })
+      it('should return an error for 1', () => {
+        const actual = arrayType(TYPE_PRIMATIVES.integer)(1)
+        assert.isOk(actual)
+      })
+      it('should return an error for "1"', () => {
+        const actual = arrayType(TYPE_PRIMATIVES.integer)('1')
+        assert.isOk(actual)
+      })
+      it('should return undefined for [1,2,3]', () => {
+        const actual = arrayType(TYPE_PRIMATIVES.integer)([1, 2, 3])
+        assert.isUndefined(actual)
+      })
+      it('should return an error for [1,"2",3]', () => {
+        const actual = arrayType(TYPE_PRIMATIVES.integer)([1, '2', 3])
+        assert.isOk(actual)
+      })
+    })
+  })
+})

package/constants.d.ts

@@ -1,14 +0,0 @@
-declare enum PROPERTY_TYPES {
-    UniqueId = "UniqueId",
-    DateProperty = "DateProperty",
-    ArrayProperty = "ArrayProperty",
-    ReferenceProperty = "ReferenceProperty",
-    IntegerProperty = "IntegerProperty",
-    TextProperty = "TextProperty",
-    ConstantValueProperty = "ConstantValueProperty",
-    NumberProperty = "NumberProperty",
-    ObjectProperty = "ObjectProperty",
-    EmailProperty = "EmailProperty",
-    BooleanProperty = "BooleanProperty"
-}
-export { PROPERTY_TYPES };

package/constants.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROPERTY_TYPES = void 0;
-var PROPERTY_TYPES;
-(function (PROPERTY_TYPES) {
-    PROPERTY_TYPES["UniqueId"] = "UniqueId";
-    PROPERTY_TYPES["DateProperty"] = "DateProperty";
-    PROPERTY_TYPES["ArrayProperty"] = "ArrayProperty";
-    PROPERTY_TYPES["ReferenceProperty"] = "ReferenceProperty";
-    PROPERTY_TYPES["IntegerProperty"] = "IntegerProperty";
-    PROPERTY_TYPES["TextProperty"] = "TextProperty";
-    PROPERTY_TYPES["ConstantValueProperty"] = "ConstantValueProperty";
-    PROPERTY_TYPES["NumberProperty"] = "NumberProperty";
-    PROPERTY_TYPES["ObjectProperty"] = "ObjectProperty";
-    PROPERTY_TYPES["EmailProperty"] = "EmailProperty";
-    PROPERTY_TYPES["BooleanProperty"] = "BooleanProperty";
-})(PROPERTY_TYPES || (PROPERTY_TYPES = {}));
-exports.PROPERTY_TYPES = PROPERTY_TYPES;
-//# sourceMappingURL=constants.js.map