feat: refactor and enable And, Not, Or operators with tests

lib/execute-operator.js

@@ -0,0 +1,20 @@
+const findOperator = require('./find-operator')
+
+const isJSONPath = p => (p && typeof p.valueOf() === 'string') && p.length !== 0 && p[0] === '$'
+
+module.exports = function executeOperator (choice, inputCache, values) {
+  const operator = findOperator(choice)
+
+  const inputValue = inputCache.get(choice.Variable, values)
+
+  if (operator.isPath && isJSONPath(operator.value)) {
+    operator.value = inputCache.get(operator.value, values)
+  }
+
+  return operator.operator(
+    inputValue,
+    operator.value,
+    choice.Next,
+    inputCache
+  )
+}

lib/find-operator.js

@@ -0,0 +1,27 @@
+const operators = require('./operators')
+
+module.exports = function findOperator (choice) {
+  let operator
+  let value
+  let isPath = false
+
+  Object.entries(choice).forEach(([k, v]) => {
+    if (operator === undefined) {
+      if (k.endsWith('Path')) {
+        k = k.split('Path')[0]
+        isPath = true
+      }
+
+      if (operators[k]) {
+        operator = operators[k]
+        value = v
+      }
+    }
+  })
+
+  return {
+    operator,
+    value,
+    isPath
+  }
+}

lib/index.js

@@ -1,30 +1,37 @@
 'use strict'
 
 const InputValueCache = require('./Input-value-cache')
-const getTopLevelChoices = require('./get-top-level-choices')
-const isJSONPath = p => (p && typeof p.valueOf() === 'string') && p.length !== 0 && p[0] === '$'
+const executeOperator = require('./execute-operator')
 
 module.exports = function (definition) {
-  const choices = getTopLevelChoices(definition.Choices)
-
   return function calculateNextState (values) {
     const inputCache = new InputValueCache()
 
-    for (const choice of choices) {
-      const inputValue = inputCache.get(choice.definition.Variable, values)
-
-      if (choice.operatorIsPath && isJSONPath(choice.operatorValue)) {
-        choice.operatorValue = inputCache.get(choice.operatorValue, values)
+    for (const choice of definition.Choices) {
+      if (choice.Not) {
+        const nextState = executeOperator({ ...choice.Not, Next: choice.Next }, inputCache, values)
+
+        if (!nextState) return choice.Next
+      } else if (choice.And || choice.Or) {
+        const allChoices = choice.And || choice.Or
+        const allNextStates = allChoices.map(c => executeOperator({ ...c, Next: choice.Next }, inputCache, values))
+
+        if (choice.And) {
+          const allEqual = arr => arr.every(v => v === arr[0])
+
+          if (allEqual(allNextStates) && allNextStates[0] === choice.Next) {
+            return choice.Next
+          }
+        } else if (choice.Or) {
+          if (allNextStates.includes(choice.Next)) {
+            return choice.Next
+          }
+        }
+      } else {
+        const nextState = executeOperator(choice, inputCache, values)
+
+        if (nextState) return nextState
       }
-
-      const nextState = choice.operator(
-        inputValue,
-        choice.operatorValue,
-        choice.definition.Next,
-        inputCache
-      )
-
-      if (nextState) return nextState
     }
 
     return definition.Default ? definition.Default : null

lib/operators/index.js

@@ -1,16 +1,13 @@
 module.exports = {
-  And: require('./and'),
   BooleanEquals: require('./boolean-equals'),
   Includes: require('./includes'),
   IsUndefined: require('./is-undefined'),
   IsNull: require('./is-null'),
-  Not: require('./not'),
   NumericEquals: require('./numeric-equals'),
   NumericGreaterThan: require('./numeric-greater-than'),
   NumericGreaterThanEquals: require('./numeric-greater-than-equals'),
   NumericLessThan: require('./numeric-less-than'),
   NumericLessThanEquals: require('./numeric-less-than-equals'),
-  Or: require('./or'),
   StringEquals: require('./string-equals'),
   StringGreaterThan: require('./string-greater-than'),
   StringGreaterThanEquals: require('./string-greater-than-equals'),

test/boolean-expr-tests.js

@@ -0,0 +1,208 @@
+/* eslint-env mocha */
+
+'use strict'
+
+const chai = require('chai')
+const expect = chai.expect
+
+// As inspired-by: http://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-choice-state.html#amazon-states-language-choice-state-rules
+
+const choiceProcessor = require('./../lib')
+
+const tests = {
+  Not: [
+    {
+      choices: {
+        Choices: [
+          {
+            Not: {
+              Variable: '$.type',
+              StringEquals: 'Private'
+            },
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { type: 'Public' },
+      expected: 'NextState'
+    },
+    {
+      choices: {
+        Choices: [
+          {
+            Not: {
+              Variable: '$.type',
+              StringEquals: 'Private'
+            },
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { type: 'Private' },
+      expected: 'DefaultState'
+    }
+  ],
+  And: [
+    {
+      choices: {
+        Choices: [
+          {
+            And: [
+              {
+                Variable: '$.value',
+                NumericGreaterThan: 20
+              },
+              {
+                Variable: '$.value',
+                NumericLessThan: 25
+              }
+            ],
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { value: 21 },
+      expected: 'NextState'
+    },
+    {
+      choices: {
+        Choices: [
+          {
+            And: [
+              {
+                Variable: '$.value',
+                NumericGreaterThan: 20
+              },
+              {
+                Variable: '$.value',
+                NumericLessThan: 25
+              }
+            ],
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { value: 20 },
+      expected: 'DefaultState'
+    },
+    {
+      choices: {
+        Choices: [
+          {
+            And: [
+              {
+                Variable: '$.value',
+                NumericGreaterThan: 20
+              },
+              {
+                Variable: '$.value',
+                NumericLessThan: 25
+              }
+            ],
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { value: 28 },
+      expected: 'DefaultState'
+    }
+  ],
+  Or: [
+    {
+      choices: {
+        Choices: [
+          {
+            Or: [
+              {
+                Variable: '$.value',
+                NumericGreaterThan: 22
+              },
+              {
+                Variable: '$.value',
+                NumericLessThan: 25
+              }
+            ],
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { value: 22 },
+      expected: 'NextState'
+    },
+    {
+      choices: {
+        Choices: [
+          {
+            Or: [
+              {
+                Variable: '$.value',
+                NumericGreaterThan: 22
+              },
+              {
+                Variable: '$.value',
+                NumericLessThan: 25
+              }
+            ],
+            Next: 'NextState'
+          }
+        ],
+        Default: 'DefaultState'
+      },
+      input: { value: 25 },
+      expected: 'NextState'
+    }
+  ],
+  Mixed: [
+    {
+      choices: {
+        Choices: [
+          {
+            Not: {
+              Variable: '$.type',
+              StringEquals: 'Private'
+            },
+            Next: 'Public'
+          },
+          {
+            And: [
+              {
+                Variable: '$.value',
+                NumericGreaterThanEquals: 20
+              },
+              {
+                Variable: '$.value',
+                NumericLessThan: 30
+              }
+            ],
+            Next: 'ValueInTwenties'
+          }
+        ],
+        Default: 'RecordEvent'
+      },
+      input: { type: 'Private', value: 22 },
+      expected: 'ValueInTwenties'
+    }
+  ]
+}
+
+describe('Boolean expression', () => {
+  for (const [operator, t] of Object.entries(tests)) {
+    describe(operator, () => {
+      let i = 0
+      for (const { choices, input, expected } of t) {
+        i++
+        it(`${i}`, () => {
+          const calculateNextState = choiceProcessor(choices)
+          const result = calculateNextState(input)
+          expect(result).to.eql(expected)
+        })
+      }
+    })
+  }
+})