Add failureEvents to engine results

Author: Cache Hamm

src/almanac.js

@@ -22,7 +22,7 @@ export default class Almanac {
     this.factResultsCache = new Map() // { cacheKey:  Promise<factValu> }
     this.allowUndefinedFacts = Boolean(options.allowUndefinedFacts)
     this.pathResolver = options.pathResolver || defaultPathResolver
-    this.successEvents = []
+    this.events = { success: [], failure: [] }
     this.ruleResults = []
 
     for (const factId in runtimeFacts) {
@@ -42,15 +42,17 @@ export default class Almanac {
    * Adds a success event
    * @param {Object} event
    */
-  addSuccessEvent (event) {
-    this.successEvents.push(event)
+  addEvent (event, outcome) {
+    if (!outcome) throw new Error('outcome required: "success" | "failure"]')
+    this.events[outcome].push(event)
   }
 
   /**
    * retrieve successful events
    */
-  getSuccessEvents () {
-    return this.successEvents
+  getEvents (outcome = '') {
+    if (outcome) return this.events[outcome]
+    return this.events.success.concat(this.events.failure)
   }
 
   /**

src/engine.js

@@ -193,10 +193,11 @@ class Engine extends EventEmitter {
         debug(`engine::run ruleResult:${ruleResult.result}`)
         almanac.addRuleResult(ruleResult)
         if (ruleResult.result) {
-          almanac.addSuccessEvent(ruleResult.event)
+          almanac.addEvent(ruleResult.event, 'success')
           return this.emitAsync('success', ruleResult.event, almanac, ruleResult)
             .then(() => this.emitAsync(ruleResult.event.type, ruleResult.event.params, almanac, ruleResult))
         } else {
+          almanac.addEvent(ruleResult.event, 'failure')
           return this.emitAsync('failure', ruleResult.event, almanac, ruleResult)
         }
       })
@@ -231,8 +232,6 @@ class Engine extends EventEmitter {
       cursor.then(() => {
         this.status = FINISHED
         debug('engine::run completed')
-        return almanac.getSuccessEvents()
-      }).then(events => {
         const ruleResults = almanac.getRuleResults()
         const { results, failureResults } = ruleResults.reduce((hash, ruleResult) => {
           const group = ruleResult.result ? 'results' : 'failureResults'
@@ -241,12 +240,11 @@ class Engine extends EventEmitter {
         }, { results: [], failureResults: [] })
 
         resolve({
+          almanac,
           results,
           failureResults,
-          almanac,
-
-          // deprecated:
-          events
+          events: almanac.getEvents('success'),
+          failureEvents: almanac.getEvents('failure')
         })
       }).catch(reject)
     })

test/acceptance/acceptance.js

@@ -146,11 +146,16 @@ describe('Acceptance', () => {
       lowPriorityValue: [2]
     })
 
-    const engineResult = await engine.run({ baseIndex: 1 })
+    const {
+      results,
+      failureResults,
+      events,
+      failureEvents
+    } = await engine.run({ baseIndex: 1 })
 
     // results
-    expect(engineResult.results.length).to.equal(2)
-    expect(engineResult.results[0]).to.deep.equal({
+    expect(results.length).to.equal(2)
+    expect(results[0]).to.deep.equal({
       conditions: {
         all: [
           {
@@ -189,7 +194,7 @@ describe('Acceptance', () => {
       priority: 10,
       result: true
     })
-    expect(engineResult.results[1]).to.deep.equal({
+    expect(results[1]).to.deep.equal({
       conditions: {
         all: [
           {
@@ -219,12 +224,13 @@ describe('Acceptance', () => {
       priority: 1,
       result: true
     })
-    expect(engineResult.failureResults).to.be.empty()
+    expect(failureResults).to.be.empty()
 
     // events
-    expect(engineResult.events.length).to.equal(2)
-    expect(engineResult.events[0]).to.deep.equal(event1)
-    expect(engineResult.events[1]).to.deep.equal(event2)
+    expect(failureEvents.length).to.equal(0)
+    expect(events.length).to.equal(2)
+    expect(events[0]).to.deep.equal(event1)
+    expect(events[1]).to.deep.equal(event2)
 
     // callbacks
     expect(successSpy).to.have.been.calledTwice()
@@ -240,13 +246,19 @@ describe('Acceptance', () => {
       lowPriorityValue: [3] // falsey
     })
 
-    const engineResult = await engine.run({ baseIndex: 1, 'rule-created-fact': '' })
+    const {
+      results,
+      failureResults,
+      events,
+      failureEvents
+    } = await engine.run({ baseIndex: 1, 'rule-created-fact': '' })
 
-    expect(engineResult.results.length).to.equal(0)
-    expect(engineResult.failureResults.length).to.equal(2)
-    expect(engineResult.failureResults.every(rr => rr.result === false)).to.be.true()
+    expect(results.length).to.equal(0)
+    expect(failureResults.length).to.equal(2)
+    expect(failureResults.every(rr => rr.result === false)).to.be.true()
 
-    expect(engineResult.events.length).to.equal(0)
+    expect(events.length).to.equal(0)
+    expect(failureEvents.length).to.equal(2)
     expect(failureSpy).to.have.been.calledTwice()
     expect(failureSpy).to.have.been.calledWith(event1)
     expect(failureSpy).to.have.been.calledWith(event2)

test/almanac.test.js

@@ -41,14 +41,25 @@ describe('Almanac', () => {
     })
   })
 
-  describe('addSuccessEvent() / getSuccessEvents()', () => {
-    it('manages success events', () => {
-      const event = {}
-      almanac = new Almanac()
-      expect(almanac.getSuccessEvents()).to.be.empty()
-      almanac.addSuccessEvent(event)
-      expect(almanac.getSuccessEvents()).to.have.a.lengthOf(1)
-      expect(almanac.getSuccessEvents()[0]).to.equal(event)
+  describe('addEvent() / getEvents()', () => {
+    const event = {};
+    ['success', 'failure'].forEach(outcome => {
+      it(`manages ${outcome} events`, () => {
+        almanac = new Almanac()
+        expect(almanac.getEvents(outcome)).to.be.empty()
+        almanac.addEvent(event, outcome)
+        expect(almanac.getEvents(outcome)).to.have.a.lengthOf(1)
+        expect(almanac.getEvents(outcome)[0]).to.equal(event)
+      })
+
+      it('getEvent() filters when outcome provided, or returns all events', () => {
+        almanac = new Almanac()
+        almanac.addEvent(event, 'success')
+        almanac.addEvent(event, 'failure')
+        expect(almanac.getEvents('success')).to.have.a.lengthOf(1)
+        expect(almanac.getEvents('failure')).to.have.a.lengthOf(1)
+        expect(almanac.getEvents()).to.have.a.lengthOf(2)
+      })
     })
   })
 

test/engine-run.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 import engineFactory from '../src/index'
+import Almanac from '../src/almanac'
 import sinon from 'sinon'
 
 describe('Engine: run', () => {
@@ -62,11 +63,12 @@ describe('Engine: run', () => {
   })
 
   describe('returns', () => {
-    it('activated events', () => {
-      return engine.run({ age: 30 }).then(results => {
-        expect(results.events.length).to.equal(1)
-        expect(results.events).to.deep.include(rule.event)
-      })
+    it('activated events', async () => {
+      const { events, failureEvents } = await engine.run({ age: 30 })
+      expect(events.length).to.equal(1)
+      expect(events).to.deep.include(rule.event)
+      expect(failureEvents.length).to.equal(1)
+      expect(failureEvents).to.deep.include(rule2.event)
     })
 
     it('multiple activated events', () => {
@@ -85,7 +87,7 @@ describe('Engine: run', () => {
 
     it('includes the almanac', () => {
       return engine.run({ age: 10 }).then(results => {
-        // expect(results.almanac).assert.instanceOf
+        expect(results.almanac).to.be.an.instanceOf(Almanac)
         return results.almanac.factValue('age')
       }).then(ageFact => expect(ageFact).to.equal(10))
     })

types/index.d.ts

@@ -6,6 +6,8 @@ export interface EngineOptions {
 export interface EngineResult {
   events: Event[];
   almanac: Almanac;
+  results: RuleResult[];
+  failureResults: RuleResult[];
 }
 
 export default function engineFactory(