Add test for undefined fact values with equals operator

Author: Cache Hamm

Diff for: src/fact.js

@@ -26,9 +26,6 @@ class Fact {
     }
 
     if (!this.id) throw new Error('factId required')
-    // if (typeof this.value === 'undefined' && typeof this.calculationMethod === 'undefined') {
-    //   throw new Error('facts must have a value or method')
-    // }
 
     this.priority = parseInt(options.priority || 1, 10)
     this.options = Object.assign({}, defaultOptions, options)

Diff for: test/condition.test.js

@@ -66,15 +66,14 @@ describe('Condition', () => {
     let condition
     let almanac
     function setup (options, factValue) {
-      if (typeof factValue === 'undefined') factValue = 1
       const properties = Object.assign({}, conditionBase, options)
       condition = new Condition(properties)
       const fact = new Fact(conditionBase.fact, factValue)
       almanac = new Almanac(new Map([[fact.id, fact]]))
     }
 
     context('validations', () => {
-      beforeEach(() => setup())
+      beforeEach(() => setup({}, 1))
       it('throws when missing an almanac', () => {
         return expect(condition.evaluate(undefined, operators)).to.be.rejectedWith('almanac required')
       })
@@ -94,6 +93,18 @@ describe('Condition', () => {
       expect((await condition.evaluate(almanac, operators, 5)).result).to.equal(false)
     })
 
+    it('evaluates "equal" to check for undefined', async () => {
+      condition = new Condition({ fact: 'age', operator: 'equal', value: undefined })
+      let fact = new Fact('age', undefined)
+      almanac = new Almanac(new Map([[fact.id, fact]]))
+
+      expect((await condition.evaluate(almanac, operators)).result).to.equal(true)
+
+      fact = new Fact('age', 1)
+      almanac = new Almanac(new Map([[fact.id, fact]]))
+      expect((await condition.evaluate(almanac, operators)).result).to.equal(false)
+    })
+
     it('evaluates "notEqual"', async () => {
       setup({ operator: 'notEqual' }, 50)
       expect((await condition.evaluate(almanac, operators)).result).to.equal(false)

Diff for: test/engine.test.js

@@ -2,8 +2,11 @@
 
 import sinon from 'sinon'
 import engineFactory, { Fact, Rule, Operator } from '../src/index'
+import defaultOperators from '../src/engine-default-operators'
 
 describe('Engine', () => {
+  const operatorCount = defaultOperators.length
+
   let engine
   let sandbox
   before(() => {
@@ -31,7 +34,7 @@ describe('Engine', () => {
     it('initializes with the default state', () => {
       expect(engine.status).to.equal('READY')
       expect(engine.rules.length).to.equal(0)
-      expect(engine.operators.size).to.equal(10)
+      expect(engine.operators.size).to.equal(operatorCount)
     })
 
     it('can be initialized with rules', () => {
@@ -119,37 +122,37 @@ describe('Engine', () => {
 
   describe('addOperator()', () => {
     it('adds the operator', () => {
-      expect(engine.operators.size).to.equal(10)
+      expect(engine.operators.size).to.equal(operatorCount)
       engine.addOperator('startsWithLetter', (factValue, jsonValue) => {
         return factValue[0] === jsonValue
       })
-      expect(engine.operators.size).to.equal(11)
+      expect(engine.operators.size).to.equal(operatorCount + 1)
       expect(engine.operators.get('startsWithLetter')).to.exist()
       expect(engine.operators.get('startsWithLetter')).to.be.an.instanceof(Operator)
     })
 
     it('accepts an operator instance', () => {
-      expect(engine.operators.size).to.equal(10)
+      expect(engine.operators.size).to.equal(operatorCount)
       const op = new Operator('my-operator', _ => true)
       engine.addOperator(op)
-      expect(engine.operators.size).to.equal(11)
+      expect(engine.operators.size).to.equal(operatorCount + 1)
       expect(engine.operators.get('my-operator')).to.equal(op)
     })
   })
 
   describe('removeOperator()', () => {
     it('removes the operator', () => {
-      expect(engine.operators.size).to.equal(10)
+      expect(engine.operators.size).to.equal(operatorCount)
       engine.addOperator('startsWithLetter', (factValue, jsonValue) => {
         return factValue[0] === jsonValue
       })
-      expect(engine.operators.size).to.equal(11)
+      expect(engine.operators.size).to.equal(operatorCount + 1)
       engine.removeOperator('startsWithLetter')
-      expect(engine.operators.size).to.equal(10)
+      expect(engine.operators.size).to.equal(operatorCount)
     })
 
     it('can only remove added operators', () => {
-      expect(engine.operators.size).to.equal(10)
+      expect(engine.operators.size).to.equal(operatorCount)
       const isRemoved = engine.removeOperator('nonExisting')
       expect(isRemoved).to.equal(false)
     })