functional-models 1.0.2 → 1.0.3

package/.eslintignore

@@ -1,3 +1,4 @@
 dist/
 node_modules/
 test/
+features/

package/.github/workflows/feature.yml

@@ -0,0 +1,26 @@
+name: Feature Tests
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 15.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install dependencies
+        run: npm install
+      - name: Run Cucumber Tests
+        run: npm run feature-tests

package/.github/workflows/{ci.yml → ut.yml}

@@ -1,14 +1,13 @@
-name: CI
+name: Unit Tests
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     strategy:
@@ -23,11 +22,11 @@ jobs:
           node-version: ${{ matrix.node-version }}
       - name: Install dependencies
         run: npm install
-      - run: npm test
-      - run: npm run coverage 
+      - name: Run Unit Tests
+        run: npm test
+      - run: npm run coverage
 
       - name: Coveralls
         uses: coverallsapp/github-action@master
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
-

package/.prettierignore

@@ -1,4 +1,5 @@
 node_modules/
+*.json
 dist/
 *.html
 build

package/README.md

@@ -1,11 +1,12 @@
 # Functional Models
-![CI](https://github.com/monolithst/functional-models/actions/workflows/ci.yml/badge.svg)
+
+![Unit Tests](https://github.com/monolithst/functional-models/actions/workflows/ut.yml/badge.svg?branch=master)
+![Feature Tests](https://github.com/monolithst/functional-models/actions/workflows/feature.yml/badge.svg?branch=master)
 [![Coverage Status](https://coveralls.io/repos/github/monolithst/functional-models/badge.svg?branch=master)](https://coveralls.io/github/monolithst/functional-models?branch=master)
 
-Love functional javascript but still like composing objects/models? This is the library for you. 
+Love functional javascript but still like composing objects/models? This is the library for you.
 This library empowers the creation of pure JavaScript function based models that can be used on a client, a web frontend, and/or a backend all the same time. Use this library to create readable, read-only, models.
 
-
 ## Example Usage
 
     const {
@@ -51,5 +52,3 @@ This library empowers the creation of pure JavaScript function based models that
     console.log(sameTruck.getModel())  // 'F-150'
     console.log(sameTruck.getColor())  // 'White'
     console.log(sameTruck.getYear())   // 2013
-
-

package/features/stepDefinitions/steps.js

@@ -0,0 +1,56 @@
+const assert = require('chai').assert
+const flatMap = require('lodash/flatMap')
+const { Given, When, Then } = require('@cucumber/cucumber')
+
+const { smartObject, property, named, typed } = require('../../index')
+
+const MODEL_DEFINITIONS = {
+  TestModel1: ({ name, type, flag }) =>
+    smartObject([
+      named({ required: true })(name),
+      typed({ required: true, isString: 'true' })(type),
+      property('flag', { required: true, isNumber: true })(flag),
+    ]),
+}
+
+const MODEL_INPUT_VALUES = {
+  TestModel1a: {
+    name: 'my-name',
+    type: 1,
+    flag: '1',
+  },
+  TestModel1b: {
+    name: 'my-name',
+    type: 'a-type',
+    flag: 1,
+  },
+}
+
+Given(
+  'the {word} has been created, with {word} inputs provided',
+  function (modelDefinition, modelInputValues) {
+    const def = MODEL_DEFINITIONS[modelDefinition]
+    const input = MODEL_INPUT_VALUES[modelInputValues]
+    if (!def) {
+      throw new Error(`${modelDefinition} did not result in a definition`)
+    }
+    if (!input) {
+      throw new Error(`${modelInputValues} did not result in an input`)
+    }
+    this.instance = def(input)
+  }
+)
+
+When('functions.validate is called', function () {
+  return this.instance.functions.validate.object().then(x => {
+    this.errors = x
+  })
+})
+
+Then('an array of {int} errors is shown', function (errorCount) {
+  const errors = flatMap(Object.values(this.errors))
+  if (errors.length !== errorCount) {
+    console.error(this.errors)
+  }
+  assert.equal(errors.length, errorCount)
+})

package/features/validation.feature

@@ -0,0 +1,12 @@
+Feature: Validation
+
+  Scenario: Creating TestModel1 with required arguments but not having them.
+    Given the TestModel1 has been created, with TestModel1a inputs provided
+    When functions.validate is called
+    Then an array of 2 errors is shown
+
+  Scenario: Creating TestModel1 with required arguments and having them.
+    Given the TestModel1 has been created, with TestModel1b inputs provided
+    When functions.validate is called
+    Then an array of 0 errors is shown
+

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "functional-models",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A library for creating JavaScript function based models.",
   "main": "index.js",
   "scripts": {
     "test": "nyc --all mocha --recursive ./test/**/*.test.js",
+    "feature-tests": "./node_modules/@cucumber/cucumber/bin/cucumber-js",
     "coverage": "nyc --all --reporter=lcov npm test"
   },
   "repository": {
@@ -26,11 +27,16 @@
   },
   "homepage": "https://github.com/monolithst/functional-models#readme",
   "nyc": {
-    "all": true
+    "all": true,
+    "exclude": [
+      "features/stepDefinitions/*",
+      "test/*"
+    ]
   },
   "devDependencies": {
     "babel-eslint": "^10.1.0",
     "chai": "^4.3.0",
+    "cucumber": "^7.0.0-rc.0",
     "eslint": "^7.19.0",
     "eslint-config-prettier": "^7.2.0",
     "eslint-plugin-functional": "^3.2.1",
@@ -42,6 +48,7 @@
   },
   "dependencies": {
     "get-random-values": "^1.2.2",
-    "lazy-property": "^1.0.0"
+    "lazy-property": "^1.0.0",
+    "lodash": "^4.17.21"
   }
 }

package/src/dates.js

@@ -2,7 +2,7 @@ const { property } = require('./properties')
 
 const _autonowDate = ({ key }) => (date = null, ...args) => {
   const theDate = date ? date : new Date()
-  return property(key, theDate, ...args)
+  return property(key, ...args)(theDate)
 }
 const lastModifiedProperty = _autonowDate({ key: 'lastModified' })
 const lastUpdatedProperty = _autonowDate({ key: 'lastUpdated' })

package/src/objects.js

@@ -1,23 +1,49 @@
+const merge = require('lodash/merge')
+const get = require('lodash/get')
 const { toJson } = require('./serialization')
 
+const findValidateFunctions = smartObject => {
+  return Object.entries(get(smartObject, 'functions.validate', {}))
+}
+
 const smartObject = (
   internals,
   { metaProperties = {}, functions = {} } = {}
 ) => {
   const realInternals = Array.isArray(internals)
-    ? internals.reduce((acc, obj) => ({ ...acc, ...obj }), {})
+    ? internals.reduce((acc, obj) => merge(acc, obj), {})
     : internals
 
-  return {
-    ...(metaProperties ? { meta: { ...metaProperties } } : {}),
-    ...realInternals,
+  const passedInData = merge(
+    metaProperties ? { meta: { ...metaProperties } } : {},
+    realInternals,
+    { functions }
+  )
+  const internalFunctions = {
     functions: {
       ...functions,
       toJson: toJson(realInternals),
+      validate: {
+        object: async () => {
+          const keysAndfunctions = findValidateFunctions(realInternals)
+          const data = await Promise.all(
+            keysAndfunctions.map(async ([key, validator]) => {
+              return [key, await validator()]
+            })
+          )
+          return data
+            .filter(([_, errors]) => Boolean(errors) && errors.length > 0)
+            .reduce((acc, [key, errors]) => {
+              return { ...acc, [key]: errors }
+            }, {})
+        },
+      },
     },
   }
+  return merge(passedInData, internalFunctions)
 }
 
 module.exports = {
   smartObject,
+  findValidateFunctions,
 }

package/src/properties.js

@@ -1,27 +1,19 @@
 const { createPropertyTitle, createUuid } = require('./utils')
+const { createPropertyValidate } = require('./validation')
 
-const property = (key, arg) => {
-  if (typeof key === 'object') {
-    return Object.entries(key).reduce((acc, [keyName, realValue]) => {
-      const propertyKey = createPropertyTitle(keyName)
-      return {
-        ...acc,
-        [propertyKey]: () => realValue,
-      }
-    }, {})
-  }
+const property = (key, config = {}) => arg => {
   const method = typeof arg === 'function' ? arg : () => arg
   const propertyKey = createPropertyTitle(key)
   return {
     [propertyKey]: method,
+    ...createPropertyValidate(key, config)(arg),
   }
 }
 
-const named = name => property('Name', name)
-const typed = type => property('Type', type)
-const uniqueId = (id = null) => {
-  return property('id', id || createUuid())
-}
+const named = config => property('Name', config)
+const typed = config => property('Type', config)
+const uniqueId = config => (id = null) =>
+  property('id', config)(id || createUuid(), config)
 
 module.exports = {
   property,

package/src/utils.js

@@ -55,4 +55,5 @@ module.exports = {
   loweredTitleCase,
   lazyValue,
   createPropertyTitle,
+  toTitleCase,
 }

package/src/validation.js

@@ -0,0 +1,165 @@
+const isEmpty = require('lodash/isEmpty')
+const flatMap = require('lodash/flatMap')
+
+const _trueOrError = (method, error) => value => {
+  if (method(value) === false) {
+    return error
+  }
+  return undefined
+}
+
+const _typeOrError = (type, errorMessage) => value => {
+  if (typeof value !== type) {
+    return errorMessage
+  }
+  return undefined
+}
+
+const isType = type => value => {
+  return _typeOrError(type, `Must be a ${type}`)(value)
+}
+const isNumber = isType('number')
+const isInteger = _trueOrError(v => {
+  const numberError = isNumber(v)
+  if (numberError) {
+    return false
+  }
+  return Number.isNaN(parseInt(v, 10)) === false
+}, 'Must be an integer')
+
+const isBoolean = isType('boolean')
+const isString = isType('string')
+
+const meetsRegex = (
+  regex,
+  flags,
+  errorMessage = 'Format was invalid'
+) => value => {
+  const reg = new RegExp(regex, flags)
+  return _trueOrError(v => reg.test(v), errorMessage)(value)
+}
+
+const choices = choiceArray => value => {
+  if (choiceArray.includes(value) === false) {
+    return 'Not a valid choice'
+  }
+  return undefined
+}
+
+const isRequired = value => {
+  if (value === true || value === false) {
+    return undefined
+  }
+  if (isNumber(value) === undefined) {
+    return undefined
+  }
+  return isEmpty(value) ? 'A value is required' : undefined
+}
+
+const maxNumber = max => value => {
+  const numberError = isNumber(value)
+  if (numberError) {
+    return numberError
+  }
+  if (value > max) {
+    return `The maximum is ${max}`
+  }
+  return undefined
+}
+
+const minNumber = min => value => {
+  const numberError = isNumber(value)
+  if (numberError) {
+    return numberError
+  }
+  if (value < min) {
+    return `The minimum is ${min}`
+  }
+  return undefined
+}
+
+const maxTextLength = max => value => {
+  const stringError = isString(value)
+  if (stringError) {
+    return stringError
+  }
+  if (value.length > max) {
+    return `The maximum length is ${max}`
+  }
+  return undefined
+}
+
+const minTextLength = min => value => {
+  const stringError = isString(value)
+  if (stringError) {
+    return stringError
+  }
+  if (value.length < min) {
+    return `The minimum length is ${min}`
+  }
+  return undefined
+}
+
+const aggregateValidator = methodOrMethods => async value => {
+  const toDo = Array.isArray(methodOrMethods)
+    ? methodOrMethods
+    : [methodOrMethods]
+  const values = await Promise.all(
+    toDo.map(method => {
+      return method(value)
+    })
+  )
+  return values.filter(x => x)
+}
+
+const emptyValidator = () => []
+
+const _boolChoice = method => value => {
+  return value ? method : undefined
+}
+
+const CONFIG_TO_VALIDATE_METHOD = {
+  required: _boolChoice(isRequired),
+  isInteger: _boolChoice(isInteger),
+  isNumber: _boolChoice(isNumber),
+  isString: _boolChoice(isString),
+}
+
+const createPropertyValidate = (key, config) => value => {
+  const validators = [
+    ...Object.entries(config).map(([key, value]) => {
+      return (CONFIG_TO_VALIDATE_METHOD[key] || (() => undefined))(value)
+    }),
+    ...(config.validators ? config.validators : []),
+  ].filter(x => x)
+  const validator =
+    validators.length > 0 ? aggregateValidator(validators) : emptyValidator
+  return {
+    functions: {
+      validate: {
+        [key]: async () => {
+          const errors = await validator(value)
+          return flatMap(errors)
+        },
+      },
+    },
+  }
+}
+
+module.exports = {
+  isNumber,
+  isBoolean,
+  isString,
+  isInteger,
+  isType,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  emptyValidator,
+  createPropertyValidate,
+}

package/test/src/objects.test.js

@@ -3,6 +3,26 @@ const { smartObject } = require('../../src/objects')
 
 describe('/src/objects.js', () => {
   describe('#smartObject()', () => {
+    it('should use the functions.validation of two objects correctly', async () => {
+      const instance = smartObject([
+        { functions: { validate: { property1: () => ['failed1'] } } },
+        { functions: { validate: { property2: () => ['failed2'] } } },
+      ])
+      const actual = await instance.functions.validate.object()
+      const expected = {
+        property1: ['failed1'],
+        property2: ['failed2'],
+      }
+      assert.deepEqual(actual, expected)
+    })
+    it('should combine functions.validate of two objects correctly', () => {
+      const instance = smartObject([
+        { functions: { validate: { property1: () => {} } } },
+        { functions: { validate: { property2: () => {} } } },
+      ])
+      assert.isOk(instance.functions.validate.property1)
+      assert.isOk(instance.functions.validate.property2)
+    })
     it('should allow a single value for internals', async () => {
       const instance = smartObject({
         key: 'value',

package/test/src/properties.test.js

@@ -5,41 +5,33 @@ describe('/src/properties.js', () => {
   describe('#uniqueId()', () => {
     describe('#getId()', () => {
       it('should use the id passed in', () => {
-        const actual = uniqueId('passed-in').getId()
+        const actual = uniqueId()('passed-in').getId()
         const expected = 'passed-in'
         assert.equal(actual, expected)
       })
       it('should create an id if null is passed in', () => {
-        const actual = uniqueId().getId()
+        const actual = uniqueId()().getId()
         assert.isOk(actual)
       })
     })
   })
   describe('#property()', () => {
     it('should take an arg that is a function', async () => {
-      const instance = property('property', () => 'hello world')
+      const instance = property('property')(() => 'hello world')
       const actual = await instance.getProperty()
     })
     it('should return an object that has a key "getKey" that returns "value" when "Key" is passed in', () => {
-      const actual = property('Key', 'value')
+      const actual = property('Key')('value')
       const [actualKey, actualValue] = Object.entries(actual)[0]
       const expectedKey = 'getKey'
       const expectedValue = 'value'
       assert.equal(actualKey, expectedKey)
       assert.equal(actualValue(), expectedValue)
     })
-    it('should return an object that has a key "getUpperCased" that returns "value" when {upperCased: "value"} is passed in', () => {
-      const actual = property({ upperCased: 'value' })
-      const [actualKey, actualValue] = Object.entries(actual)[0]
-      const expectedKey = 'getUpperCased'
-      const expectedValue = 'value'
-      assert.equal(actualKey, expectedKey)
-      assert.equal(actualValue(), expectedValue)
-    })
   })
   describe('#named()', () => {
     it('should return an object with a key "getName" that returns "name" when "name" is passed in', () => {
-      const actual = named('name')
+      const actual = named()('name')
       const [actualKey, actualValue] = Object.entries(actual)[0]
       const expectedKey = 'getName'
       const expectedValue = 'name'
@@ -49,7 +41,7 @@ describe('/src/properties.js', () => {
   })
   describe('#typed()', () => {
     it('should return an object with a key "getType" that returns "theType" when "theType" is passed in', () => {
-      const actual = typed('theType')
+      const actual = typed()('theType')
       const [actualKey, actualValue] = Object.entries(actual)[0]
       const expectedKey = 'getType'
       const expectedValue = 'theType'

package/test/src/references.test.js

@@ -55,7 +55,7 @@ describe('/src/references.js', () => {
       assert.deepEqual(actual, expected)
     })
     it('should take the smartObject as a value', async () => {
-      const input = ['MyObject', smartObject([uniqueId('obj-id')])]
+      const input = ['MyObject', smartObject([uniqueId()('obj-id')])]
       const instance = smartObjectReference({})(...input)
       const classThing = await instance.getMyObject()
       const actual = await (await instance.getMyObject()).getId()
@@ -64,7 +64,7 @@ describe('/src/references.js', () => {
     })
     describe('#functions.toJson()', () => {
       it('should use the getId of the smartObject passed in when toJson is called', async () => {
-        const input = ['MyObject', smartObject([uniqueId('obj-id')])]
+        const input = ['MyObject', smartObject([uniqueId()('obj-id')])]
         const instance = smartObjectReference({})(...input)
         const actual = await (await instance.getMyObject()).functions.toJson()
         const expected = 'obj-id'

package/test/src/validation.test.js

@@ -0,0 +1,271 @@
+const assert = require('chai').assert
+const {
+  isNumber,
+  isBoolean,
+  isInteger,
+  isString,
+  isRequired,
+  maxNumber,
+  minNumber,
+  choices,
+  maxTextLength,
+  minTextLength,
+  meetsRegex,
+  aggregateValidator,
+  emptyValidator,
+  createPropertyValidate,
+} = require('../../src/validation')
+
+describe('/src/validation.js', () => {
+  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 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('#createPropertyValidate()', () => {
+    it('should result in {}.functions.validate.myProperty when key="myProperty"', () => {
+      const actual = createPropertyValidate('myProperty', {})('value')
+      assert.isOk(actual.functions.validate.myProperty)
+    })
+    it('should create a isRequired validator when config contains isRequired=true', async () => {
+      const property = createPropertyValidate('myProperty', { required: true })(
+        null
+      )
+      const actual = (await property.functions.validate.myProperty()).length
+      const expected = 1
+      assert.equal(actual, expected)
+    })
+    it('should not use isRequired validator when config contains isRequired=false', async () => {
+      const property = createPropertyValidate('myProperty', {
+        required: false,
+      })(null)
+      const actual = (await property.functions.validate.myProperty()).length
+      const expected = 0
+      assert.equal(actual, expected)
+    })
+    it('should use the validators passed in', async () => {
+      const property = createPropertyValidate('myProperty', {
+        validators: [maxTextLength(5)],
+      })('hello world')
+      const actual = (await property.functions.validate.myProperty()).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)
+    })
+  })
+})