Merge pull request #111 from bazyleu/feature/reflex-support

Reflex support

Author: bazyleu

Assets/UniState/Runtime/Integrations/Reflex/ReflexBuildExtensions.cs

@@ -1,119 +1,184 @@
-#if UNISTATE_REFLEX_SUPPORT
-
+#if UNISTATE_REFLEX_SUPPORT
+
 using System;
+using System.Collections.Generic;
 using Reflex.Core;
-
-namespace UniState
-{
+using Reflex.Enums;
+using Reflex.Resolvers;
+
+namespace UniState
+{
     public static class ReflexBuildExtensions
     {
         public static void AddStateMachine(
             this ContainerBuilder builder,
             Type stateMachineImplementation,
             Type stateMachineContract)
         {
-            ValidateStateMachineBindingInput(stateMachineImplementation, stateMachineContract);
-
-            builder.AddTransient(stateMachineImplementation);
-            builder.AddTransient(container =>
-            {
-                var stateMachine = (IStateMachine)container.Resolve(stateMachineImplementation);
-                stateMachine.SetResolver(container.ToTypeResolver());
-
-                return stateMachine;
-            }, stateMachineContract);
+            AddStateMachineInternal(builder, stateMachineImplementation, stateMachineContract, Lifetime.Transient);
         }
-
+
         public static void AddSingletonStateMachine(
             this ContainerBuilder builder,
             Type stateMachineImplementation,
             Type stateMachineContract)
         {
-            ValidateStateMachineBindingInput(stateMachineImplementation, stateMachineContract);
-
-            builder.AddSingleton(stateMachineImplementation);
-            builder.AddSingleton(container =>
-            {
-                var stateMachine = (IStateMachine)container.Resolve(stateMachineImplementation);
-                stateMachine.SetResolver(container.ToTypeResolver());
-
-                return stateMachine;
-            }, stateMachineContract);
+            AddStateMachineInternal(builder, stateMachineImplementation, stateMachineContract, Lifetime.Singleton);
         }
-
+
         public static void AddState(this ContainerBuilder builder, Type state)
         {
             ValidateStateBindingInput(state);
 
-            builder.AddTransient(state);
+            builder.AddTransient(state, GetStateContracts(state));
         }
-
-        public static void AddState(this ContainerBuilder builder, Type stateImplementation, Type stateContract)
-        {
-            ValidateStateBindingInput(stateImplementation, stateContract);
-
-            builder.AddTransient(stateImplementation, stateContract);
-        }
-
+
+        public static void AddState(this ContainerBuilder builder, Type stateImplementation, Type stateContract)
+        {
+            ValidateStateBindingInput(stateImplementation, stateContract);
+
+            builder.AddTransient(stateImplementation, stateContract);
+        }
+
         public static void AddSingletonState(this ContainerBuilder builder, Type state)
         {
             ValidateStateBindingInput(state);
 
-            builder.AddSingleton(state);
+            builder.AddSingleton(state, GetStateContracts(state));
         }
-
-        public static void AddSingletonState(this ContainerBuilder builder, Type stateImplementation,
-            Type stateContract)
-        {
-            ValidateStateBindingInput(stateImplementation, stateContract);
-
-            builder.AddSingleton(stateImplementation, stateContract);
-        }
-
-        private static void ValidateStateBindingInput(Type stateImplementation, Type stateContract)
+
+        public static void AddSingletonState(this ContainerBuilder builder, Type stateImplementation,
+            Type stateContract)
+        {
+            ValidateStateBindingInput(stateImplementation, stateContract);
+
+            builder.AddSingleton(stateImplementation, stateContract);
+        }
+
+        private static void ValidateStateBindingInput(Type stateImplementation, Type stateContract)
+        {
+            ValidateStateBindingInput(stateImplementation);
+
+            if (!stateContract.IsAssignableFrom(stateImplementation))
+            {
+                throw new ArgumentException(
+                    $"AddState({stateImplementation.Name}): Type parameter state must implement {stateContract.Name}.");
+            }
+        }
+
+        private static void ValidateStateBindingInput(Type state)
         {
-            ValidateStateBindingInput(stateImplementation);
-
-            if (!stateContract.IsAssignableFrom(stateImplementation))
+            if (!typeof(IExecutableState).IsAssignableFrom(state))
             {
                 throw new ArgumentException(
-                    $"AddState({stateImplementation.Name}): Type parameter state must implement {stateContract.Name}.");
+                    $"AddState({state.Name}): Type parameter state must implement IState<TPayload>");
             }
         }
 
-        private static void ValidateStateBindingInput(Type state)
+        private static Type[] GetStateContracts(Type state)
         {
-            if (!typeof(IExecutableState).IsAssignableFrom(state))
+            var interfaces = state.GetInterfaces();
+            var contracts = new Type[interfaces.Length + 1];
+            contracts[0] = state;
+
+            for (var i = 0; i < interfaces.Length; i++)
             {
-                throw new ArgumentException(
-                    $"AddState({state.Name}): Type parameter state must implement IState<TPayload>");
+                contracts[i + 1] = interfaces[i];
             }
+
+            return contracts;
         }
+
+        private static void ValidateStateMachineBindingInput(Type stateMachineImplementation, Type stateMachineContract)
+        {
+            if (stateMachineImplementation == stateMachineContract)
+            {
+                throw new ArgumentException(
+                    $"AddStateMachine<{stateMachineImplementation.Name}>: Type parameters must differ : " +
+                    "use AddStateMachine() where stateMachineImplementation implements stateMachineContract.\");");
+            }
+
+            if (!stateMachineContract.IsAssignableFrom(stateMachineImplementation))
+            {
+                throw new ArgumentException(
+                    $"AddStateMachine: Type {stateMachineImplementation.Name} " +
+                    $"must implement {stateMachineContract.Name}.");
+            }
+
+            if (!typeof(IStateMachine).IsAssignableFrom(stateMachineContract))
+            {
+                throw new ArgumentException(
+                    $"AddStateMachine: Type {stateMachineContract.Name} " +
+                    $"must implement IStateMachine.");
+            }
+        }
+
+        private static void AddStateMachineInternal(
+            ContainerBuilder builder,
+            Type stateMachineImplementation,
+            Type stateMachineContract,
+            Lifetime lifetime)
+        {
+            ValidateStateMachineBindingInput(stateMachineImplementation, stateMachineContract);
 
-        private static void ValidateStateMachineBindingInput(Type stateMachineImplementation, Type stateMachineContract)
+            builder.Bindings.Add(Binding.Validated(
+                new ReflexStateMachineResolver(stateMachineImplementation, lifetime),
+                stateMachineImplementation,
+                stateMachineImplementation,
+                stateMachineContract));
+        }
+
+        private sealed class ReflexStateMachineResolver : IResolver
         {
-            if (stateMachineImplementation == stateMachineContract)
+            private readonly Type _stateMachineImplementation;
+            private readonly Lifetime _lifetime;
+            private readonly List<IDisposable> _disposables = new();
+
+            private object _instance;
+
+            public Lifetime Lifetime => _lifetime;
+
+            public ReflexStateMachineResolver(Type stateMachineImplementation, Lifetime lifetime)
             {
-                throw new ArgumentException(
-                    $"AddStateMachine<{stateMachineImplementation.Name}>: Type parameters must differ : " +
-                    "use AddStateMachine() where stateMachineImplementation implements stateMachineContract.\");");
+                _stateMachineImplementation = stateMachineImplementation;
+                _lifetime = lifetime;
             }
 
-            if (!stateMachineContract.IsAssignableFrom(stateMachineImplementation))
+            public object Resolve(Container container)
             {
-                throw new ArgumentException(
-                    $"AddStateMachine: Type {stateMachineImplementation.Name} " +
-                    $"must implement {stateMachineContract.Name}.");
+                if (_lifetime == Lifetime.Singleton && _instance != null)
+                {
+                    return _instance;
+                }
+
+                var stateMachine = (IStateMachine)container.Construct(_stateMachineImplementation);
+                stateMachine.SetResolver(container.ToTypeResolver());
+
+                if (_lifetime == Lifetime.Singleton)
+                {
+                    _instance = stateMachine;
+                }
+
+                if (stateMachine is IDisposable disposable)
+                {
+                    _disposables.Add(disposable);
+                }
+
+                return stateMachine;
             }
 
-            if (!typeof(IStateMachine).IsAssignableFrom(stateMachineContract))
+            public void Dispose()
             {
-                throw new ArgumentException(
-                    $"AddStateMachine: Type {stateMachineContract.Name} " +
-                    $"must implement IStateMachine.");
+                for (var i = _disposables.Count - 1; i >= 0; i--)
+                {
+                    _disposables[i].Dispose();
+                }
+
+                _disposables.Clear();
+                _instance = null;
             }
         }
     }
 }
-
-#endif
+
+#endif

Assets/UniStateTests/Common/TestFixture/ReflexTestsBase.cs

@@ -0,0 +1,43 @@
+using Cysharp.Threading.Tasks;
+using Reflex.Core;
+using UniState;
+
+namespace UniStateTests.Common
+{
+    public abstract class ReflexTestsBase : TestsBase
+    {
+        private Container _container;
+
+        protected Container Container => _container;
+
+        public override void Setup()
+        {
+            base.Setup();
+
+            var builder = new ContainerBuilder();
+            SetupBindings(builder);
+            _container = builder.Build();
+        }
+
+        public override void TearDown()
+        {
+            base.TearDown();
+
+            _container?.Dispose();
+            _container = null;
+        }
+
+        protected async UniTask RunAndVerify<TStateMachine, TState>()
+            where TStateMachine : class, IStateMachine, IVerifiableStateMachine
+            where TState : class, IState<EmptyPayload>
+        {
+            await StateMachineTestHelper.RunAndVerify<TStateMachine, TState>(Container.ToTypeResolver(),
+                GetTimeoutToken());
+        }
+
+        protected virtual void SetupBindings(ContainerBuilder builder)
+        {
+            builder.AddSingleton(typeof(ExecutionLogger));
+        }
+    }
+}

Assets/UniStateTests/Common/TestFixture/ReflexTestsBase.cs.meta

@@ -0,0 +1,32 @@
+using System.Collections;
+using Cysharp.Threading.Tasks;
+using NUnit.Framework;
+using Reflex.Core;
+using UniState;
+using UniStateTests.Common;
+using UniStateTests.PlayMode.StateBehaviorAttributeTests.Infrastructure;
+using UnityEngine.TestTools;
+
+namespace UniStateTests.PlayMode.StateBehaviorAttributeTests
+{
+    [TestFixture]
+    public class BehaviorAttributeReflexTests : ReflexTestsBase
+    {
+        [UnityTest]
+        public IEnumerator RunChaneOfStateWithAttributes_ExitFromChain_ChainExecutedCorrectly() => UniTask.ToCoroutine(async () =>
+        {
+            await RunAndVerify<IVerifiableStateMachine, FirstState>();
+        });
+
+        protected override void SetupBindings(ContainerBuilder builder)
+        {
+            base.SetupBindings(builder);
+
+            builder.AddStateMachine(typeof(StateMachineBehaviourAttribute), typeof(IVerifiableStateMachine));
+            builder.AddState(typeof(FirstState));
+            builder.AddState(typeof(NoReturnState));
+            builder.AddState(typeof(FastInitializeState));
+            builder.AddSingleton(typeof(BehaviourAttributeTestHelper));
+        }
+    }
+}

Assets/UniStateTests/PlayMode/BehaviorAttributeTests/BehaviorAttributeReflexTests.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using Cysharp.Threading.Tasks;
+using NUnit.Framework;
+using Reflex.Core;
+using UniState;
+using UniStateTests.Common;
+using UniStateTests.PlayMode.Execution.Infrastructure;
+using UnityEngine.TestTools;
+using FirstState = UniStateTests.PlayMode.Execution.Infrastructure.FirstState;
+
+namespace UniStateTests.PlayMode.Execution
+{
+    [TestFixture]
+    public class ExecutionReflexTests : ReflexTestsBase
+    {
+        [UnityTest]
+        public IEnumerator RunStateMachineSeveralTime_EndExecution_ExecutionStatusValid() => UniTask.ToCoroutine(
+            async () =>
+            {
+                var testHelper = Container.Resolve<ExecutionTestHelper>();
+                testHelper.SetPath(StateMachineExecutionType.Default);
+
+                await RunAndVerify<IVerifiableStateMachine, FirstState>();
+                Assert.False(testHelper.CurrentStateMachine.IsExecuting);
+
+                testHelper.SetPath(StateMachineExecutionType.WrongDependency);
+
+                await RunAndVerify<IVerifiableStateMachine, FirstState>();
+                Assert.False(testHelper.CurrentStateMachine.IsExecuting);
+
+                testHelper.SetPath(StateMachineExecutionType.Exception);
+
+                await RunAndVerify<IVerifiableStateMachine, FirstState>();
+                Assert.False(testHelper.CurrentStateMachine.IsExecuting);
+            });
+
+        protected override void SetupBindings(ContainerBuilder builder)
+        {
+            base.SetupBindings(builder);
+
+            builder.AddSingleton(typeof(ExecutionTestHelper));
+            builder.AddStateMachine(typeof(ExecutionStateMachine), typeof(IVerifiableStateMachine));
+            builder.AddState(typeof(FirstState));
+            builder.AddState(typeof(SecondState));
+            builder.AddState(typeof(SecondStateWithException));
+            builder.AddState(typeof(SecondStateWithWrongDependency));
+        }
+    }
+}