Add RoleStore with IQueryableRoleStore

- Add IdentityRole
- Note on implementation decision of RoleStore, make methods virtual to allow custom tweaks in consumers

resolves g0t4#3

Author: g0t4

src/AspNet.Identity.MongoDB/AspNet.Identity.MongoDB.csproj

@@ -53,9 +53,11 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="IdentityContext.cs" />
+    <Compile Include="IdentityRole.cs" />
     <Compile Include="IdentityUser.cs" />
     <Compile Include="IdentityUserClaim.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RoleStore.cs" />
     <Compile Include="UserStore.cs" />
   </ItemGroup>
   <ItemGroup>

src/AspNet.Identity.MongoDB/IdentityContext.cs

@@ -6,13 +6,19 @@
 	public class IdentityContext
 	{
 		public MongoCollection Users { get; private set; }
+		public MongoCollection Roles { get; private set; }
 
 		public IdentityContext(MongoCollection users)
 		{
 			Users = users;
 			EnsureUniqueIndexOnUserName(users);
 		}
 
+		public IdentityContext(MongoCollection users, MongoCollection roles) : this(users)
+		{
+			Roles = roles;
+		}
+
 		private void EnsureUniqueIndexOnUserName(MongoCollection users)
 		{
 			var userName = new IndexKeysBuilder().Ascending("UserName");

src/AspNet.Identity.MongoDB/IdentityRole.cs

@@ -0,0 +1,24 @@
+namespace AspNet.Identity.MongoDB
+{
+	using global::MongoDB.Bson;
+	using global::MongoDB.Bson.Serialization.Attributes;
+	using Microsoft.AspNet.Identity;
+
+	public class IdentityRole : IRole<string>
+	{
+		public IdentityRole()
+		{
+			Id = ObjectId.GenerateNewId().ToString();
+		}
+
+		public IdentityRole(string roleName) : this()
+		{
+			Name = roleName;
+		}
+
+		[BsonRepresentation(BsonType.ObjectId)]
+		public string Id { get; private set; }
+
+		public string Name { get; set; }
+	}
+}

src/AspNet.Identity.MongoDB/RoleStore.cs

@@ -0,0 +1,63 @@
+namespace AspNet.Identity.MongoDB
+{
+	using System.Linq;
+	using System.Threading.Tasks;
+	using global::MongoDB.Bson;
+	using global::MongoDB.Driver.Builders;
+	using global::MongoDB.Driver.Linq;
+	using Microsoft.AspNet.Identity;
+
+	/// <summary>
+	///     Note: Deleting and updating do not modify the roles stored on a user document. If you desire this dynamic
+	///     capability, override the appropriate operations on RoleStore as desired for your application. For example you could
+	///     perform a document modification on the users collection before a delete or a rename.
+	/// </summary>
+	/// <typeparam name="TRole"></typeparam>
+	public class RoleStore<TRole> : IRoleStore<TRole>, IQueryableRoleStore<TRole>
+		where TRole : IdentityRole
+	{
+		private readonly IdentityContext _Context;
+
+		public RoleStore(IdentityContext context)
+		{
+			_Context = context;
+		}
+
+		public virtual IQueryable<TRole> Roles
+		{
+			get { return _Context.Roles.AsQueryable<TRole>(); }
+		}
+
+		public virtual void Dispose()
+		{
+			// no need to dispose of anything, mongodb handles connection pooling automatically
+		}
+
+		public virtual Task CreateAsync(TRole role)
+		{
+			return Task.Run(() => _Context.Roles.Insert(role));
+		}
+
+		public virtual Task UpdateAsync(TRole role)
+		{
+			return Task.Run(() => _Context.Roles.Save(role));
+		}
+
+		public virtual Task DeleteAsync(TRole role)
+		{
+			var queryById = Query<TRole>.EQ(r => r.Id, role.Id);
+			return Task.Run(() => _Context.Roles.Remove(queryById));
+		}
+
+		public virtual Task<TRole> FindByIdAsync(string roleId)
+		{
+			return Task.Run(() => _Context.Roles.FindOneByIdAs<TRole>(ObjectId.Parse(roleId)));
+		}
+
+		public virtual Task<TRole> FindByNameAsync(string roleName)
+		{
+			var queryByName = Query<TRole>.EQ(r => r.Name, roleName);
+			return Task.Run(() => _Context.Roles.FindOneAs<TRole>(queryByName));
+		}
+	}
+}

src/AspNet.Identity.MongoDB/UserStore.cs

@@ -48,8 +48,8 @@ public Task UpdateAsync(TUser user)
 
 		public Task DeleteAsync(TUser user)
 		{
-			var remove = Query<TUser>.EQ(u => u.Id, user.Id);
-			return Task.Run(() => _Context.Users.Remove(remove));
+			var queryById = Query<TUser>.EQ(u => u.Id, user.Id);
+			return Task.Run(() => _Context.Users.Remove(queryById));
 		}
 
 		public Task<TUser> FindByIdAsync(string userId)
@@ -60,8 +60,8 @@ public Task<TUser> FindByIdAsync(string userId)
 		public Task<TUser> FindByNameAsync(string userName)
 		{
 			// todo exception on duplicates? or better to enforce unique index to ensure this
-			var byName = Query<TUser>.EQ(u => u.UserName, userName);
-			return Task.Run(() => _Context.Users.FindOneAs<TUser>(byName));
+			var queryByName = Query<TUser>.EQ(u => u.UserName, userName);
+			return Task.Run(() => _Context.Users.FindOneAs<TUser>(queryByName));
 		}
 
 		public Task SetPasswordHashAsync(TUser user, string passwordHash)

src/IntegrationTests/EnsureWeCanExtendIdentityRoleTests.cs

@@ -0,0 +1,53 @@
+namespace IntegrationTests
+{
+	using System.Linq;
+	using AspNet.Identity.MongoDB;
+	using Microsoft.AspNet.Identity;
+	using NUnit.Framework;
+
+	[TestFixture]
+	public class EnsureWeCanExtendIdentityRoleTests : UserIntegrationTestsBase
+	{
+		private RoleManager<ExtendedIdentityRole> _Manager;
+		private ExtendedIdentityRole _Role;
+
+		public class ExtendedIdentityRole : IdentityRole
+		{
+			public string ExtendedField { get; set; }
+		}
+
+		[SetUp]
+		public void BeforeEachTestAfterBase()
+		{
+			var context = new IdentityContext(Users, Roles);
+			var roleStore = new RoleStore<ExtendedIdentityRole>(context);
+			_Manager = new RoleManager<ExtendedIdentityRole>(roleStore);
+			_Role = new ExtendedIdentityRole
+			{
+				Name = "admin"
+			};
+		}
+
+		[Test]
+		public void Create_ExtendedRoleType_SavesExtraFields()
+		{
+			_Role.ExtendedField = "extendedField";
+
+			_Manager.Create(_Role);
+
+			var savedRole = Roles.FindAllAs<ExtendedIdentityRole>().Single();
+			Expect(savedRole.ExtendedField, Is.EqualTo("extendedField"));
+		}
+
+		[Test]
+		public void Create_ExtendedRoleType_ReadsExtraFields()
+		{
+			_Role.ExtendedField = "extendedField";
+
+			_Manager.Create(_Role);
+
+			var savedRole = _Manager.FindById(_Role.Id);
+			Expect(savedRole.ExtendedField, Is.EqualTo("extendedField"));
+		}
+	}
+}

src/IntegrationTests/IdentityUserTests.cs

@@ -12,7 +12,7 @@ public class IdentityUserTests : UserIntegrationTestsBase
 		public void Insert_NoId_SetsId()
 		{
 			var user = new IdentityUser();
-			user.SetUserId(null);
+			user.SetId(null);
 
 			Users.Insert(user);
 

src/IntegrationTests/IntegrationTests.csproj

@@ -58,9 +58,11 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="EnsureWeCanExtendIdentityUserTests.cs" />
+    <Compile Include="EnsureWeCanExtendIdentityRoleTests.cs" />
     <Compile Include="IdentityContextTests.cs" />
     <Compile Include="IdentityUserTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RoleStoreTests.cs" />
     <Compile Include="UserClaimStoreTests.cs" />
     <Compile Include="UserEmailStoreTests.cs" />
     <Compile Include="UserIntegrationTestsBase.cs" />

src/IntegrationTests/RoleStoreTests.cs

@@ -0,0 +1,84 @@
+namespace IntegrationTests
+{
+	using System.Linq;
+	using AspNet.Identity.MongoDB;
+	using Microsoft.AspNet.Identity;
+	using MongoDB.Bson;
+	using NUnit.Framework;
+	using Tests;
+
+	[TestFixture]
+	public class RoleStoreTests : UserIntegrationTestsBase
+	{
+		[Test]
+		public void Create_NewRole_Saves()
+		{
+			var roleName = "admin";
+			var role = new IdentityRole(roleName);
+			var manager = GetRoleManager();
+
+			manager.Create(role);
+
+			var savedRole = Roles.FindAll().Single();
+			Expect(savedRole.Name, Is.EqualTo(roleName));
+		}
+
+		[Test]
+		public void FindByName_SavedRole_ReturnsRole()
+		{
+			var roleName = "name";
+			var role = new IdentityRole {Name = roleName};
+			var manager = GetRoleManager();
+			manager.Create(role);
+
+			var foundRole = manager.FindByName(roleName);
+
+			Expect(foundRole, Is.Not.Null);
+			Expect(foundRole.Name, Is.EqualTo(roleName));
+		}
+
+		[Test]
+		public void FindById_SavedRole_ReturnsRole()
+		{
+			var roleId = ObjectId.GenerateNewId().ToString();
+			var role = new IdentityRole {Name = "name"};
+			role.SetId(roleId);
+			var manager = GetRoleManager();
+			manager.Create(role);
+
+			var foundRole = manager.FindById(roleId);
+
+			Expect(foundRole, Is.Not.Null);
+			Expect(foundRole.Id, Is.EqualTo(roleId));
+		}
+
+		[Test]
+		public void Delete_ExistingRole_Removes()
+		{
+			var role = new IdentityRole {Name = "name"};
+			var manager = GetRoleManager();
+			manager.Create(role);
+			Expect(Roles.FindAll(), Is.Not.Empty);
+
+			manager.Delete(role);
+
+			Expect(Roles.FindAll(), Is.Empty);
+		}
+
+		[Test]
+		public void Update_ExistingRole_Updates()
+		{
+			var role = new IdentityRole {Name = "name"};
+			var manager = GetRoleManager();
+			manager.Create(role);
+			var savedRole = manager.FindById(role.Id);
+			savedRole.Name = "newname";
+
+			manager.Update(savedRole);
+
+			var changedRole = Roles.FindAll().Single();
+			Expect(changedRole, Is.Not.Null);
+			Expect(changedRole.Name, Is.EqualTo("newname"));
+		}
+	}
+}

src/IntegrationTests/UserIntegrationTestsBase.cs

@@ -9,6 +9,7 @@ public class UserIntegrationTestsBase : AssertionHelper
 	{
 		protected MongoDatabase Database;
 		protected MongoCollection<IdentityUser> Users;
+		protected MongoCollection<IdentityRole> Roles;
 		protected IdentityContext IdentityContext;
 
 		[SetUp]
@@ -17,15 +18,23 @@ public void BeforeEachTest()
 			var client = new MongoClient("mongodb://localhost:27017");
 			Database = client.GetServer().GetDatabase("identity-testing");
 			Users = Database.GetCollection<IdentityUser>("users");
-			IdentityContext = new IdentityContext(Users);
+			Roles = Database.GetCollection<IdentityRole>("roles");
+			IdentityContext = new IdentityContext(Users, Roles);
 
 			Database.DropCollection("users");
+			Database.DropCollection("roles");
 		}
 
 		protected UserManager<IdentityUser> GetUserManager()
 		{
 			var store = new UserStore<IdentityUser>(IdentityContext);
 			return new UserManager<IdentityUser>(store);
 		}
+
+		protected RoleManager<IdentityRole> GetRoleManager()
+		{
+			var store = new RoleStore<IdentityRole>(IdentityContext);
+			return new RoleManager<IdentityRole>(store);
+		}
 	}
 }

src/IntegrationTests/UserStoreTests.cs

@@ -52,7 +52,7 @@ public void FindById_SavedUser_ReturnsUser()
 		{
 			var userId = ObjectId.GenerateNewId().ToString();
 			var user = new IdentityUser {UserName = "name"};
-			user.SetUserId(userId);
+			user.SetId(userId);
 			var manager = GetUserManager();
 			manager.Create(user);