public void LoadingNonInitializedStateMachine( AsyncPassiveStateMachine <State, Event> loadedMachine) { "when a non-initialized state machine is loaded".x(async() => { var loader = new StateMachineLoader <State>(); loader.SetCurrentState(new Initializable <State>()); loader.SetHistoryStates(new Dictionary <State, State>()); var stateMachineDefinitionBuilder = new StateMachineDefinitionBuilder <State, Event>(); SetupStates(stateMachineDefinitionBuilder); loadedMachine = stateMachineDefinitionBuilder .WithInitialState(State.A) .Build() .CreatePassiveStateMachine(); await loadedMachine.Load(loader); }); "it should not be initialized already".x(async() => { var stateMachineSaver = new StateMachineSaver <State>(); await loadedMachine.Save(stateMachineSaver); stateMachineSaver .CurrentStateId .IsInitialized .Should() .BeFalse(); }); }
public void SavingEventsForPassiveStateMachine( AsyncPassiveStateMachine <string, int> machine, StateMachineSaver <string, int> saver) { "establish a state machine".x(() => { var stateMachineDefinitionBuilder = new StateMachineDefinitionBuilder <string, int>(); stateMachineDefinitionBuilder .In("A") .On(1) .Goto("B"); stateMachineDefinitionBuilder .In("B") .On(2) .Goto("C"); stateMachineDefinitionBuilder .In("C") .On(3) .Goto("A"); machine = stateMachineDefinitionBuilder .WithInitialState("A") .Build() .CreatePassiveStateMachine(); }); "when events are fired".x(async() => { await machine.Fire(1); await machine.Fire(2); await machine.FirePriority(3); await machine.FirePriority(4); }); "and it is saved".x(async() => { saver = new StateMachineSaver <string, int>(); await machine.Save(saver); }); "it should save those events".x(() => { saver .Events .Select(x => x.EventId) .Should() .HaveCount(2) .And .ContainInOrder(1, 2); saver .PriorityEvents .Select(x => x.EventId) .Should() .HaveCount(2) .And .ContainInOrder(4, 3); }); }
public void Loading( StateMachineSaver <State> saver, StateMachineLoader <State> loader, FakeExtension extension, State sourceState, State targetState) { "establish a saved state machine with history"._(async() => { var machine = new AsyncPassiveStateMachine <State, Event>(); DefineMachine(machine); await machine.Initialize(State.A); await machine.Start(); await machine.Fire(Event.S2); // set history of super state S await machine.Fire(Event.B); // set current state to B saver = new StateMachineSaver <State>(); loader = new StateMachineLoader <State>(); await machine.Save(saver); }); "when state machine is loaded"._(async() => { loader.SetCurrentState(saver.CurrentStateId); loader.SetHistoryStates(saver.HistoryStates); extension = new FakeExtension(); var loadedMachine = new AsyncPassiveStateMachine <State, Event>(); loadedMachine.AddExtension(extension); DefineMachine(loadedMachine); await loadedMachine.Load(loader); loadedMachine.TransitionCompleted += (sender, args) => { sourceState = args.StateId; targetState = args.NewStateId; }; await loadedMachine.Start(); await loadedMachine.Fire(Event.S); }); "it should reset current state"._(() => sourceState.Should().Be(State.B)); "it should reset all history states of super states"._(() => targetState.Should().Be(State.S2)); "it should notify extensions"._(() => extension.LoadedCurrentState .Should().BeEquivalentTo(State.B)); }