Merge pull request #7 from AAulicino/feature/custom-assertions

Feature/custom assertions

Author: AAulicino

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [UNRELEASED]
+### Added
+ - MoveNextAndExpect<T>() custom assertion.
+ - MoveNextAndExpect(object value) custom assertion.
+
 ## [1.1.0] - 2022-06-16
 ### Added
  - Nested coroutine calls support.
@@ -12,5 +17,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial release.
 
+[UNRELEASED]: https://github.com/AAulicino/Unity-Coroutines-for-NSubstitute/compare/1.1.0...UNRELEASED
 [1.1.0]: https://github.com/AAulicino/Unity-Coroutines-for-NSubstitute/compare/1.0.0...1.1.0
 [1.0.0]: https://github.com/AAulicino/Unity-Coroutines-for-NSubstitute/releases/tag/1.0.0

Editor/Assertions.meta

@@ -0,0 +1,99 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using CoroutineSubstitute.Substitutes;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace CoroutineSubstitute.Assertions
+{
+    public static class CoroutineRunnerAssertions
+    {
+        internal static readonly Dictionary<Type, TypeAssert> customTypes = new Dictionary<Type, TypeAssert>();
+
+        public static void RegisterCustomType<T> (TypeAssert typeAssert)
+        {
+            customTypes[typeof(T)] = typeAssert;
+        }
+
+        public static void MoveNextAndExpect<T> (ICoroutineRunnerSubstitute runner)
+        {
+            if (runner.ActiveCoroutines.Count > 1)
+            {
+                throw new InvalidOperationException(
+                    "MoveNextAndExpect currently only supports a single Coroutine instance"
+                );
+            }
+
+            runner.MoveNext();
+            object current = runner.ActiveCoroutines.Single().Current;
+
+            if (current is T)
+                return;
+
+            Assert.Fail($"Expected: {typeof(T).Name}\nBut was: {GetTypeName(current)}");
+        }
+
+        public static void MoveNextAndExpect (ICoroutineRunnerSubstitute runner, object value)
+        {
+            if (runner.ActiveCoroutines.Count > 1)
+            {
+                throw new InvalidOperationException(
+                    "MoveNextAndExpect currently only supports a single Coroutine instance"
+                );
+            }
+
+            runner.MoveNext();
+            object current = runner.ActiveCoroutines.Single().Current;
+
+            AssertType(value, current);
+
+            switch (value)
+            {
+                case WaitForSeconds val:
+                    Assert.AreEqual(GetTotalSeconds(val), GetTotalSeconds(Cast(current, val)));
+                    break;
+
+                case WaitForSecondsRealtime val:
+                    Assert.AreEqual(val.waitTime, Cast(current, val).waitTime);
+                    break;
+
+                case WaitForEndOfFrame _:
+                case WaitForFixedUpdate _:
+                case IEnumerator _:
+                case null:
+                    Assert.Pass();
+                    break;
+
+                default:
+                    if (customTypes.TryGetValue(value.GetType(), out TypeAssert typeAssert))
+                        typeAssert(value, current);
+                    else
+                        throw new NotSupportedException(
+                            $"{GetTypeName(value)} is not supported. You can register your custom types"
+                            + $" using {nameof(CoroutineSubstitute)}.{nameof(CoroutineSubstitute.RegisterCustomType)}."
+                        );
+                    break;
+            }
+        }
+
+        static void AssertType (object expected, object actual)
+        {
+            if (expected?.GetType() != actual?.GetType())
+                Assert.Fail($"Expected {GetTypeName(expected)} but got {GetTypeName(actual)}");
+        }
+
+        static string GetTypeName (object obj) => obj?.GetType()?.Name ?? "null";
+
+        static T Cast<T> (object value, T _) => (T)value;
+
+        static float GetTotalSeconds (WaitForSeconds waitForSeconds)
+        {
+            return (float)typeof(WaitForSeconds)
+                .GetField("m_Seconds", BindingFlags.NonPublic | BindingFlags.Instance)
+                .GetValue(waitForSeconds);
+        }
+    }
+}

Editor/Assertions/CoroutineRunnerAssertions.cs

@@ -1,11 +1,17 @@
+using CoroutineSubstitute.Assertions;
 using CoroutineSubstitute.Substitutes;
 using NSubstitute;
 
 namespace CoroutineSubstitute
 {
+    public delegate void TypeAssert (object expected, object actual);
+
     public static class CoroutineSubstitute
     {
         public static ICoroutineRunner Create ()
             => Substitute.ForPartsOf<CoroutineRunnerSubstitute>();
+
+        public static void RegisterCustomType<T> (TypeAssert typeAssert)
+            => CoroutineRunnerAssertions.RegisterCustomType<T>(typeAssert);
     }
 }

Editor/Assertions/CoroutineRunnerAssertions.cs.meta

@@ -1,4 +1,5 @@
 using System;
+using CoroutineSubstitute.Assertions;
 using CoroutineSubstitute.Substitutes;
 
 namespace CoroutineSubstitute
@@ -8,6 +9,12 @@ public static class ICoroutineRunnerTestExtensions
         public static bool MoveNext (this ICoroutineRunner runner)
             => CastToSubstitute(runner).MoveNext();
 
+        public static void MoveNextAndExpect<T> (this ICoroutineRunner runner)
+            => CoroutineRunnerAssertions.MoveNextAndExpect<T>(CastToSubstitute(runner));
+
+        public static void MoveNextAndExpect (this ICoroutineRunner runner, object value)
+            => CoroutineRunnerAssertions.MoveNextAndExpect(CastToSubstitute(runner), value);
+
         static CoroutineRunnerSubstitute CastToSubstitute (ICoroutineRunner runner)
         {
             if (runner is CoroutineRunnerSubstitute substitute)

Editor/CoroutineSubstitute.cs

@@ -10,10 +10,12 @@ namespace CoroutineSubstitute.Substitutes
 {
     public class CoroutineRunnerSubstitute : ICoroutineRunner, ICoroutineRunnerSubstitute
     {
+        public ICollection<IStartCoroutineCall> ActiveCoroutines => activeCoroutinesDict.Values;
+
         static readonly IStartCoroutineCallFactory defaultCallFactory = new StartCoroutineCallFactory();
 
+        readonly Dictionary<int, IStartCoroutineCall> activeCoroutinesDict;
         readonly IStartCoroutineCallFactory callFactory;
-        readonly Dictionary<int, IStartCoroutineCall> activeCoroutines;
 
         public CoroutineRunnerSubstitute () : this(defaultCallFactory)
         {
@@ -22,7 +24,7 @@ public CoroutineRunnerSubstitute () : this(defaultCallFactory)
         public CoroutineRunnerSubstitute (IStartCoroutineCallFactory callFactory)
         {
             this.callFactory = callFactory;
-            activeCoroutines = new Dictionary<int, IStartCoroutineCall>();
+            activeCoroutinesDict = new Dictionary<int, IStartCoroutineCall>();
         }
 
         public virtual Coroutine StartCoroutine (IEnumerator enumerator)
@@ -31,29 +33,29 @@ public virtual Coroutine StartCoroutine (IEnumerator enumerator)
                 throw new ArgumentNullException(nameof(enumerator));
 
             IStartCoroutineCall call = callFactory.Create(enumerator);
-            activeCoroutines.Add(call.Id, call);
+            activeCoroutinesDict.Add(call.Id, call);
             return CoroutineFactory.Create(call.Id);
         }
 
         public virtual void StopAllCoroutines ()
         {
-            activeCoroutines.Clear();
+            activeCoroutinesDict.Clear();
         }
 
         public virtual void StopCoroutine (Coroutine routine)
         {
             if (routine == null)
                 throw new ArgumentNullException(nameof(routine));
 
-            activeCoroutines.Remove(routine.GetId());
+            activeCoroutinesDict.Remove(routine.GetId());
         }
 
         public virtual bool MoveNext ()
         {
             bool anySucceeded = false;
             HashSet<int> callsToRemove = new HashSet<int>();
 
-            foreach (IStartCoroutineCall call in activeCoroutines.Values.ToArray())
+            foreach (IStartCoroutineCall call in activeCoroutinesDict.Values.ToArray())
             {
                 bool result = call.MoveNext();
 
@@ -63,21 +65,21 @@ public virtual bool MoveNext ()
                 if (call.Current is Coroutine coroutine)
                 {
                     int coroutineId = coroutine.GetId();
-                    call.SetNestedCoroutine(activeCoroutines[coroutineId]);
+                    call.SetNestedCoroutine(activeCoroutinesDict[coroutineId]);
                     callsToRemove.Add(coroutineId);
                 }
                 anySucceeded |= result;
             }
 
             foreach (int id in callsToRemove)
-                activeCoroutines.Remove(id);
+                activeCoroutinesDict.Remove(id);
 
             return anySucceeded;
         }
 
         public virtual void Reset ()
         {
-            foreach (IStartCoroutineCall call in activeCoroutines.Values)
+            foreach (IStartCoroutineCall call in activeCoroutinesDict.Values)
                 call.Reset();
         }
     }

Editor/ICoroutineRunnerTestExtensions.cs

@@ -1,7 +1,11 @@
+using System.Collections.Generic;
+using CoroutineSubstitute.Substitutes.Call;
+
 namespace CoroutineSubstitute.Substitutes
 {
     public interface ICoroutineRunnerSubstitute : ICoroutineRunner
     {
+        ICollection<IStartCoroutineCall> ActiveCoroutines { get; }
         bool MoveNext ();
         void Reset ();
     }