functional-models 1.0.27 → 1.1.2

package/stepDefinitions/tssteps.ts

@@ -0,0 +1,107 @@
+import { Given, When, Then } from '@cucumber/cucumber'
+import { assert } from 'chai'
+import { BaseModel } from '../src/models'
+import { WrapperInstanceMethod, WrapperModelMethod } from '../src/methods'
+import {
+  Model,
+  FunctionalModel,
+  ModelInstanceMethodTyped,
+  ModelMethodTyped,
+  ModelInstanceInputData,
+  Nullable,
+} from '../src/interfaces'
+import { ObjectProperty, TextProperty, UniqueId } from '../src/properties'
+
+type MyTSType = {
+  name: string
+  data: FunctionalModel
+  notRequired?: Nullable<string>
+  myMethod: ModelInstanceMethodTyped<MyTSType>
+  myModelMethod: ModelMethodTyped<MyTSType>
+}
+
+const TE_FULL_TEST = () => {
+  const m = BaseModel<MyTSType>('TSFullTests', {
+    properties: {
+      id: UniqueId({ value: 'my-unique-id' }),
+      name: TextProperty({ required: true }),
+      data: ObjectProperty({}),
+      notRequired: TextProperty({}),
+    },
+    instanceMethods: {
+      myMethod: WrapperInstanceMethod<MyTSType>((instance, args) => {
+        return 'InstanceMethod'
+      }),
+    },
+    modelMethods: {
+      myModelMethod: WrapperModelMethod<MyTSType>((model, args) => {
+        return 'ModelMethod'
+      }),
+    },
+  })
+  return m
+}
+
+const TE_FULL_TEST_1 = () => {
+  return {
+    id: 'my-unique-id',
+    name: 'My name',
+    data: { my: 'data' },
+    notRequired: null,
+  }
+}
+
+const DATA_SET: { [s: string]: () => ModelInstanceInputData<MyTSType> } = {
+  TE_FULL_TEST_1,
+}
+
+const MODEL_SET: { [s: string]: () => Model<MyTSType> } = {
+  TE_FULL_TEST,
+}
+
+Given('model {word} is used', function (modelName: string) {
+  this.theModel = MODEL_SET[modelName]()
+})
+
+When(
+  'a model instanced is created is called on model with {word}',
+  async function (dataName: string) {
+    this.theModelInstance = this.theModel.create(DATA_SET[dataName]())
+  }
+)
+
+When('toObj is called on the model instance', async function () {
+  this.results = await this.theModelInstance.toObj()
+})
+
+Then('the results match {word} obj data', function (dataName) {
+  const data = DATA_SET[dataName]()
+  assert.deepEqual(data, this.results)
+})
+
+When('instance method {word} is called', async function (methodName) {
+  this.instanceMethodActual = await this.theModelInstance.methods[methodName]()
+})
+
+Then('the result of instance method is {word}', function (expected) {
+  const actual = this.instanceMethodActual
+  assert.equal(actual, expected)
+})
+
+When('model method {word} is called', async function (methodName) {
+  this.modelMethodActual = await this.theModel.methods[methodName]()
+})
+
+Then('the result of model method is {word}', function (expected) {
+  const actual = this.modelMethodActual
+  assert.equal(actual, expected)
+})
+
+When('validate is called on model instance', async function () {
+  this.validationActual = await this.theModelInstance.validate()
+})
+
+Then('the model instance validated successfully', function () {
+  const expected = {}
+  assert.deepEqual(this.validationActual, expected)
+})

package/test/src/errors.test.ts

@@ -0,0 +1,31 @@
+import { assert } from 'chai'
+import { ValidationError } from '../../src/errors'
+
+describe('/src/errors.ts', () => {
+  describe('ValidationError', () => {
+    it('should have the correct modelName', () => {
+      const instance = new ValidationError('modelName', {
+        name: ['error1', 'error2'],
+      })
+      const actual = instance.modelName
+      const expected = 'modelName'
+      assert.equal(actual, expected)
+    })
+    it('should have the correct keysToErrors', () => {
+      const instance = new ValidationError('modelName', {
+        name: ['error1', 'error2'],
+      })
+      const actual = instance.keysToErrors
+      const expected = { name: ['error1', 'error2'] }
+      assert.deepEqual(actual, expected)
+    })
+    it('should have the correct name', () => {
+      const instance = new ValidationError('modelName', {
+        name: ['error1', 'error2'],
+      })
+      const actual = instance.name
+      const expected = 'ValidationError'
+      assert.equal(actual, expected)
+    })
+  })
+})

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

@@ -1,8 +1,8 @@
-const assert = require('chai').assert
-const sinon = require('sinon')
-const { lazyValue } = require('../../src/lazy')
+import { assert } from 'chai'
+import sinon from 'sinon'
+import { lazyValue } from '../../src/lazy'
 
-describe('/src/lazy.js', () => {
+describe('/src/lazy.ts', () => {
   describe('#lazyValue()', () => {
     it('should only call the method passed in once even after two calls', async () => {
       const method = sinon.stub().returns('hello-world')

package/test/src/methods.test.ts

@@ -0,0 +1,45 @@
+import { assert } from 'chai'
+import sinon from 'sinon'
+import { BaseModel } from '../../src/models'
+import { TextProperty, Property } from '../../src/properties'
+import { WrapperInstanceMethod } from '../../src/methods'
+
+type TEST_MODEL_TYPE = { text: string }
+
+describe('/src/methods.js', () => {
+  describe('#InstanceMethod()', () => {
+    it('should return "Hello-world" when passed in', () => {
+      const method = sinon.stub().callsFake(input => {
+        return `${input.get.text()}-world`
+      })
+      const myInstanceMethod = WrapperInstanceMethod<TEST_MODEL_TYPE>(method)
+      const wrappedObj = 'Hello'
+      const model = BaseModel<TEST_MODEL_TYPE>('Test', {
+        properties: { text: TextProperty() },
+      })
+      const modelInstance = model.create({ text: 'Hello' })
+      const actual = myInstanceMethod(modelInstance)
+      const expected = 'Hello-world'
+      assert.equal(actual, expected)
+    })
+    it('should call the method when InstanceMethod()() called', () => {
+      const method = sinon.stub().callsFake(input => {
+        return `${input}-world`
+      })
+      const myInstanceMethod = WrapperInstanceMethod<TEST_MODEL_TYPE>(method)
+      const model = BaseModel<TEST_MODEL_TYPE>('Test', {
+        properties: { text: TextProperty() },
+      })
+      const modelInstance = model.create({ text: 'Hello' })
+      const actual = myInstanceMethod(modelInstance)
+      sinon.assert.calledOnce(method)
+    })
+    it('should not call the method when InstanceMethod() called', () => {
+      const method = sinon.stub().callsFake(input => {
+        return `${input}-world`
+      })
+      const myInstanceMethod = WrapperInstanceMethod<TEST_MODEL_TYPE>(method)
+      sinon.assert.notCalled(method)
+    })
+  })
+})

package/test/src/models.test.ts

@@ -0,0 +1,417 @@
+import {
+  ModelDefinition,
+  ReferenceValueType,
+  ModelMethod,
+  ModelInstanceMethod,
+  ModelInstance,
+} from '../../src/interfaces'
+
+import _ from 'lodash'
+import sinon from 'sinon'
+import { assert } from 'chai'
+import { BaseModel } from '../../src/models'
+import { Property, TextProperty, ReferenceProperty } from '../../src/properties'
+import { WrapperInstanceMethod, WrapperModelMethod } from '../../src/methods'
+import { UniqueId } from '../../src/properties'
+
+type TEST_MODEL_TYPE = {
+  name: string
+}
+
+const TEST_MODEL_1 = BaseModel<TEST_MODEL_TYPE>('MyModel', {
+  properties: {
+    name: TextProperty(),
+  },
+})
+
+describe('/src/models.ts', () => {
+  describe('#Model()', () => {
+    it('should pass a functional instance to the instanceMethods by the time the function is called by a client', () => {
+      const model = BaseModel<{
+        name: string
+        func1: ModelInstanceMethod
+        func2: ModelInstanceMethod
+      }>('ModelName', {
+        properties: {
+          name: TextProperty(),
+        },
+        instanceMethods: {
+          func1: WrapperInstanceMethod((instance: ModelInstance<any>) => {
+            // @ts-ignore
+            return instance.methods.func2()
+          }),
+          func2: (instance: ModelInstance<any>) => {
+            return 'from instance func2'
+          },
+        },
+      })
+      const instance = model.create({ name: 'name' })
+      const actual = instance.methods.func1()
+      const expected = 'from instance func2'
+      assert.deepEqual(actual, expected)
+    })
+    it('should pass the clients arguments before the model is passed', () => {
+      const model = BaseModel<{ func1: ModelMethod; func2: ModelMethod }>(
+        'ModelName',
+        {
+          properties: {},
+          modelMethods: {
+            func1: WrapperModelMethod((model, input) => {
+              return `${input} ${model.methods.func2()}`
+            }),
+            func2: WrapperModelMethod(model => {
+              return 'from func2'
+            }),
+          },
+        }
+      )
+      const actual = model.methods.func1('hello')
+      const expected = 'hello from func2'
+      assert.deepEqual(actual, expected)
+    })
+    it('should pass a functional model to the modelFunction by the time the function is called by a client', () => {
+      const model = BaseModel<{ func1: ModelMethod; func2: ModelMethod }>(
+        'ModelName',
+        {
+          properties: {},
+          modelMethods: {
+            func1: model => {
+              return model.methods.func2()
+            },
+            func2: model => {
+              return 'from func2'
+            },
+          },
+        }
+      )
+      const actual = model.methods.func1()
+      const expected = 'from func2'
+      assert.deepEqual(actual, expected)
+    })
+    it('should find model.myString when modelExtension has myString function in it', () => {
+      const model = BaseModel<{ myString: ModelMethod }>('ModelName', {
+        properties: {},
+        modelMethods: {
+          myString: model => {
+            return 'To String'
+          },
+        },
+      })
+      assert.isFunction(model.methods.myString)
+    })
+    describe('#getPrimaryKeyName()', () => {
+      it('should return "primaryKey" when this value is passed in as the primaryKey', () => {
+        const expected = 'primaryKey'
+        const model = BaseModel<{ myString: ModelMethod }>('ModelName', {
+          getPrimaryKeyName: () => expected,
+          properties: {},
+          modelMethods: {
+            myString: model => {
+              return 'To String'
+            },
+          },
+        })
+        const actual = model.getPrimaryKeyName()
+        assert.equal(actual, expected)
+      })
+    })
+    describe('#create()', () => {
+      it('should have a references.theReference when properties has a ReferenceProperty named "theReference"', () => {
+        const model = BaseModel<{
+          theReference?: ReferenceValueType<TEST_MODEL_TYPE>
+        }>('ModelName', {
+          properties: {
+            theReference: ReferenceProperty(TEST_MODEL_1),
+          },
+        })
+        const instance = model.create({})
+        assert.isFunction(instance.references.theReference)
+      })
+      it('should have an "get.id" field when no primaryKey is passed', () => {
+        const model = BaseModel<{}>('ModelName', {
+          properties: {},
+        })
+        const instance = model.create({})
+        assert.isFunction(instance.get.id)
+      })
+      it('should have an "getMyPrimaryKeyId" field when "myPrimaryKeyId" is passed as the "getPrimaryKey" is passed', () => {
+        const model = BaseModel<{ myPrimaryKeyId: string }>('ModelName', {
+          getPrimaryKeyName: () => 'myPrimaryKeyId',
+          properties: {
+            myPrimaryKeyId: UniqueId(),
+          },
+        })
+        const instance = model.create({ myPrimaryKeyId: 'blah' })
+        assert.isFunction(instance.get.myPrimaryKeyId)
+      })
+      it('should find instance.methods.toString when in instanceMethods', () => {
+        const model = BaseModel<{ toString: ModelInstanceMethod }>(
+          'ModelName',
+          {
+            properties: {},
+            instanceMethods: {
+              toString: instance => {
+                return 'An instance'
+              },
+            },
+          }
+        )
+        const instance = model.create({})
+        assert.isFunction(instance.methods.toString)
+      })
+      it('should call all the instanceCreatedCallback functions when create() is called', () => {
+        const input = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+        }
+        const callbacks = [sinon.stub(), sinon.stub()]
+        const model = BaseModel('name', input, {
+          instanceCreatedCallback: callbacks,
+        })
+        model.create({ myProperty: 'value' })
+        callbacks.forEach(x => {
+          sinon.assert.calledOnce(x)
+        })
+      })
+      it('should call the instanceCreatedCallback function when create() is called', () => {
+        const input = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+        }
+        const callback = sinon.stub()
+        const model = BaseModel('name', input, {
+          instanceCreatedCallback: callback,
+        })
+        model.create({ myProperty: 'value' })
+        sinon.assert.calledOnce(callback)
+      })
+      it('should not throw an exception if nothing is passed into function', () => {
+        const input = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+        }
+        const model = BaseModel('name', input)
+        assert.doesNotThrow(() => {
+          model.create({})
+        })
+      })
+      it('should return an object that contains getModel().getModelDefinition().properties.myProperty', () => {
+        type MyType = { myProperty: string }
+        const input: ModelDefinition<MyType> = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+        }
+
+        const model = BaseModel<MyType>('name', input)
+        const instance = model.create({ myProperty: 'value' })
+        const actual = instance.getModel().getModelDefinition()
+          .properties.myProperty
+        assert.isOk(actual)
+      })
+      it('should flow through the additional special functions within the keyValues', () => {
+        const input = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+          instanceMethods: {
+            custom: () => 'works',
+          },
+        }
+        const model = BaseModel<{
+          myProperty: string
+          custom: ModelInstanceMethod
+        }>('name', input)
+        const instance = model.create({ myProperty: 'value' })
+        const actual = instance.methods.custom()
+        const expected = 'works'
+        assert.equal(actual, expected)
+      })
+      it('should return an object that contains .getModel().getName()===test-the-name', () => {
+        const input = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+        }
+        const model = BaseModel('test-the-name', input)
+        const instance = model.create({ myProperty: 'value' })
+        const actual = instance.getModel().getName()
+        const expected = 'test-the-name'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value passed in when Property.defaultValue and Property.value are not set', () => {
+        const input = {
+          properties: {
+            myProperty: TextProperty({ required: true }),
+          },
+        }
+        const model = BaseModel<{ myProperty: string }>('name', input)
+        const instance = model.create({ myProperty: 'passed-in' })
+        const actual = instance.get.myProperty()
+        const expected = 'passed-in'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for Property.value when even if Property.defaultValue is set and a value is passed in', () => {
+        const input = {
+          properties: {
+            myProperty: Property('MyProperty', {
+              value: 'value',
+              defaultValue: 'default-value',
+            }),
+          },
+        }
+        const model = BaseModel<{ myProperty: string }>('name', input)
+        const instance = model.create({ myProperty: 'passed-in' })
+        const actual = instance.get.myProperty()
+        const expected = 'value'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for Property.value when even if Property.defaultValue is not set and a value is passed in', async () => {
+        const input = {
+          properties: {
+            myProperty: Property('MyProperty', { value: 'value' }),
+          },
+        }
+        const model = BaseModel<{ myProperty: string }>('name', input)
+        const instance = model.create({ myProperty: 'passed-in' })
+        const actual = instance.get.myProperty()
+        const expected = 'value'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for Property.defaultValue when Property.value is not set and no value is passed in', async () => {
+        const input = {
+          properties: {
+            myProperty: Property('MyProperty', {
+              defaultValue: 'defaultValue',
+            }),
+          },
+        }
+        const model = BaseModel<{ myProperty: string }>('name', input)
+        // @ts-ignore
+        const instance = model.create({})
+        const actual = instance.get.myProperty()
+        const expected = 'defaultValue'
+        assert.deepEqual(actual, expected)
+      })
+      it('should use the value for Property.defaultValue when Property.value is not set and null is passed as a value', async () => {
+        const input = {
+          properties: {
+            myProperty: Property('MyProperty', {
+              defaultValue: 'defaultValue',
+            }),
+          },
+        }
+        const model = BaseModel<{ myProperty: string | null }>('name', input)
+        const instance = model.create({ myProperty: null })
+        const actual = instance.get.myProperty()
+        const expected = 'defaultValue'
+        assert.deepEqual(actual, expected)
+      })
+      it('should return a model with get.id and get.type for the provided valid keyToProperty', () => {
+        const input = {
+          properties: {
+            id: UniqueId({ required: true }),
+            type: Property('MyProperty', {}),
+          },
+        }
+        const model = BaseModel<{ type: string }>('name', input)
+        const actual = model.create({ id: 'my-id', type: 'my-type' })
+        assert.isOk(actual.get.id)
+        assert.isOk(actual.get.type)
+      })
+      it('should return the id when get.id() is called', () => {
+        const expected = 'my-id'
+        const input = {
+          properties: {
+            id: Property<string>('myid', {}),
+            type: Property('MyProperty', {}),
+          },
+        }
+        const model = BaseModel('name', input)
+        const instance = model.create({ id: expected, type: 'my-type' })
+        const actual = instance.get.id()
+        assert.equal(actual, expected)
+      })
+      it('should have a Promise for the default get.id()', () => {
+        const expected = 'my-id'
+        const input = {
+          properties: {
+            type: Property('MyProperty', {}),
+          },
+        }
+        const model = BaseModel('name', input)
+        const instance = model.create({ id: expected, type: 'my-type' })
+        const actual = instance.get.id()
+        // @ts-ignore
+        assert.isOk(actual.then)
+      })
+      it('should return a model where validate returns one error for id', async () => {
+        const input = {
+          properties: {
+            id: Property<string>('MyId', { required: true }),
+            type: Property('MyProperty', {}),
+          },
+        }
+        const model = BaseModel('name', input)
+        const instance = model.create({ type: 'my-type' })
+        const actual = await instance.validate()
+        const expected = 1
+        assert.equal(Object.values(actual).length, expected)
+      })
+      it('should return a model where validate returns one error for the missing text property', async () => {
+        const input = {
+          properties: {
+            id: Property<string>('MyProperty', { required: true }),
+            text: TextProperty({ required: true }),
+          },
+        }
+        const model = BaseModel('name', input)
+        const instance = model.create({ id: 'my-id' })
+        const actual = await instance.validate()
+        const expected = 1
+        assert.equal(Object.values(actual).length, expected)
+      })
+    })
+    it('should return an object with a function "create" when called once with valid data', () => {
+      const actual = BaseModel<{}>('name', { properties: {} })
+      assert.isFunction(actual.create)
+    })
+    describe('#references.getMyReferencedId()', () => {
+      it('should return the id from the ReferenceProperty', () => {
+        const model = BaseModel<{
+          myReference: ReferenceValueType<TEST_MODEL_TYPE>
+        }>('ModelName', {
+          properties: {
+            myReference: ReferenceProperty(TEST_MODEL_1),
+          },
+        })
+        const instance = model.create({ myReference: 'unit-test-id' })
+        const actual = instance.references.myReference()
+        const expected = 'unit-test-id'
+        assert.deepEqual(actual, expected)
+      })
+    })
+    describe('#getPrimaryKey()', () => {
+      it('should return the id field when no primaryKey is passed', async () => {
+        const model = BaseModel('ModelName', { properties: {} })
+        const expected = 'my-primary-key'
+        const instance = model.create({ id: expected })
+        const actual = await instance.getPrimaryKey()
+        assert.equal(actual, expected)
+      })
+      it('should return the primaryKey field when "primaryKey" is passed as primaryKey', async () => {
+        const model = BaseModel('ModelName', {
+          getPrimaryKeyName: () => 'primaryKey',
+          properties: {},
+        })
+        const expected = 'my-primary-key'
+        const instance = model.create({ primaryKey: expected })
+        const actual = await instance.getPrimaryKey()
+        assert.equal(actual, expected)
+      })
+    })
+  })
+})