Add acceptance tests

Author: Cache Hamm

docs/rules.md

@@ -219,7 +219,7 @@ For an example, see [fact-dependency](../examples/04-fact-dependency.js)
 
 ### Comparing facts
 
-Sometimes it is necessary to compare facts against others facts.  This can be accomplished by nesting the second fact within the `value` property.  This second fact has access to the same `params` and `path` helpers as the primary fact.
+Sometimes it is necessary to compare facts against other facts.  This can be accomplished by nesting the second fact within the `value` property.  This second fact has access to the same `params` and `path` helpers as the primary fact.
 
 ```js
 // identifies whether the current widget price is above a maximum

package.json

@@ -48,6 +48,7 @@
     ],
     "file": "./test/support/bootstrap.js",
     "checkLeaks": true,
+    "recursive": true,
     "globals": [
       "expect"
     ]

src/almanac.js

@@ -114,7 +114,7 @@ export default class Almanac {
           .then(factValue => {
             if (isObjectLike(factValue)) {
               const pathValue = JSONPath({ path, json: factValue, wrap: false })
-              debug(`condition::evaluate extracting object property ${path}, received: ${pathValue}`)
+              debug(`condition::evaluate extracting object property ${path}, received: ${JSON.stringify(pathValue)}`)
               return pathValue
             } else {
               debug(`condition::evaluate could not compute object path(${path}) of non-object: ${factValue} <${typeof factValue}>; continuing with ${factValue}`)

src/condition.js

@@ -101,7 +101,7 @@ export default class Condition {
         return almanac.factValue(this.fact, this.params, this.path)
           .then(leftHandSideValue => {
             const result = op.evaluate(leftHandSideValue, rightHandSideValue)
-            debug(`condition::evaluate <${leftHandSideValue} ${this.operator} ${rightHandSideValue}?> (${result})`)
+            debug(`condition::evaluate <${JSON.stringify(leftHandSideValue)} ${this.operator} ${JSON.stringify(rightHandSideValue)}?> (${result})`)
             return { result, leftHandSideValue, rightHandSideValue, operator: this.operator }
           })
       })

src/engine.js

@@ -212,7 +212,6 @@ class Engine extends EventEmitter {
    */
   run (runtimeFacts = {}) {
     debug('engine::run started')
-    debug('engine::run runtimeFacts:', runtimeFacts)
     runtimeFacts['success-events'] = new Fact('success-events', SuccessEventFact(), { cache: false })
     this.status = RUNNING
     const almanac = new Almanac(this.facts, runtimeFacts, { allowUndefinedFacts: this.allowUndefinedFacts })

test/acceptance/acceptance.js

@@ -0,0 +1,176 @@
+'use strict'
+
+import sinon from 'sinon'
+import { expect } from 'chai'
+import { Engine } from '../../src/index'
+
+/**
+ * acceptance tests are intended to use features that, when used in combination,
+ * could cause integration bugs not caught by the rest of the test suite
+ */
+describe('Acceptance', () => {
+  let sandbox
+  before(() => {
+    sandbox = sinon.createSandbox()
+  })
+  afterEach(() => {
+    sandbox.restore()
+  })
+  const factParam = 1
+  const event1 = {
+    type: 'event-1',
+    params: {
+      eventParam: 1
+    }
+  }
+  const event2 = {
+    type: 'event-2'
+  }
+  const expectedFirstRuleResult = {
+    all: [{
+      fact: 'high-priority',
+      params: {
+        factParam
+      },
+      operator: 'contains',
+      path: '$.values',
+      value: 2,
+      factResult: [2],
+      result: true
+    },
+    {
+      fact: 'low-priority',
+      operator: 'in',
+      value: [2],
+      factResult: 2,
+      result: true
+    }
+    ],
+    operator: 'all',
+    priority: 1
+  }
+  let successSpy
+  let failureSpy
+  let highPrioritySpy
+  let lowPrioritySpy
+
+  function delay (value) {
+    return new Promise(resolve => setTimeout(() => resolve(value), 5))
+  }
+
+  function setup (options = {}) {
+    const engine = new Engine()
+    highPrioritySpy = sandbox.spy()
+    lowPrioritySpy = sandbox.spy()
+
+    engine.addRule({
+      name: 'first',
+      priority: 10,
+      conditions: {
+        all: [{
+          fact: 'high-priority',
+          params: {
+            factParam
+          },
+          operator: 'contains',
+          path: '$.values',
+          value: options.highPriorityValue
+        }, {
+          fact: 'low-priority',
+          operator: 'in',
+          value: options.lowPriorityValue
+        }]
+      },
+      event: event1,
+      onSuccess: async (event, almanac, ruleResults) => {
+        expect(ruleResults.name).to.equal('first')
+        expect(ruleResults.event).to.deep.equal(event1)
+        expect(ruleResults.priority).to.equal(10)
+        expect(ruleResults.conditions).to.deep.equal(expectedFirstRuleResult)
+
+        return delay(almanac.addRuntimeFact('rule-created-fact', { array: options.highPriorityValue }))
+      }
+    })
+
+    engine.addRule({
+      name: 'second',
+      priority: 1,
+      conditions: {
+        all: [{
+          fact: 'high-priority',
+          params: {
+            factParam
+          },
+          operator: 'containsDivisibleValuesOf',
+          path: '$.values',
+          value: {
+            fact: 'rule-created-fact',
+            path: '$.array' // set by 'success' of first rule
+          }
+        }]
+      },
+      event: event2
+    })
+
+    engine.addOperator('containsDivisibleValuesOf', (factValue, jsonValue) => {
+      return factValue.some(v => v % jsonValue === 0)
+    })
+
+    engine.addFact('high-priority', async function (params, almanac) {
+      highPrioritySpy(params)
+      const idx = await almanac.factValue('sub-fact')
+      return delay({ values: [idx + params.factParam] }) // { values: [baseIndex + factParam] }
+    }, { priority: 2 })
+
+    engine.addFact('low-priority', async function (params, almanac) {
+      lowPrioritySpy(params)
+      const idx = await almanac.factValue('sub-fact')
+      return delay(idx + 1) // baseIndex + 1
+    }, { priority: 1 })
+
+    engine.addFact('sub-fact', async function (params, almanac) {
+      const baseIndex = await almanac.factValue('baseIndex')
+      return delay(baseIndex)
+    })
+    successSpy = sandbox.spy()
+    failureSpy = sandbox.spy()
+    engine.on('success', successSpy)
+    engine.on('failure', failureSpy)
+
+    return engine
+  }
+
+  it('succeeds', async () => {
+    const engine = setup({
+      highPriorityValue: 2,
+      lowPriorityValue: [2]
+    })
+
+    const engineResult = await engine.run({ baseIndex: 1 })
+
+    expect(engineResult.events.length).to.equal(2)
+    expect(engineResult.events[0]).to.deep.equal(event1)
+    expect(engineResult.events[1]).to.deep.equal(event2)
+    expect(successSpy).to.have.been.calledTwice()
+    expect(successSpy).to.have.been.calledWith(event1)
+    expect(successSpy).to.have.been.calledWith(event2)
+    expect(highPrioritySpy).to.have.been.calledBefore(lowPrioritySpy)
+    expect(failureSpy).to.not.have.been.called()
+  })
+
+  it('fails', async () => {
+    const engine = setup({
+      highPriorityValue: 2,
+      lowPriorityValue: [3] // falsey
+    })
+
+    const engineResult = await engine.run({ baseIndex: 1, 'rule-created-fact': '' })
+
+    expect(engineResult.events.length).to.equal(0)
+    expect(failureSpy).to.have.been.calledTwice()
+    expect(failureSpy).to.have.been.calledWith(event1)
+    expect(failureSpy).to.have.been.calledWith(event2)
+    expect(highPrioritySpy).to.have.been.calledBefore(lowPrioritySpy)
+    expect(successSpy).to.not.have.been.called()
+  })
+})