/// <summary>
/// Fires the specified event.
/// </summary>
/// <param name="eventId">The event.</param>
/// <param name="eventArgument">The event argument.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task Fire(TEvent eventId, object eventArgument)
{
this.CheckThatStateMachineIsInitialized();
this.CheckThatStateMachineHasEnteredInitialState();
await this.ForEach(extension => extension.FiringEvent(this, ref eventId, ref eventArgument))
.ConfigureAwait(false);
ITransitionContext <TState, TEvent> context = this.factory.CreateTransitionContext(this.CurrentState, new Missable <TEvent>(eventId), eventArgument, this);
ITransitionResult <TState, TEvent> result = await this.CurrentState.Fire(context).ConfigureAwait(false);
if (!result.Fired)
{
this.OnTransitionDeclined(context);
return;
}
await this.SetCurrentState(result.NewState)
.ConfigureAwait(false);
await this.ForEach(extension => extension.FiredEvent(this, context))
.ConfigureAwait(false);
this.OnTransitionCompleted(context);
}
/// <summary>
/// Goes recursively up the state hierarchy until a state is found that can handle the event.
/// </summary>
/// <param name="context">The event context.</param>
/// <returns>The result of the transition.</returns>
public ITransitionResult <TState, TEvent> Fire(ITransitionContext <TState, TEvent> context)
{
Ensure.ArgumentNotNull(context, "context");
ITransitionResult <TState, TEvent> result = TransitionResult <TState, TEvent> .NotFired;
var transitionsForEvent = this.transitions[context.EventId.Value];
if (transitionsForEvent != null)
{
foreach (ITransition <TState, TEvent> transition in transitionsForEvent)
{
result = transition.Fire(context);
if (result.Fired)
{
return(result);
}
}
}
if (this.SuperState != null)
{
result = this.SuperState.Fire(context);
}
return(result);
}
public void ReturnsNotFiredTransitionResult_WhenGuardIsNotMet()
{
var guard = Builder <States, Events> .CreateGuardHolder().ReturningFalse().Build();
this.Testee.Guard = guard;
ITransitionResult <States, Events> result = this.Testee.Fire(this.TransitionContext);
result.Should().BeNotFiredTransitionResult <States, Events>();
}
public static void BeNotFiredTransitionResult <TStates, TEvents>(this ObjectAssertions assertions)
where TStates : IComparable
where TEvents : IComparable
{
ITransitionResult <TStates, TEvents> transitionResult = (ITransitionResult <TStates, TEvents>)assertions.Subject;
Execute.Assertion
.ForCondition(!transitionResult.Fired)
.FailWith("expected not fired transition result.");
}
public static void BeSuccessfulTransitionResultWithNewState <TStates, TEvents>(this ObjectAssertions assertions, IState <TStates, TEvents> expectedNewState)
where TStates : IComparable
where TEvents : IComparable
{
ITransitionResult <TStates, TEvents> transitionResult = (ITransitionResult <TStates, TEvents>)assertions.Subject;
Execute.Assertion
.ForCondition(transitionResult.Fired)
.FailWith("expected successful (fired) transition result.");
Execute.Assertion
.ForCondition(transitionResult.NewState.Id.CompareTo(expectedNewState.Id) == 0)
.FailWith("expected transition result with new state = `" + expectedNewState.Id + "`, but found `" + transitionResult.NewState.Id + "`.");
}
public void NotifiesExtensions_WhenGuardIsNotMet()
{
var extension = A.Fake <IExtension <States, Events> >();
this.ExtensionHost.Extension = extension;
IGuardHolder guard = Builder <States, Events> .CreateGuardHolder().ReturningFalse().Build();
this.Testee.Guard = guard;
ITransitionResult <States, Events> result = this.Testee.Fire(this.TransitionContext);
A.CallTo(() => extension.SkippedTransition(
this.StateMachineInformation,
A <ITransition <States, Events> > .That.Matches(t => t.Source == this.Source && t.Target == this.Target),
this.TransitionContext)).MustHaveHappened();
}
protected void SetCookies(HttpResponse httpResponse, ITransitionResult result)
{
if (!(result is StateResult))
{
return;
}
var cookies = ((StateResult)result).Cookies;
foreach (var cookie in cookies)
{
if (!cookie.Remove)
{
httpResponse.Cookies.Append(cookie.Name, cookie.Value, cookie.Options);
}
else
{
httpResponse.Cookies.Delete(cookie.Name, cookie.Options);
}
}
}
/// <summary>
/// Fires the specified event.
/// </summary>
/// <param name="eventId">The event.</param>
/// <param name="eventArgument">The event argument.</param>
public void Fire(TEvent eventId, object eventArgument)
{
this.CheckThatStateMachineIsInitialized();
this.CheckThatStateMachineHasEnteredInitialState();
this.extensions.ForEach(extension => extension.FiringEvent(this, ref eventId, ref eventArgument));
ITransitionContext <TState, TEvent> context = this.factory.CreateTransitionContext(this.CurrentState, new Missable <TEvent>(eventId), eventArgument, this);
ITransitionResult <TState, TEvent> result = this.CurrentState.Fire(context);
if (!result.Fired)
{
this.OnTransitionDeclined(context);
return;
}
this.CurrentState = result.NewState;
this.extensions.ForEach(extension => extension.FiredEvent(this, context));
this.OnTransitionCompleted(context);
}
public void ReturnsFiredTransitionResult()
{
ITransitionResult <States, Events> result = this.Testee.Fire(this.TransitionContext);
result.Fired.Should().BeTrue();
}
public void ReturnsSuccessfulTransitionResult()
{
ITransitionResult <States, Events> result = this.Testee.Fire(this.TransitionContext);
result.Should().BeSuccessfulTransitionResultWithNewState(this.Target);
}
public async Task ReturnsNotFiredTransitionResult()
{
ITransitionResult <States, Events> result = await this.Testee.Fire(this.TransitionContext);
result.Fired.Should().BeFalse();
}
