@wmfs/statelint 1.24.0 → 1.26.0

package/test/statelint_test.js

@@ -7,43 +7,84 @@ const expect = chai.expect
 const stateLint = require('../lib')
 
 describe('StateMachineLint', () => {
-  verify(
-    'Allow Fail states to omit optional Cause/Error fields',
-    require('./fixtures/minimal-fail-state.json'),
-    0
-  )
+  describe('Fail states', () => {
+    verify(
+      'Allow Fail states to omit optional Cause/Error fields',
+      require('./fixtures/minimal-fail-state.json')
+    )
+
+    verify(
+      'Allow Fail states to use ErrorPath and CausePath fields',
+      require('./fixtures/fail-with-error-and-cause-path.json')
+    )
+
+    verify(
+      'Allow Fail states to use ErrorPath and CausePath fields with intrinsic functions',
+      require('./fixtures/fail-with-error-and-cause-path-using-intrinsic-functions.json')
+    )
+
+    verify(
+      'Reject Fail state with both static and dynamic error',
+      require('./fixtures/fail-with-static-and-dynamic-error.json'),
+      'may have only one of Error,ErrorPath'
+    )
+
+    verify(
+      'Reject Fail state with both static and dynamic cause',
+      require('./fixtures/fail-with-static-and-dynamic-cause.json'),
+      'may have only one of Cause,CausePath'
+    )
+  })
+
+  describe('Delay and Jitter', () => {
+    verify(
+      'Allow Retry to with MaxDelaySeconds and JitterStrategy',
+      require('./fixtures/backoff-with-jitter-on-retry.json')
+    )
+
+    verify(
+      'Reject invalid JitterStrategy',
+      require('./fixtures/backoff-with-invalid-jitter-on-retry.json'),
+      'not one of the allowed values FULL,NONE'
+    )
+
+    verify(
+      'Reject invalid MaxDelaySeconds',
+      require('./fixtures/invalid-backoff-with-jitter-on-retry.json'),
+      'allowed floor is 0'
+    )
+  })
 
   describe('Empty ErrorEquals clauses', () => {
     verify(
-      'reject empty ErrorEquals on Catch',
+      'Reject empty ErrorEquals on Catch',
       require('./fixtures/empty-error-equals-on-catch'),
-      1,
       'non-empty required'
     )
 
     verify(
-      'reject empty ErrorEquals on Retry',
+      'Reject empty ErrorEquals on Retry',
       require('./fixtures/empty-error-equals-on-retry'),
-      1,
       'non-empty required'
     )
   })
 
-  describe('Parameters only valid on Pass, Task, and Parallel', () => {
+  describe('Parameters only valid on Pass, Task, Parallel, and Map', () => {
+    verify(
+      'Pass with Parameters',
+      require('./fixtures/pass-with-parameters')
+    )
     verify(
-      'Pass With Parameters',
-      require('./fixtures/pass-with-parameters'),
-      0
+      'Task with Parameters',
+      require('./fixtures/task-with-parameters')
     )
     verify(
-      'Task With Parameters',
-      require('./fixtures/task-with-parameters'),
-      0
+      'Parallel with Parameters',
+      require('./fixtures/parallel-with-parameters')
     )
     verify(
-      'Parallel With Parameters',
-      require('./fixtures/parallel-with-parameters'),
-      0
+      'Map with Parameters',
+      require('./fixtures/map-with-parameters')
     )
   })
 
@@ -51,25 +92,21 @@ describe('StateMachineLint', () => {
     verify(
       'Choice With Parameters',
       require('./fixtures/choice-with-parameters'),
-      1,
       '"Parameters'
     )
     verify(
       'Wait With Parameters',
       require('./fixtures/wait-with-parameters'),
-      1,
       '"Parameters'
     )
     verify(
       'Succeed With Parameters',
       require('./fixtures/succeed-with-parameters'),
-      1,
       '"Parameters'
     )
     verify(
       'Fail With Parameters',
       require('./fixtures/fail-with-parameters'),
-      1,
       '"Parameters'
     )
   })
@@ -78,7 +115,6 @@ describe('StateMachineLint', () => {
     verify(
       'reject non-Path constructs in Parameter fields ending in ".$"',
       require('./fixtures/parameter-path-problems'),
-      4,
       'bad1',
       'bad2',
       'bad3',
@@ -89,18 +125,15 @@ describe('StateMachineLint', () => {
   describe('ResultPath only valid on Pass, Task, Parallel', () => {
     verify(
       'Pass with ResultPath',
-      require('./fixtures/pass-with-resultpath'),
-      0
+      require('./fixtures/pass-with-resultpath')
     )
     verify(
       'Task with ResultPath',
-      require('./fixtures/task-with-resultpath'),
-      0
+      require('./fixtures/task-with-resultpath')
     )
     verify(
       'Parallel with ResultPath',
-      require('./fixtures/parallel-with-resultpath'),
-      0
+      require('./fixtures/parallel-with-resultpath')
     )
   })
 
@@ -108,199 +141,239 @@ describe('StateMachineLint', () => {
     verify(
       'Choice with ResultPath',
       require('./fixtures/choice-with-resultpath'),
-      1,
       '"ResultPath"'
     )
     verify(
       'Wait with ResultPath',
       require('./fixtures/wait-with-resultpath'),
-      1,
       '"ResultPath"'
     )
     verify(
       'Succeed with ResultPath',
       require('./fixtures/succeed-with-resultpath'),
-      1,
       '"ResultPath"'
     )
     verify(
       'Fail with ResultPath',
       require('./fixtures/fail-with-resultpath'),
-      1,
       '"ResultPath"'
     )
   })
 
-  describe('StateNode', () => {
-    verify(
-      'should find missing StartAt targets',
-      {
-        StartAt: 'x',
-        States: {
-          y: {
-            Type: 'Succeed'
-          }
-        }
-      },
-      2
+  describe('Context object', () => {
+    verify(
+      'Allow context object access in InputPath and OutputPath',
+      require('./fixtures/pass-with-io-path-context-object.json')
     )
-
     verify(
-      'should catch nested problems',
-      {
-        StartAt: 'x',
-        States: {
-          x: {
-            StartAt: 'z',
-            States: {
-              w: 1
-            }
-          }
-        }
-      },
-      8
+      'Allow context object access in Choice state Variable',
+      require('./fixtures/choice-with-context-object.json')
     )
-
     verify(
-      'should find States.ALL not in last position',
-      {
-        Retry: [
-          { ErrorEquals: ['States.ALL'] },
-          { ErrorEquals: ['YET ANOTHER'] }
-        ]
-      },
-      6
+      'Allow context object access in Map state ItemsPath',
+      require('./fixtures/map-with-itemspath-context-object.json')
     )
+  })
 
+  describe('Timeouts', () => {
+    verify(
+      'Allow dynamic timeout fields in Task state',
+      require('./fixtures/task-with-dynamic-timeouts.json')
+    )
     verify(
-      'should find States.ALL not by itself',
-      {
-        Retry: [
-          { ErrorEquals: ['YET ANOTHER'] },
-          { ErrorEquals: ['States.ALL', 'other'] }
-        ]
-      },
-      6
+      'Reject task with static and dynamic timeouts',
+      require('./fixtures/task-with-static-and-dynamic-timeout.json'),
+      'may have only one of TimeoutSeconds,TimeoutSecondsPath'
     )
+    verify(
+      'Reject task with static and dynamic timeouts',
+      require('./fixtures/task-with-static-and-dynamic-heartbeat.json'),
+      'may have only one of HeartbeatSeconds,HeartbeatSecondsPath'
+    )
+  })
 
+  describe('Null paths', () => {
     verify(
-      'should use Default field correctly',
-      {
-        StartAt: 'A',
-        States: {
-          A: {
-            Type: 'Choice',
-            Choices: [
-              {
-                Variable: '$.a',
-                StringEquals: 'whoo',
-                Next: 'B'
-              }
-            ],
-            Default: 'C'
-          },
-          B: {
-            Type: 'Succeed'
-          },
-          C: {
-            Type: 'Succeed'
-          }
-        }
-      },
-      0
+      'Allow null values in InputPath',
+      require('./fixtures/pass-with-null-inputpath.json')
     )
+    verify(
+      'Allow null values in OutputPath',
+      require('./fixtures/pass-with-null-outputpath.json')
+    )
+    verify(
+      'Not allow null value in Map state ItemsPath',
+      require('./fixtures/map-with-null-itemspath.json'),
+      'ItemsPath'
+    )
+  })
 
+  describe('ResultSelector', () => {
+    verify(
+      'Allow ResultSelector on Task',
+      require('./fixtures/task-with-resultselector.json')
+    )
+    verify(
+      'Allow ResultSelector on Parallel',
+      require('./fixtures/parallel-with-resultselector.json')
+    )
+    verify(
+      'Allow ResultSelector on Map',
+      require('./fixtures/map-with-resultselector.json')
+    )
     verify(
-      'should find Next fields with targets that don\'t match state names',
-      {
-        StartAt: 'A',
-        States: {
-          A: {
-            Type: 'Pass',
-            Next: 'B'
-          }
-        }
-      },
-      2
+      'Reject ResultSelector on Pass',
+      require('./fixtures/pass-with-resultselector.json'),
+      '"ResultSelector"'
     )
+    verify(
+      'Reject ResultSelector on Wait',
+      require('./fixtures/wait-with-resultselector.json'),
+      '"ResultSelector"'
+    )
+    verify(
+      'Reject ResultSelector on Fail',
+      require('./fixtures/fail-with-resultselector.json'),
+      '"ResultSelector"'
+    )
+    verify(
+      'Reject ResultSelector on Succeed',
+      require('./fixtures/succeed-with-resultselector.json'),
+      '"ResultSelector"'
+    )
+    verify(
+      'Reject ResultSelector on Choice',
+      require('./fixtures/choice-with-resultselector.json'),
+      '"ResultSelector"'
+    )
+  })
 
+  describe('Intrinsic function invocation in payload builder fields', () => {
+    verify(
+      'States Array invocation',
+      require('./fixtures/states-array-invocation.json')
+    )
+    verify(
+      'States Format invocation',
+      require('./fixtures/states-format-invocation.json')
+    )
+    verify(
+      'States StringToJson invocation',
+      require('./fixtures/states-stringtojson-invocation.json')
+    )
+    verify(
+      'States JsonToString invocation',
+      require('./fixtures/states-jsontostring-invocation.json')
+    )
+    verify(
+      'Reject invalid States Array invocation',
+      require('./fixtures/states-array-invocation-leftpad.json'),
+      'not a JSONPath or intrinsic function expression'
+    )
+    verify(
+      'Reject invalid Function invocation',
+      require('./fixtures/invalid-function-invocation.json'),
+      'not a JSONPath or intrinsic function expression'
+    )
     verify(
-      'should find un-pointed-to states',
-      {
-        StartAt: 'A',
-        States: {
-          A: {
-            Type: 'Succeed'
-          },
-          X: {
-            Type: 'Succeed'
-          }
-        }
-      },
-      1
+      'Reject intrinsic function inputpath',
+      require('./fixtures/pass-with-intrinsic-function-inputpath.json'),
+      '"InputPath"'
     )
+  })
 
+  describe('Functions added in 2022', () => {
+    verify(
+      'Array intrinsic function',
+      require('./fixtures/states-array-intrinsic-functions.json')
+    )
     verify(
-      'should find missing terminal state',
-      {
-        StartAt: 'A',
-        States: {
-          A: {
-            Type: 'Pass',
-            Next: 'B'
-          },
-          B: {
-            Type: 'Pass',
-            Next: 'A'
-          }
-        }
-      },
-      1
+      'Encoding/decoding intrinsic function',
+      require('./fixtures/states-encoding-decoding-intrinsic-functions.json')
     )
+    verify(
+      'Hash intrinsic function',
+      require('./fixtures/states-hash-intrinsic-functions.json')
+    )
+    verify(
+      'Json intrinsic function',
+      require('./fixtures/states-json-intrinsic-functions.json')
+    )
+    verify(
+      'Math intrinsic function',
+      require('./fixtures/states-math-intrinsic-functions.json')
+    )
+    verify(
+      'String intrinsic function',
+      require('./fixtures/states-string-intrinsic-functions.json')
+    )
+    verify(
+      'UUID intrinsic function',
+      require('./fixtures/states-uuid-intrinsic-functions.json')
+    )
+  })
 
+  describe('Comment', () => {
     verify(
-      'should handle complex missing terminal',
-      require('./fixtures/no-terminal.json'),
-      1
+      'Allow Choice Rule to use Comment',
+      require('./fixtures/choice-rule-with-comment.json')
     )
+    verify(
+      'Allow a Comment field in Catcher',
+      require('./fixtures/succeed-with-comment-in-catcher.json')
+    )
+  })
 
+  describe('Map state', () => {
+    verify(
+      'Allow ItemProcessor in Map',
+      require('./fixtures/map-with-itemprocessor.json')
+    )
+    verify(
+      'Reject Map state with both Iterator and ItemProcessor',
+      require('./fixtures/map-with-itemprocessor-and-iterator.json'),
+      'may have only one of Iterator,ItemProcessor'
+    )
     verify(
-      'should catch linkage from one parallel branch to another',
-      require('./fixtures/linked-parallel.json'),
-      4
+      'Reject Map state with both Parameters and ItemSelector',
+      require('./fixtures/map-with-parameters-and-itemselector.json'),
+      'may have only one of ItemSelector,Parameters'
     )
+  })
 
+  describe('Task state', () => {
+    verify(
+      'Allow Credentials in Task',
+      require('./fixtures/task-with-credentials.json')
+    )
     verify(
-      'should catch duplicate state names, even in parallels',
-      require('./fixtures/has-dupes.json'),
-      1
+      'Reject invalid Credentials in Task',
+      require('./fixtures/task-with-invalid-credentials.json'),
+      'should be an Object'
     )
   })
 
   describe('Validate Catch', () => {
     verify(
       'Catch States.ALL',
-      require('./fixtures/hello-world-with-caught-failures'),
-      0)
+      require('./fixtures/hello-world-with-caught-failures')
+    )
   })
 
   describe('Real-life state machines', () => {
     verify(
       'BackoffRate maybe an integer',
-      require('./fixtures/j2119_issues_37'),
-      0
+      require('./fixtures/j2119_issues_37')
     )
   })
 })
 
-function verify (label, json, count, ...msg) {
+function verify (label, json, ...msg) {
   it(label, () => {
     const linter = stateLint()
     const problems = linter.validate(json)
 
-    console.log(problems)
-
-    expect(problems.length).to.eql(count)
+    expect(problems.length).to.eql(msg.length)
     for (let i = 0; i !== msg.length; ++i) {
       expect(problems[i]).to.include(msg[i])
     }