Add missing transitionTo to If/ElseIf/Else statements

Author: leeoades

FunctionalStateMachine.Core.Tests/StateMachineAnalysisTests.cs

@@ -207,6 +207,56 @@ public void Validate_AllowsMultipleImmediateTransitionsWithoutCycle()
         Assert.NotNull(machine);
     }
 
+    [Fact]
+    public void Validate_DetectsConditionalTransitionToAmbiguity()
+    {
+        var machine = StateMachine<State, Trigger, Data, CommandBase>.Create()
+            .StartWith(State.A)
+            .For(State.A)
+                .On<Trigger.T1>()
+                    .If(data => data.Value > 5)
+                        .TransitionTo(State.B)
+                        .ElseIf(data => data.Value <= 5)
+                        .TransitionTo(State.C)
+                        .Done()
+            .For(State.B)
+                .On<Trigger.T1>()
+                    .TransitionTo(State.A)
+            .For(State.C)
+                .On<Trigger.T1>()
+                    .TransitionTo(State.A)
+            .Build();
+
+        Assert.NotNull(machine);
+    }
+
+    [Fact]
+    public void Validate_DetectsMultipleTransitionToInSameTransition()
+    {
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+        {
+            var machine = StateMachine<State, Trigger, Data, CommandBase>.Create()
+                .StartWith(State.A)
+                .For(State.A)
+                    .On<Trigger.T1>()
+                        .TransitionTo(State.B)
+                        .If(data => data.Value > 5)
+                            .Execute(() => new Command.Noop())
+                            .Else()
+                            .TransitionTo(State.C)
+                            .Done()
+                .For(State.B)
+                    .On<Trigger.T1>()
+                        .TransitionTo(State.A)
+                .For(State.C)
+                    .On<Trigger.T1>()
+                        .TransitionTo(State.A)
+                .Build();
+        });
+
+        Assert.Contains("TransitionTo", exception.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
     [Fact]
     public void Validate_AllowsComplexReachableStateMachine()
     {

FunctionalStateMachine.Core.Tests/StateMachineConditionalTests.cs

@@ -224,9 +224,54 @@ public void ElseIf_StopsAtFirstMatch()
         Assert.DoesNotContain("ElseIf2", executionLog);
     }
 
+    [Fact]
+    public void If_ConditionalTransitionToRequiresSingleTarget()
+    {
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+        {
+            var machine = StateMachine<State, Trigger, Data, CommandBase>.Create()
+                .StartWith(State.Ready)
+                .For(State.Ready)
+                    .On<Trigger.PayTrigger>()
+                        .If((data, trigger) => trigger.Amount >= 10m)
+                            .TransitionTo(State.Approved)
+                            .TransitionTo(State.Ready)
+                            .Done()
+                .For(State.Approved)
+                    .On<Trigger.PayTrigger>()
+                        .Ignore()
+                .Build();
+        });
+
+        Assert.Contains("TransitionTo", exception.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void If_AllowsSingleConditionalTransitionTo()
+    {
+        var machine = StateMachine<State, Trigger, Data, CommandBase>.Create()
+            .StartWith(State.Ready)
+            .For(State.Ready)
+                .On<Trigger.PayTrigger>()
+                    .If((data, trigger) => trigger.Amount >= 10m)
+                        .TransitionTo(State.Approved)
+                        .Else()
+                        .Execute(() => new LogCommand("Declined"))
+                        .Done()
+            .For(State.Approved)
+                .On<Trigger.PayTrigger>()
+                    .Ignore()
+            .Build();
+
+        var (newState, _, _) = machine.Fire(new Trigger.PayTrigger(4m), State.Ready, new Data(0m));
+
+        Assert.Equal(State.Ready, newState);
+    }
+
     private enum State
     {
-        Ready
+        Ready,
+        Approved
     }
 
     private abstract record Trigger

FunctionalStateMachine.Core/StateMachine.cs

@@ -146,15 +146,23 @@ private bool TryFireInternal(
                 return true;
             }
 
-            var targetState = transition.HasTargetState ? transition.TargetState! : currentState;
-            targetState = ResolveInitialLeaf(targetState);
-
             var commandList = new List<TCommand>();
-            var isStateChange = transition.HasTargetState
+            var updatedData = ApplyTransitionSteps(
+                commandList,
+                transition.Steps,
+                currentState,
+                currentData,
+                trigger,
+                out var conditionalHasTargetState,
+                out var conditionalTargetState);
+            var hasTargetState = transition.HasTargetState || conditionalHasTargetState;
+            var targetState = transition.HasTargetState
+                ? transition.TargetState!
+                : conditionalHasTargetState ? conditionalTargetState : currentState;
+            targetState = ResolveInitialLeaf(targetState);
+            var isStateChange = hasTargetState
                 && !EqualityComparer<TState>.Default.Equals(currentState, targetState);
 
-            var updatedData = ApplyTransitionSteps(commandList, transition, currentState, currentData, trigger);
-
             if (isStateChange)
             {
                 AppendExitCommands(commandList, currentState, targetState, updatedData);
@@ -260,12 +268,21 @@ internal void Validate(bool skipAnalysis = false)
         {
             foreach (var transition in definition.GetTransitions())
             {
-                if (!transition.HasTargetState)
+                if (!transition.HasTargetState && !HasTransitionTargetSteps(transition.Steps))
                 {
                     continue;
                 }
 
-                if (!_states.ContainsKey(transition.TargetState!))
+                foreach (var targetState in GetTransitionTargetStates(transition.Steps))
+                {
+                    if (!_states.ContainsKey(targetState))
+                    {
+                        throw new InvalidOperationException(
+                            $"State '{definition.State}' transitions to '{targetState}', but it is not configured.");
+                    }
+                }
+
+                if (transition.HasTargetState && !_states.ContainsKey(transition.TargetState!))
                 {
                     throw new InvalidOperationException(
                         $"State '{definition.State}' transitions to '{transition.TargetState}', but it is not configured.");
@@ -538,6 +555,41 @@ private List<TState> GetStatesToRoot(TState start)
         return states;
     }
 
+    private static bool HasTransitionTargetSteps(List<TransitionStep> steps)
+    {
+        return GetTransitionTargetStates(steps).Count > 0;
+    }
+
+    private static HashSet<TState> GetTransitionTargetStates(List<TransitionStep> steps)
+    {
+        var targets = new HashSet<TState>();
+        CollectTransitionTargetStates(steps, targets);
+        return targets;
+    }
+
+    private static void CollectTransitionTargetStates(List<TransitionStep> steps, HashSet<TState> targets)
+    {
+        foreach (var step in steps)
+        {
+            switch (step.Kind)
+            {
+                case TransitionStepKind.Transition:
+                    targets.Add(step.TargetState!);
+                    break;
+                case TransitionStepKind.Conditional:
+                    CollectTransitionTargetStates(step.ConditionalTrueSteps!, targets);
+                    CollectTransitionTargetStates(step.ConditionalFalseSteps!, targets);
+                    break;
+                case TransitionStepKind.ConditionalChain:
+                    foreach (var branch in step.ConditionalBranches!)
+                    {
+                        CollectTransitionTargetStates(branch.Steps, targets);
+                    }
+                    break;
+            }
+        }
+    }
+
     private bool TryFindLowestCommonAncestor(TState currentState, TState targetState, out TState lca)
     {
         var currentChain = GetHierarchyChain(currentState);
@@ -635,7 +687,7 @@ private static void AppendCommands(
             }
 
             var targetState = ResolveInitialLeaf(matched.TargetState!);
-            var updatedData = ApplyTransitionSteps(commands, matched, state, data, trigger);
+            var updatedData = ApplyTransitionSteps(commands, matched.Steps, state, data, trigger, out _, out _);
             var isStateChange = !EqualityComparer<TState>.Default.Equals(state, targetState);
 
             if (isStateChange)
@@ -652,23 +704,17 @@ private static void AppendCommands(
             $"Immediate transition loop detected starting at '{currentState}'.");
     }
 
-    private static TData ApplyTransitionSteps(
-        List<TCommand> commands,
-        TransitionDefinition transition,
-        TState currentState,
-        TData currentData,
-        TTrigger trigger)
-    {
-        return ApplyTransitionSteps(commands, transition.Steps, currentState, currentData, trigger);
-    }
-
     private static TData ApplyTransitionSteps(
         List<TCommand> commands,
         List<TransitionStep> steps,
         TState currentState,
         TData currentData,
-        TTrigger trigger)
+        TTrigger trigger,
+        out bool hasTargetState,
+        out TState targetState)
     {
+        hasTargetState = false;
+        targetState = default!;
         var updatedData = currentData;
         foreach (var step in steps)
         {
@@ -683,18 +729,46 @@ private static TData ApplyTransitionSteps(
                         commands.Add(command);
                     }
                     break;
+                case TransitionStepKind.Transition:
+                    hasTargetState = true;
+                    targetState = step.TargetState!;
+                    break;
                 case TransitionStepKind.Conditional:
                     var branch = step.Predicate!(currentState, updatedData, trigger)
                         ? step.ConditionalTrueSteps!
                         : step.ConditionalFalseSteps!;
-                    updatedData = ApplyTransitionSteps(commands, branch, currentState, updatedData, trigger);
+                    updatedData = ApplyTransitionSteps(
+                        commands,
+                        branch,
+                        currentState,
+                        updatedData,
+                        trigger,
+                        out var conditionalHasTargetState,
+                        out var conditionalTargetState);
+                    if (conditionalHasTargetState && !hasTargetState)
+                    {
+                        hasTargetState = true;
+                        targetState = conditionalTargetState;
+                    }
                     break;
                 case TransitionStepKind.ConditionalChain:
                     var matchedBranch = step.ConditionalBranches!.FirstOrDefault(b => 
                         b.Predicate(currentState, updatedData, trigger));
                     if (matchedBranch.Steps != null)
                     {
-                        updatedData = ApplyTransitionSteps(commands, matchedBranch.Steps, currentState, updatedData, trigger);
+                        updatedData = ApplyTransitionSteps(
+                            commands,
+                            matchedBranch.Steps,
+                            currentState,
+                            updatedData,
+                            trigger,
+                            out var chainHasTargetState,
+                            out var chainTargetState);
+                        if (chainHasTargetState && !hasTargetState)
+                        {
+                            hasTargetState = true;
+                            targetState = chainTargetState;
+                        }
                     }
                     break;
             }
@@ -1439,6 +1513,12 @@ public ConditionalTransitionConfiguration Execute(Func<IEnumerable<TCommand>> ac
             return Execute((state, data, trigger) => action());
         }
 
+        public ConditionalTransitionConfiguration TransitionTo(TState state)
+        {
+            _currentBranchSteps!.Add(TransitionStep.ForTransition(state));
+            return this;
+        }
+
         public ConditionalTransitionConfiguration ElseIf(Func<TData, TTrigger, bool> predicate)
         {
             _branches.Add(((state, data, trigger) => predicate(data, trigger), []));
@@ -1604,6 +1684,12 @@ public ConditionalTransitionConfiguration<TDerivedTrigger> Execute(Func<IEnumera
             return Execute((state, data, trigger) => action());
         }
 
+        public ConditionalTransitionConfiguration<TDerivedTrigger> TransitionTo(TState state)
+        {
+            _currentBranchSteps!.Add(TransitionStep.ForTransition(state));
+            return this;
+        }
+
         public ConditionalTransitionConfiguration<TDerivedTrigger> ElseIf(
             Func<TData, TDerivedTrigger, bool> predicate)
         {
@@ -1736,6 +1822,7 @@ internal enum TransitionStepKind
     {
         ModifyData,
         Execute,
+        Transition,
         Conditional,
         ConditionalChain
     }
@@ -1755,6 +1842,8 @@ private TransitionStep(TransitionStepKind kind)
 
         public Func<TState, TData, TTrigger, bool>? Predicate { get; private init; }
 
+        public TState? TargetState { get; private init; }
+
         public List<TransitionStep>? ConditionalTrueSteps { get; private init; }
 
         public List<TransitionStep>? ConditionalFalseSteps { get; private init; }
@@ -1771,6 +1860,11 @@ public static TransitionStep ForExecute(Func<TState, TData, TTrigger, IEnumerabl
             return new TransitionStep(TransitionStepKind.Execute) { Executor = action };
         }
 
+        public static TransitionStep ForTransition(TState targetState)
+        {
+            return new TransitionStep(TransitionStepKind.Transition) { TargetState = targetState };
+        }
+
         public static TransitionStep ForConditional(
             Func<TState, TData, TTrigger, bool> predicate,
             List<TransitionStep> trueSteps,
@@ -2362,6 +2456,12 @@ public ConditionalTransitionConfiguration Execute(Func<IEnumerable<TCommand>> ac
             return this;
         }
 
+        public ConditionalTransitionConfiguration TransitionTo(TState state)
+        {
+            _inner.TransitionTo(state);
+            return this;
+        }
+
         public ConditionalTransitionConfiguration Else()
         {
             _inner.Else();
@@ -2455,6 +2555,12 @@ public ConditionalTransitionConfiguration<TDerivedTrigger> Execute(Func<IEnumera
             return this;
         }
 
+        public ConditionalTransitionConfiguration<TDerivedTrigger> TransitionTo(TState state)
+        {
+            _inner.TransitionTo(state);
+            return this;
+        }
+
         public ConditionalTransitionConfiguration<TDerivedTrigger> Else()
         {
             _inner.Else();