upgrade dev dependencies

Author: Cache Hamm

package.json

@@ -45,22 +45,23 @@
   "devDependencies": {
     "babel-cli": "^6.4.5",
     "babel-core": "~6.9.1",
-    "babel-eslint": "^5.0.0-beta6",
+    "babel-eslint": "^7.1.1",
     "babel-loader": "~6.2.4",
     "babel-plugin-transform-async-to-generator": "^6.4.6",
     "babel-polyfill": "~6.7.4",
     "babel-preset-es2015": "~6.9.0",
     "babel-preset-stage-0": "~6.5.0",
     "babel-register": "^6.4.3",
-    "chai": "3.4.1",
-    "chai-as-promised": "^5.2.0",
+    "chai": "^3.5.0",
+    "chai-as-promised": "^6.0.0",
     "colors": "~1.1.2",
-    "mocha": "3.2.0",
+    "dirty-chai": "1.2.2",
+    "mocha": "^3.2.0",
     "regenerator": "~0.8.46",
     "sinon": "^1.17.2",
     "sinon-chai": "^2.8.0",
     "snazzy": "^2.0.1",
-    "standard": "^5.4.1"
+    "standard": "^9.0.0"
   },
   "dependencies": {
     "debug": "2.2.0",

src/condition.js

@@ -62,7 +62,7 @@ export default class Condition {
   /**
    * Interprets .value as either a primitive, or if a fact, retrieves the fact value
    */
-  async _getValue(almanac) {
+  async _getValue (almanac) {
     let value = this.value
     if (isPlainObject(value) && value.hasOwnProperty('fact')) { // value: { fact: 'xyz' }
       value = await almanac.factValue(value.fact, value.params, value.path)

src/rule.js

@@ -110,7 +110,7 @@ class Rule extends EventEmitter {
       let priority = condition.priority
       if (!priority) {
         let fact = this.engine.getFact(condition.fact)
-        priority = fact && fact.priority || 1
+        priority = (fact && fact.priority) || 1
       }
       if (!sets[priority]) sets[priority] = []
       sets[priority].push(condition)

test/almanac.test.js

@@ -113,7 +113,7 @@ describe('Almanac', () => {
     it('honors facts with caching disabled', (done) => {
       setup(new Fact('id', 1, { cache: false }))
       let promise = almanac._setFactValue(fact, {}, FACT_VALUE)
-      expect(almanac.factResultsCache.values().next().value).to.be.undefined
+      expect(almanac.factResultsCache.values().next().value).to.be.undefined()
       promise.then(value => expect(value).to.equal(FACT_VALUE)).then(_ => done()).catch(done)
     })
   })
@@ -135,15 +135,15 @@ describe('Almanac', () => {
       almanac.factValue('foo')
       almanac.factValue('foo')
       almanac.factValue('foo')
-      expect(factSpy).to.have.been.calledThrice
+      expect(factSpy).to.have.been.calledThrice()
     })
 
     it('evaluates the fact once when fact caching is on', () => {
       setup({ cache: true })
       almanac.factValue('foo')
       almanac.factValue('foo')
       almanac.factValue('foo')
-      expect(factSpy).to.have.been.calledOnce
+      expect(factSpy).to.have.been.calledOnce()
     })
   })
 })

test/condition.test.js

@@ -76,14 +76,14 @@ describe('Condition', () => {
     context('validations', () => {
       beforeEach(() => setup())
       it('throws when missing an almanac', () => {
-        return expect(condition.evaluate(undefined, operators)).to.be.rejectedWith('Error: almanac required')
+        return expect(condition.evaluate(undefined, operators)).to.be.rejectedWith('almanac required')
       })
       it('throws when missing operators', () => {
-        return expect(condition.evaluate(almanac, undefined)).to.be.rejectedWith('Error: operatorMap required')
+        return expect(condition.evaluate(almanac, undefined)).to.be.rejectedWith('operatorMap required')
       })
       it('throws when run against a boolean operator', () => {
         condition.all = []
-        return expect(condition.evaluate(almanac, operators)).to.be.rejectedWith('Error: Cannot evaluate() a boolean condition')
+        return expect(condition.evaluate(almanac, operators)).to.be.rejectedWith('Cannot evaluate() a boolean condition')
       })
     })
 
@@ -102,17 +102,17 @@ describe('Condition', () => {
     })
 
     it('evaluates "in"', async () => {
-      setup({ operator: 'in', value: [5, 10, 15, 20]}, 15)
+      setup({ operator: 'in', value: [5, 10, 15, 20] }, 15)
       expect(await condition.evaluate(almanac, operators)).to.equal(true)
-      setup({ operator: 'in', value: [5, 10, 15, 20]}, 99)
+      setup({ operator: 'in', value: [5, 10, 15, 20] }, 99)
       expect(await condition.evaluate(almanac, operators)).to.equal(false)
     })
 
     it('evaluates "contains"', async () => {
       setup({ operator: 'contains', value: 10 }, [5, 10, 15])
-      expect(await condition.evaluate(almanac,operators)).to.equal(true)
+      expect(await condition.evaluate(almanac, operators)).to.equal(true)
       setup({ operator: 'contains', value: 10 }, [1, 2, 3])
-      expect(await condition.evaluate(almanac,operators)).to.equal(false)
+      expect(await condition.evaluate(almanac, operators)).to.equal(false)
     })
 
     it('evaluates "doesNotContain"', async () => {
@@ -170,7 +170,7 @@ describe('Condition', () => {
         setup({ operator: 'contains' }, null)
         expect(await condition.evaluate(almanac, operators)).to.equal(false)
         setup({ operator: 'doesNotContain' }, null)
-        expect(await condition.evaluate(almanac,operators)).to.equal(false)
+        expect(await condition.evaluate(almanac, operators)).to.equal(false)
       })
 
       it('returns false when using comparison operators with null', async () => {
@@ -209,7 +209,7 @@ describe('Condition', () => {
       expect(await condition.evaluate(almanac, operators)).to.equal(false)
     })
 
-    it('ignores "path" when non-objects are returned by the fact', async  () => {
+    it('ignores "path" when non-objects are returned by the fact', async () => {
       let ageFact = new Fact('age', 50)
       let facts = new Map([[ageFact.id, ageFact]])
       let almanac = new Almanac(facts)
@@ -282,7 +282,7 @@ describe('Condition', () => {
       }
     }
     it('recursively parses nested conditions', () => {
-      expect(() => new Condition(complexCondition())).to.not.throw
+      expect(() => new Condition(complexCondition())).to.not.throw()
     })
 
     it('throws if a nested condition is invalid', () => {

test/engine-cache.test.js

@@ -35,14 +35,14 @@ describe('Engine: cache', () => {
   it('loads facts once and caches the results for future use', async () => {
     setup({cache: true})
     await engine.run()
-    expect(eventSpy).to.have.been.calledThrice
-    expect(factSpy).to.have.been.calledOnce
+    expect(eventSpy).to.have.been.calledThrice()
+    expect(factSpy).to.have.been.calledOnce()
   })
 
   it('allows caching to be turned off', async () => {
     setup({cache: false})
     await engine.run()
-    expect(eventSpy).to.have.been.calledThrice
-    expect(factSpy).to.have.been.calledThrice
+    expect(eventSpy).to.have.been.calledThrice()
+    expect(factSpy).to.have.been.calledThrice()
   })
 })

test/engine-controls.test.js

@@ -50,9 +50,9 @@ describe('Engine: fact priority', () => {
         engine.stop()
       })
       await engine.run()
-      expect(eventSpy).to.have.been.calledOnce
-      expect(ageStub).to.have.been.calledOnce
-      expect(segmentStub).to.not.have.been.called
+      expect(eventSpy).to.have.been.calledOnce()
+      expect(ageStub).to.have.been.calledOnce()
+      expect(segmentStub).to.not.have.been.called()
     })
   })
 })

test/engine-fact-comparison.test.js

@@ -1,14 +1,13 @@
 'use strict'
 
 import engineFactory from '../src/index'
-import { Fact } from '../src/index'
 import sinon from 'sinon'
 
 describe('Engine: fact to fact comparison', () => {
   let engine
   let eventSpy = sinon.spy()
 
-  function setup(conditions) {
+  function setup (conditions) {
     let event = { type: 'success-event' }
     eventSpy.reset()
     engine = engineFactory()
@@ -30,7 +29,7 @@ describe('Engine: fact to fact comparison', () => {
     it('allows a fact to retrieve other fact values', async () => {
       setup(constantCondition)
       await engine.run({ height: 1, width: 2 })
-      expect(eventSpy).to.have.been.calledOnce
+      expect(eventSpy).to.have.been.calledOnce()
 
       eventSpy.reset()
 
@@ -66,7 +65,7 @@ describe('Engine: fact to fact comparison', () => {
         return params.multiplier * width
       })
       await engine.run({ height: 5, width: 10 })
-      expect(eventSpy).to.have.been.calledOnce
+      expect(eventSpy).to.have.been.calledOnce()
 
       eventSpy.reset()
 
@@ -80,7 +79,7 @@ describe('Engine: fact to fact comparison', () => {
       all: [{
         fact: 'widthMultiplier',
         params: {
-          multiplier: 2,
+          multiplier: 2
         },
         path: '.feet',
         operator: 'equal',
@@ -104,7 +103,7 @@ describe('Engine: fact to fact comparison', () => {
         return { feet: params.multiplier * width }
       })
       await engine.run({ height: 5, width: 10 })
-      expect(eventSpy).to.have.been.calledOnce
+      expect(eventSpy).to.have.been.calledOnce()
 
       eventSpy.reset()
 

test/engine-fact-priority.test.js

@@ -51,23 +51,23 @@ describe('Engine: fact priority', () => {
       setup(allCondition)
       ageStub.returns(10) // fail
       await engine.run()
-      expect(failureSpy).to.have.been.called
-      expect(eventSpy).to.not.have.been.called
-      expect(ageStub).to.have.been.calledOnce
-      expect(segmentStub).to.not.have.been.called
-      expect(accountTypeStub).to.not.have.been.called
+      expect(failureSpy).to.have.been.called()
+      expect(eventSpy).to.not.have.been.called()
+      expect(ageStub).to.have.been.calledOnce()
+      expect(segmentStub).to.not.have.been.called()
+      expect(accountTypeStub).to.not.have.been.called()
     })
 
     it('stops on the first fact to fail, part 2', async () => {
       setup(allCondition)
       ageStub.returns(20) // pass
       segmentStub.returns('android') // fail
       await engine.run()
-      expect(failureSpy).to.have.been.called
-      expect(eventSpy).to.not.have.been.called
-      expect(ageStub).to.have.been.calledOnce
-      expect(segmentStub).to.have.been.calledOnce
-      expect(accountTypeStub).to.not.have.been.called
+      expect(failureSpy).to.have.been.called()
+      expect(eventSpy).to.not.have.been.called()
+      expect(ageStub).to.have.been.calledOnce()
+      expect(segmentStub).to.have.been.calledOnce()
+      expect(accountTypeStub).to.not.have.been.called()
     })
 
     describe('sub-conditions', () => {
@@ -96,11 +96,11 @@ describe('Engine: fact priority', () => {
         ageStub.returns(20) // pass
         segmentStub.returns('android') // fail
         await engine.run()
-        expect(failureSpy).to.have.been.called
-        expect(eventSpy).to.not.have.been.called
-        expect(ageStub).to.have.been.calledOnce
-        expect(segmentStub).to.have.been.calledOnce
-        expect(accountTypeStub).to.not.have.been.called
+        expect(failureSpy).to.have.been.called()
+        expect(eventSpy).to.not.have.been.called()
+        expect(ageStub).to.have.been.calledOnce()
+        expect(segmentStub).to.have.been.calledOnce()
+        expect(accountTypeStub).to.not.have.been.called()
       })
     })
   })
@@ -125,23 +125,23 @@ describe('Engine: fact priority', () => {
       setup(anyCondition)
       ageStub.returns(20) // succeed
       await engine.run()
-      expect(eventSpy).to.have.been.calledOnce
-      expect(failureSpy).to.not.have.been.called
-      expect(ageStub).to.have.been.calledOnce
-      expect(segmentStub).to.not.have.been.called
-      expect(accountTypeStub).to.not.have.been.called
+      expect(eventSpy).to.have.been.calledOnce()
+      expect(failureSpy).to.not.have.been.called()
+      expect(ageStub).to.have.been.calledOnce()
+      expect(segmentStub).to.not.have.been.called()
+      expect(accountTypeStub).to.not.have.been.called()
     })
 
     it('short circuits on the first fact to fail, part 2', async () => {
       setup(anyCondition)
       ageStub.returns(10) // fail
       segmentStub.returns('human') // pass
       await engine.run()
-      expect(eventSpy).to.have.been.calledOnce
-      expect(failureSpy).to.not.have.been.called
-      expect(ageStub).to.have.been.calledOnce
-      expect(segmentStub).to.have.been.calledOnce
-      expect(accountTypeStub).to.not.have.been.called
+      expect(eventSpy).to.have.been.calledOnce()
+      expect(failureSpy).to.not.have.been.called()
+      expect(ageStub).to.have.been.calledOnce()
+      expect(segmentStub).to.have.been.calledOnce()
+      expect(accountTypeStub).to.not.have.been.called()
     })
 
     describe('sub-conditions', () => {
@@ -170,11 +170,11 @@ describe('Engine: fact priority', () => {
         ageStub.returns(20) // success
         segmentStub.returns('human') // success
         await engine.run()
-        expect(failureSpy).to.not.have.been.called
-        expect(eventSpy).to.have.been.called
-        expect(ageStub).to.have.been.calledOnce
-        expect(segmentStub).to.have.been.calledOnce
-        expect(accountTypeStub).to.not.have.been.called
+        expect(failureSpy).to.not.have.been.called()
+        expect(eventSpy).to.have.been.called()
+        expect(ageStub).to.have.been.calledOnce()
+        expect(segmentStub).to.have.been.calledOnce()
+        expect(accountTypeStub).to.not.have.been.called()
       })
     })
   })

test/engine-fact.test.js

@@ -92,8 +92,8 @@ describe('Engine: fact evaluation', () => {
           })
           setup(conditions, { allowUndefinedFacts: true })
           await engine.run()
-          expect(successSpy).to.have.been.called
-          expect(failureSpy).to.not.have.been.called
+          expect(successSpy).to.have.been.called()
+          expect(failureSpy).to.not.have.been.called()
         })
 
         it('emits "failure" when the condition fails', async () => {
@@ -106,8 +106,8 @@ describe('Engine: fact evaluation', () => {
           conditions.any[0].params.eligibilityId = 2
           setup(conditions, { allowUndefinedFacts: true })
           await engine.run()
-          expect(successSpy).to.not.have.been.called
-          expect(failureSpy).to.have.been.called
+          expect(successSpy).to.not.have.been.called()
+          expect(failureSpy).to.have.been.called()
         })
       })
     })
@@ -125,7 +125,7 @@ describe('Engine: fact evaluation', () => {
       conditions.any[0].params.eligibilityId = 2
       setup(conditions)
       await engine.run()
-      expect(successSpy).to.not.have.been.called
+      expect(successSpy).to.not.have.been.called()
     })
   })
 
@@ -154,7 +154,7 @@ describe('Engine: fact evaluation', () => {
       failureCondition.any[0].params.eligibilityId = 2
       setup(failureCondition)
       await engine.run()
-      expect(successSpy).to.not.have.been.called
+      expect(successSpy).to.not.have.been.called()
     })
 
     it('emits when complex object paths meet the conditions', async () => {
@@ -210,7 +210,7 @@ describe('Engine: fact evaluation', () => {
       }
       engine.addFact('eligibilityField', eligibilityField)
       await engine.run()
-      expect(successSpy).to.have.been.called
+      expect(successSpy).to.have.been.called()
     })
   })
 
@@ -222,7 +222,7 @@ describe('Engine: fact evaluation', () => {
       }
       engine.addFact('eligibilityField', eligibilityField)
       await engine.run()
-      expect(successSpy).to.have.been.called
+      expect(successSpy).to.have.been.called()
     })
 
     it('works with synchronous, non-promise evaluations that are falsey', async () => {
@@ -232,7 +232,7 @@ describe('Engine: fact evaluation', () => {
       }
       engine.addFact('eligibilityField', eligibilityField)
       await engine.run()
-      expect(successSpy).to.not.have.been.called
+      expect(successSpy).to.not.have.been.called()
     })
   })
 })