public void TransitionState_OnEnteredSendsFeedback_TransitionFurtherByFeedback()
{
//-- Arrange
var codeBehind = new PhilisopherCodeBehindWithEvents()
{
FeedBackFromEating = true
};
var machine = new TransientStateMachine <PhilisopherState, PhilisopherTrigger>(
codeBehind,
null);
machine.ReceiveTrigger(PhilisopherTrigger.Hungry);
codeBehind.TakeLog();
//-- Act
machine.ReceiveTrigger(PhilisopherTrigger.GotForks); // will receive feedback Full from EatingEntered
//-- Assert
Assert.Equal(machine.CurrentState, PhilisopherState.Thinking);
Assert.Equal(codeBehind.TakeLog(), new[] {
"AcquiringForksLeaving(from[AcquiringForks]to[Eating]by[GotForks])",
"TransitioningFromAcquiringForksToEating(from[AcquiringForks]to[Eating]by[GotForks])",
"EatingEntered(from[AcquiringForks]to[Eating]by[GotForks])",
"EatingLeaving(from[Eating]to[Thinking]by[Full])",
"TransitioningFromEatingToThinking(from[Eating]to[Thinking]by[Full])",
"ThinkingEntered(from[Eating]to[Thinking]by[Full])",
});
}
public void TransitionState_OnEnterThrows_StayInDestinationState()
{
//-- Arrange
var codeBehind = new PhilisopherCodeBehindWithEvents()
{
ThrowFromAcquiringForksEntered = true
};
var machine = new TransientStateMachine <PhilisopherState, PhilisopherTrigger>(
codeBehind,
null);
codeBehind.TakeLog();
//-- Act
var exception = Assert.Throws <TestCodeBehindException>(() => {
machine.ReceiveTrigger(PhilisopherTrigger.Hungry);
});
//-- Assert
Assert.Equal(exception.Message, "AcquiringForksEntered");
Assert.Equal(machine.CurrentState, PhilisopherState.AcquiringForks);
Assert.Equal(codeBehind.TakeLog(), new[] {
"ThinkingLeaving(from[Thinking]to[AcquiringForks]by[Hungry])",
"TransitioningFromThinkingToAcquiringForks(from[Thinking]to[AcquiringForks]by[Hungry])",
"THROWING-FROM:AcquiringForksEntered(from[Thinking]to[AcquiringForks]by[Hungry])",
});
}
public void TransitionState_OnTransitioningThrows_EnterOriginStateBack()
{
//-- Arrange
var codeBehind = new PhilisopherCodeBehindWithEvents()
{
ThrowFromTransitioningFromAcquiringForksToEating = true
};
var machine = new TransientStateMachine <PhilisopherState, PhilisopherTrigger>(
codeBehind,
null);
//-- Act
machine.ReceiveTrigger(PhilisopherTrigger.Hungry);
codeBehind.TakeLog();
var exception = Assert.Throws <TestCodeBehindException>(() => {
machine.ReceiveTrigger(PhilisopherTrigger.GotForks);
});
//-- Assert
Assert.Equal(exception.Message, "TransitioningFromAcquiringForksToEating");
Assert.Equal(machine.CurrentState, PhilisopherState.AcquiringForks);
Assert.Equal(codeBehind.TakeLog(), new[] {
"AcquiringForksLeaving(from[AcquiringForks]to[Eating]by[GotForks])",
"THROWING-FROM:TransitioningFromAcquiringForksToEating(from[AcquiringForks]to[Eating]by[GotForks])",
"AcquiringForksEntered(from[AcquiringForks]to[Eating]by[GotForks])"
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void FinalizeAfterUnload()
{
if (Interlocked.Decrement(ref _initializationCount) > 0)
{
return;
}
_container.Dispose();
_container = null;
_stateMachine = null;
}
public void NewInstance_InitialState()
{
//-- Arrange, Act
var machine = new TransientStateMachine <PhilisopherState, PhilisopherTrigger>(
new PhilisopherCodeBehind(),
null);
//-- Assert
Assert.Equal(machine.CurrentState, PhilisopherState.Thinking);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void InitializeBeforeConfigure()
{
if (Interlocked.Increment(ref _initializationCount) > 1)
{
return;
}
//_container = BuildBaseContainer(_registerHostComponents);
_stateMachine = new TransientStateMachine <MicroserviceState, MicroserviceTrigger>(
new StateMachineCodeBehind(this),
new Mocks.TransientStateMachineLoggerMock <MicroserviceState, MicroserviceTrigger>());
//_container.Resolve<TransientStateMachine<MicroserviceState, MicroserviceTrigger>.ILogger>());
_stateMachine.CurrentStateChanged += OnStateChanged;
}
public void TransitionState_InvokeEventHandlers()
{
//-- Arrange
var codeBehind = new PhilisopherCodeBehindWithEvents();
//-- Act
var machine = new TransientStateMachine <PhilisopherState, PhilisopherTrigger>(
codeBehind,
null);
var log1 = codeBehind.TakeLog();
machine.ReceiveTrigger(PhilisopherTrigger.Hungry);
var log2 = codeBehind.TakeLog();
machine.ReceiveTrigger(PhilisopherTrigger.GotForks);
var log3 = codeBehind.TakeLog();
machine.ReceiveTrigger(PhilisopherTrigger.Full);
var log4 = codeBehind.TakeLog();
//-- Assert
Assert.Equal(log1, new[] {
"ThinkingEntered(to[Thinking])",
});
Assert.Equal(log2, new[] {
"ThinkingLeaving(from[Thinking]to[AcquiringForks]by[Hungry])",
"TransitioningFromThinkingToAcquiringForks(from[Thinking]to[AcquiringForks]by[Hungry])",
"AcquiringForksEntered(from[Thinking]to[AcquiringForks]by[Hungry])",
});
Assert.Equal(log3, new[] {
"AcquiringForksLeaving(from[AcquiringForks]to[Eating]by[GotForks])",
"TransitioningFromAcquiringForksToEating(from[AcquiringForks]to[Eating]by[GotForks])",
"EatingEntered(from[AcquiringForks]to[Eating]by[GotForks])",
});
Assert.Equal(log4, new[] {
"EatingLeaving(from[Eating]to[Thinking]by[Full])",
"TransitioningFromEatingToThinking(from[Eating]to[Thinking]by[Full])",
"ThinkingEntered(from[Eating]to[Thinking]by[Full])",
});
}
public void ReceiveTrigger_TransitionState()
{
//-- Arrange
var machine = new TransientStateMachine <PhilisopherState, PhilisopherTrigger>(
new PhilisopherCodeBehind(),
null);
//-- Act
machine.ReceiveTrigger(PhilisopherTrigger.Hungry);
var state1 = machine.CurrentState;
machine.ReceiveTrigger(PhilisopherTrigger.GotForks);
var state2 = machine.CurrentState;
//-- Assert
Assert.Equal(state1, PhilisopherState.AcquiringForks);
Assert.Equal(state2, PhilisopherState.Eating);
}
