xstate 3.2.1 → 3.3.3

package/test/transient.test.ts

@@ -1,4 +1,4 @@
-import { Machine } from '../src/index';
+import { Machine, matchesState } from '../src/index';
 import { assert } from 'chai';
 
 describe('transient states (eventless transitions)', () => {
@@ -85,4 +85,186 @@ describe('transient states (eventless transitions)', () => {
 
     assert.deepEqual(state.actions, ['exit_A', 'timer', 'enter_B']);
   });
+
+  it('should execute all internal events one after the other', () => {
+    const machine = Machine({
+      parallel: true,
+      states: {
+        A: {
+          initial: 'A1',
+          states: {
+            A1: {
+              on: {
+                E: 'A2'
+              }
+            },
+            A2: {
+              onEntry: {
+                type: 'xstate.raise',
+                event: 'INT1'
+              }
+            }
+          }
+        },
+
+        B: {
+          initial: 'B1',
+          states: {
+            B1: {
+              on: {
+                E: 'B2'
+              }
+            },
+            B2: {
+              onEntry: {
+                type: 'xstate.raise',
+                event: 'INT2'
+              }
+            }
+          }
+        },
+
+        C: {
+          initial: 'C1',
+          states: {
+            C1: {
+              on: {
+                INT1: 'C2',
+                INT2: 'C3'
+              }
+            },
+            C2: {
+              on: {
+                INT2: 'C4'
+              }
+            },
+            C3: {
+              on: {
+                INT1: 'C4'
+              }
+            },
+            C4: {}
+          }
+        }
+      }
+    });
+
+    const state = machine.transition(machine.initialState, 'E');
+
+    assert.deepEqual(state.value, { A: 'A2', B: 'B2', C: 'C4' });
+  });
+
+  it('should execute all eventless transitions in the same microstep', () => {
+    const machine = Machine({
+      parallel: true,
+      states: {
+        A: {
+          initial: 'A1',
+          states: {
+            A1: {
+              on: {
+                E: 'A2' // the external event
+              }
+            },
+            A2: {
+              on: {
+                '': 'A3'
+              }
+            },
+            A3: {
+              on: {
+                '': {
+                  A4: { in: 'B.B3' }
+                }
+              }
+            },
+            A4: {}
+          }
+        },
+
+        B: {
+          initial: 'B1',
+          states: {
+            B1: {
+              on: {
+                E: 'B2'
+              }
+            },
+            B2: {
+              on: {
+                '': {
+                  B3: {
+                    in: 'A.A2'
+                  }
+                }
+              }
+            },
+            B3: {
+              on: {
+                '': {
+                  B4: {
+                    in: 'A.A3'
+                  }
+                }
+              }
+            },
+            B4: {}
+          }
+        }
+      }
+    });
+
+    const state = machine.transition(machine.initialState, 'E');
+
+    assert.deepEqual(state.value, { A: 'A4', B: 'B4' });
+  });
+
+  it('should check for automatic transitions even after microsteps are done', () => {
+    const machine = Machine({
+      parallel: true,
+      states: {
+        A: {
+          initial: 'A1',
+          states: {
+            A1: {
+              on: {
+                A: 'A2'
+              }
+            },
+            A2: {}
+          }
+        },
+        B: {
+          initial: 'B1',
+          states: {
+            B1: {
+              on: {
+                '': {
+                  B2: { cond: (_xs, _e, cs) => matchesState('A.A2', cs) }
+                }
+              }
+            },
+            B2: {}
+          }
+        },
+        C: {
+          initial: 'C1',
+          states: {
+            C1: {
+              on: {
+                '': {
+                  C2: { in: 'A.A2' }
+                }
+              }
+            },
+            C2: {}
+          }
+        }
+      }
+    });
+
+    let state = machine.initialState; // A1, B1, C1
+    state = machine.transition(state, 'A'); // A2, B2, C2
+    assert.deepEqual(state.value, { A: 'A2', B: 'B2', C: 'C2' });
+  });
 });