Async await in Unittests

I am struggling with writing unittests for async methods since the unittest itself can not be async. I am trying to work around this by using task.Wait() but this seems to result in a deadlock in certain situations.
See the following code:

Code (CSharp):

1.  
2.  
3.         [Test]
4.         public void TestAwait()
5.         {
6.             var task = GetTestTask();
7.             task.Wait();
8.             Assert.AreEqual(1, 1);
9.         }
10.  
11.         private async Task GetTestTask()
12.         {
13.             UnityEngine.Debug.Log("1");
14.             await Task.Delay(TimeSpan.FromMilliseconds(200));
15.             UnityEngine.Debug.Log("2");
16.             await Task.Run(async () => await Task.Delay(TimeSpan.FromSeconds(1)));
17.             UnityEngine.Debug.Log("3");
18.             await Task.Delay(TimeSpan.FromMilliseconds(200));
19.             UnityEngine.Debug.Log("4");
20.         }

I guess that some of the code in GetTestTask will run on a different thread and try to sync up with the main thread while the mainthread is blocked because of task.Wait().
How can i work around this issue, and is this a bug or a feature?
Any help appreciated!

 

I have same problem.

I also tried the following way.

[Test]

public void AwaitTest()

{

    Task<bool> task = GetTask(); // Task will be fired from GetTask method.

    while(!task.IsCompleted) {}

    Assert.IsTrue(task.Result);

}

But it doesn't work.

 

Alternatively, you could use the Trilleon Automation Framework that supports both Unit Testing and Integration Automation tests. It uses Coroutines to simulate asynchronocity, but it does not use multi threading or actual async (with a socket connection for server communication being the exception to that). But given your sample, it doesn't look as if you need real async. You just need something that can wait for work to be done before continuing the test execution. (Trilleon uses "WaitFor" which passes in a predicate that can express any boolean state, such as "is this work done yet?").

You can try it out from here. https://github.com/disruptorbeam/trilleon.

It is an entire framework, and will take care of this problem for you. However, your Unit Tests written in Trilleon will not run on compilation. It is not designed identically to something like NUnit. It however allows you to unit test IEnumerators and anything that requires gameplay context to validate.

 

I'm surprised that just using `public async Task MyAysyncTest()` doesn't work out of the box with NUnit

 

Same problem, Unity GUI hangs and I have to kill the Unity process. It's a serious bug and should be solved.

Have reported bug: https://fogbugz.unity3d.com/default.asp?1129455_2qh1olgn71f7hr6l

 

Unity uses an old Nunit framework. I don't know which version. But it does not offer proper async Task support.
You can use a workaround that’s inefficient but works: Execute the async test logic on a different thread pool thread, and then (synchronously) block the unit test method until the actual test completes.

The example test below will fail nicely:

Code (CSharp):

1. [Test]
2. public void TestAwait()
3. {
4.     Task.Run(async () =>
5.     {
6.         await GetTestTaskAsync();
7.     }).GetAwaiter().GetResult();
8.    
9.     Assert.AreEqual(1, 2);
10. }
11.  
12. public async Task GetTestTaskAsync()
13. {
14.     Debug.Log("1");
15.     await Task.Delay(TimeSpan.FromMilliseconds(200));
16.     Debug.Log("2");
17.     await Task.Run(async () => await Task.Delay(TimeSpan.FromSeconds(1)));
18.     Debug.Log("3");
19.     await Task.Delay(TimeSpan.FromMilliseconds(200));
20.     Debug.Log("4");
21. }
22.  

TestAwait (1.427s)



Message: 

  Expected: 2

  But was:  1



Output: 

1

2

3

4

 

@Mathijs_Bakker yes it works! Thanks.

A bit simplified it is:

Task.Run(() => GetTestTaskAsync()).GetAwaiter().GetResult();

 

Here is the pattern I use; it avoids deadlock if the code you're testing needs to wait for work that's posted to the Unity SynchronizationContext.

Code (CSharp):

1.   [UnityTest]
2.   public IEnumerator TestSomeAsyncThing() {
3.     var task = Task.Run(async () => {
4.       /* non-boilerplate code goes here */
5.     });
6.     while (!task.IsCompleted) { yield return null; }
7.     if (task.IsFaulted) { throw task.Exception; }
8.   }
9.  

Edit: to propagate exceptions

 

I see your very useful boiler plate and raise you a static method:

Code (CSharp):

1. public static IEnumerator Execute (Task task)
2. {
3.     while (!task.IsCompleted) { yield return null; }
4.     if (task.IsFaulted) { throw task.Exception; }
5. }

Used like this:

Code (CSharp):

1. [UnityTest]
2. public IEnumerator AddReceiver ()
3. {
4.     yield return AsyncTest.Execute (manager.AddReceiverAsync (workingCredentials.streamID));
5.  
6.     Assert.True (manager.ReceiverCount == 1);
7. }

 

@Mathijs_Bakker works like a charm!
And if you need to get a result out of a task, it works in the similar way:
(You can change UnityTest to just Test if your NUnit version requires it to be like that)

Code (CSharp):

1. [UnityTest]
2. public void TestAwait()
3. {
4.     var task = Task.Run(async () =>
5.     {
6.         return await GetTestTaskAsync();
7.     });
8.  
9.     Assert.AreEqual(1, task.Result);
10. }
11.  
12. public async Task<int> GetTestTaskAsync()
13. {
14.     await Task.Delay(TimeSpan.FromMilliseconds(200));
15.     return 1;
16. }
17.  

 

Good!

 

Based on @Mathijs_Bakker I write some generic helper methods

Code (CSharp):

1.  
2. public static class UnityTestUtils {
3.  
4.         public static T RunAsyncMethodSync<T>(Func<Task<T>> asyncFunc) {
5.             return Task.Run(async () => await asyncFunc()).GetAwaiter().GetResult();
6.         }
7.         public static void RunAsyncMethodSync(Func<Task> asyncFunc) {
8.             Task.Run(async () => await asyncFunc()).GetAwaiter().GetResult();
9.         }
10. }

Usage:

Code (CSharp):

1.      
2.         [Test]
3.         public void Test()
4.         {
5.             var result = RunAsyncMethodSync(() => GetTestTaskAsync(4));
6.             Assert.That(result, Is.EqualTo(4));
7.         }
8.  
9.         public async Task<int> GetTestTaskAsync(int a) {
10.             await Task.Delay(TimeSpan.FromMilliseconds(200));
11.             return a;
12.         }
13.  
14.         [Test]
15.         public void Testthrow() {
16.             Assert.Throws<InvalidOperationException>(
17.                            ()=> RunAsyncMethodSync(() => ThrowTaskAsync(4)));
18.         }
19.  
20.         public async Task<int> ThrowTaskAsync(int a) {
21.             await Task.Delay(TimeSpan.FromMilliseconds(200));
22.             throw new InvalidOperationException();
23.         }

 

Here's _another_ variation that I arrived at...


I have these static Await utilities, similar to @pid and @JakHussain ...

Code (CSharp):

1.  
2.         public static IEnumerator Await(Task task)
3.         {
4.             while (!task.IsCompleted) { yield return null; }
5.             if (task.IsFaulted) { throw task.Exception; }
6.         }
7.         public static IEnumerator Await(Func<Task> taskDelegate)
8.         {
9.             return Await(taskDelegate.Invoke());
10.         }
11.  

Which can be used to 'await' for an async delegate or an async Task within a coroutine like...

Code (CSharp):

1.  
2.         [UnityTest]
3.         public IEnumerator TestSomeAsyncThing() {
4.             yield return Await(async () => {
5.                 await UniTask.Delay(TimeSpan.FromSeconds(5)); // example async thing
6.             });
7.         }
8.         async Task AsyncTestMethod()
9.         {
10.             await UniTask.Delay(TimeSpan.FromSeconds(5)); // example async thing
11.         }
12.         [UnityTest]
13.         public IEnumerator TestSomeOtherAsyncThing() {
14.             yield return Await(AsyncTestMethod());
15.         }
16.  

The main reasons I went with this approach:
1) Calling GetResult() or reading Result, as above, blocks the main thread which is the thread most of the Unity code I want to test is designed to run from.
2) It avoids using Task.Run() (which will run code via a thread pool), again because most of the Unity code I'm looking to test is designed to run on the main thread (or will handle spawning work on threads itself where appropriate)
3) The static Await() utilities feel similar to using the await keyword but within a coroutine
4) It supports the convenience of using an async lambda for writing tests

 

Check out this potential solution, although I (as commented in that thread) couldn't get it to work even with the fork of Unity Test Framework..?

https://forum.unity.com/threads/support-for-async-await-in-tests.787853/#post-6838493

Async / await is supposed to be supported there.
You can try by adding their package using the Git URL:
https://github.com/8bitforest/com.unity.test-framework.git

 

Thanks so much for sharing!
I'll take a look at this soon, for feedback, would replying to this thread, or somewhere else be preferred?