Merge pull request #532 from mclift/bugfix/OnEntryFromAsync-InvalidOp…

…erationException Bugfix: execute OnEntryFromAsync actions from FireAsync
dotnet-state-machine · Jul 4, 2023 · b45b999 · b45b999
2 parents 22e29cd + 5bcedd6
commit b45b999
Show file tree

Hide file tree

Showing 2 changed files with 75 additions and 1 deletion.
diff --git a/src/Stateless/EntryActionBehaviour.cs b/src/Stateless/EntryActionBehaviour.cs
@@ -96,12 +96,18 @@ public AsyncFrom(TTriggerType trigger, Func<Transition, object[], Task> action,
                 public override void Execute(Transition transition, object[] args)
                 {
                     if (transition.Trigger.Equals(Trigger))
+                    {
                         base.Execute(transition, args);
+                    }
                 }
 
                 public override Task ExecuteAsync(Transition transition, object[] args)
                 {
-                    Execute(transition, args);
+                    if (transition.Trigger.Equals(Trigger))
+                    {
+                        return base.ExecuteAsync(transition, args);
+                    }
+
                     return TaskResult.Done;
                 }
             }

diff --git a/test/Stateless.Tests/AsyncActionsFixture.cs b/test/Stateless.Tests/AsyncActionsFixture.cs
@@ -472,6 +472,74 @@ public void VerifyNotEnterSuperstateWhenDoingInitialTransition()
 
             Assert.Equal(State.D, sm.State);
         }
+
+        [Fact]
+        public void OnEntryFromAsync_WhenTriggeredSynchronously_Throws()
+        {
+            var sm = new StateMachine<State, Trigger>(State.A);
+
+            sm.Configure(State.A).Permit(Trigger.X, State.B);
+
+            sm.Configure(State.B)
+                .OnEntryFromAsync(Trigger.X, async () => await Task.Run(() => { }));
+
+            Assert.Throws<InvalidOperationException>(() => sm.Fire(Trigger.X));
+        }
+
+        [Fact]
+        public async Task OnEntryFromAsync_WhenTriggered_InvokesAction()
+        {
+            bool wasInvoked = false;
+
+            var sm = new StateMachine<State, Trigger>(State.A);
+
+            sm.Configure(State.A).Permit(Trigger.X, State.B);
+
+            sm.Configure(State.B)
+                .OnEntryFromAsync(Trigger.X, async () => await Task.Run(() => { wasInvoked = true; }));
+
+            await sm.FireAsync(Trigger.X);
+
+            Assert.True(wasInvoked);
+        }
+
+        [Fact]
+        public void OnEntryFromAsync_WhenEnteringByAnotherTriggerSynchronously_DoesNotThrow()
+        {
+            bool wasInvoked = false;
+
+            var sm = new StateMachine<State, Trigger>(State.A);
+
+            sm.Configure(State.A)
+                .Permit(Trigger.X, State.B)
+                .Permit(Trigger.Y, State.B);
+
+            sm.Configure(State.B)
+                .OnEntryFromAsync(Trigger.X, async () => await Task.Run(() => { wasInvoked = true; }));
+
+            sm.Fire(Trigger.Y);
+
+            Assert.False(wasInvoked);
+        }
+
+        [Fact]
+        public async Task OnEntryFromAsync_WhenEnteringByAnotherTrigger_InvokesAction()
+        {
+            bool wasInvoked = false;
+
+            var sm = new StateMachine<State, Trigger>(State.A);
+
+            sm.Configure(State.A)
+                .Permit(Trigger.X, State.B)
+                .Permit(Trigger.Y, State.B);
+
+            sm.Configure(State.B)
+                .OnEntryFromAsync(Trigger.X, async () => await Task.Run(() => { wasInvoked = true; }));
+
+            await sm.FireAsync(Trigger.Y);
+
+            Assert.False(wasInvoked);
+        }
     }
 }