Introduced AsyncHelper (#128)

ivaylokenov · ivaylokenov · commit 4fda3183c063 · 2016-07-09T10:40:44.000+03:00
diff --git a/samples/MusicStore/MusicStore.Web/Models/SampleData.cs b/samples/MusicStore/MusicStore.Web/Models/SampleData.cs
@@ -17,34 +17,33 @@ public static class SampleData
         const string defaultAdminUserName = "DefaultAdminUserName";
         const string defaultAdminPassword = "DefaultAdminPassword";
 
-        public static async Task InitializeMusicStoreDatabaseAsync(IServiceProvider serviceProvider, bool createUsers = true)
+        public static void InitializeMusicStoreDatabase(IServiceProvider serviceProvider, bool createUsers = true)
         {
             using (var serviceScope = serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())
             {
                 var db = serviceScope.ServiceProvider.GetService<MusicStoreContext>();
 
-                if (await db.Database.EnsureCreatedAsync())
+                if (db.Database.EnsureCreated())
                 {
-                    await InsertTestData(serviceProvider);
+                    InsertTestData(serviceProvider);
                     if (createUsers)
                     {
-                        await CreateAdminUser(serviceProvider);
+                        CreateAdminUser(serviceProvider);
                     }
                 }
             }
         }
 
-        private static async Task InsertTestData(IServiceProvider serviceProvider)
+        private static void InsertTestData(IServiceProvider serviceProvider)
         {
             var albums = GetAlbums(imgUrl, Genres, Artists);
 
-            await AddOrUpdateAsync(serviceProvider, g => g.GenreId, Genres.Select(genre => genre.Value));
-            await AddOrUpdateAsync(serviceProvider, a => a.ArtistId, Artists.Select(artist => artist.Value));
-            await AddOrUpdateAsync(serviceProvider, a => a.AlbumId, albums);
+            AddOrUpdateAsync(serviceProvider, g => g.GenreId, Genres.Select(genre => genre.Value));
+            AddOrUpdateAsync(serviceProvider, a => a.ArtistId, Artists.Select(artist => artist.Value));
+            AddOrUpdateAsync(serviceProvider, a => a.AlbumId, albums);
         }
-
-        // TODO [EF] This may be replaced by a first class mechanism in EF
-        private static async Task AddOrUpdateAsync<TEntity>(
+        
+        private static void AddOrUpdateAsync<TEntity>(
             IServiceProvider serviceProvider,
             Func<TEntity, object> propertyToMatch, IEnumerable<TEntity> entities)
             where TEntity : class
@@ -67,7 +66,7 @@ private static async Task AddOrUpdateAsync<TEntity>(
                         : EntityState.Added;
                 }
 
-                await db.SaveChangesAsync();
+                db.SaveChanges();
             }
         }
 
@@ -76,7 +75,7 @@ private static async Task AddOrUpdateAsync<TEntity>(
         /// </summary>
         /// <param name="serviceProvider"></param>
         /// <returns></returns>
-        private static async Task CreateAdminUser(IServiceProvider serviceProvider)
+        private static void CreateAdminUser(IServiceProvider serviceProvider)
         {
             var env = serviceProvider.GetService<IHostingEnvironment>();
 
@@ -96,13 +95,13 @@ private static async Task CreateAdminUser(IServiceProvider serviceProvider)
             //    await roleManager.CreateAsync(new IdentityRole(adminRole));
             //}
 
-            var user = await userManager.FindByNameAsync(configuration[defaultAdminUserName]);
+            var user = userManager.FindByNameAsync(configuration[defaultAdminUserName]).GetAwaiter().GetResult();
             if (user == null)
             {
                 user = new ApplicationUser { UserName = configuration[defaultAdminUserName] };
-                await userManager.CreateAsync(user, configuration[defaultAdminPassword]);
+                userManager.CreateAsync(user, configuration[defaultAdminPassword]).GetAwaiter().GetResult();
                 //await userManager.AddToRoleAsync(user, adminRole);
-                await userManager.AddClaimAsync(user, new Claim("ManageStore", "Allowed"));
+                userManager.AddClaimAsync(user, new Claim("ManageStore", "Allowed")).GetAwaiter().GetResult();
             }
 
 #if TESTING
@@ -112,10 +111,10 @@ private static async Task CreateAdminUser(IServiceProvider serviceProvider)
                 for (int i = 0; i < 100; ++i)
                 {
                     var email = string.Format("User{0:D3}@example.com", i);
-                    var normalUser = await userManager.FindByEmailAsync(email);
+                    var normalUser = userManager.FindByEmailAsync(email).GetAwaiter().GetResult();
                     if (normalUser == null)
                     {
-                        await userManager.CreateAsync(new ApplicationUser { UserName = email, Email = email }, "Password~!1");
+                        userManager.CreateAsync(new ApplicationUser { UserName = email, Email = email }, "Password~!1").GetAwaiter().GetResult();
                     }
                 }
             }
diff --git a/samples/MusicStore/MusicStore.Web/StartupNtlmAuthentication.cs b/samples/MusicStore/MusicStore.Web/StartupNtlmAuthentication.cs
@@ -144,7 +144,7 @@ public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
             });
 
             //Populates the MusicStore sample data
-            Task.Run(async () => await SampleData.InitializeMusicStoreDatabaseAsync(app.ApplicationServices, false)).Wait();
+            SampleData.InitializeMusicStoreDatabase(app.ApplicationServices, false);
         }
     }
 }
diff --git a/samples/MusicStore/MusicStore.Web/StartupOpenIdConnect.cs b/samples/MusicStore/MusicStore.Web/StartupOpenIdConnect.cs
@@ -152,7 +152,7 @@ public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
             });
 
             //Populates the MusicStore sample data
-            Task.Run(async () => await SampleData.InitializeMusicStoreDatabaseAsync(app.ApplicationServices)).Wait();
+            SampleData.InitializeMusicStoreDatabase(app.ApplicationServices, false);
         }
     }
 }
diff --git a/src/MyTested.AspNetCore.Mvc.Core/Builders/Actions/VoidActionResultTestBuilder.cs b/src/MyTested.AspNetCore.Mvc.Core/Builders/Actions/VoidActionResultTestBuilder.cs
@@ -32,7 +32,6 @@ public IBaseTestBuilderWithInvokedAction ShouldReturnEmpty()
         /// <inheritdoc />
         public IShouldHaveTestBuilder<VoidActionResult> ShouldHave()
         {
-            this.TestContext.ActionResult = VoidActionResult.Instance;
             return new ShouldHaveTestBuilder<VoidActionResult>(this.TestContext);
         }
 
diff --git a/src/MyTested.AspNetCore.Mvc.Core/Builders/Controllers/ControllerActionCallBuilder.cs b/src/MyTested.AspNetCore.Mvc.Core/Builders/Controllers/ControllerActionCallBuilder.cs
@@ -14,6 +14,7 @@
     using Microsoft.Extensions.DependencyInjection;
     using Utilities;
     using Utilities.Extensions;
+    using Internal;
 
     /// <content>
     /// Used for building the controller which will be tested.
@@ -45,11 +46,11 @@ public IActionResultTestBuilder<TActionResult> Calling<TActionResult>(Expression
 
             try
             {
-                actionResult = Task.Run(async () => await actionInfo.ActionResult).Result;
+                actionResult = AsyncHelper.RunSync(() => actionInfo.ActionResult);
             }
-            catch (AggregateException aggregateException)
+            catch (Exception exception)
             {
-                actionInfo.CaughtException = aggregateException;
+                actionInfo.CaughtException = new AggregateException(exception);
             }
 
             this.TestContext.Apply(actionInfo);
@@ -76,6 +77,7 @@ public IVoidActionResultTestBuilder Calling(Expression<Action<TController>> acti
             this.TestContext.ActionName = actionName;
             this.TestContext.ActionCall = actionCall;
             this.TestContext.CaughtException = caughtException;
+            this.TestContext.ActionResult = VoidActionResult.Instance;
 
             return new VoidActionResultTestBuilder(this.TestContext);
         }
@@ -87,14 +89,15 @@ public IVoidActionResultTestBuilder Calling(Expression<Func<TController, Task>>
 
             try
             {
-                Task.Run(async () => await actionInfo.ActionResult).Wait();
+                AsyncHelper.RunSync(() => actionInfo.ActionResult);
             }
-            catch (AggregateException aggregateException)
+            catch (Exception exception)
             {
-                actionInfo.CaughtException = aggregateException;
+                actionInfo.CaughtException = new AggregateException(exception);
             }
 
             this.TestContext.Apply(actionInfo);
+            this.TestContext.ActionResult = VoidActionResult.Instance;
 
             return new VoidActionResultTestBuilder(this.TestContext);
         }
diff --git a/src/MyTested.AspNetCore.Mvc.Core/Internal/AsyncHelper.cs b/src/MyTested.AspNetCore.Mvc.Core/Internal/AsyncHelper.cs
@@ -0,0 +1,33 @@
+﻿namespace MyTested.AspNetCore.Mvc.Internal
+{
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    public class AsyncHelper
+    {
+        private static readonly TaskFactory taskFactory = new TaskFactory(
+            CancellationToken.None,
+            TaskCreationOptions.None,
+            TaskContinuationOptions.None,
+            TaskScheduler.Default);
+
+        public static TResult RunSync<TResult>(Func<Task<TResult>> func)
+        {
+            return taskFactory
+                .StartNew(func)
+                .Unwrap()
+                .GetAwaiter()
+                .GetResult();
+        }
+
+        public static void RunSync(Func<Task> func)
+        {
+            taskFactory
+                .StartNew(func)
+                .Unwrap()
+                .GetAwaiter()
+                .GetResult();
+        }
+    }
+}
diff --git a/src/MyTested.AspNetCore.Mvc.Core/Internal/Formatters/FormattersHelper.cs b/src/MyTested.AspNetCore.Mvc.Core/Internal/Formatters/FormattersHelper.cs
@@ -54,7 +54,7 @@ public static TModel ReadFromStream<TModel>(Stream stream, string contentType, E
                 return formatter;
             });
 
-            var result = Task.Run(async () => await inputFormatter.ReadAsync(inputFormatterContext)).Result.Model;
+            var result = AsyncHelper.RunSync(() => inputFormatter.ReadAsync(inputFormatterContext)).Model;
 
             try
             {
@@ -91,7 +91,7 @@ public static Stream WriteToStream<TBody>(TBody value, string contentType, Encod
                 return formatter;
             });
 
-            Task.Run(async () => await outputFormatter.WriteAsync(outputFormatterCanWriteContext)).Wait();
+            AsyncHelper.RunSync(() => outputFormatter.WriteAsync(outputFormatterCanWriteContext));
 
             // copy memory stream because formatters close the original one
             return new MemoryStream(((MemoryStream)httpContext.Response.Body).ToArray());
diff --git a/src/MyTested.AspNetCore.Mvc.Core/Internal/Routes/InternalRouteResolver.cs b/src/MyTested.AspNetCore.Mvc.Core/Internal/Routes/InternalRouteResolver.cs
@@ -83,7 +83,7 @@ public static ResolvedRouteContext Resolve(IServiceProvider services, IRouter ro
 
             try
             {
-                Task.Run(async() => await modelBindingActionInvoker.InvokeAsync()).Wait();
+                AsyncHelper.RunSync(() => modelBindingActionInvoker.InvokeAsync());
             }
             catch (Exception ex)
             {
@@ -116,8 +116,8 @@ public static RouteData ResolveRouteData(IRouter router, RouteContext routeConte
             {
                 return null;
             }
-            
-            Task.Run(async () => await router.RouteAsync(routeContext)).Wait();
+
+            AsyncHelper.RunSync(() => router.RouteAsync(routeContext));
 
             var routeData = routeContext.RouteData;
             routeContext.HttpContext.SetRouteData(routeData);

Original file line number	Diff line number	Diff line change
`@@ -17,34 +17,33 @@ public static class SampleData`
`17`	`17`	`const string defaultAdminUserName = "DefaultAdminUserName";`
`18`	`18`	`const string defaultAdminPassword = "DefaultAdminPassword";`
`19`	`19`
`20`		`- public static async Task InitializeMusicStoreDatabaseAsync(IServiceProvider serviceProvider, bool createUsers = true)`
	`20`	`+ public static void InitializeMusicStoreDatabase(IServiceProvider serviceProvider, bool createUsers = true)`
`21`	`21`	`{`
`22`	`22`	`using (var serviceScope = serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())`
`23`	`23`	`{`
`24`	`24`	`var db = serviceScope.ServiceProvider.GetService<MusicStoreContext>();`
`25`	`25`
`26`		`- if (await db.Database.EnsureCreatedAsync())`
	`26`	`+ if (db.Database.EnsureCreated())`
`27`	`27`	`{`
`28`		`- await InsertTestData(serviceProvider);`
	`28`	`+ InsertTestData(serviceProvider);`
`29`	`29`	`if (createUsers)`
`30`	`30`	`{`
`31`		`- await CreateAdminUser(serviceProvider);`
	`31`	`+ CreateAdminUser(serviceProvider);`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`- private static async Task InsertTestData(IServiceProvider serviceProvider)`
	`37`	`+ private static void InsertTestData(IServiceProvider serviceProvider)`
`38`	`38`	`{`
`39`	`39`	`var albums = GetAlbums(imgUrl, Genres, Artists);`
`40`	`40`
`41`		`- await AddOrUpdateAsync(serviceProvider, g => g.GenreId, Genres.Select(genre => genre.Value));`
`42`		`- await AddOrUpdateAsync(serviceProvider, a => a.ArtistId, Artists.Select(artist => artist.Value));`
`43`		`- await AddOrUpdateAsync(serviceProvider, a => a.AlbumId, albums);`
	`41`	`+ AddOrUpdateAsync(serviceProvider, g => g.GenreId, Genres.Select(genre => genre.Value));`
	`42`	`+ AddOrUpdateAsync(serviceProvider, a => a.ArtistId, Artists.Select(artist => artist.Value));`
	`43`	`+ AddOrUpdateAsync(serviceProvider, a => a.AlbumId, albums);`
`44`	`44`	`}`
`45`		`-`
`46`		`- // TODO [EF] This may be replaced by a first class mechanism in EF`
`47`		`- private static async Task AddOrUpdateAsync<TEntity>(`
	`45`	`+`
	`46`	`+ private static void AddOrUpdateAsync<TEntity>(`
`48`	`47`	`IServiceProvider serviceProvider,`
`49`	`48`	`Func<TEntity, object> propertyToMatch, IEnumerable<TEntity> entities)`
`50`	`49`	`where TEntity : class`
`@@ -67,7 +66,7 @@ private static async Task AddOrUpdateAsync<TEntity>(`
`67`	`66`	`: EntityState.Added;`
`68`	`67`	`}`
`69`	`68`
`70`		`- await db.SaveChangesAsync();`
	`69`	`+ db.SaveChanges();`
`71`	`70`	`}`
`72`	`71`	`}`
`73`	`72`
`@@ -76,7 +75,7 @@ private static async Task AddOrUpdateAsync<TEntity>(`
`76`	`75`	`/// </summary>`
`77`	`76`	`/// <param name="serviceProvider"></param>`
`78`	`77`	`/// <returns></returns>`
`79`		`- private static async Task CreateAdminUser(IServiceProvider serviceProvider)`
	`78`	`+ private static void CreateAdminUser(IServiceProvider serviceProvider)`
`80`	`79`	`{`
`81`	`80`	`var env = serviceProvider.GetService<IHostingEnvironment>();`
`82`	`81`
`@@ -96,13 +95,13 @@ private static async Task CreateAdminUser(IServiceProvider serviceProvider)`
`96`	`95`	`// await roleManager.CreateAsync(new IdentityRole(adminRole));`
`97`	`96`	`//}`
`98`	`97`
`99`		`- var user = await userManager.FindByNameAsync(configuration[defaultAdminUserName]);`
	`98`	`+ var user = userManager.FindByNameAsync(configuration[defaultAdminUserName]).GetAwaiter().GetResult();`
`100`	`99`	`if (user == null)`
`101`	`100`	`{`
`102`	`101`	`user = new ApplicationUser { UserName = configuration[defaultAdminUserName] };`
`103`		`- await userManager.CreateAsync(user, configuration[defaultAdminPassword]);`
	`102`	`+ userManager.CreateAsync(user, configuration[defaultAdminPassword]).GetAwaiter().GetResult();`
`104`	`103`	`//await userManager.AddToRoleAsync(user, adminRole);`
`105`		`- await userManager.AddClaimAsync(user, new Claim("ManageStore", "Allowed"));`
	`104`	`+ userManager.AddClaimAsync(user, new Claim("ManageStore", "Allowed")).GetAwaiter().GetResult();`
`106`	`105`	`}`
`107`	`106`
`108`	`107`	`#if TESTING`
`@@ -112,10 +111,10 @@ private static async Task CreateAdminUser(IServiceProvider serviceProvider)`
`112`	`111`	`for (int i = 0; i < 100; ++i)`
`113`	`112`	`{`
`114`	`113`	`var email = string.Format("User{0:D3}@example.com", i);`
`115`		`- var normalUser = await userManager.FindByEmailAsync(email);`
	`114`	`+ var normalUser = userManager.FindByEmailAsync(email).GetAwaiter().GetResult();`
`116`	`115`	`if (normalUser == null)`
`117`	`116`	`{`
`118`		`- await userManager.CreateAsync(new ApplicationUser { UserName = email, Email = email }, "Password~!1");`
	`117`	`+ userManager.CreateAsync(new ApplicationUser { UserName = email, Email = email }, "Password~!1").GetAwaiter().GetResult();`
`119`	`118`	`}`
`120`	`119`	`}`
`121`	`120`	`}`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)`
`144`	`144`	`});`
`145`	`145`
`146`	`146`	`//Populates the MusicStore sample data`
`147`		`- Task.Run(async () => await SampleData.InitializeMusicStoreDatabaseAsync(app.ApplicationServices, false)).Wait();`
	`147`	`+ SampleData.InitializeMusicStoreDatabase(app.ApplicationServices, false);`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)`
`152`	`152`	`});`
`153`	`153`
`154`	`154`	`//Populates the MusicStore sample data`
`155`		`- Task.Run(async () => await SampleData.InitializeMusicStoreDatabaseAsync(app.ApplicationServices)).Wait();`
	`155`	`+ SampleData.InitializeMusicStoreDatabase(app.ApplicationServices, false);`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@ public IBaseTestBuilderWithInvokedAction ShouldReturnEmpty()`
`32`	`32`	`/// <inheritdoc />`
`33`	`33`	`public IShouldHaveTestBuilder<VoidActionResult> ShouldHave()`
`34`	`34`	`{`
`35`		`- this.TestContext.ActionResult = VoidActionResult.Instance;`
`36`	`35`	`return new ShouldHaveTestBuilder<VoidActionResult>(this.TestContext);`
`37`	`36`	`}`
`38`	`37`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`using Microsoft.Extensions.DependencyInjection;`
`15`	`15`	`using Utilities;`
`16`	`16`	`using Utilities.Extensions;`
	`17`	`+ using Internal;`
`17`	`18`
`18`	`19`	`/// <content>`
`19`	`20`	`/// Used for building the controller which will be tested.`
`@@ -45,11 +46,11 @@ public IActionResultTestBuilder<TActionResult> Calling<TActionResult>(Expression`
`45`	`46`
`46`	`47`	`try`
`47`	`48`	`{`
`48`		`- actionResult = Task.Run(async () => await actionInfo.ActionResult).Result;`
	`49`	`+ actionResult = AsyncHelper.RunSync(() => actionInfo.ActionResult);`
`49`	`50`	`}`
`50`		`- catch (AggregateException aggregateException)`
	`51`	`+ catch (Exception exception)`
`51`	`52`	`{`
`52`		`- actionInfo.CaughtException = aggregateException;`
	`53`	`+ actionInfo.CaughtException = new AggregateException(exception);`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`this.TestContext.Apply(actionInfo);`
`@@ -76,6 +77,7 @@ public IVoidActionResultTestBuilder Calling(Expression<Action<TController>> acti`
`76`	`77`	`this.TestContext.ActionName = actionName;`
`77`	`78`	`this.TestContext.ActionCall = actionCall;`
`78`	`79`	`this.TestContext.CaughtException = caughtException;`
	`80`	`+ this.TestContext.ActionResult = VoidActionResult.Instance;`
`79`	`81`
`80`	`82`	`return new VoidActionResultTestBuilder(this.TestContext);`
`81`	`83`	`}`
`@@ -87,14 +89,15 @@ public IVoidActionResultTestBuilder Calling(Expression<Func<TController, Task>>`
`87`	`89`
`88`	`90`	`try`
`89`	`91`	`{`
`90`		`- Task.Run(async () => await actionInfo.ActionResult).Wait();`
	`92`	`+ AsyncHelper.RunSync(() => actionInfo.ActionResult);`
`91`	`93`	`}`
`92`		`- catch (AggregateException aggregateException)`
	`94`	`+ catch (Exception exception)`
`93`	`95`	`{`
`94`		`- actionInfo.CaughtException = aggregateException;`
	`96`	`+ actionInfo.CaughtException = new AggregateException(exception);`
`95`	`97`	`}`
`96`	`98`
`97`	`99`	`this.TestContext.Apply(actionInfo);`
	`100`	`+ this.TestContext.ActionResult = VoidActionResult.Instance;`
`98`	`101`
`99`	`102`	`return new VoidActionResultTestBuilder(this.TestContext);`
`100`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ public static ResolvedRouteContext Resolve(IServiceProvider services, IRouter ro`
`83`	`83`
`84`	`84`	`try`
`85`	`85`	`{`
`86`		`- Task.Run(async() => await modelBindingActionInvoker.InvokeAsync()).Wait();`
	`86`	`+ AsyncHelper.RunSync(() => modelBindingActionInvoker.InvokeAsync());`
`87`	`87`	`}`
`88`	`88`	`catch (Exception ex)`
`89`	`89`	`{`
`@@ -116,8 +116,8 @@ public static RouteData ResolveRouteData(IRouter router, RouteContext routeConte`
`116`	`116`	`{`
`117`	`117`	`return null;`
`118`	`118`	`}`
`119`		`-`
`120`		`- Task.Run(async () => await router.RouteAsync(routeContext)).Wait();`
	`119`	`+`
	`120`	`+ AsyncHelper.RunSync(() => router.RouteAsync(routeContext));`
`121`	`121`
`122`	`122`	`var routeData = routeContext.RouteData;`
`123`	`123`	`routeContext.HttpContext.SetRouteData(routeData);`