functional-models 1.0.27 → 1.1.2

package/test/src/{validation.test.js → validation.test.ts}

@@ -1,11 +1,10 @@
-const chai = require('chai')
-const assert = chai.assert
-const chaiAsPromised = require('chai-as-promised')
+import chai from 'chai'
+import chaiAsPromised from 'chai-as-promised'
 chai.use(chaiAsPromised)
-const sinon = require('sinon')
-const { Model } = require('../../src/models')
-const { UniqueId, TextProperty } = require('../../src/properties')
-const {
+import sinon from 'sinon'
+import { BaseModel } from '../../src/models'
+import { TextProperty } from '../../src/properties'
+import {
   isNumber,
   isBoolean,
   isInteger,
@@ -25,236 +24,289 @@ const {
   emptyValidator,
   createModelValidator,
   createPropertyValidator,
-  TYPE_PRIMATIVES,
-} = require('../../src/validation')
+  TYPE_PRIMITIVES,
+} from '../../src/validation'
+import { ModelComponentValidator } from '../../src/interfaces'
+
+const assert = chai.assert
 
-const TestModel1 = Model('TestModel1', {
-  id: UniqueId(),
+const TestModel1 = BaseModel('TestModel1', {
+  properties: {},
 })
 
-const TestModel2 = Model('TestModel2', {
-  id: UniqueId(),
+const TestModel2 = BaseModel('TestModel2', {
+  properties: {},
 })
 
-const createTestModel3 = modelValidators =>
-  Model(
-    'TestModel3',
-    {
-      id: UniqueId(),
+const createTestModel3 = (modelValidators: ModelComponentValidator[]) =>
+  BaseModel<{ name: string }>('TestModel3', {
+    properties: {
       name: TextProperty(),
     },
-    {
-      modelValidators,
-    }
-  )
+    modelValidators,
+  })
+
+type EMPTY_MODEL_TYPE = {}
+const EMPTY_MODEL = BaseModel<EMPTY_MODEL_TYPE>('EmptyModel', {
+  properties: {},
+})
+const EMPTY_MODEL_INSTANCE = EMPTY_MODEL.create({})
 
-describe('/src/validation.js', () => {
+describe('/src/validation.ts', () => {
   describe('#isDate()', () => {
     it('should return an error if value is null', () => {
-      const actual = isDate(null)
+      // @ts-ignore
+      const actual = isDate(null, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error if value is undefined', () => {
-      const actual = isDate(undefined)
+      // @ts-ignore
+      const actual = isDate(undefined, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error object does not have toISOString', () => {
-      const actual = isDate({})
+      // @ts-ignore
+      const actual = isDate({}, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined if a date', () => {
-      const actual = isDate(new Date())
+      const actual = isDate(new Date(), EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
   describe('#referenceTypeMatch()', () => {
-    it('should allow a function for a model', () => {
-      const myModel = TestModel1.create()
-      const actual = referenceTypeMatch(() => TestModel1)(myModel)
+    it('should return an error if undefined is passed as a value', () => {
+      const myModel = TestModel1.create({})
+      const actual = referenceTypeMatch(TestModel1)(
+        // @ts-ignore
+        undefined,
+        EMPTY_MODEL_INSTANCE,
+        {}
+      )
+      assert.isOk(actual)
+    })
+    it('should return an error if null is passed as a value', () => {
+      const myModel = TestModel1.create({})
+      const actual = referenceTypeMatch(TestModel1)(
+        // @ts-ignore
+        null,
+        EMPTY_MODEL_INSTANCE,
+        {}
+      )
+      assert.isOk(actual)
+    })
+    it('should allow a function for a model', async () => {
+      const myModel = EMPTY_MODEL.create({})
+      const actual = referenceTypeMatch<EMPTY_MODEL_TYPE>(() => EMPTY_MODEL)(
+        myModel,
+        myModel,
+        await myModel.toObj()
+      )
       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)
+    it('should validate when the correct object matches the model', async () => {
+      const myModel = EMPTY_MODEL.create({})
+      const actual = referenceTypeMatch<EMPTY_MODEL_TYPE>(EMPTY_MODEL)(
+        myModel,
+        myModel,
+        await myModel.toObj()
+      )
       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)
+      const myModel = EMPTY_MODEL.create({})
+      const actual = referenceTypeMatch(TestModel1)(
+        // @ts-ignore
+        myModel,
+        myModel,
+        {}
+      )
       assert.isOk(actual)
     })
   })
   describe('#isNumber()', () => {
     it('should return an error when empty is passed', () => {
-      const actual = isNumber(null)
+      const actual = isNumber(null, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error when "asdf" is passed', () => {
-      const actual = isNumber('asdf')
+      const actual = isNumber('asdf', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined when 1 is passed', () => {
-      const actual = isNumber(1)
+      const actual = isNumber(1, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return error when "1" is passed', () => {
-      const actual = isNumber('1')
+      const actual = isNumber('1', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
   })
   describe('#isString()', () => {
     it('should return undefined when "1" is passed', () => {
-      const actual = isString('1')
+      const actual = isString('1', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return error when 1 is passed', () => {
-      const actual = isString(1)
+      const actual = isString(1, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
   })
   describe('#isRequired()', () => {
     it('should return undefined when 1 is passed', () => {
-      const actual = isRequired(1)
+      const actual = isRequired(1, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined when a date is passed', () => {
-      const actual = isRequired(new Date())
+      const actual = isRequired(new Date(), EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined when 0 is passed', () => {
-      const actual = isRequired(0)
+      const actual = isRequired(0, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined when "something" is passed', () => {
-      const actual = isRequired('something')
+      const actual = isRequired('something', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return error when null is passed', () => {
-      const actual = isRequired(null)
+      const actual = isRequired(null, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return error when undefined is passed', () => {
-      const actual = isRequired(undefined)
+      const actual = isRequired(undefined, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined when false is passed', () => {
-      const actual = isRequired(false)
+      const actual = isRequired(false, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined when true is passed', () => {
-      const actual = isRequired(true)
+      const actual = isRequired(true, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
   describe('#isBoolean()', () => {
     it('should return error when "true" is passed"', () => {
-      const actual = isBoolean('true')
+      const actual = isBoolean('true', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error when "false" is passed', () => {
-      const actual = isBoolean('false')
+      const actual = isBoolean('false', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined when true is passed"', () => {
-      const actual = isBoolean(true)
+      const actual = isBoolean(true, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined when false is passed', () => {
-      const actual = isBoolean(false)
+      const actual = isBoolean(false, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
   describe('#maxNumber()', () => {
     it('should return error if max=5 and value="hello world"', () => {
-      const actual = maxNumber(5)('hello world')
+      // @ts-ignore
+      const actual = maxNumber(5)('hello world', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return error if max=5 and value=6', () => {
-      const actual = maxNumber(5)(6)
+      const actual = maxNumber(5)(6, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined if max=5 and value=5', () => {
-      const actual = maxNumber(5)(5)
+      const actual = maxNumber(5)(5, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined if max=5 and value=4', () => {
-      const actual = maxNumber(5)(4)
+      const actual = maxNumber(5)(4, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
   describe('#minNumber()', () => {
     it('should return error if min=5 and value="hello world"', () => {
-      const actual = minNumber(5)('hello world')
+      // @ts-ignore
+      const actual = minNumber(5)('hello world', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return error if min=5 and value=4', () => {
-      const actual = minNumber(5)(4)
+      const actual = minNumber(5)(4, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined if min=5 and value=4', () => {
-      const actual = minNumber(5)(5)
+      const actual = minNumber(5)(5, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined if min=5 and value=6', () => {
-      const actual = minNumber(5)(6)
+      const actual = minNumber(5)(6, EMPTY_MODEL_INSTANCE, {})
       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)
+      const actual = choices(['1', '2', '3'])('4', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined if choices are [1,2,3] and value is 1', () => {
-      const actual = choices([1, 2, 3])(1)
+      const actual = choices(['1', '2', '3'])('1', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
   describe('#minTextLength()', () => {
     it('should return error if min=5 and value=5', () => {
-      const actual = minTextLength(5)(5)
+      // @ts-ignore
+      const actual = minTextLength(5)(5, EMPTY_MODEL_INSTANCE, {})
+      assert.isOk(actual)
+    })
+    it('should return error if min=5 and value=5', () => {
+      const actual = minTextLength(5)('5', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return error if length=5 and value="asdf"', () => {
-      const actual = minTextLength(5)('asdf')
+      const actual = minTextLength(5)('asdf', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined if length=5 and value="hello"', () => {
-      const actual = minTextLength(5)('hello')
+      const actual = minTextLength(5)('hello', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined if length=5 and value="hello world"', () => {
-      const actual = minTextLength(5)('hello world')
+      const actual = minTextLength(5)('hello world', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
   describe('#maxTextLength()', () => {
-    it('should return error if max=5 and value=5', () => {
-      const actual = maxTextLength(5)(5)
+    it('should return error if length=5 and value=5', () => {
+      // @ts-ignore
+      const actual = maxTextLength(5)(5, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return error if length=5 and value="hello world"', () => {
-      const actual = maxTextLength(5)('hello world')
+      const actual = maxTextLength(5)('hello world', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined if length=5 and value="hello"', () => {
-      const actual = maxTextLength(5)('hello')
+      const actual = maxTextLength(5)('hello', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined if length=5 and value="asdf"', () => {
-      const actual = maxTextLength(5)('asdf')
+      const actual = maxTextLength(5)('asdf', EMPTY_MODEL_INSTANCE, {})
       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')
+      const actual = meetsRegex(/asdf/, 'g')(
+        'hello world',
+        EMPTY_MODEL_INSTANCE,
+        {}
+      )
       assert.isOk(actual)
     })
     it('should return undefined with regex=/asdf/ flags="g" and value="hello asdf world"', () => {
-      const actual = meetsRegex(/asdf/, 'g')('asdf')
+      const actual = meetsRegex(/asdf/, 'g')('asdf', EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
@@ -262,52 +314,56 @@ describe('/src/validation.js', () => {
     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 actual = (
+        await aggregateValidator(value, validators)(EMPTY_MODEL_INSTANCE, {})
+      ).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 actual = (
+        await aggregateValidator(value, validators)(EMPTY_MODEL_INSTANCE, {})
+      ).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
+    it('should return undefined with a value of 1', () => {
+      const actual = emptyValidator(1, EMPTY_MODEL_INSTANCE, {})
+      const expected = undefined
       assert.equal(actual, expected)
     })
-    it('should return an empty array with a value of "1"', () => {
-      const actual = emptyValidator('1').length
-      const expected = 0
+    it('should return undefined with a value of "1"', () => {
+      const actual = emptyValidator('1', EMPTY_MODEL_INSTANCE, {})
+      const expected = undefined
       assert.equal(actual, expected)
     })
-    it('should return an empty array with a value of true', () => {
-      const actual = emptyValidator(true).length
-      const expected = 0
+    it('should return undefined with a value of true', () => {
+      const actual = emptyValidator(true, EMPTY_MODEL_INSTANCE, {})
+      const expected = undefined
       assert.equal(actual, expected)
     })
-    it('should return an empty array with a value of false', () => {
-      const actual = emptyValidator(false).length
-      const expected = 0
+    it('should return undefined with a value of false', () => {
+      const actual = emptyValidator(false, EMPTY_MODEL_INSTANCE, {})
+      const expected = undefined
       assert.equal(actual, expected)
     })
-    it('should return an empty array with a value of undefined', () => {
-      const actual = emptyValidator(undefined).length
-      const expected = 0
+    it('should return undefined with a value of undefined', () => {
+      const actual = emptyValidator(undefined, EMPTY_MODEL_INSTANCE, {})
+      const expected = undefined
       assert.equal(actual, expected)
     })
   })
   describe('#isInteger()', () => {
     it('should return an error with a value of "1"', () => {
-      const actual = isInteger('1')
+      const actual = isInteger('1', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined with a value of 1', () => {
-      const actual = isInteger(1)
+      const actual = isInteger(1, EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
   })
@@ -315,33 +371,30 @@ describe('/src/validation.js', () => {
     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),
-          },
-        },
+        id: sinon.stub().returns(undefined),
+        name: sinon.stub().returns(undefined),
       }
       const validator = createModelValidator(properties, [modelValidator])
-      assert.isRejected(validator())
+      // @ts-ignore
+      assert.isRejected(validator(undefined, {}))
     })
     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),
-          },
-        },
+        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',
-        })
+        }),
+        {
+          id: 'test-id',
+          name: 'my-name',
+        }
       )
       sinon.assert.calledOnce(modelValidator)
     })
@@ -349,19 +402,15 @@ describe('/src/validation.js', () => {
       const modelValidator = sinon.stub().returns(undefined)
       const testModel3 = createTestModel3([modelValidator])
       const properties = {
-        functions: {
-          validators: {
-            id: sinon.stub().returns(undefined),
-            name: sinon.stub().returns(undefined),
-          },
-        },
+        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)
+      await validator(instance, {})
 
       const actual = modelValidator.getCall(0).args[0]
       const expected = instance
@@ -371,20 +420,16 @@ describe('/src/validation.js', () => {
       const modelValidator = sinon.stub().returns(undefined)
       const testModel3 = createTestModel3([modelValidator])
       const properties = {
-        functions: {
-          validators: {
-            id: sinon.stub().returns(undefined),
-            name: sinon.stub().returns(undefined),
-          },
-        },
+        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 expected = await instance.toObj()
+      await validator(instance, {})
 
       const actual = modelValidator.getCall(0).args[1]
       assert.deepEqual(actual, expected)
@@ -393,19 +438,15 @@ describe('/src/validation.js', () => {
       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),
-          },
-        },
+        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 actual = await validator(instance, {})
       const expected = {
         overall: ['my-validation-error'],
       }
@@ -416,12 +457,8 @@ describe('/src/validation.js', () => {
       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),
-          },
-        },
+        id: sinon.stub().returns(undefined),
+        name: sinon.stub().returns(undefined),
       }
       const validator = createModelValidator(properties, [
         modelValidator1,
@@ -431,182 +468,213 @@ describe('/src/validation.js', () => {
         id: 'test-id',
         name: 'my-name',
       })
-      const actual = await validator(instance)
+      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 properties = {
+        id: sinon.stub().returns(undefined),
+        type: sinon.stub().returns(undefined),
       }
-      const validator = createModelValidator(propertys)
-      const testModel3 = Model('Model', {})
+      const validator = createModelValidator(properties)
+      const testModel3 = BaseModel('Model', { properties: {} })
       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)
+      await validator(instance, {})
+      sinon.assert.calledOnce(properties.id)
+      sinon.assert.calledOnce(properties.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 properties = {
+        id: sinon.stub().returns(undefined),
+        type: sinon.stub().returns(undefined),
+        model: sinon.stub().returns(undefined),
       }
-      const validator = createModelValidator(propertys)
-      const testModel3 = Model('Model', {})
+      const validator = createModelValidator(properties)
+      const testModel3 = BaseModel('Model', { properties: {} })
       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'),
-          },
-        },
+      await validator(instance, {})
+      sinon.assert.called(properties.model)
+    })
+    it('should combine results for both validators for two objects that error', async () => {
+      const properties = {
+        id: sinon.stub().returns(['error1']),
+        type: sinon.stub().returns(['error2']),
       }
-      const validator = createModelValidator(propertys)
-      const testModel3 = Model('Model', {})
+      const validator = createModelValidator(properties)
+      const testModel3 = BaseModel('Model', { properties: {} })
       const instance = testModel3.create({
         id: 'test-id',
         type: 'my-name',
       })
-      const actual = await validator(instance)
+      const actual = await validator(instance, {})
       const expected = {
-        id: 'error1',
-        type: 'error2',
+        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 properties = {
+        id: sinon.stub().returns(undefined),
+        type: sinon.stub().returns(['error2']),
       }
-      const validator = createModelValidator(propertys)
-      const testModel3 = Model('Model', {})
+      const validator = createModelValidator(properties)
+      const testModel3 = BaseModel('Model', { properties: {} })
       const instance = testModel3.create({
         id: 'test-id',
         type: 'my-name',
       })
-      const actual = await validator(instance)
+      const actual = await validator(instance, {})
       const expected = {
-        type: 'error2',
+        type: ['error2'],
       }
       assert.deepEqual(actual, expected)
     })
   })
   describe('#createPropertyValidator()', () => {
+    it('should accept an undefined configuration', async () => {
+      // @ts-ignore
+      const validator = createPropertyValidator(() => null, undefined)
+      const actual = await validator(EMPTY_MODEL_INSTANCE, {})
+      const expected: readonly string[] = []
+      assert.deepEqual(actual, expected)
+    })
+
+    it('should accept unhandled configurations without exception', async () => {
+      const validator = createPropertyValidator(() => null, {
+        // @ts-ignore
+        notarealarg: false,
+      })
+      const actual = await validator(EMPTY_MODEL_INSTANCE, {})
+      const expected: readonly string[] = []
+      assert.deepEqual(actual, expected)
+    })
     it('should not include isRequired if required=false, returning []', async () => {
-      const validator = createPropertyValidator({ required: false })
-      const actual = await validator(null)
-      const expected = []
+      const validator = createPropertyValidator(() => null, { required: false })
+      // @ts-ignore
+      const actual = await validator(null, {})
+      const expected: readonly string[] = []
       assert.deepEqual(actual, expected)
     })
     it('should return [] if no configs are provided', async () => {
-      const validator = createPropertyValidator({})
-      const actual = await validator(null)
-      const expected = []
+      const validator = createPropertyValidator(() => null, {})
+      // @ts-ignore
+      const actual = await validator(null, {})
+      const expected: readonly string[] = []
       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 validator = createPropertyValidator(() => null, { required: true })
+      // @ts-ignore
+      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 validator = createPropertyValidator(() => null, {
+        validators: [isRequired],
+      })
+      // @ts-ignore
+      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)
+      const actual = isArray(null, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error for undefined', () => {
-      const actual = isArray(undefined)
+      const actual = isArray(undefined, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error for 1', () => {
-      const actual = isArray(1)
+      const actual = isArray(1, EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return an error for "1"', () => {
-      const actual = isArray('1')
+      const actual = isArray('1', EMPTY_MODEL_INSTANCE, {})
       assert.isOk(actual)
     })
     it('should return undefined for [1,2,3]', () => {
-      const actual = isArray([1, 2, 3])
+      const actual = isArray([1, 2, 3], EMPTY_MODEL_INSTANCE, {})
       assert.isUndefined(actual)
     })
     it('should return undefined for []', () => {
-      const actual = isArray([])
+      const actual = isArray([], EMPTY_MODEL_INSTANCE, {})
       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)
+        const actual = arrayType('object')(null, EMPTY_MODEL_INSTANCE, {})
         assert.isOk(actual)
       })
       it('should return an error for 1', () => {
-        const actual = arrayType('object')(1)
+        const actual = arrayType('object')(1, EMPTY_MODEL_INSTANCE, {})
         assert.isOk(actual)
       })
       it('should return undefined for [{}]', () => {
-        const actual = arrayType('object')([{}])
+        const actual = arrayType('object')([{}], EMPTY_MODEL_INSTANCE, {})
         assert.isUndefined(actual)
       })
     })
     describe('#(integer)()', () => {
       it('should return an error for null', () => {
-        const actual = arrayType(TYPE_PRIMATIVES.integer)(null)
+        const actual = arrayType(TYPE_PRIMITIVES.integer)(
+          null,
+          EMPTY_MODEL_INSTANCE,
+          {}
+        )
         assert.isOk(actual)
       })
       it('should return an error for undefined', () => {
-        const actual = arrayType(TYPE_PRIMATIVES.integer)(undefined)
+        const actual = arrayType(TYPE_PRIMITIVES.integer)(
+          undefined,
+          EMPTY_MODEL_INSTANCE,
+          {}
+        )
         assert.isOk(actual)
       })
       it('should return an error for 1', () => {
-        const actual = arrayType(TYPE_PRIMATIVES.integer)(1)
+        const actual = arrayType(TYPE_PRIMITIVES.integer)(
+          1,
+          EMPTY_MODEL_INSTANCE,
+          {}
+        )
         assert.isOk(actual)
       })
       it('should return an error for "1"', () => {
-        const actual = arrayType(TYPE_PRIMATIVES.integer)('1')
+        const actual = arrayType(TYPE_PRIMITIVES.integer)(
+          '1',
+          EMPTY_MODEL_INSTANCE,
+          {}
+        )
         assert.isOk(actual)
       })
       it('should return undefined for [1,2,3]', () => {
-        const actual = arrayType(TYPE_PRIMATIVES.integer)([1, 2, 3])
+        const actual = arrayType(TYPE_PRIMITIVES.integer)(
+          [1, 2, 3],
+          EMPTY_MODEL_INSTANCE,
+          {}
+        )
         assert.isUndefined(actual)
       })
       it('should return an error for [1,"2",3]', () => {
-        const actual = arrayType(TYPE_PRIMATIVES.integer)([1, '2', 3])
+        const actual = arrayType(TYPE_PRIMITIVES.integer)(
+          [1, '2', 3],
+          EMPTY_MODEL_INSTANCE,
+          {}
+        )
         assert.isOk(actual)
       })
     })