Use async methods

RoleStore:async methods+code cleaning+unit tests
UserStore: async+code cleaning+unit tests

Author: lnu

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
+    {
+    }
 }

source/NHibernate.AspNet.Identity.Tests/NHibernate.AspNet.Identity.Tests.csproj

@@ -104,6 +104,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" />

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);
+        }
+    }
+}

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;
@@ -12,7 +12,7 @@ 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 +26,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();