diff --git a/source/NHibernate.AspNet.Identity.Tests/Models/IdentityModels.cs b/source/NHibernate.AspNet.Identity.Tests/Models/IdentityModels.cs
index c860cec..42b80fe 100644
--- a/source/NHibernate.AspNet.Identity.Tests/Models/IdentityModels.cs
+++ b/source/NHibernate.AspNet.Identity.Tests/Models/IdentityModels.cs
@@ -1,8 +1,12 @@
-using NHibernate.AspNet.Identity;
+using NHibernate.AspNet.Identity;
 
 namespace NHibernate.AspNet.Identity.Tests.Models
 {
     public class ApplicationUser : IdentityUser
     {
     }
+
+    public class ApplicationRole : IdentityRole
+    {
+    }
 }
\ No newline at end of file
diff --git a/source/NHibernate.AspNet.Identity.Tests/NHibernate.AspNet.Identity.Tests.csproj b/source/NHibernate.AspNet.Identity.Tests/NHibernate.AspNet.Identity.Tests.csproj
index b999556..5401b51 100644
--- a/source/NHibernate.AspNet.Identity.Tests/NHibernate.AspNet.Identity.Tests.csproj
+++ b/source/NHibernate.AspNet.Identity.Tests/NHibernate.AspNet.Identity.Tests.csproj
@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\packages\NUnit3TestAdapter.3.10.0\build\net35\NUnit3TestAdapter.props" Condition="Exists('..\..\packages\NUnit3TestAdapter.3.10.0\build\net35\NUnit3TestAdapter.props')" />
+  <Import Project="..\..\packages\NUnit.3.10.1\build\NUnit.props" Condition="Exists('..\..\packages\NUnit.3.10.1\build\NUnit.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -19,6 +21,8 @@
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
     <TargetFrameworkProfile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -70,8 +74,8 @@
     <Reference Include="NHibernate, Version=5.0.0.0, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
       <HintPath>..\..\packages\NHibernate.5.0.0\lib\net461\NHibernate.dll</HintPath>
     </Reference>
-    <Reference Include="nunit.framework">
-      <HintPath>..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+    <Reference Include="nunit.framework, Version=3.10.1.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NUnit.3.10.1\lib\net45\nunit.framework.dll</HintPath>
     </Reference>
     <Reference Include="Remotion.Linq, Version=2.1.0.0, Culture=neutral, PublicKeyToken=fee00910d6e5f53b, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Remotion.Linq.2.1.2\lib\net45\Remotion.Linq.dll</HintPath>
@@ -104,6 +108,7 @@
   <ItemGroup>
     <Compile Include="Models\Foo.cs" />
     <Compile Include="Models\IdentityModels.cs" />
+    <Compile Include="RoleStoreTest.cs" />
     <Compile Include="UserStoreTest.cs" />
     <Compile Include="MapTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -149,6 +154,13 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\..\packages\System.Data.SQLite.Core.1.0.96.0\build\net451\System.Data.SQLite.Core.targets" Condition="Exists('..\..\packages\System.Data.SQLite.Core.1.0.96.0\build\net451\System.Data.SQLite.Core.targets')" />
   <Import Project="..\..\packages\GitVersionTask.2.0.1\Build\GitVersionTask.targets" Condition="Exists('..\..\packages\GitVersionTask.2.0.1\Build\GitVersionTask.targets')" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\packages\NUnit.3.10.1\build\NUnit.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\NUnit.3.10.1\build\NUnit.props'))" />
+    <Error Condition="!Exists('..\..\packages\NUnit3TestAdapter.3.10.0\build\net35\NUnit3TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\NUnit3TestAdapter.3.10.0\build\net35\NUnit3TestAdapter.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/source/NHibernate.AspNet.Identity.Tests/RoleStoreTest.cs b/source/NHibernate.AspNet.Identity.Tests/RoleStoreTest.cs
new file mode 100644
index 0000000..1335dd7
--- /dev/null
+++ b/source/NHibernate.AspNet.Identity.Tests/RoleStoreTest.cs
@@ -0,0 +1,123 @@
+using Microsoft.AspNet.Identity;
+using NHibernate.AspNet.Identity.Tests.Models;
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Security.Claims;
+using System.Transactions;
+using TestClass = NUnit.Framework.TestFixtureAttribute;
+using TestCleanup = NUnit.Framework.TearDownAttribute;
+using TestInitialize = NUnit.Framework.SetUpAttribute;
+using TestMethod = NUnit.Framework.TestAttribute;
+
+namespace NHibernate.AspNet.Identity.Tests
+{
+    [TestClass]
+    public class RoleStoreTest
+    {
+        ISession _session;
+
+        [TestInitialize]
+        public void Initialize()
+        {
+            var factory = SessionFactoryProvider.Instance.SessionFactory;
+            _session = factory.OpenSession();
+            SessionFactoryProvider.Instance.BuildSchema();
+        }
+
+        [TestCleanup]
+        public void Cleanup()
+        {
+            _session.Close();
+            _session.Dispose();
+        }
+
+        [TestMethod]
+        public void WhenCreateRole()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            var role = new ApplicationRole() { Name = "RealRoleName" };
+
+            using (var transaction = new TransactionScope())
+            {
+                var result = roleManager.CreateAsync(role).GetAwaiter().GetResult();
+                transaction.Complete();
+                Assert.AreEqual(0, result.Errors.Count());
+            }
+
+            var actual = _session.Query<ApplicationRole>().FirstOrDefault(x => x.Name == role.Name);
+
+            Assert.IsNotNull(actual);
+            Assert.AreEqual(role.Name, actual.Name);
+        }
+
+        [TestMethod]
+        public void WhenDeleteRole()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            var role = new ApplicationRole() { Name = "RealRoleName" };
+
+            using (var transaction = new TransactionScope())
+            {
+                var result = roleManager.CreateAsync(role).GetAwaiter().GetResult();
+                transaction.Complete();
+                Assert.AreEqual(0, result.Errors.Count());
+            }
+
+            using (var transaction = new TransactionScope())
+            {
+                var result = roleManager.DeleteAsync(role).GetAwaiter().GetResult();
+                transaction.Complete();
+                Assert.AreEqual(0, result.Errors.Count());
+            }
+
+            var actual = _session.Query<ApplicationRole>().FirstOrDefault(x => x.Name == role.Name);
+
+            Assert.IsNull(actual);
+        }
+
+        [TestMethod]
+        public void FindByName()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            roleManager.Create(new ApplicationRole() { Name = "test" });
+            var x = roleManager.FindByName("test");
+            Assert.IsNotNull(x);
+        }
+
+        [TestMethod]
+        public void FindByNameIsCaseInsensitive()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            roleManager.Create(new ApplicationRole() { Name = "test" });
+            var x = roleManager.FindByName("TeSt");
+            Assert.IsNotNull(x);
+        }
+
+        [TestMethod]
+        public void FindByNameNotExisting()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            var x = roleManager.FindByName("xxx");
+            Assert.IsNull(x);
+        }
+
+        [TestMethod]
+        public void FindById()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            var role = new ApplicationRole() { Name = "test" };
+            roleManager.Create(role);
+            var x = roleManager.FindById(role.Id);
+            Assert.IsNotNull(x);
+        }
+
+        [TestMethod]
+        public void FindByIdNotExisting()
+        {
+            var roleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(_session));
+            var x = roleManager.FindById(new Guid().ToString());
+            Assert.IsNull(x);
+        }
+    }
+}
diff --git a/source/NHibernate.AspNet.Identity.Tests/SessionFactoryProvider.cs b/source/NHibernate.AspNet.Identity.Tests/SessionFactoryProvider.cs
index 74f20be..4ca46c5 100644
--- a/source/NHibernate.AspNet.Identity.Tests/SessionFactoryProvider.cs
+++ b/source/NHibernate.AspNet.Identity.Tests/SessionFactoryProvider.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Linq;
 using NHibernate.AspNet.Identity.DomainModel;
@@ -6,13 +6,14 @@
 using NHibernate.Cfg;
 using NHibernate.Mapping.ByCode;
 using NHibernate.Tool.hbm2ddl;
+using NUnit.Framework;
 
 namespace NHibernate.AspNet.Identity.Tests
 {
     public sealed class SessionFactoryProvider
     {
         private static volatile SessionFactoryProvider _instance;
-        private static object _syncRoot = new Object();
+        private static object _syncRoot = new object();
 
         private Configuration _configuration;
 
@@ -26,19 +27,20 @@ private SessionFactoryProvider()
         {
             Name = "NHibernate.AspNet.Identity";
 
-            var baseEntityToIgnore = new[] { 
-                typeof(SharpArch.Domain.DomainModel.Entity), 
-                typeof(EntityWithTypedId<int>), 
-                typeof(EntityWithTypedId<string>), 
+            var baseEntityToIgnore = new[] {
+                typeof(SharpArch.Domain.DomainModel.Entity),
+                typeof(EntityWithTypedId<int>),
+                typeof(EntityWithTypedId<string>),
             };
 
-            var allEntities = new[] { 
-                typeof(IdentityUser), 
-                typeof(ApplicationUser), 
-                typeof(IdentityRole), 
-                typeof(IdentityUserLogin), 
-                typeof(IdentityUserClaim), 
-                typeof(Foo), 
+            var allEntities = new[] {
+                typeof(IdentityUser),
+                typeof(ApplicationUser),
+                typeof(ApplicationRole),
+                typeof(IdentityRole),
+                typeof(IdentityUserLogin),
+                typeof(IdentityUserClaim),
+                typeof(Foo),
             };
 
             var mapper = new ConventionModelMapper();
@@ -52,7 +54,8 @@ private SessionFactoryProvider()
             var mapping = mapper.CompileMappingForEach(allEntities);
 
             _configuration = new Configuration();
-            _configuration.Configure("sqlite-nhibernate-config.xml");
+            // nunit3 change: the directory is not set by default and must be retrieved from TestContext
+            _configuration.Configure(Path.Combine(TestContext.CurrentContext.TestDirectory, "sqlite-nhibernate-config.xml"));
             foreach (var map in mapping)
             {
                 Console.WriteLine(map.AsString());
diff --git a/source/NHibernate.AspNet.Identity.Tests/UserStoreTest.cs b/source/NHibernate.AspNet.Identity.Tests/UserStoreTest.cs
index 994e537..728873c 100644
--- a/source/NHibernate.AspNet.Identity.Tests/UserStoreTest.cs
+++ b/source/NHibernate.AspNet.Identity.Tests/UserStoreTest.cs
@@ -1,14 +1,14 @@
-using System;
-using System.Linq;
-using System.Security.Claims;
-using System.Transactions;
 using Microsoft.AspNet.Identity;
 using NHibernate.AspNet.Identity.Tests.Models;
-using NHibernate.Linq;
 using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using System.Transactions;
 using TestClass = NUnit.Framework.TestFixtureAttribute;
-using TestInitialize = NUnit.Framework.SetUpAttribute;
 using TestCleanup = NUnit.Framework.TearDownAttribute;
+using TestInitialize = NUnit.Framework.SetUpAttribute;
 using TestMethod = NUnit.Framework.TestAttribute;
 
 namespace NHibernate.AspNet.Identity.Tests
@@ -30,20 +30,21 @@ public void Initialize()
         public void Cleanup()
         {
             _session.Close();
+            _session.Dispose();
         }
 
         [TestMethod]
-        public void WhenHaveNoUser()
+        public async Task WhenHaveNoUser()
         {
             var login = new UserLoginInfo("ProviderTest", "ProviderKey");
             var store = new UserStore<IdentityUser>(_session);
-            var user = store.FindAsync(login).Result;
+            var user = await store.FindAsync(login);
 
             Assert.IsNull(user);
         }
 
         [TestMethod]
-        public void WhenAddLoginAsync()
+        public async Task WhenAddLoginAsync()
         {
             var user = new IdentityUser("Lukz");
             var login = new UserLoginInfo("ProviderTest02", "ProviderKey02");
@@ -54,9 +55,12 @@ public void WhenAddLoginAsync()
                 ts.Complete();
                 Assert.IsNull(result.Exception);
             }
+            // clear session
+            this._session.Flush();
+            this._session.Clear();
 
             var actual = _session.Query<IdentityUser>().FirstOrDefault(x => x.UserName == user.UserName);
-            var userStored = store.FindAsync(login).Result;
+            var userStored = await store.FindAsync(login);
 
             Assert.IsNotNull(actual);
             Assert.AreEqual(user.UserName, actual.UserName);
@@ -79,23 +83,27 @@ public void WhenRemoveLoginAsync()
                 ts.Complete();
                 Assert.IsNull(result.Exception);
             }
+            // clear session
+            this._session.Flush();
+            this._session.Clear();
 
             var actual = _session.Query<IdentityUser>().FirstOrDefault(x => x.UserName == user.UserName);
             Assert.IsFalse(actual.Logins.Any());
         }
 
         [TestMethod]
-        public void WhenCreateUserAsync()
+        public async Task WhenCreateUserAsync()
         {
             var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(_session));
             var user = new ApplicationUser() { UserName = "RealUserName" };
 
             using (var transaction = new TransactionScope())
             {
-                var result = userManager.CreateAsync(user, "RealPassword").GetAwaiter().GetResult();
+                var result = await userManager.CreateAsync(user, "RealPassword");
                 transaction.Complete();
                 Assert.AreEqual(0, result.Errors.Count());
             }
+            _session.Clear();
 
             var actual = _session.Query<ApplicationUser>().FirstOrDefault(x => x.UserName == user.UserName);
 
@@ -104,16 +112,16 @@ public void WhenCreateUserAsync()
         }
 
         [TestMethod]
-        public void GivenHaveRoles_WhenDeleteUser_ThenDeletingCausesNoCascade()
+        public async Task GivenHaveRoles_WhenDeleteUser_ThenDeletingCausesNoCascade()
         {
             var user = new IdentityUser("Lukz 04");
             var role = new IdentityRole("ADM");
             var store = new UserStore<IdentityUser>(_session);
             var roleStore = new RoleStore<IdentityRole>(_session);
 
-            roleStore.CreateAsync(role);
-            store.CreateAsync(user);
-            store.AddToRoleAsync(user, "ADM");
+            await roleStore.CreateAsync(role);
+            await store.CreateAsync(user);
+            await store.AddToRoleAsync(user, "ADM");
 
             Assert.IsTrue(_session.Query<IdentityRole>().Any(x => x.Name == "ADM"));
             Assert.IsTrue(_session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 04"));
@@ -126,31 +134,31 @@ public void GivenHaveRoles_WhenDeleteUser_ThenDeletingCausesNoCascade()
         }
 
         [TestMethod]
-        public void WhenRemoveUserFromRole_ThenDoNotDeleteRole_BugFix()
+        public async Task WhenRemoveUserFromRole_ThenDoNotDeleteRole_BugFix()
         {
             var user = new IdentityUser("Lukz 05");
             var role = new IdentityRole("ADM05");
             var store = new UserStore<IdentityUser>(_session);
             var roleStore = new RoleStore<IdentityRole>(_session);
 
-            roleStore.CreateAsync(role);
-            store.CreateAsync(user);
-            store.AddToRoleAsync(user, "ADM05");
+            await roleStore.CreateAsync(role);
+            await store.CreateAsync(user);
+            await store.AddToRoleAsync(user, "ADM05");
 
             Assert.IsTrue(_session.Query<IdentityRole>().Any(x => x.Name == "ADM05"));
             Assert.IsTrue(_session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 05"));
-            Assert.IsTrue(store.IsInRoleAsync(user, "ADM05").Result);
+            Assert.IsTrue(await store.IsInRoleAsync(user, "ADM05"));
 
             var result = store.RemoveFromRoleAsync(user, "ADM05");
 
             Assert.IsNull(result.Exception);
-            Assert.IsFalse(store.IsInRoleAsync(user, "ADM05").Result);
+            Assert.IsFalse(await store.IsInRoleAsync(user, "ADM05"));
             Assert.IsTrue(_session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 05"));
             Assert.IsTrue(_session.Query<IdentityRole>().Any(x => x.Name == "ADM05"));
         }
 
         [TestMethod]
-        public void GetAllUsers()
+        public async Task GetAllUsers()
         {
             var user1 = new IdentityUser("Lukz 04");
             var user2 = new IdentityUser("Moa 01");
@@ -160,15 +168,15 @@ public void GetAllUsers()
             var store = new UserStore<IdentityUser>(this._session);
             var roleStore = new RoleStore<IdentityRole>(this._session);
 
-            roleStore.CreateAsync(role);
-            store.CreateAsync(user1);
-            store.CreateAsync(user2);
-            store.CreateAsync(user3);
-            store.CreateAsync(user4);
-            store.AddToRoleAsync(user1, "ADM");
-            store.AddToRoleAsync(user2, "ADM");
-            store.AddToRoleAsync(user3, "ADM");
-            store.AddToRoleAsync(user4, "ADM");
+            await roleStore.CreateAsync(role);
+            await store.CreateAsync(user1);
+            await store.CreateAsync(user2);
+            await store.CreateAsync(user3);
+            await store.CreateAsync(user4);
+            await store.AddToRoleAsync(user1, "ADM");
+            await store.AddToRoleAsync(user2, "ADM");
+            await store.AddToRoleAsync(user3, "ADM");
+            await store.AddToRoleAsync(user4, "ADM");
 
             Assert.IsTrue(this._session.Query<IdentityRole>().Any(x => x.Name == "ADM"));
             Assert.IsTrue(this._session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 04"));
@@ -181,7 +189,7 @@ public void GetAllUsers()
         }
 
         [TestMethod]
-        public void GetAllRoles()
+        public async Task GetAllRoles()
         {
             var user1 = new IdentityUser("Lukz 04");
             var user2 = new IdentityUser("Moa 01");
@@ -192,18 +200,18 @@ public void GetAllRoles()
             var store = new UserStore<IdentityUser>(this._session);
             var roleStore = new RoleStore<IdentityRole>(this._session);
 
-            roleStore.CreateAsync(role);
-            roleStore.CreateAsync(role2);
-            store.CreateAsync(user1);
-            store.CreateAsync(user2);
-            store.CreateAsync(user3);
-            store.CreateAsync(user4);
-            store.AddToRoleAsync(user1, "ADM");
-            store.AddToRoleAsync(user2, "ADM");
-            store.AddToRoleAsync(user3, "ADM");
-            store.AddToRoleAsync(user4, "ADM");
-            store.AddToRoleAsync(user1, "USR");
-            store.AddToRoleAsync(user4, "USR");
+            await roleStore.CreateAsync(role);
+            await roleStore.CreateAsync(role2);
+            await store.CreateAsync(user1);
+            await store.CreateAsync(user2);
+            await store.CreateAsync(user3);
+            await store.CreateAsync(user4);
+            await store.AddToRoleAsync(user1, "ADM");
+            await store.AddToRoleAsync(user2, "ADM");
+            await store.AddToRoleAsync(user3, "ADM");
+            await store.AddToRoleAsync(user4, "ADM");
+            await store.AddToRoleAsync(user1, "USR");
+            await store.AddToRoleAsync(user4, "USR");
 
             Assert.IsTrue(this._session.Query<IdentityRole>().Any(x => x.Name == "ADM"));
             Assert.IsTrue(this._session.Query<IdentityUser>().Any(x => x.UserName == "Lukz 04"));
@@ -218,10 +226,12 @@ public void GetAllRoles()
         [TestMethod]
         public void LockoutAccount()
         {
-            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
-            userManager.MaxFailedAccessAttemptsBeforeLockout = 3;
-            userManager.UserLockoutEnabledByDefault = true;
-            userManager.DefaultAccountLockoutTimeSpan = new TimeSpan(0, 10, 0);
+            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session))
+            {
+                MaxFailedAccessAttemptsBeforeLockout = 3,
+                UserLockoutEnabledByDefault = true,
+                DefaultAccountLockoutTimeSpan = new TimeSpan(0, 10, 0)
+            };
             userManager.Create(new ApplicationUser() { UserName = "test", LockoutEnabled = true }, "Welcome");
             var user = userManager.Find("test", "Welcome");
             Assert.AreEqual(0, userManager.GetAccessFailedCount(user.Id));
@@ -284,10 +294,26 @@ public void AddClaim()
         }
 
         [TestMethod]
-        public void EmailConfirmationToken()
+        public void RemoveClaim()
         {
             var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
-            userManager.UserTokenProvider = new EmailTokenProvider<ApplicationUser, string>() { BodyFormat = "xxxx {0}", Subject = "Reset password" };
+            var user = new ApplicationUser() { UserName = "test", Email = "aaa@bbb.com", EmailConfirmed = true };
+            userManager.Create(user, "Welcome");
+            Claim c = new Claim(ClaimTypes.Role, "Admin");
+            var x = userManager.AddClaim(user.Id, c);
+            Assert.AreEqual(1, userManager.GetClaims(user.Id).Count());
+
+            userManager.RemoveClaimAsync(user.Id, c);
+            Assert.AreEqual(0, userManager.GetClaims(user.Id).Count());
+        }
+
+        [TestMethod]
+        public void EmailConfirmationToken()
+        {
+            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session))
+            {
+                UserTokenProvider = new EmailTokenProvider<ApplicationUser, string>() { BodyFormat = "xxxx {0}", Subject = "Reset password" }
+            };
             userManager.Create(new ApplicationUser() { UserName = "test", Email = "aaa@bbb.com", EmailConfirmed = false }, "Welcome");
             var x = userManager.FindByEmail("aaa@bbb.com");
             string token = userManager.GeneratePasswordResetToken(x.Id);
diff --git a/source/NHibernate.AspNet.Identity.Tests/packages.config b/source/NHibernate.AspNet.Identity.Tests/packages.config
index 8b9b20b..23e0247 100644
--- a/source/NHibernate.AspNet.Identity.Tests/packages.config
+++ b/source/NHibernate.AspNet.Identity.Tests/packages.config
@@ -11,7 +11,9 @@
   <package id="MilesiBastos.SharpArch.Domain" version="4.0.3000" targetFramework="net451" />
   <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net451" />
   <package id="NHibernate" version="5.0.0" targetFramework="net461" />
-  <package id="NUnit" version="2.6.4" targetFramework="net451" />
+  <package id="NUnit" version="3.10.1" targetFramework="net461" />
+  <package id="NUnit3TestAdapter" version="3.10.0" targetFramework="net461" />
+  <package id="NUnitTestAdapter" version="2.1.1" targetFramework="net461" />
   <package id="Remotion.Linq" version="2.1.2" targetFramework="net461" />
   <package id="Remotion.Linq.EagerFetching" version="2.1.0" targetFramework="net461" />
   <package id="System.Data.SQLite.Core" version="1.0.96.0" targetFramework="net451" />
diff --git a/source/NHibernate.AspNet.Identity/RoleStore`1.cs b/source/NHibernate.AspNet.Identity/RoleStore`1.cs
index 1556f78..4289704 100644
--- a/source/NHibernate.AspNet.Identity/RoleStore`1.cs
+++ b/source/NHibernate.AspNet.Identity/RoleStore`1.cs
@@ -1,9 +1,8 @@
-using System;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
 using Microsoft.AspNet.Identity;
 using NHibernate.Linq;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace NHibernate.AspNet.Identity
 {
@@ -12,7 +11,7 @@ public class RoleStore<TRole> : IQueryableRoleStore<TRole>, IRoleStore<TRole>, I
         private bool _disposed;
 
         /// <summary>
-        /// If true then disposing this object will also dispose (close) the session. False means that external code is responsible for disposing the session.
+        /// If true then disposing object will also dispose (close) the session. False means that external code is responsible for disposing the session.
         /// </summary>
         public bool ShouldDisposeSession { get; set; }
 
@@ -21,82 +20,89 @@ public class RoleStore<TRole> : IQueryableRoleStore<TRole>, IRoleStore<TRole>, I
         public RoleStore(ISession context)
         {
             if (context == null)
+            {
                 throw new ArgumentNullException("context");
+            }
 
             ShouldDisposeSession = true;
-            this.Context = context;
+            Context = context;
         }
 
         public virtual Task<TRole> FindByIdAsync(string roleId)
         {
-            this.ThrowIfDisposed();
-            return Task.FromResult(Context.Get<TRole>((object)roleId));
+            ThrowIfDisposed();
+            return Context.GetAsync<TRole>(roleId);
         }
 
         public virtual Task<TRole> FindByNameAsync(string roleName)
         {
-            this.ThrowIfDisposed();
-            return Task.FromResult<TRole>(Queryable.FirstOrDefault<TRole>(Queryable.Where<TRole>(this.Context.Query<TRole>(), (Expression<Func<TRole, bool>>)(u => u.Name.ToUpper() == roleName.ToUpper()))));
+            ThrowIfDisposed();
+            return Roles.FirstOrDefaultAsync(u => u.Name.ToUpper() == roleName.ToUpper());
         }
 
-        public virtual  Task CreateAsync(TRole role)
+        public virtual async Task CreateAsync(TRole role)
         {
-            this.ThrowIfDisposed();
-            if ((object)role == null)
+            ThrowIfDisposed();
+            if (role == null)
+            {
                 throw new ArgumentNullException("role");
-            Context.Save(role);
-            Context.Flush();
-            return Task.FromResult(0);
+            }
+            await Context.SaveAsync(role);
+            await Context.FlushAsync();
         }
 
-        public virtual Task DeleteAsync(TRole role)
+        public virtual async Task DeleteAsync(TRole role)
         {
-            this.ThrowIfDisposed();
+            ThrowIfDisposed();
             if (role == null)
             {
                 throw new ArgumentNullException("role");
             }
-            Context.Delete(role);
-            Context.Flush();
-            return Task.FromResult(0);
+            await Context.DeleteAsync(role);
+            await Context.FlushAsync();
         }
 
-        public virtual Task UpdateAsync(TRole role)
+        public virtual async Task UpdateAsync(TRole role)
         {
-            this.ThrowIfDisposed();
-            if ((object)role == null)
+            ThrowIfDisposed();
+            if (role == null)
+            {
                 throw new ArgumentNullException("role");
-            Context.Update(role);
-            Context.Flush();
-            return Task.FromResult(0);
+            }
+            await Context.UpdateAsync(role);
+            await Context.FlushAsync();
         }
 
         private void ThrowIfDisposed()
         {
-            if (this._disposed)
-                throw new ObjectDisposedException(this.GetType().Name);
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(GetType().Name);
+            }
         }
 
         public void Dispose()
         {
-            this.Dispose(true);
-            GC.SuppressFinalize((object)this);
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
         protected virtual void Dispose(bool disposing)
         {
-            if (disposing && !this._disposed && ShouldDisposeSession)
-                this.Context.Dispose();
-            this._disposed = true;
-            this.Context = (ISession)null;
+            if (disposing && !_disposed && ShouldDisposeSession)
+            {
+                Context.Dispose();
+            }
+            _disposed = true;
+            Context = null;
         }
 
         public IQueryable<TRole> Roles
         {
             get
             {
-                this.ThrowIfDisposed();
-                return this.Context.Query<TRole>();
+                ThrowIfDisposed();
+                return Context.Query<TRole>();
             }
         }
     }
diff --git a/source/NHibernate.AspNet.Identity/UserStore`1.cs b/source/NHibernate.AspNet.Identity/UserStore`1.cs
index a45da90..783f580 100644
--- a/source/NHibernate.AspNet.Identity/UserStore`1.cs
+++ b/source/NHibernate.AspNet.Identity/UserStore`1.cs
@@ -1,13 +1,13 @@
-using System;
+using Microsoft.AspNet.Identity;
+using NHibernate.AspNet.Identity.Properties;
+using NHibernate.Linq;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Security.Claims;
 using System.Threading.Tasks;
-using Microsoft.AspNet.Identity;
-using NHibernate.AspNet.Identity.Properties;
-using NHibernate.Linq;
 
 namespace NHibernate.AspNet.Identity
 {
@@ -40,56 +40,49 @@ public UserStore(ISession context)
         public virtual Task<TUser> FindByIdAsync(string userId)
         {
             this.ThrowIfDisposed();
-            //return Task.FromResult(this.Context.Get<TUser>((object)userId));
             return this.GetUserAggregateAsync((TUser u) => u.Id.Equals(userId));
         }
 
         public virtual Task<TUser> FindByNameAsync(string userName)
         {
             this.ThrowIfDisposed();
-            //return Task.FromResult<TUser>(Queryable.FirstOrDefault<TUser>(Queryable.Where<TUser>(this.Context.Query<TUser>(), (Expression<Func<TUser, bool>>)(u => u.UserName.ToUpper() == userName.ToUpper()))));
             return this.GetUserAggregateAsync((TUser u) => u.UserName.ToUpper() == userName.ToUpper());
         }
 
-        public virtual Task CreateAsync(TUser user)
+        public virtual async Task CreateAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
 
-            Context.Save(user);
-            Context.Flush();
-
-            return Task.FromResult(0);
+            await Context.SaveAsync(user);
+            await Context.FlushAsync();
         }
 
-        public virtual Task DeleteAsync(TUser user)
+        public virtual async Task DeleteAsync(TUser user)
         {
-            if ((object)user == null)
+            this.ThrowIfDisposed();
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
 
-            this.Context.Delete(user);
-            Context.Flush();
-
-            return Task.FromResult(0);
+            await Context.DeleteAsync(user);
+            await Context.FlushAsync();
         }
 
-        public virtual Task UpdateAsync(TUser user)
+        public virtual async Task UpdateAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
 
-            this.Context.Update(user);
-            Context.Flush();
-
-            return Task.FromResult(0);
+            await Context.UpdateAsync(user);
+            await Context.FlushAsync();
         }
 
         private void ThrowIfDisposed()
@@ -103,7 +96,7 @@ private void ThrowIfDisposed()
         public void Dispose()
         {
             this.Dispose(true);
-            GC.SuppressFinalize((object)this);
+            GC.SuppressFinalize(this);
         }
 
         protected virtual void Dispose(bool disposing)
@@ -113,10 +106,10 @@ protected virtual void Dispose(bool disposing)
                 this.Context.Dispose();
             }
             this._disposed = true;
-            this.Context = (ISession)null;
+            this.Context = null;
         }
 
-        public virtual Task<TUser> FindAsync(UserLoginInfo login)
+        public virtual async Task<TUser> FindAsync(UserLoginInfo login)
         {
             this.ThrowIfDisposed();
             if (login == null)
@@ -124,18 +117,21 @@ public virtual Task<TUser> FindAsync(UserLoginInfo login)
                 throw new ArgumentNullException("login");
             }
 
-            var query = from u in this.Context.Query<TUser>()
-                        from l in u.Logins
-                        where l.LoginProvider == login.LoginProvider && l.ProviderKey == login.ProviderKey
-                        select u;
-
-            return Task.FromResult(query.SingleOrDefault());
+            var user = await (from u in this.Context.Query<TUser>()
+                              from l in u.Logins
+                              where l.LoginProvider == login.LoginProvider && l.ProviderKey == login.ProviderKey
+                              select u).FirstOrDefaultAsync();
+            if (user != null)
+            {
+                return await GetUserAggregateAsync(u => u.Id.Equals(user.Id));
+            }
+            return null;
         }
 
         public virtual Task AddLoginAsync(TUser user, UserLoginInfo login)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -150,14 +146,13 @@ public virtual Task AddLoginAsync(TUser user, UserLoginInfo login)
                 LoginProvider = login.LoginProvider
             });
 
-            this.Context.SaveOrUpdate(user);
-            return Task.FromResult<int>(0);
+            return Context.SaveOrUpdateAsync(user);
         }
 
-        public virtual Task RemoveLoginAsync(TUser user, UserLoginInfo login)
+        public virtual async Task RemoveLoginAsync(TUser user, UserLoginInfo login)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -170,50 +165,36 @@ public virtual Task RemoveLoginAsync(TUser user, UserLoginInfo login)
             if (info != null)
             {
                 user.Logins.Remove(info);
-                this.Context.Update(user);
+                await Context.UpdateAsync(user);
             }
-
-            return Task.FromResult<int>(0);
         }
 
         public virtual Task<IList<UserLoginInfo>> GetLoginsAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
 
-            IList<UserLoginInfo> result = new List<UserLoginInfo>();
-            foreach (IdentityUserLogin identityUserLogin in (IEnumerable<IdentityUserLogin>)user.Logins)
-            {
-                result.Add(new UserLoginInfo(identityUserLogin.LoginProvider, identityUserLogin.ProviderKey));
-            }
-
-            return Task.FromResult<IList<UserLoginInfo>>(result);
+            return Task.FromResult<IList<UserLoginInfo>>(user.Logins.Select(l => new UserLoginInfo(l.LoginProvider, l.ProviderKey)).ToList());
         }
 
         public virtual Task<IList<Claim>> GetClaimsAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
 
-            IList<Claim> result = new List<Claim>();
-            foreach (IdentityUserClaim identityUserClaim in (IEnumerable<IdentityUserClaim>)user.Claims)
-            {
-                result.Add(new Claim(identityUserClaim.ClaimType, identityUserClaim.ClaimValue));
-            }
-
-            return Task.FromResult<IList<Claim>>(result);
+            return Task.FromResult<IList<Claim>>(user.Claims.Select(c => new Claim(c.ClaimType, c.ClaimValue)).ToList());
         }
 
         public virtual Task AddClaimAsync(TUser user, Claim claim)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -229,13 +210,13 @@ public virtual Task AddClaimAsync(TUser user, Claim claim)
                 ClaimValue = claim.Value
             });
 
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task RemoveClaimAsync(TUser user, Claim claim)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -244,7 +225,7 @@ public virtual Task RemoveClaimAsync(TUser user, Claim claim)
                 throw new ArgumentNullException("claim");
             }
 
-            foreach (IdentityUserClaim identityUserClaim in Enumerable.ToList<IdentityUserClaim>(Enumerable.Where<IdentityUserClaim>((IEnumerable<IdentityUserClaim>)user.Claims, (Func<IdentityUserClaim, bool>)(uc =>
+            foreach (IdentityUserClaim identityUserClaim in user.Claims.Where(uc =>
             {
                 if (uc.ClaimValue == claim.Value)
                 {
@@ -254,18 +235,18 @@ public virtual Task RemoveClaimAsync(TUser user, Claim claim)
                 {
                     return false;
                 }
-            }))))
+            }).ToList())
             {
                 user.Claims.Remove(identityUserClaim);
             }
 
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
-        public virtual Task AddToRoleAsync(TUser user, string role)
+        public virtual async Task AddToRoleAsync(TUser user, string role)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -274,21 +255,18 @@ public virtual Task AddToRoleAsync(TUser user, string role)
                 throw new ArgumentException(Resources.ValueCannotBeNullOrEmpty, "role");
             }
 
-            IdentityRole identityRole = Queryable.SingleOrDefault<IdentityRole>(this.Context.Query<IdentityRole>(), (Expression<Func<IdentityRole, bool>>)(r => r.Name.ToUpper() == role.ToUpper()));
+            IdentityRole identityRole = await this.Context.Query<IdentityRole>().SingleOrDefaultAsync(r => r.Name.ToUpper() == role.ToUpper());
             if (identityRole == null)
             {
-                throw new InvalidOperationException(string.Format((IFormatProvider)CultureInfo.CurrentCulture, Resources.RoleNotFound, new object[1] { (object)role }));
+                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.RoleNotFound, new object[1] { role }));
             }
             user.Roles.Add(identityRole);
-      
-            return Task.FromResult<int>(0);
-
         }
 
         public virtual Task RemoveFromRoleAsync(TUser user, string role)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -297,32 +275,34 @@ public virtual Task RemoveFromRoleAsync(TUser user, string role)
                 throw new ArgumentException(Resources.ValueCannotBeNullOrEmpty, "role");
             }
 
-            IdentityRole identityUserRole = Enumerable.FirstOrDefault<IdentityRole>(Enumerable.Where<IdentityRole>((IEnumerable<IdentityRole>)user.Roles, (Func<IdentityRole, bool>)(r => r.Name.ToUpper() == role.ToUpper())));
+            IdentityRole identityUserRole = user.Roles.FirstOrDefault(r => r.Name.ToUpper() == role.ToUpper());
             if (identityUserRole != null)
             {
                 user.Roles.Remove(identityUserRole);
             }
 
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task<IList<string>> GetRolesAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
-            else
-            {
-                return Task.FromResult<IList<string>>((IList<string>)Enumerable.ToList<string>(Enumerable.Select<IdentityRole, string>((IEnumerable<IdentityRole>)user.Roles, (Func<IdentityRole, string>)(u => u.Name))));
-            }
+
+            var userId = user.Id;
+            var query = from r in user.Roles
+                        select r.Name;
+
+            return Task.FromResult<IList<string>>(query.ToList());
         }
 
         public virtual Task<bool> IsInRoleAsync(TUser user, string role)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
@@ -330,63 +310,58 @@ public virtual Task<bool> IsInRoleAsync(TUser user, string role)
             {
                 throw new ArgumentException(Resources.ValueCannotBeNullOrEmpty, "role");
             }
-            else
-            {
-                return Task.FromResult<bool>(Enumerable.Any<IdentityRole>((IEnumerable<IdentityRole>)user.Roles, (Func<IdentityRole, bool>)(r => r.Name.ToUpper() == role.ToUpper())));
-            }
+
+            return Task.FromResult((user.Roles.Any(r => r.Name.ToUpper() == role.ToUpper())));
         }
 
         public virtual Task SetPasswordHashAsync(TUser user, string passwordHash)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
             user.PasswordHash = passwordHash;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task<string> GetPasswordHashAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
-            else
-            {
-                return Task.FromResult<string>(user.PasswordHash);
-            }
+
+            return Task.FromResult(user.PasswordHash);
         }
 
         public virtual Task SetSecurityStampAsync(TUser user, string stamp)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
+
             user.SecurityStamp = stamp;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task<string> GetSecurityStampAsync(TUser user)
         {
             this.ThrowIfDisposed();
-            if ((object)user == null)
+            if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
-            else
-            {
-                return Task.FromResult<string>(user.SecurityStamp);
-            }
+
+            return Task.FromResult(user.SecurityStamp);
         }
 
         public virtual Task<bool> HasPasswordAsync(TUser user)
         {
-            return Task.FromResult<bool>(user.PasswordHash != null);
+            return Task.FromResult(user.PasswordHash != null);
         }
 
         public IQueryable<TUser> Users
@@ -405,7 +380,7 @@ public Task<int> GetAccessFailedCountAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<int>(user.AccessFailedCount);
+            return Task.FromResult(user.AccessFailedCount);
         }
 
         public virtual Task<bool> GetLockoutEnabledAsync(TUser user)
@@ -415,27 +390,20 @@ public virtual Task<bool> GetLockoutEnabledAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<bool>(user.LockoutEnabled);
+            return Task.FromResult(user.LockoutEnabled);
         }
 
         public virtual Task<DateTimeOffset> GetLockoutEndDateAsync(TUser user)
         {
-            DateTimeOffset dateTimeOffset;
             this.ThrowIfDisposed();
             if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
-            if (user.LockoutEndDateUtc.HasValue)
-            {
-                DateTime? lockoutEndDateUtc = user.LockoutEndDateUtc;
-                dateTimeOffset = new DateTimeOffset(DateTime.SpecifyKind(lockoutEndDateUtc.Value, DateTimeKind.Utc));
-            }
-            else
-            {
-                dateTimeOffset = new DateTimeOffset();
-            }
-            return Task.FromResult<DateTimeOffset>(dateTimeOffset);
+
+            return Task.FromResult(user.LockoutEndDateUtc.HasValue
+                   ? new DateTimeOffset(DateTime.SpecifyKind(user.LockoutEndDateUtc.Value, DateTimeKind.Utc))
+                   : new DateTimeOffset());
         }
 
         public virtual Task<int> IncrementAccessFailedCountAsync(TUser user)
@@ -445,8 +413,8 @@ public virtual Task<int> IncrementAccessFailedCountAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            user.AccessFailedCount = user.AccessFailedCount + 1;
-            return Task.FromResult<int>(user.AccessFailedCount);
+            user.AccessFailedCount++;
+            return Task.FromResult(user.AccessFailedCount);
         }
 
         public virtual Task ResetAccessFailedCountAsync(TUser user)
@@ -457,7 +425,7 @@ public virtual Task ResetAccessFailedCountAsync(TUser user)
                 throw new ArgumentNullException("user");
             }
             user.AccessFailedCount = 0;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task SetLockoutEnabledAsync(TUser user, bool enabled)
@@ -467,28 +435,21 @@ public virtual Task SetLockoutEnabledAsync(TUser user, bool enabled)
             {
                 throw new ArgumentNullException("user");
             }
+
             user.LockoutEnabled = enabled;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task SetLockoutEndDateAsync(TUser user, DateTimeOffset lockoutEnd)
         {
-            DateTime? nullable;
             this.ThrowIfDisposed();
             if (user == null)
             {
                 throw new ArgumentNullException("user");
             }
-            if (lockoutEnd == DateTimeOffset.MinValue)
-            {
-                nullable = null;
-            }
-            else
-            {
-                nullable = new DateTime?(lockoutEnd.UtcDateTime);
-            }
-            user.LockoutEndDateUtc = nullable;
-            return Task.FromResult<int>(0);
+
+            user.LockoutEndDateUtc = lockoutEnd == DateTimeOffset.MinValue ? (DateTime?)null : lockoutEnd.UtcDateTime;
+            return Task.FromResult(0);
         }
 
         public virtual Task<TUser> FindByEmailAsync(string email)
@@ -504,7 +465,7 @@ public virtual Task<string> GetEmailAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<string>(user.Email);
+            return Task.FromResult(user.Email);
         }
 
         public virtual Task<bool> GetEmailConfirmedAsync(TUser user)
@@ -514,7 +475,7 @@ public virtual Task<bool> GetEmailConfirmedAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<bool>(user.EmailConfirmed);
+            return Task.FromResult(user.EmailConfirmed);
         }
 
         public virtual Task SetEmailAsync(TUser user, string email)
@@ -525,7 +486,7 @@ public virtual Task SetEmailAsync(TUser user, string email)
                 throw new ArgumentNullException("user");
             }
             user.Email = email;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task SetEmailConfirmedAsync(TUser user, bool confirmed)
@@ -536,7 +497,7 @@ public virtual Task SetEmailConfirmedAsync(TUser user, bool confirmed)
                 throw new ArgumentNullException("user");
             }
             user.EmailConfirmed = confirmed;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task<string> GetPhoneNumberAsync(TUser user)
@@ -546,7 +507,7 @@ public virtual Task<string> GetPhoneNumberAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<string>(user.PhoneNumber);
+            return Task.FromResult(user.PhoneNumber);
         }
 
         public virtual Task<bool> GetPhoneNumberConfirmedAsync(TUser user)
@@ -556,7 +517,7 @@ public virtual Task<bool> GetPhoneNumberConfirmedAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<bool>(user.PhoneNumberConfirmed);
+            return Task.FromResult(user.PhoneNumberConfirmed);
         }
 
         public virtual Task SetPhoneNumberAsync(TUser user, string phoneNumber)
@@ -567,7 +528,7 @@ public virtual Task SetPhoneNumberAsync(TUser user, string phoneNumber)
                 throw new ArgumentNullException("user");
             }
             user.PhoneNumber = phoneNumber;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task SetPhoneNumberConfirmedAsync(TUser user, bool confirmed)
@@ -578,7 +539,7 @@ public virtual Task SetPhoneNumberConfirmedAsync(TUser user, bool confirmed)
                 throw new ArgumentNullException("user");
             }
             user.PhoneNumberConfirmed = confirmed;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
         public virtual Task<bool> GetTwoFactorEnabledAsync(TUser user)
@@ -588,7 +549,7 @@ public virtual Task<bool> GetTwoFactorEnabledAsync(TUser user)
             {
                 throw new ArgumentNullException("user");
             }
-            return Task.FromResult<bool>(user.TwoFactorEnabled);
+            return Task.FromResult(user.TwoFactorEnabled);
         }
 
         public virtual Task SetTwoFactorEnabledAsync(TUser user, bool enabled)
@@ -599,20 +560,16 @@ public virtual Task SetTwoFactorEnabledAsync(TUser user, bool enabled)
                 throw new ArgumentNullException("user");
             }
             user.TwoFactorEnabled = enabled;
-            return Task.FromResult<int>(0);
+            return Task.FromResult(0);
         }
 
-        private Task<TUser> GetUserAggregateAsync(Expression<Func<TUser, bool>> filter)
+        protected virtual Task<TUser> GetUserAggregateAsync(Expression<Func<TUser, bool>> filter)
         {
-            return Task.Run(() =>
-            {
-                // no cartesian product, batch call. Don't know if it's really needed: should we eager load or let lazy loading do its stuff?
-                var query = this.Context.Query<TUser>().Where(filter);
-                query.Fetch(p => p.Roles).ToFuture();
-                query.Fetch(p => p.Claims).ToFuture();
-                query.Fetch(p => p.Logins).ToFuture();
-                return query.ToFuture().FirstOrDefault();
-            });
+            var query = this.Context.Query<TUser>().Where(filter);
+            query.Fetch(p => p.Roles).ToFuture();
+            query.Fetch(p => p.Claims).ToFuture();
+            query.Fetch(p => p.Logins).ToFuture();
+            return query.ToFutureValue().GetValueAsync();
         }
     }
 }