xstate 3.3.2 → 3.3.3

package/test/parallel.test.ts

@@ -1,5 +1,6 @@
 import { assert } from 'chai';
-import { Machine } from '../src/index';
+import { raise } from '../src/actions';
+import { Machine } from '../src/StateNode';
 import { testMultiTransition } from './utils';
 
 const composerMachine = Machine({
@@ -300,6 +301,157 @@ const flatParallelMachine = Machine({
   }
 });
 
+const raisingParallelMachine = Machine({
+  strict: true,
+  parallel: true,
+  states: {
+    OUTER1: {
+      initial: 'C',
+      states: {
+        A: {
+          onEntry: [raise('TURN_OFF')],
+          on: {
+            EVENT_OUTER1_B: 'B',
+            EVENT_OUTER1_C: 'C'
+          }
+        },
+        B: {
+          onEntry: [raise('TURN_ON')],
+          on: {
+            EVENT_OUTER1_A: 'A',
+            EVENT_OUTER1_C: 'C'
+          }
+        },
+        C: {
+          onEntry: [raise('CLEAR')],
+          on: {
+            EVENT_OUTER1_A: 'A',
+            EVENT_OUTER1_B: 'B'
+          }
+        }
+      }
+    },
+    OUTER2: {
+      parallel: true,
+      states: {
+        INNER1: {
+          initial: 'ON',
+          states: {
+            OFF: {
+              on: {
+                TURN_ON: 'ON'
+              }
+            },
+            ON: {
+              on: {
+                CLEAR: 'OFF'
+              }
+            }
+          }
+        },
+        INNER2: {
+          initial: 'OFF',
+          states: {
+            OFF: {
+              on: {
+                TURN_ON: 'ON'
+              }
+            },
+            ON: {
+              on: {
+                TURN_OFF: 'OFF'
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+});
+
+const nestedParallelState = Machine({
+  parallel: true,
+  states: {
+    OUTER1: {
+      initial: 'STATE_OFF',
+      states: {
+        STATE_OFF: {
+          on: {
+            EVENT_COMPLEX: 'STATE_ON',
+            EVENT_SIMPLE: 'STATE_ON'
+          }
+        },
+        STATE_ON: {
+          parallel: true,
+          states: {
+            STATE_NTJ0: {
+              initial: 'STATE_IDLE_0',
+              states: {
+                STATE_IDLE_0: {
+                  on: {
+                    EVENT_STATE_NTJ0_WORK: 'STATE_WORKING_0'
+                  }
+                },
+                STATE_WORKING_0: {
+                  on: {
+                    EVENT_STATE_NTJ0_IDLE: 'STATE_IDLE_0'
+                  }
+                }
+              }
+            },
+            STATE_NTJ1: {
+              initial: 'STATE_IDLE_1',
+              states: {
+                STATE_IDLE_1: {
+                  on: {
+                    EVENT_STATE_NTJ1_WORK: 'STATE_WORKING_1'
+                  }
+                },
+                STATE_WORKING_1: {
+                  on: {
+                    EVENT_STATE_NTJ1_IDLE: 'STATE_IDLE_1'
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    OUTER2: {
+      initial: 'STATE_OFF',
+      states: {
+        STATE_OFF: {
+          on: {
+            EVENT_COMPLEX: 'STATE_ON_COMPLEX',
+            EVENT_SIMPLE: 'STATE_ON_SIMPLE'
+          }
+        },
+        STATE_ON_SIMPLE: {},
+        STATE_ON_COMPLEX: {
+          parallel: true,
+          states: {
+            STATE_INNER1: {
+              initial: 'STATE_OFF',
+              states: {
+                STATE_OFF: {},
+                STATE_ON: {}
+              }
+            },
+            STATE_INNER2: {
+              initial: 'STATE_OFF',
+              states: {
+                STATE_OFF: {},
+                STATE_ON: {}
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+});
+
 describe('parallel states', () => {
   it('should have initial parallel states', () => {
     const { initialState } = wordMachine;
@@ -409,4 +561,80 @@ describe('parallel states', () => {
       }
     });
   });
+
+  it('should properly transition according to onEntry events on an initial state', () => {
+    assert.deepEqual(raisingParallelMachine.initialState.value, {
+      OUTER1: 'C',
+      OUTER2: {
+        INNER1: 'OFF',
+        INNER2: 'OFF'
+      }
+    });
+  });
+
+  it('should properly transition when raising events for a parallel state', () => {
+    const nextState = raisingParallelMachine.transition(
+      raisingParallelMachine.initialState,
+      'EVENT_OUTER1_B'
+    );
+
+    assert.deepEqual(nextState.value, {
+      OUTER1: 'B',
+      OUTER2: {
+        INNER1: 'ON',
+        INNER2: 'ON'
+      }
+    });
+  });
+
+  describe('transitions with nested parallel states', () => {
+    const initialState = nestedParallelState.initialState;
+    const simpleNextState = nestedParallelState.transition(
+      initialState,
+      'EVENT_SIMPLE'
+    );
+    const complexNextState = nestedParallelState.transition(
+      initialState,
+      'EVENT_COMPLEX'
+    );
+
+    it('should properly transition when in a simple nested state', () => {
+      const nextState = nestedParallelState.transition(
+        simpleNextState,
+        'EVENT_STATE_NTJ0_WORK'
+      );
+
+      assert.deepEqual(nextState.value, {
+        OUTER1: {
+          STATE_ON: {
+            STATE_NTJ0: 'STATE_WORKING_0',
+            STATE_NTJ1: 'STATE_IDLE_1'
+          }
+        },
+        OUTER2: 'STATE_ON_SIMPLE'
+      });
+    });
+
+    it('should properly transition when in a complex nested state', () => {
+      const nextState = nestedParallelState.transition(
+        complexNextState,
+        'EVENT_STATE_NTJ0_WORK'
+      );
+
+      assert.deepEqual(nextState.value, {
+        OUTER1: {
+          STATE_ON: {
+            STATE_NTJ0: 'STATE_WORKING_0',
+            STATE_NTJ1: 'STATE_IDLE_1'
+          }
+        },
+        OUTER2: {
+          STATE_ON_COMPLEX: {
+            STATE_INNER1: 'STATE_OFF',
+            STATE_INNER2: 'STATE_OFF'
+          }
+        }
+      });
+    });
+  });
 });