Cleaned up the code to remove the synchronization context (#78)

Author: dennisdoomen

Src/Chill/Common/NoSynchronizationContextScope.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Threading;
+
+namespace Chill.Common
+{
+    internal static class NoSynchronizationContextScope
+    {
+        public static DisposingAction Enter()
+        {
+            var context = SynchronizationContext.Current;
+            SynchronizationContext.SetSynchronizationContext(null);
+            return new DisposingAction(() => SynchronizationContext.SetSynchronizationContext(context));
+        }
+
+        internal class DisposingAction : IDisposable
+        {
+            private readonly Action action;
+
+            public DisposingAction(Action action)
+            {
+                this.action = action;
+            }
+
+            public void Dispose()
+            {
+                action();
+            }
+        }
+    }
+}

Src/Chill/Common/TaskExtensions.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Chill.Common
+{
+    /// <summary>
+    /// Some unit test frameworks (like xUnit) have their own synchronization context
+    /// that does not work well with blocking waits and can lead to deadlocks.
+    /// These methods create the task in the default synchronization context
+    /// and blocks until the task is completed.
+    /// </summary>
+    internal static class TaskExtensions
+    {
+        public static void ExecuteInDefaultSynchronizationContext(this Action action)
+        {
+            using (NoSynchronizationContextScope.Enter())
+            {
+                action();
+            }                
+        }
+
+        public static TResult ExecuteInDefaultSynchronizationContext<TResult>(this Func<TResult> action)
+        {
+            using (NoSynchronizationContextScope.Enter())
+            {
+                return action();
+            }                
+        }
+
+    }
+}

Src/Chill/GivenSubject.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Chill.Common;
 
 namespace Chill
 {
@@ -48,6 +49,24 @@ protected void WhenLater(Func<TResult> whenFunc)
             When(whenFunc, deferredExecution: true);
         }
 
+        /// <summary>
+        /// Records the asynchronous action that will trigger the actual test, when later executing the <see cref="WhenAction"/>
+        /// </summary>
+        protected void WhenLater(Func<Task<TResult>> whenFunc)
+        {
+            When(whenFunc, deferredExecution: true);
+        }
+
+        /// <summary>
+        /// Records the asynchronous action that will trigger the actual test
+        /// </summary>
+        /// <param name="whenFunc"></param>
+        /// <param name="deferredExecution">Should the test be executed immediately or be deferred?</param>
+        protected void When(Func<Task<TResult>> whenFunc, bool? deferredExecution = null)
+        {
+            When(() => whenFunc().GetAwaiter().GetResult(), deferredExecution);
+        }
+
         /// <summary>
         /// Records the action that will trigger the actual test
         /// </summary>
@@ -61,34 +80,26 @@ protected void When(Func<TResult> whenFunc, bool? deferredExecution = null)
             {
                 throw new InvalidOperationException("When already defined");
             }
-            whenAction = whenFunc;
+            
+            whenAction = whenFunc.ExecuteInDefaultSynchronizationContext;
             if (!DeferredExecution)
             {
                 EnsureTestTriggered(false);
             }
         }
 
-        /// <summary>
-        /// Records the asynchronous action that will trigger the actual test, when later executing the <see cref="WhenAction"/>
-        /// </summary>
-        protected void WhenLater(Func<Task<TResult>> whenFunc)
+        internal override void TriggerTest(bool expectExceptions)
         {
-            When(whenFunc, deferredExecution: true);
+            TriggerTest(() => result = whenAction(), expectExceptions);
         }
 
         /// <summary>
-        /// Records the asynchronous action that will trigger the actual test
+        /// Records an asynchronous precondittion
         /// </summary>
-        /// <param name="whenFunc"></param>
-        /// <param name="deferredExecution">Should the test be executed immediately or be deferred?</param>
-        protected void When(Func<Task<TResult>> whenFunc, bool? deferredExecution = null)
-        {
-            this.When(() => whenFunc.ExecuteInDefaultSynchronizationContext(), deferredExecution);
-        }
-
-        internal override void TriggerTest(bool expectExceptions)
+        /// <param name="givenFuncASync">The async precondition.</param>
+        public void Given(Func<Task> givenFuncASync)
         {
-            TriggerTest(() => result = whenAction(), expectExceptions);
+            Given(() => givenFuncASync().GetAwaiter().GetResult());
         }
 
         /// <summary>
@@ -98,18 +109,8 @@ internal override void TriggerTest(bool expectExceptions)
         public void Given(Action a)
         {
             EnsureContainer();
-            a();
-        }
-
-        /// <summary>
-        /// Records an asynchronous precondittion
-        /// </summary>
-        /// <param name="givenFuncASync">The async precondition.</param>
-        public void Given(Func<Task> givenFuncASync)
-        {
-            this.Given(() => givenFuncASync.ExecuteInDefaultSynchronizationContext());
+            a.ExecuteInDefaultSynchronizationContext();
         }
-
     }
 
     /// <summary>
@@ -126,7 +127,7 @@ public abstract class GivenSubject<TSubject> : TestFor<TSubject> where TSubject
         /// </summary>
         public Action WhenAction
         {
-            get { return whenAction; }
+            get => whenAction;
             set
             {
                 EnsureSubject(); 
@@ -142,6 +143,24 @@ public void WhenLater(Action whenAction)
             When(whenAction, deferredExecution: true);
         }
 
+        /// <summary>
+        /// Records the asynchronous action that will trigger the actual test, when later executing the <see cref="WhenAction"/>
+        /// </summary>
+        public void WhenLater(Func<Task> whenActionAsync)
+        {
+            When(whenActionAsync, deferredExecution: true);
+        }
+
+        /// <summary>
+        /// Records the asynchronous action that will trigger the actual test
+        /// </summary>
+        /// <param name="whenActionAsync"></param>
+        /// <param name="deferredExecution">Should the test be executed immediately or be deferred?</param>
+        public void When(Func<Task> whenActionAsync, bool? deferredExecution = null)
+        {
+            When(() => whenActionAsync().GetAwaiter().GetResult(), deferredExecution);
+        }
+
         /// <summary>
         /// Records the action that will trigger the actual test
         /// </summary>
@@ -155,32 +174,14 @@ public void When(Action whenAction, bool? deferredExecution = null)
             {
                 throw new InvalidOperationException("When already defined");
             }
-            this.whenAction = whenAction;
+            this.whenAction = whenAction.ExecuteInDefaultSynchronizationContext;
             if (!DeferredExecution)
             {
                 EnsureTestTriggered(false);
             }
 
         }
 
-        /// <summary>
-        /// Records the asynchronous action that will trigger the actual test, when later executing the <see cref="WhenAction"/>
-        /// </summary>
-        public void WhenLater(Func<Task> whenActionAsync)
-        {
-            When(whenActionAsync, deferredExecution: true);
-        }
-
-        /// <summary>
-        /// Records the asynchronous action that will trigger the actual test
-        /// </summary>
-        /// <param name="whenActionAsync"></param>
-        /// <param name="deferredExecution">Should the test be executed immediately or be deferred?</param>
-        public void When(Func<Task> whenActionAsync, bool? deferredExecution = null)
-        {
-            When(() => whenActionAsync.ExecuteInDefaultSynchronizationContext(), deferredExecution);
-        }
-
         internal override void TriggerTest(bool expectExceptions)
         {
             TriggerTest(whenAction, expectExceptions);
@@ -192,17 +193,17 @@ internal override void TriggerTest(bool expectExceptions)
         /// <param name="givenFuncASync">The async precondition</param>
         public void Given(Func<Task> givenFuncASync)
         {
-            this.Given(() => givenFuncASync.ExecuteInDefaultSynchronizationContext());
+            Given(() => givenFuncASync().GetAwaiter().GetResult());
         }
 
         /// <summary>
         /// Records a precondition
         /// </summary>
-        /// <param name="a"></param>
-        public void Given(Action a)
+        /// <param name="action"></param>
+        public void Given(Action action)
         {
             EnsureContainer();
-            a();
+            action.ExecuteInDefaultSynchronizationContext();
         }
     }
 }