diff --git a/src/NServiceBus.Testing.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt b/src/NServiceBus.Testing.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt
index f6862ab7..e1e272d2 100644
--- a/src/NServiceBus.Testing.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt
+++ b/src/NServiceBus.Testing.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt
@@ -58,6 +58,10 @@ namespace NServiceBus.Testing
         public void OnMessage<TMessage>(System.Action<TMessage> initializeMessage = null) { }
         public void OnMessage<TMessage>(TMessage message, string messageId) { }
         public void OnMessage<TMessage>(TMessage initializedMessage) { }
+        public System.Threading.Tasks.Task OnMessageAsync<TMessage>(string messageId, System.Action<TMessage> initializeMessage = null) { }
+        public System.Threading.Tasks.Task OnMessageAsync<TMessage>(System.Action<TMessage> initializeMessage = null) { }
+        public System.Threading.Tasks.Task OnMessageAsync<TMessage>(TMessage message, string messageId) { }
+        public System.Threading.Tasks.Task OnMessageAsync<TMessage>(TMessage initializedMessage) { }
         public NServiceBus.Testing.Handler<T> SetIncomingHeader(string key, string value) { }
         public NServiceBus.Testing.Handler<T> WithExternalDependencies(System.Action<T> actionToSetUpExternalDependencies) { }
     }
@@ -139,14 +143,24 @@ namespace NServiceBus.Testing
         public NServiceBus.Testing.Saga<T> When(System.Func<T, NServiceBus.IMessageHandlerContext, System.Threading.Tasks.Task> sagaIsInvoked) { }
         public NServiceBus.Testing.Saga<T> When<TMessage>(System.Func<T, System.Func<TMessage, NServiceBus.IMessageHandlerContext, System.Threading.Tasks.Task>> handlerSelector, TMessage message) { }
         public NServiceBus.Testing.Saga<T> When<TMessage>(System.Func<T, System.Func<TMessage, NServiceBus.IMessageHandlerContext, System.Threading.Tasks.Task>> handlerSelector, System.Action<TMessage> messageInitializer = null) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenAsync(System.Func<T, NServiceBus.IMessageHandlerContext, System.Threading.Tasks.Task> sagaIsInvoked) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenAsync<TMessage>(System.Func<T, System.Func<TMessage, NServiceBus.IMessageHandlerContext, System.Threading.Tasks.Task>> handlerSelector, TMessage message) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenAsync<TMessage>(System.Func<T, System.Func<TMessage, NServiceBus.IMessageHandlerContext, System.Threading.Tasks.Task>> handlerSelector, System.Action<TMessage> messageInitializer = null) { }
         public NServiceBus.Testing.Saga<T> WhenHandling<TMessage>(System.Action<TMessage> initializeMessage = null) { }
         public NServiceBus.Testing.Saga<T> WhenHandling<TMessage>(TMessage message) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenHandlingAsync<TMessage>(System.Action<TMessage> initializeMessage = null) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenHandlingAsync<TMessage>(TMessage message) { }
         public NServiceBus.Testing.Saga<T> WhenHandlingTimeout<TMessage>(System.Action<TMessage> initializeMessage = null) { }
         public NServiceBus.Testing.Saga<T> WhenHandlingTimeout<TMessage>(TMessage message) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenHandlingTimeoutAsync<TMessage>(System.Action<TMessage> initializeMessage = null) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenHandlingTimeoutAsync<TMessage>(TMessage message) { }
         public NServiceBus.Testing.Saga<T> WhenReceivesMessageFrom(string client) { }
         public NServiceBus.Testing.Saga<T> WhenSagaTimesOut(System.TimeSpan after) { }
         public NServiceBus.Testing.Saga<T> WhenSagaTimesOut(System.DateTime at) { }
         public NServiceBus.Testing.Saga<T> WhenSagaTimesOut() { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenSagaTimesOutAsync(System.TimeSpan after) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenSagaTimesOutAsync(System.DateTime at) { }
+        public System.Threading.Tasks.Task<NServiceBus.Testing.Saga<T>> WhenSagaTimesOutAsync() { }
         public NServiceBus.Testing.Saga<T> WithExternalDependencies(System.Action<T> actionToSetUpExternalDependencies) { }
     }
     public class SentMessage<TMessage> : NServiceBus.Testing.OutgoingMessage<TMessage, NServiceBus.SendOptions>
diff --git a/src/NServiceBus.Testing/Handler.cs b/src/NServiceBus.Testing/Handler.cs
index d4f36dcb..d6e7019d 100644
--- a/src/NServiceBus.Testing/Handler.cs
+++ b/src/NServiceBus.Testing/Handler.cs
@@ -1,6 +1,7 @@
 namespace NServiceBus.Testing
 {
     using System;
+    using System.Threading.Tasks;
     using MessageInterfaces.MessageMapper.Reflection;
 
     /// <summary>
@@ -266,9 +267,7 @@ public void OnMessage<TMessage>(string messageId, Action<TMessage> initializeMes
         /// </summary>
         public void OnMessage<TMessage>(Action<TMessage> initializeMessage = null)
         {
-            var message = messageCreator.CreateInstance<TMessage>();
-            initializeMessage?.Invoke(message);
-            OnMessage(message);
+            OnMessageAsync(initializeMessage).GetAwaiter().GetResult();
         }
 
         /// <summary>
@@ -276,12 +275,53 @@ public void OnMessage<TMessage>(Action<TMessage> initializeMessage = null)
         /// setting the incoming headers and the message Id.
         /// </summary>
         public void OnMessage<TMessage>(TMessage message, string messageId)
+        {
+            OnMessageAsync(message, messageId).GetAwaiter().GetResult();
+        }
+
+        /// <summary>Activates the test that has been set up passing in a specific message to be used.</summary>
+        /// <param name="initializedMessage">A message to be used with message handler.</param>
+        /// <remarks>
+        /// This is different from <see cref="OnMessage{TMessage}(System.Action{TMessage})" /> in a way that
+        /// it uses the message, and not calls to an action.
+        /// </remarks>
+        /// <example><![CDATA[var message = new TestMessage {//...}; Test.Handler<EmptyHandler>().OnMessage<TestMessage>(message);]]></example>
+        public void OnMessage<TMessage>(TMessage initializedMessage)
+        {
+            OnMessageAsync(initializedMessage).GetAwaiter().GetResult();
+        }
+        
+        /// <summary>
+        /// Activates the test that has been set up passing in the given message,
+        /// setting the incoming headers and the message Id.
+        /// </summary>
+        public Task OnMessageAsync<TMessage>(string messageId, Action<TMessage> initializeMessage = null)
         {
             testableMessageHandlerContext.MessageId = messageId;
+            return OnMessageAsync(initializeMessage);
+        }
 
-            OnMessage(message);
+        /// <summary>
+        /// Activates the test that has been set up passing in the given message.
+        /// </summary>
+        public Task OnMessageAsync<TMessage>(Action<TMessage> initializeMessage = null)
+        {
+            var message = messageCreator.CreateInstance<TMessage>();
+            initializeMessage?.Invoke(message);
+            return OnMessageAsync(message);
         }
 
+        /// <summary>
+        /// Activates the test that has been set up passing in given message,
+        /// setting the incoming headers and the message Id.
+        /// </summary>
+        public Task OnMessageAsync<TMessage>(TMessage message, string messageId)
+        {
+            testableMessageHandlerContext.MessageId = messageId;
+
+            return OnMessageAsync(message);
+        }
+        
         /// <summary>Activates the test that has been set up passing in a specific message to be used.</summary>
         /// <param name="initializedMessage">A message to be used with message handler.</param>
         /// <remarks>
@@ -289,12 +329,12 @@ public void OnMessage<TMessage>(TMessage message, string messageId)
         /// it uses the message, and not calls to an action.
         /// </remarks>
         /// <example><![CDATA[var message = new TestMessage {//...}; Test.Handler<EmptyHandler>().OnMessage<TestMessage>(message);]]></example>
-        public void OnMessage<TMessage>(TMessage initializedMessage)
+        public async Task OnMessageAsync<TMessage>(TMessage initializedMessage)
         {
             var messageType = messageCreator.GetMappedTypeFor(initializedMessage.GetType());
             var handleMethods = handler.GetType().CreateInvokers(messageType, typeof(IHandleMessages<>));
 
-            handleMethods.InvokeSerially(handler, initializedMessage, testableMessageHandlerContext).GetAwaiter().GetResult();
+            await handleMethods.InvokeSerially(handler, initializedMessage, testableMessageHandlerContext).ConfigureAwait(false);
 
             testableMessageHandlerContext.Validate();
         }
diff --git a/src/NServiceBus.Testing/Saga.cs b/src/NServiceBus.Testing/Saga.cs
index 10eb007c..ffa02b16 100644
--- a/src/NServiceBus.Testing/Saga.cs
+++ b/src/NServiceBus.Testing/Saga.cs
@@ -254,8 +254,7 @@ public Saga<T> ExpectNotPublish<TMessage>(Action<TMessage> check)
         /// </summary>
         public Saga<T> WhenHandling<TMessage>(Action<TMessage> initializeMessage = null)
         {
-            var message = messageCreator.CreateInstance(initializeMessage);
-            return WhenHandling(message);
+            return WhenHandlingAsync(initializeMessage).GetAwaiter().GetResult();
         }
 
         /// <summary>
@@ -263,8 +262,7 @@ public Saga<T> WhenHandling<TMessage>(Action<TMessage> initializeMessage = null)
         /// </summary>
         public Saga<T> WhenHandling<TMessage>(TMessage message)
         {
-            var invokers = saga.GetType().CreateInvokers(typeof(TMessage), typeof(IHandleMessages<>));
-            return When((s, c) => invokers.InvokeSerially(saga, message, c));
+            return WhenHandlingAsync(message).GetAwaiter().GetResult();
         }
 
         /// <summary>
@@ -273,8 +271,7 @@ public Saga<T> WhenHandling<TMessage>(TMessage message)
         /// </summary>
         public Saga<T> WhenHandlingTimeout<TMessage>(Action<TMessage> initializeMessage = null)
         {
-            var message = messageCreator.CreateInstance(initializeMessage);
-            return WhenHandlingTimeout(message);
+            return WhenHandlingTimeoutAsync(initializeMessage).GetAwaiter().GetResult();
         }
 
         /// <summary>
@@ -282,8 +279,7 @@ public Saga<T> WhenHandlingTimeout<TMessage>(Action<TMessage> initializeMessage
         /// </summary>
         public Saga<T> WhenHandlingTimeout<TMessage>(TMessage message)
         {
-            var invokers = saga.GetType().CreateInvokers(typeof(TMessage), typeof(IHandleTimeouts<>));
-            return When((s, c) => invokers.InvokeSerially(saga, message, c));
+            return WhenHandlingTimeoutAsync(message).GetAwaiter().GetResult();
         }
 
         /// <summary>
@@ -293,7 +289,103 @@ public Saga<T> WhenHandlingTimeout<TMessage>(TMessage message)
         /// </summary>
         public Saga<T> When(Func<T, IMessageHandlerContext, Task> sagaIsInvoked)
         {
-            sagaIsInvoked(saga, testContext).GetAwaiter().GetResult();
+            return WhenAsync(sagaIsInvoked).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Uses the given delegate to select the message handler and invoking it with the given message. Checks all the expectations previously, and then clearing them for continued testing.
+        /// example: <c>When(s => s.Handle, new MyMessage())</c>
+        /// </summary>
+        public Saga<T> When<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Task>> handlerSelector, TMessage message)
+        {
+            return WhenAsync((s, context) => handlerSelector(s)(message, context)).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Uses the given delegate to select the message handler and invoking it with the specified message. Checks all the expectations previously, and then clearing them for continued testing.
+        /// example: <c>When&lt;MyMessage>(s => s.Handle, m => { m.Value = 42 })</c>
+        /// </summary>
+        public Saga<T> When<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Task>> handlerSelector, Action<TMessage> messageInitializer = null)
+        {
+            return WhenAsync(handlerSelector, messageInitializer).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Expires requested timeouts for the saga by simulating that time has passed
+        /// and then clears out all previous expectations.
+        /// This will only invoke timeouts set with a <see cref="TimeSpan"/> argument.
+        /// </summary>
+        /// <param name="after">The amount of time that has passed to simulate.</param>
+        public Saga<T> WhenSagaTimesOut(TimeSpan after)
+        {
+            return WhenSagaTimesOutAsync(after).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Expires requested timeouts for the saga by simulating the passed in date and time
+        /// and then clears out all previous expectations.
+        /// This will only invoke timeouts set with a <see cref="DateTime"/> argument.
+        /// </summary>
+        /// <param name="at">The Date and time to simuluate.</param>
+        public Saga<T> WhenSagaTimesOut(DateTime at)
+        {
+            return WhenSagaTimesOutAsync(at).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Expires all requested timeouts for the saga and then clears out all previous expectations.
+        /// </summary>
+        public Saga<T> WhenSagaTimesOut()
+        {
+            return WhenSagaTimesOutAsync().GetAwaiter().GetResult();
+        }
+        
+        /// <summary>
+        /// Initializes the given message type and checks all the expectations previously set up,
+        /// and then clears them for continued testing.
+        /// </summary>
+        public Task<Saga<T>> WhenHandlingAsync<TMessage>(Action<TMessage> initializeMessage = null)
+        {
+            var message = messageCreator.CreateInstance(initializeMessage);
+            return WhenHandlingAsync(message);
+        }
+
+        /// <summary>
+        /// Checks all the expectations previously set up, and then clears them for continued testing.
+        /// </summary>
+        public Task<Saga<T>> WhenHandlingAsync<TMessage>(TMessage message)
+        {
+            var invokers = saga.GetType().CreateInvokers(typeof(TMessage), typeof(IHandleMessages<>));
+            return WhenAsync((s, c) => invokers.InvokeSerially(saga, message, c));
+        }
+
+        /// <summary>
+        /// Initializes the given timeout message type and checks all the expectations previously set up,
+        /// and then clears them for continued testing.
+        /// </summary>
+        public Task<Saga<T>> WhenHandlingTimeoutAsync<TMessage>(Action<TMessage> initializeMessage = null)
+        {
+            var message = messageCreator.CreateInstance(initializeMessage);
+            return WhenHandlingTimeoutAsync(message);
+        }
+
+        /// <summary>
+        /// Checks all the expectations previously set up, and then clears them for continued testing.
+        /// </summary>
+        public Task<Saga<T>> WhenHandlingTimeoutAsync<TMessage>(TMessage message)
+        {
+            var invokers = saga.GetType().CreateInvokers(typeof(TMessage), typeof(IHandleTimeouts<>));
+            return WhenAsync((s, c) => invokers.InvokeSerially(saga, message, c));
+        }
+
+        /// <summary>
+        /// Uses the given delegate to invoke the saga, checking all the expectations previously set up,
+        /// and then clearing them for continued testing.
+        /// example: <c>When((saga, context) => s.Handle(new MyMessage(), context))</c>
+        /// </summary>
+        public async Task<Saga<T>> WhenAsync(Func<T, IMessageHandlerContext, Task> sagaIsInvoked)
+        {
+            await sagaIsInvoked(saga, testContext).ConfigureAwait(false);
 
             testContext.Validate();
             testContext = new TestingContext(messageCreator, testContext.previousTimeouts.Concat(testContext.TimeoutMessages).ToArray());
@@ -305,20 +397,20 @@ public Saga<T> When(Func<T, IMessageHandlerContext, Task> sagaIsInvoked)
         /// Uses the given delegate to select the message handler and invoking it with the given message. Checks all the expectations previously, and then clearing them for continued testing.
         /// example: <c>When(s => s.Handle, new MyMessage())</c>
         /// </summary>
-        public Saga<T> When<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Task>> handlerSelector, TMessage message)
+        public Task<Saga<T>> WhenAsync<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Task>> handlerSelector, TMessage message)
         {
-            return When((s, context) => handlerSelector(s)(message, context));
+            return WhenAsync((s, context) => handlerSelector(s)(message, context));
         }
 
         /// <summary>
         /// Uses the given delegate to select the message handler and invoking it with the specified message. Checks all the expectations previously, and then clearing them for continued testing.
         /// example: <c>When&lt;MyMessage>(s => s.Handle, m => { m.Value = 42 })</c>
         /// </summary>
-        public Saga<T> When<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Task>> handlerSelector, Action<TMessage> messageInitializer = null)
+        public Task<Saga<T>> WhenAsync<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Task>> handlerSelector, Action<TMessage> messageInitializer = null)
         {
             var message = (TMessage)messageCreator.CreateInstance(typeof(TMessage));
             messageInitializer?.Invoke(message);
-            return When((s, context) => handlerSelector(s)(message, context));
+            return WhenAsync((s, context) => handlerSelector(s)(message, context));
         }
 
         /// <summary>
@@ -327,11 +419,11 @@ public Saga<T> When<TMessage>(Func<T, Func<TMessage, IMessageHandlerContext, Tas
         /// This will only invoke timeouts set with a <see cref="TimeSpan"/> argument.
         /// </summary>
         /// <param name="after">The amount of time that has passed to simulate.</param>
-        public Saga<T> WhenSagaTimesOut(TimeSpan after)
+        public async Task<Saga<T>> WhenSagaTimesOutAsync(TimeSpan after)
         {
-            InvokeTimeouts(testContext.previousTimeouts
+            await InvokeTimeoutsAsync(testContext.previousTimeouts
                 .Where(t => t.Within.HasValue)
-                .Where(t => t.Within <= after));
+                .Where(t => t.Within <= after)).ConfigureAwait(false);
 
             return this;
         }
@@ -342,11 +434,11 @@ public Saga<T> WhenSagaTimesOut(TimeSpan after)
         /// This will only invoke timeouts set with a <see cref="DateTime"/> argument.
         /// </summary>
         /// <param name="at">The Date and time to simuluate.</param>
-        public Saga<T> WhenSagaTimesOut(DateTime at)
+        public async Task<Saga<T>> WhenSagaTimesOutAsync(DateTime at)
         {
-            InvokeTimeouts(testContext.previousTimeouts
+            await InvokeTimeoutsAsync(testContext.previousTimeouts
                 .Where(t => t.At.HasValue)
-                .Where(t => t.At <= at));
+                .Where(t => t.At <= at)).ConfigureAwait(false);
 
             return this;
         }
@@ -354,9 +446,9 @@ public Saga<T> WhenSagaTimesOut(DateTime at)
         /// <summary>
         /// Expires all requested timeouts for the saga and then clears out all previous expectations.
         /// </summary>
-        public Saga<T> WhenSagaTimesOut()
+        public async Task<Saga<T>> WhenSagaTimesOutAsync()
         {
-            InvokeTimeouts(testContext.previousTimeouts);
+            await InvokeTimeoutsAsync(testContext.previousTimeouts).ConfigureAwait(false);
 
             return this;
         }
@@ -515,17 +607,16 @@ public Saga<T> ExpectSagaData<TSagaData>(Func<TSagaData, bool> check) where TSag
             return this;
         }
 
-        void InvokeTimeouts(IEnumerable<TimeoutMessage<object>> messages)
+        async Task InvokeTimeoutsAsync(IEnumerable<TimeoutMessage<object>> messages)
         {
-            messages
-                .OrderBy(t => t.Within)
-                .ToList()
-                .ForEach(t =>
-                {
-                    var messageType = messageCreator.GetMappedTypeFor(t.Message.GetType());
-                    var invokers = saga.GetType().CreateInvokers(messageType, typeof(IHandleTimeouts<>));
-                    invokers.InvokeSerially(saga, t.Message, testContext).GetAwaiter().GetResult();
-                });
+            var timeoutHandlers = messages.OrderBy(t => t.Within).ToList();
+
+            foreach (var timeoutHandler in timeoutHandlers)
+            {
+                var messageType = messageCreator.GetMappedTypeFor(timeoutHandler.Message.GetType());
+                var invokers = saga.GetType().CreateInvokers(messageType, typeof(IHandleTimeouts<>));
+                await invokers.InvokeSerially(saga, timeoutHandler.Message, testContext).ConfigureAwait(false);
+            }
 
             testContext.Validate();
             testContext = new TestingContext(messageCreator);
diff --git a/src/NServiceBus.Testing/TypeExtensions.cs b/src/NServiceBus.Testing/TypeExtensions.cs
index 1d5f0c99..65b2a3be 100644
--- a/src/NServiceBus.Testing/TypeExtensions.cs
+++ b/src/NServiceBus.Testing/TypeExtensions.cs
@@ -1,21 +1,21 @@
 namespace NServiceBus.Testing
- {
-     using System;
-     using System.Collections.Generic;
-     using System.Linq;
-     using System.Linq.Expressions;
-     using System.Threading.Tasks;
-
-     static class TypeExtensions
-     {
-         public static IEnumerable<Func<object, object, IMessageHandlerContext, Task>> CreateInvokers(this Type targetType, Type messageType, Type interfaceGenericType)
-         {
-             var interfaceTypes = targetType.GetInterfaces()
-                 .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceGenericType)
-                 .Where(i => i.GenericTypeArguments.First().IsAssignableFrom(messageType));
-
-             foreach (var interfaceType in interfaceTypes)
-             {
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Threading.Tasks;
+
+    static class TypeExtensions
+    {
+        public static IEnumerable<Func<object, object, IMessageHandlerContext, Task>> CreateInvokers(this Type targetType, Type messageType, Type interfaceGenericType)
+        {
+            var interfaceTypes = targetType.GetInterfaces()
+                .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceGenericType)
+                .Where(i => i.GenericTypeArguments.First().IsAssignableFrom(messageType));
+
+            foreach (var interfaceType in interfaceTypes)
+            {
                 var methodInfo = targetType.GetInterfaceMap(interfaceType).TargetMethods.FirstOrDefault();
                 if (methodInfo == null)
                 {
@@ -35,14 +35,14 @@ public static IEnumerable<Func<object, object, IMessageHandlerContext, Task>> Cr
 
                 yield return Expression.Lambda<Func<object, object, IMessageHandlerContext, Task>>(body, target, messageParam, contextParam).Compile();
             }
-         }
+        }
 
-         public static async Task InvokeSerially(this IEnumerable<Func<object, object, IMessageHandlerContext, Task>> invokers, object instance, object message, IMessageHandlerContext context)
-         {
+        public static async Task InvokeSerially(this IEnumerable<Func<object, object, IMessageHandlerContext, Task>> invokers, object instance, object message, IMessageHandlerContext context)
+        {
             foreach (var invocation in invokers)
             {
                 await invocation(instance, message, context).ConfigureAwait(false);
             }
         }
-     }
- }
+    }
+}
\ No newline at end of file