From 28dc0245bf3792aaa0617b410fd0a04f4f99baa6 Mon Sep 17 00:00:00 2001 From: Suhas Joshi Date: Thu, 26 Feb 2015 11:48:01 -0800 Subject: [PATCH] Moved POCOs to EF and fixed tests --- .../IdentitySample.Mvc/Models/SampleData.cs | 1 + samples/IdentitySample.Mvc/Startup.cs | 1 + .../IdentityDbContext.cs | 10 +- .../IdentityRole.cs | 6 +- .../IdentityRoleClaim.cs | 2 +- .../IdentityUser.cs | 18 +- .../IdentityUserClaim.cs | 2 +- .../IdentityUserLogin.cs | 2 +- .../IdentityUserRole.cs | 2 +- .../IdentityServiceCollectionExtensions.cs | 5 - .../InMemoryEFUserStoreTest.cs | 35 +- .../RoleStoreTest.cs | 4 +- .../DefaultPocoTest.cs | 146 ++++- .../SqlStoreTestBase.cs | 39 +- .../UserStoreGuidKeyTest.cs | 1 + .../UserStoreIntKeyTest.cs | 1 + .../UserStoreStringKeyTest.cs | 1 + .../UserStoreTest.cs | 74 ++- .../FunctionalTest.cs | 13 +- .../HttpSignInTest.cs | 14 +- .../InMemoryRoleStore.cs | 5 +- .../InMemoryStoreTest.cs | 39 +- .../InMemoryUserStore.cs | 33 +- .../IdentityBuilderTest.cs | 80 +-- .../IdentityOptionsTest.cs | 8 +- .../PasswordValidatorTest.cs | 22 +- .../SecurityStampValidatorTest.cs | 40 +- .../SignInManagerTest.cs | 10 +- .../UserManagerTest.cs | 13 +- test/Shared/ApplicationUser.cs | 7 - test/Shared/TestRole.cs | 65 ++- test/Shared/TestRoleClaim.cs | 36 ++ test/Shared/TestUser.cs | 96 +++- test/Shared/TestUserClaim.cs | 36 ++ test/Shared/TestUserLogin.cs | 36 ++ test/Shared/TestUserRole.cs | 26 + test/Shared/UserManagerTestBase.cs | 534 +++++++++--------- 37 files changed, 994 insertions(+), 469 deletions(-) rename src/{Microsoft.AspNet.Identity => Microsoft.AspNet.Identity.EntityFramework}/IdentityRole.cs (92%) rename src/{Microsoft.AspNet.Identity => Microsoft.AspNet.Identity.EntityFramework}/IdentityRoleClaim.cs (95%) rename src/{Microsoft.AspNet.Identity => Microsoft.AspNet.Identity.EntityFramework}/IdentityUser.cs (79%) rename src/{Microsoft.AspNet.Identity => Microsoft.AspNet.Identity.EntityFramework}/IdentityUserClaim.cs (95%) rename src/{Microsoft.AspNet.Identity => Microsoft.AspNet.Identity.EntityFramework}/IdentityUserLogin.cs (95%) rename src/{Microsoft.AspNet.Identity => Microsoft.AspNet.Identity.EntityFramework}/IdentityUserRole.cs (93%) delete mode 100644 test/Shared/ApplicationUser.cs create mode 100644 test/Shared/TestRoleClaim.cs create mode 100644 test/Shared/TestUserClaim.cs create mode 100644 test/Shared/TestUserLogin.cs create mode 100644 test/Shared/TestUserRole.cs diff --git a/samples/IdentitySample.Mvc/Models/SampleData.cs b/samples/IdentitySample.Mvc/Models/SampleData.cs index 700ec1f84f..7dbf36d976 100644 --- a/samples/IdentitySample.Mvc/Models/SampleData.cs +++ b/samples/IdentitySample.Mvc/Models/SampleData.cs @@ -2,6 +2,7 @@ using System.Security.Claims; using System.Threading.Tasks; using Microsoft.AspNet.Identity; +using Microsoft.AspNet.Identity.EntityFramework; using Microsoft.Data.Entity.SqlServer; using Microsoft.Framework.DependencyInjection; using Microsoft.Framework.OptionsModel; diff --git a/samples/IdentitySample.Mvc/Startup.cs b/samples/IdentitySample.Mvc/Startup.cs index f3dfea2ed4..22ca9c3a45 100644 --- a/samples/IdentitySample.Mvc/Startup.cs +++ b/samples/IdentitySample.Mvc/Startup.cs @@ -2,6 +2,7 @@ using IdentitySample.Models; using Microsoft.AspNet.Builder; using Microsoft.AspNet.Diagnostics; using Microsoft.AspNet.Identity; +using Microsoft.AspNet.Identity.EntityFramework; using Microsoft.Data.Entity; using Microsoft.Framework.ConfigurationModel; using Microsoft.Framework.DependencyInjection; diff --git a/src/Microsoft.AspNet.Identity.EntityFramework/IdentityDbContext.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityDbContext.cs index 6be6d26995..63eff27ffa 100644 --- a/src/Microsoft.AspNet.Identity.EntityFramework/IdentityDbContext.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityDbContext.cs @@ -31,6 +31,10 @@ namespace Microsoft.AspNet.Identity.EntityFramework b.Key(u => u.Id); b.ForRelational().Table("AspNetUsers"); b.Property(u => u.ConcurrencyStamp).ConcurrencyToken(); + + b.Collection(u => u.Claims).InverseReference().ForeignKey(uc => uc.UserId); + b.Collection(u => u.Logins).InverseReference().ForeignKey(ul => ul.UserId); + b.Collection(u => u.Roles).InverseReference().ForeignKey(ur => ur.UserId); }); builder.Entity(b => @@ -38,19 +42,20 @@ namespace Microsoft.AspNet.Identity.EntityFramework b.Key(r => r.Id); b.ForRelational().Table("AspNetRoles"); b.Property(r => r.ConcurrencyStamp).ConcurrencyToken(); + + b.Collection(r => r.Users).InverseReference().ForeignKey(ur => ur.RoleId); + b.Collection(r => r.Claims).InverseReference().ForeignKey(rc => rc.RoleId); }); builder.Entity>(b => { b.Key(uc => uc.Id); - b.Reference().InverseCollection().ForeignKey(uc => uc.UserId); b.ForRelational().Table("AspNetUserClaims"); }); builder.Entity>(b => { b.Key(rc => rc.Id); - b.Reference().InverseCollection().ForeignKey(rc => rc.RoleId); b.ForRelational().Table("AspNetRoleClaims"); }); @@ -66,7 +71,6 @@ namespace Microsoft.AspNet.Identity.EntityFramework builder.Entity>(b => { b.Key(l => new { l.LoginProvider, l.ProviderKey }); - b.Reference().InverseCollection().ForeignKey(uc => uc.UserId); b.ForRelational().Table("AspNetUserLogins"); }); } diff --git a/src/Microsoft.AspNet.Identity/IdentityRole.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityRole.cs similarity index 92% rename from src/Microsoft.AspNet.Identity/IdentityRole.cs rename to src/Microsoft.AspNet.Identity.EntityFramework/IdentityRole.cs index 0127acb84d..1b81f9ec92 100644 --- a/src/Microsoft.AspNet.Identity/IdentityRole.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityRole.cs @@ -4,7 +4,7 @@ using System; using System.Collections.Generic; -namespace Microsoft.AspNet.Identity +namespace Microsoft.AspNet.Identity.EntityFramework { /// /// Represents a Role entity @@ -49,12 +49,12 @@ namespace Microsoft.AspNet.Identity /// /// Navigation property for users in the role /// - public virtual ICollection> Users { get; private set; } = new List>(); + public virtual ICollection> Users { get; } = new List>(); /// /// Navigation property for claims in the role /// - public virtual ICollection> Claims { get; private set; } = new List>(); + public virtual ICollection> Claims { get; } = new List>(); /// /// Role id diff --git a/src/Microsoft.AspNet.Identity/IdentityRoleClaim.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityRoleClaim.cs similarity index 95% rename from src/Microsoft.AspNet.Identity/IdentityRoleClaim.cs rename to src/Microsoft.AspNet.Identity.EntityFramework/IdentityRoleClaim.cs index c0186b17a5..2c2871d2c8 100644 --- a/src/Microsoft.AspNet.Identity/IdentityRoleClaim.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityRoleClaim.cs @@ -3,7 +3,7 @@ using System; -namespace Microsoft.AspNet.Identity +namespace Microsoft.AspNet.Identity.EntityFramework { public class IdentityRoleClaim : IdentityRoleClaim { } diff --git a/src/Microsoft.AspNet.Identity/IdentityUser.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUser.cs similarity index 79% rename from src/Microsoft.AspNet.Identity/IdentityUser.cs rename to src/Microsoft.AspNet.Identity.EntityFramework/IdentityUser.cs index 4392bf7db4..fc1c6b229b 100644 --- a/src/Microsoft.AspNet.Identity/IdentityUser.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUser.cs @@ -2,8 +2,9 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Collections.Generic; -namespace Microsoft.AspNet.Identity +namespace Microsoft.AspNet.Identity.EntityFramework { public class IdentityUser : IdentityUser { @@ -87,5 +88,20 @@ namespace Microsoft.AspNet.Identity /// Used to record failures for the purposes of lockout /// public virtual int AccessFailedCount { get; set; } + + /// + /// Navigation property for users in the role + /// + public virtual ICollection> Roles { get; } = new List>(); + + /// + /// Navigation property for users claims + /// + public virtual ICollection> Claims { get; } = new List>(); + + /// + /// Navigation property for users logins + /// + public virtual ICollection> Logins { get; } = new List>(); } } diff --git a/src/Microsoft.AspNet.Identity/IdentityUserClaim.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserClaim.cs similarity index 95% rename from src/Microsoft.AspNet.Identity/IdentityUserClaim.cs rename to src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserClaim.cs index 3dcedc5fa4..f761a43606 100644 --- a/src/Microsoft.AspNet.Identity/IdentityUserClaim.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserClaim.cs @@ -3,7 +3,7 @@ using System; -namespace Microsoft.AspNet.Identity +namespace Microsoft.AspNet.Identity.EntityFramework { public class IdentityUserClaim : IdentityUserClaim { } diff --git a/src/Microsoft.AspNet.Identity/IdentityUserLogin.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserLogin.cs similarity index 95% rename from src/Microsoft.AspNet.Identity/IdentityUserLogin.cs rename to src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserLogin.cs index c53f9b9872..4acf1adf30 100644 --- a/src/Microsoft.AspNet.Identity/IdentityUserLogin.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserLogin.cs @@ -3,7 +3,7 @@ using System; -namespace Microsoft.AspNet.Identity +namespace Microsoft.AspNet.Identity.EntityFramework { public class IdentityUserLogin : IdentityUserLogin { } diff --git a/src/Microsoft.AspNet.Identity/IdentityUserRole.cs b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserRole.cs similarity index 93% rename from src/Microsoft.AspNet.Identity/IdentityUserRole.cs rename to src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserRole.cs index 78feb2e43d..d627229224 100644 --- a/src/Microsoft.AspNet.Identity/IdentityUserRole.cs +++ b/src/Microsoft.AspNet.Identity.EntityFramework/IdentityUserRole.cs @@ -3,7 +3,7 @@ using System; -namespace Microsoft.AspNet.Identity +namespace Microsoft.AspNet.Identity.EntityFramework { public class IdentityUserRole : IdentityUserRole { } diff --git a/src/Microsoft.AspNet.Identity/IdentityServiceCollectionExtensions.cs b/src/Microsoft.AspNet.Identity/IdentityServiceCollectionExtensions.cs index 31acc8bc54..c310e0bbda 100644 --- a/src/Microsoft.AspNet.Identity/IdentityServiceCollectionExtensions.cs +++ b/src/Microsoft.AspNet.Identity/IdentityServiceCollectionExtensions.cs @@ -28,11 +28,6 @@ namespace Microsoft.Framework.DependencyInjection return services.Configure(configureOptions, IdentityOptions.ApplicationCookieAuthenticationScheme); } - public static IdentityBuilder AddIdentity(this IServiceCollection services) - { - return services.AddIdentity(configureOptions: null); - } - public static IdentityBuilder AddIdentity( this IServiceCollection services) where TUser : class diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/InMemoryEFUserStoreTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/InMemoryEFUserStoreTest.cs index bbdf4a73db..39235f184c 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/InMemoryEFUserStoreTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/InMemoryEFUserStoreTest.cs @@ -2,12 +2,13 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Linq.Expressions; using Microsoft.AspNet.Identity.Test; using Microsoft.Framework.DependencyInjection; namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test { - public class InMemoryEFUserStoreTest : UserManagerTestBase + public class InMemoryEFUserStoreTest : UserManagerTestBase { protected override object CreateTestContext() { @@ -24,5 +25,37 @@ namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test var store = new RoleStore((InMemoryContext)context); services.AddInstance>(store); } + + protected override IdentityUser CreateTestUser(string namePrefix = "", string email = "", string phoneNumber = "", + bool lockoutEnabled = false, DateTimeOffset? lockoutEnd = default(DateTimeOffset?), bool useNamePrefixAsUserName = false) + { + return new IdentityUser + { + UserName = useNamePrefixAsUserName ? namePrefix : string.Format("{0}{1}", namePrefix, Guid.NewGuid()), + Email = email, + PhoneNumber = phoneNumber, + LockoutEnabled = lockoutEnabled, + LockoutEnd = lockoutEnd + }; + } + + protected override IdentityRole CreateTestRole(string roleNamePrefix = "", bool useRoleNamePrefixAsRoleName = false) + { + var roleName = useRoleNamePrefixAsRoleName ? roleNamePrefix : string.Format("{0}{1}", roleNamePrefix, Guid.NewGuid()); + return new IdentityRole(roleName); + } + + protected override void SetUserPasswordHash(IdentityUser user, string hashedPassword) + { + user.PasswordHash = hashedPassword; + } + + protected override Expression> UserNameEqualsPredicate(string userName) => u => u.UserName == userName; + + protected override Expression> RoleNameEqualsPredicate(string roleName) => r => r.Name == roleName; + + protected override Expression> UserNameStartsWithPredicate(string userName) => u => u.UserName.StartsWith(userName); + + protected override Expression> RoleNameStartsWithPredicate(string roleName) => r => r.Name.StartsWith(roleName); } } diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/RoleStoreTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/RoleStoreTest.cs index 1ef2f46fd6..e77f79e7c3 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/RoleStoreTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/RoleStoreTest.cs @@ -18,7 +18,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test services.AddEntityFramework().AddInMemoryStore(); var store = new RoleStore(new InMemoryContext()); services.AddInstance>(store); - services.AddIdentity(); + services.AddIdentity(); var provider = services.BuildServiceProvider(); var manager = provider.GetRequiredService>(); Assert.NotNull(manager); @@ -31,7 +31,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test services.AddEntityFramework().AddInMemoryStore(); services.AddTransient(); services.AddTransient, RoleStore>(); - services.AddIdentity(); + services.AddIdentity(); services.AddSingleton>(); var provider = services.BuildServiceProvider(); var manager = provider.GetRequiredService>(); diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.Test/DefaultPocoTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.Test/DefaultPocoTest.cs index 8752dc2d26..ced390ac9f 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.Test/DefaultPocoTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.Test/DefaultPocoTest.cs @@ -2,6 +2,8 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Linq; +using System.Security.Claims; using System.Threading.Tasks; using Microsoft.AspNet.Builder; using Microsoft.AspNet.Identity.Test; @@ -14,7 +16,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test [TestCaseOrderer("Microsoft.AspNet.Identity.Test.PriorityOrderer", "Microsoft.AspNet.Identity.EntityFramework.Test")] public class DefaultPocoTest { - private readonly string ConnectionString = @"Server=(localdb)\mssqllocaldb;Database=DefaultSchemaTest" + DateTime.Now.Month + "-" + DateTime.Now.Day + "-" + DateTime.Now.Year + ";Trusted_Connection=True;"; + private readonly string ConnectionString = @"Server=(localdb)\mssqllocaldb;Database=DefaultSchemaTest" + DateTime.Now.Month + "-" + DateTime.Now.Day + "-" + DateTime.Now.Year + ";Trusted_Connection=True;MultipleActiveResultSets=true"; public IdentityDbContext CreateContext(bool ensureCreated = false) { var db = DbUtil.Create(ConnectionString); @@ -62,6 +64,148 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test IdentityResultAssert.IsSuccess(await userManager.DeleteAsync(user)); } + [Fact] + public async Task CanIncludeUserClaimsTest() + { + // Arrange + CreateContext(true); + var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider); + + var services = new ServiceCollection(); + DbUtil.ConfigureDbServices(ConnectionString, services); + services.AddIdentity().AddEntityFrameworkStores(); + builder.ApplicationServices = services.BuildServiceProvider(); + + var userManager = builder.ApplicationServices.GetRequiredService>(); + var dbContext = builder.ApplicationServices.GetRequiredService(); + + var username = "user" + new Random().Next(); + var user = new IdentityUser() { UserName = username }; + IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); + + for (var i = 0; i < 10; i++) + { + IdentityResultAssert.IsSuccess(await userManager.AddClaimAsync(user, new Claim(i.ToString(), "foo"))); + } + + user = dbContext.Users.Include(x => x.Claims).FirstOrDefault(x => x.UserName == username); + + // Assert + Assert.NotNull(user); + Assert.NotNull(user.Claims); + Assert.Equal(10, user.Claims.Count()); + } + + [Fact] + public async Task CanIncludeUserLoginsTest() + { + // Arrange + CreateContext(true); + var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider); + + var services = new ServiceCollection(); + DbUtil.ConfigureDbServices(ConnectionString, services); + services.AddIdentity().AddEntityFrameworkStores(); + builder.ApplicationServices = services.BuildServiceProvider(); + + var userManager = builder.ApplicationServices.GetRequiredService>(); + var dbContext = builder.ApplicationServices.GetRequiredService(); + + var username = "user" + new Random().Next(); + var user = new IdentityUser() { UserName = username }; + IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); + + for (var i = 0; i < 10; i++) + { + IdentityResultAssert.IsSuccess(await userManager.AddLoginAsync(user, new UserLoginInfo("foo" + i, "bar" + i, "foo"))); + } + + user = dbContext.Users.Include(x => x.Logins).FirstOrDefault(x => x.UserName == username); + + // Assert + Assert.NotNull(user); + Assert.NotNull(user.Logins); + Assert.Equal(10, user.Logins.Count()); + } + + [Fact] + public async Task CanIncludeUserRolesTest() + { + // Arrange + CreateContext(true); + var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider); + + var services = new ServiceCollection(); + DbUtil.ConfigureDbServices(ConnectionString, services); + services.AddIdentity().AddEntityFrameworkStores(); + builder.ApplicationServices = services.BuildServiceProvider(); + + var userManager = builder.ApplicationServices.GetRequiredService>(); + var roleManager = builder.ApplicationServices.GetRequiredService>(); + var dbContext = builder.ApplicationServices.GetRequiredService(); + + const string roleName = "Admin"; + for (var i = 0; i < 10; i++) + { + IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(new IdentityRole(roleName + i))); + } + var username = "user" + new Random().Next(); + var user = new IdentityUser() { UserName = username }; + IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); + + for (var i = 0; i < 10; i++) + { + IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(user, roleName + i)); + } + + user = dbContext.Users.Include(x => x.Roles).FirstOrDefault(x => x.UserName == username); + + // Assert + Assert.NotNull(user); + Assert.NotNull(user.Roles); + Assert.Equal(10, user.Roles.Count()); + + for (var i = 0; i < 10; i++) + { + var role = dbContext.Roles.Include(r => r.Users).FirstOrDefault(r => r.Name == (roleName + i)); + Assert.NotNull(role); + Assert.NotNull(role.Users); + Assert.Equal(1, role.Users.Count()); + } + } + + [Fact] + public async Task CanIncludeRoleClaimsTest() + { + // Arrange + CreateContext(true); + var builder = new ApplicationBuilder(CallContextServiceLocator.Locator.ServiceProvider); + + var services = new ServiceCollection(); + DbUtil.ConfigureDbServices(ConnectionString, services); + services.AddIdentity().AddEntityFrameworkStores(); + builder.ApplicationServices = services.BuildServiceProvider(); + + var roleManager = builder.ApplicationServices.GetRequiredService>(); + var dbContext = builder.ApplicationServices.GetRequiredService(); + + var role = new IdentityRole("Admin"); + + IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role)); + + for (var i = 0; i < 10; i++) + { + IdentityResultAssert.IsSuccess(await roleManager.AddClaimAsync(role, new Claim("foo" + i, "bar" + i))); + } + + role = dbContext.Roles.Include(x => x.Claims).FirstOrDefault(x => x.Name == "Admin"); + + // Assert + Assert.NotNull(role); + Assert.NotNull(role.Claims); + Assert.Equal(10, role.Claims.Count()); + } + [TestPriority(10000)] [Fact] public void DropDatabaseDone() diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.Test/SqlStoreTestBase.cs b/test/Microsoft.AspNet.Identity.EntityFramework.Test/SqlStoreTestBase.cs index 9a944d8be1..bd641729ab 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.Test/SqlStoreTestBase.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.Test/SqlStoreTestBase.cs @@ -11,6 +11,7 @@ using Microsoft.AspNet.TestHost; using Microsoft.Framework.DependencyInjection; using Microsoft.Framework.Runtime.Infrastructure; using Xunit; +using System.Linq.Expressions; namespace Microsoft.AspNet.Identity.EntityFramework.Test { @@ -23,6 +24,34 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test public class TestDbContext : IdentityDbContext { } + protected override TUser CreateTestUser(string namePrefix = "", string email = "", string phoneNumber = "", + bool lockoutEnabled = false, DateTimeOffset? lockoutEnd = default(DateTimeOffset?), bool useNamePrefixAsUserName = false) + { + return new TUser + { + UserName = useNamePrefixAsUserName ? namePrefix : string.Format("{0}{1}", namePrefix, Guid.NewGuid()), + Email = email, + PhoneNumber = phoneNumber, + LockoutEnabled = lockoutEnabled, + LockoutEnd = lockoutEnd + }; + } + + protected override TRole CreateTestRole(string roleNamePrefix = "", bool useRoleNamePrefixAsRoleName = false) + { + var roleName = useRoleNamePrefixAsRoleName ? roleNamePrefix : string.Format("{0}{1}", roleNamePrefix, Guid.NewGuid()); + return new TRole() { Name = roleName }; + } + + protected override Expression> RoleNameEqualsPredicate(string roleName) => r => r.Name == roleName; + + protected override Expression> UserNameEqualsPredicate(string userName) => u => u.UserName == userName; + + protected override Expression> RoleNameStartsWithPredicate(string roleName) => r => r.Name.StartsWith(roleName); + + protected override Expression> UserNameStartsWithPredicate(string userName) => u => u.UserName.StartsWith(userName); + + [TestPriority(-1000)] [Fact] public void DropDatabaseStart() @@ -69,6 +98,11 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test services.AddInstance>(new RoleStore((TestDbContext)context)); } + protected override void SetUserPasswordHash(TUser user, string hashedPassword) + { + user.PasswordHash = hashedPassword; + } + public void EnsureDatabase() { CreateContext(); @@ -168,8 +202,8 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test var context = CreateContext(); var manager = CreateManager(context); var role = CreateRoleManager(context); - var admin = CreateRole("Admin"); - var local = CreateRole("Local"); + var admin = CreateTestRole("Admin" + Guid.NewGuid().ToString()); + var local = CreateTestRole("Local" + Guid.NewGuid().ToString()); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, new UserLoginInfo("provider", user.Id.ToString(), "display"))); IdentityResultAssert.IsSuccess(await role.CreateAsync(admin)); @@ -248,5 +282,6 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test Assert.Equal(1, (await manager.GetLoginsAsync(userByEmail)).Count); Assert.Equal(2, (await manager.GetRolesAsync(userByEmail)).Count); } + } } \ No newline at end of file diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreGuidKeyTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreGuidKeyTest.cs index e7fff23bbd..bd96137d97 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreGuidKeyTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreGuidKeyTest.cs @@ -2,6 +2,7 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Linq.Expressions; using Microsoft.AspNet.Identity.Test; using Microsoft.Framework.DependencyInjection; using Xunit; diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreIntKeyTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreIntKeyTest.cs index 19975082f9..e9842cba82 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreIntKeyTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreIntKeyTest.cs @@ -2,6 +2,7 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Linq.Expressions; using Xunit; namespace Microsoft.AspNet.Identity.EntityFramework.Test diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreStringKeyTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreStringKeyTest.cs index 8d5f20a586..b7aa6475fb 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreStringKeyTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreStringKeyTest.cs @@ -2,6 +2,7 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Linq.Expressions; using Xunit; namespace Microsoft.AspNet.Identity.EntityFramework.Test diff --git a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreTest.cs b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreTest.cs index 4ccbdb96be..3c622f9d24 100644 --- a/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreTest.cs +++ b/test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreTest.cs @@ -3,6 +3,7 @@ using System; using System.Linq; +using System.Linq.Expressions; using System.Threading.Tasks; using Microsoft.AspNet.Builder; using Microsoft.AspNet.Hosting; @@ -430,48 +431,41 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test } } - // TODO: can we move these to UserManagerTestBase? - [Fact] - public async Task DeleteRoleNonEmptySucceedsTest() + protected override IdentityUser CreateTestUser(string namePrefix = "", string email = "", string phoneNumber = "", + bool lockoutEnabled = false, DateTimeOffset? lockoutEnd = default(DateTimeOffset?), bool useNamePrefixAsUserName = false) { - // Need fail if not empty? - var context = CreateTestContext(); - var userMgr = CreateManager(context); - var roleMgr = CreateRoleManager(context); - var role = new IdentityRole("deleteNonEmpty"); - Assert.False(await roleMgr.RoleExistsAsync(role.Name)); - IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - var user = new IdentityUser("t"); - IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); - IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); - var roles = await userMgr.GetRolesAsync(user); - Assert.Equal(1, roles.Count()); - IdentityResultAssert.IsSuccess(await roleMgr.DeleteAsync(role)); - Assert.Null(await roleMgr.FindByNameAsync(role.Name)); - Assert.False(await roleMgr.RoleExistsAsync(role.Name)); - // REVIEW: We should throw if deleteing a non empty role? - roles = await userMgr.GetRolesAsync(user); - - Assert.Equal(0, roles.Count()); + return new IdentityUser + { + UserName = useNamePrefixAsUserName ? namePrefix : string.Format("{0}{1}", namePrefix, Guid.NewGuid()), + Email = email, + PhoneNumber = phoneNumber, + LockoutEnabled = lockoutEnabled, + LockoutEnd = lockoutEnd + }; } - // TODO: cascading deletes? navigation properties not working - //[Fact] - //public async Task DeleteUserRemovesFromRoleTest() - //{ - // // Need fail if not empty? - // var userMgr = CreateManager(); - // var roleMgr = CreateRoleManager(); - // var role = new IdentityRole("deleteNonEmpty"); - // Assert.False(await roleMgr.RoleExistsAsync(role.Name)); - // IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - // var user = new IdentityUser("t"); - // IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); - // IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); - // Assert.Equal(1, role.Users.Count); - // IdentityResultAssert.IsSuccess(await userMgr.DeleteAsync(user)); - // role = await roleMgr.FindByIdAsync(role.Id); - // Assert.Equal(0, role.Users.Count); - //} + protected override IdentityRole CreateTestRole(string roleNamePrefix = "", bool useRoleNamePrefixAsRoleName = false) + { + var roleName = useRoleNamePrefixAsRoleName ? roleNamePrefix : string.Format("{0}{1}", roleNamePrefix, Guid.NewGuid()); + return new IdentityRole(roleName); + } + + protected override void SetUserPasswordHash(IdentityUser user, string hashedPassword) + { + user.PasswordHash = hashedPassword; + } + + protected override Expression> UserNameEqualsPredicate(string userName) => u => u.UserName == userName; + + protected override Expression> RoleNameEqualsPredicate(string roleName) => r => r.Name == roleName; + + protected override Expression> RoleNameStartsWithPredicate(string roleName) => r => r.Name.StartsWith(roleName); + + protected override Expression> UserNameStartsWithPredicate(string userName) => u => u.UserName.StartsWith(userName); + } + + public class ApplicationUser : IdentityUser + { + } } \ No newline at end of file diff --git a/test/Microsoft.AspNet.Identity.InMemory.Test/FunctionalTest.cs b/test/Microsoft.AspNet.Identity.InMemory.Test/FunctionalTest.cs index 9a24d0f51a..7a6919b99a 100644 --- a/test/Microsoft.AspNet.Identity.InMemory.Test/FunctionalTest.cs +++ b/test/Microsoft.AspNet.Identity.InMemory.Test/FunctionalTest.cs @@ -19,6 +19,7 @@ using Microsoft.AspNet.TestHost; using Microsoft.Framework.DependencyInjection; using Shouldly; using Xunit; +using Microsoft.AspNet.Identity.Test; namespace Microsoft.AspNet.Identity.InMemory { @@ -162,8 +163,8 @@ namespace Microsoft.AspNet.Identity.InMemory { var req = context.Request; var res = context.Response; - var userManager = context.RequestServices.GetRequiredService>(); - var signInManager = context.RequestServices.GetRequiredService>(); + var userManager = context.RequestServices.GetRequiredService>(); + var signInManager = context.RequestServices.GetRequiredService>(); PathString remainder; if (req.Path == new PathString("/normal")) { @@ -171,7 +172,7 @@ namespace Microsoft.AspNet.Identity.InMemory } else if (req.Path == new PathString("/createMe")) { - var result = await userManager.CreateAsync(new InMemoryUser("hao"), TestPassword); + var result = await userManager.CreateAsync(new TestUser("hao"), TestPassword); res.StatusCode = result.Succeeded ? 200 : 500; } else if (req.Path == new PathString("/protected")) @@ -220,9 +221,9 @@ namespace Microsoft.AspNet.Identity.InMemory }, services => { - services.AddIdentity(); - services.AddSingleton, InMemoryUserStore>(); - services.AddSingleton, InMemoryRoleStore>(); + services.AddIdentity(); + services.AddSingleton, InMemoryUserStore>(); + services.AddSingleton, InMemoryRoleStore>(); services.ConfigureIdentityApplicationCookie(configureAppCookie); }); server.BaseAddress = baseAddress; diff --git a/test/Microsoft.AspNet.Identity.InMemory.Test/HttpSignInTest.cs b/test/Microsoft.AspNet.Identity.InMemory.Test/HttpSignInTest.cs index fd6434c11f..ec8936548c 100644 --- a/test/Microsoft.AspNet.Identity.InMemory.Test/HttpSignInTest.cs +++ b/test/Microsoft.AspNet.Identity.InMemory.Test/HttpSignInTest.cs @@ -15,8 +15,6 @@ using Xunit; namespace Microsoft.AspNet.Identity.InMemory.Test { - public class ApplicationUser : InMemoryUser { } - public class HttpSignInTest { [Theory] @@ -37,19 +35,19 @@ namespace Microsoft.AspNet.Identity.InMemory.Test contextAccessor.Setup(a => a.HttpContext).Returns(context.Object); var services = new ServiceCollection(); services.AddInstance(contextAccessor.Object); - services.AddIdentity(); - services.AddSingleton, InMemoryUserStore>(); - services.AddSingleton, InMemoryRoleStore>(); + services.AddIdentity(); + services.AddSingleton, InMemoryUserStore>(); + services.AddSingleton, InMemoryRoleStore>(); app.ApplicationServices = services.BuildServiceProvider(); // Act - var user = new ApplicationUser + var user = new TestUser { UserName = "Yolo" }; const string password = "Yol0Sw@g!"; - var userManager = app.ApplicationServices.GetRequiredService>(); - var signInManager = app.ApplicationServices.GetRequiredService>(); + var userManager = app.ApplicationServices.GetRequiredService>(); + var signInManager = app.ApplicationServices.GetRequiredService>(); IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user, password)); var result = await signInManager.PasswordSignInAsync(user, password, isPersistent, false); diff --git a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryRoleStore.cs b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryRoleStore.cs index 0f250c4615..f4f74243c0 100644 --- a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryRoleStore.cs +++ b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryRoleStore.cs @@ -7,10 +7,11 @@ using System.Linq; using System.Security.Claims; using System.Threading; using System.Threading.Tasks; +using Microsoft.AspNet.Identity.Test; namespace Microsoft.AspNet.Identity.InMemory { - public class InMemoryRoleStore : IQueryableRoleStore, IRoleClaimStore where TRole : IdentityRole + public class InMemoryRoleStore : IQueryableRoleStore, IRoleClaimStore where TRole : TestRole { private readonly Dictionary _roles = new Dictionary(); @@ -81,7 +82,7 @@ namespace Microsoft.AspNet.Identity.InMemory public Task AddClaimAsync(TRole role, Claim claim, CancellationToken cancellationToken = default(CancellationToken)) { - role.Claims.Add(new IdentityRoleClaim { ClaimType = claim.Type, ClaimValue = claim.Value, RoleId = role.Id }); + role.Claims.Add(new TestRoleClaim { ClaimType = claim.Type, ClaimValue = claim.Value, RoleId = role.Id }); return Task.FromResult(0); } diff --git a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs index 4e034f666e..9be13371ca 100644 --- a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs +++ b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs @@ -2,12 +2,13 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Linq.Expressions; using Microsoft.AspNet.Identity.Test; using Microsoft.Framework.DependencyInjection; namespace Microsoft.AspNet.Identity.InMemory.Test { - public class InMemoryStoreTest : UserManagerTestBase + public class InMemoryStoreTest : UserManagerTestBase { protected override object CreateTestContext() { @@ -16,12 +17,44 @@ namespace Microsoft.AspNet.Identity.InMemory.Test protected override void AddUserStore(IServiceCollection services, object context = null) { - services.AddSingleton, InMemoryUserStore>(); + services.AddSingleton, InMemoryUserStore>(); } protected override void AddRoleStore(IServiceCollection services, object context = null) { - services.AddSingleton, InMemoryRoleStore>(); + services.AddSingleton, InMemoryRoleStore>(); } + + protected override void SetUserPasswordHash(TestUser user, string hashedPassword) + { + user.PasswordHash = hashedPassword; + } + + protected override TestUser CreateTestUser(string namePrefix = "", string email = "", string phoneNumber = "", + bool lockoutEnabled = false, DateTimeOffset? lockoutEnd = default(DateTimeOffset?), bool useNamePrefixAsUserName = false) + { + return new TestUser + { + UserName = useNamePrefixAsUserName ? namePrefix : string.Format("{0}{1}", namePrefix, Guid.NewGuid()), + Email = email, + PhoneNumber = phoneNumber, + LockoutEnabled = lockoutEnabled, + LockoutEnd = lockoutEnd + }; + } + + protected override TestRole CreateTestRole(string roleNamePrefix = "", bool useRoleNamePrefixAsRoleName = false) + { + var roleName = useRoleNamePrefixAsRoleName ? roleNamePrefix : string.Format("{0}{1}", roleNamePrefix, Guid.NewGuid()); + return new TestRole(roleName); + } + + protected override Expression> UserNameEqualsPredicate(string userName) => u => u.UserName == userName; + + protected override Expression> RoleNameEqualsPredicate(string roleName) => r => r.Name == roleName; + + protected override Expression> UserNameStartsWithPredicate(string userName) => u => u.UserName.StartsWith(userName); + + protected override Expression> RoleNameStartsWithPredicate(string roleName) => r => r.Name.StartsWith(roleName); } } \ No newline at end of file diff --git a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryUserStore.cs b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryUserStore.cs index ab3521f6b4..f6ab4f7e55 100644 --- a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryUserStore.cs +++ b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryUserStore.cs @@ -7,33 +7,10 @@ using System.Linq; using System.Security.Claims; using System.Threading; using System.Threading.Tasks; +using Microsoft.AspNet.Identity.Test; namespace Microsoft.AspNet.Identity.InMemory { - public class InMemoryUser : IdentityUser - { - public InMemoryUser() { } - - public InMemoryUser(string userName) : base(userName) { } - - - /// - /// Roles for the user - /// - public virtual ICollection Roles { get; } = new List(); - - /// - /// Claims for the user - /// - public virtual ICollection Claims { get; } = new List(); - - /// - /// Associated logins for the user - /// - public virtual ICollection Logins { get; } = new List(); - - } - public class InMemoryUserStore : IUserLoginStore, IUserRoleStore, @@ -45,7 +22,7 @@ namespace Microsoft.AspNet.Identity.InMemory IUserPhoneNumberStore, IQueryableUserStore, IUserTwoFactorStore - where TUser : InMemoryUser + where TUser : TestUser { private readonly Dictionary _logins = new Dictionary(); @@ -66,7 +43,7 @@ namespace Microsoft.AspNet.Identity.InMemory { foreach (var claim in claims) { - user.Claims.Add(new IdentityUserClaim { ClaimType = claim.Type, ClaimValue = claim.Value, UserId = user.Id }); + user.Claims.Add(new TestUserClaim { ClaimType = claim.Type, ClaimValue = claim.Value, UserId = user.Id }); } return Task.FromResult(0); } @@ -185,7 +162,7 @@ namespace Microsoft.AspNet.Identity.InMemory public virtual Task AddLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) { - user.Logins.Add(new IdentityUserLogin + user.Logins.Add(new TestUserLogin { UserId = user.Id, ProviderKey = login.ProviderKey, @@ -328,7 +305,7 @@ namespace Microsoft.AspNet.Identity.InMemory // RoleId == roleName for InMemory public Task AddToRoleAsync(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken)) { - user.Roles.Add(new IdentityUserRole { RoleId = role, UserId = user.Id }); + user.Roles.Add(new TestUserRole { RoleId = role, UserId = user.Id }); return Task.FromResult(0); } diff --git a/test/Microsoft.AspNet.Identity.Test/IdentityBuilderTest.cs b/test/Microsoft.AspNet.Identity.Test/IdentityBuilderTest.cs index 31dae8f25f..b6bfbc6e03 100644 --- a/test/Microsoft.AspNet.Identity.Test/IdentityBuilderTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/IdentityBuilderTest.cs @@ -18,8 +18,8 @@ namespace Microsoft.AspNet.Identity.Test public void CanOverrideUserStore() { var services = new ServiceCollection(); - services.AddIdentity().AddUserStore(); - var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; + services.AddIdentity().AddUserStore(); + var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; Assert.NotNull(thingy); } @@ -27,8 +27,8 @@ namespace Microsoft.AspNet.Identity.Test public void CanOverrideRoleStore() { var services = new ServiceCollection(); - services.AddIdentity().AddRoleStore(); - var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; + services.AddIdentity().AddRoleStore(); + var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; Assert.NotNull(thingy); } @@ -36,8 +36,8 @@ namespace Microsoft.AspNet.Identity.Test public void CanOverrideRoleValidator() { var services = new ServiceCollection(); - services.AddIdentity().AddRoleValidator(); - var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; + services.AddIdentity().AddRoleValidator(); + var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; Assert.NotNull(thingy); } @@ -45,8 +45,8 @@ namespace Microsoft.AspNet.Identity.Test public void CanOverrideUserValidator() { var services = new ServiceCollection(); - services.AddIdentity().AddUserValidator(); - var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; + services.AddIdentity().AddUserValidator(); + var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; Assert.NotNull(thingy); } @@ -54,8 +54,8 @@ namespace Microsoft.AspNet.Identity.Test public void CanOverridePasswordValidator() { var services = new ServiceCollection(); - services.AddIdentity().AddPasswordValidator(); - var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; + services.AddIdentity().AddPasswordValidator(); + var thingy = services.BuildServiceProvider().GetRequiredService>() as MyUberThingy; Assert.NotNull(thingy); } @@ -85,16 +85,16 @@ namespace Microsoft.AspNet.Identity.Test public void EnsureDefaultServices() { var services = new ServiceCollection(); - services.AddIdentity(); + services.AddIdentity(); var provider = services.BuildServiceProvider(); - var userValidator = provider.GetRequiredService>() as UserValidator; + var userValidator = provider.GetRequiredService>() as UserValidator; Assert.NotNull(userValidator); - var pwdValidator = provider.GetRequiredService>() as PasswordValidator; + var pwdValidator = provider.GetRequiredService>() as PasswordValidator; Assert.NotNull(pwdValidator); - var hasher = provider.GetRequiredService>() as PasswordHasher; + var hasher = provider.GetRequiredService>() as PasswordHasher; Assert.NotNull(hasher); } @@ -102,31 +102,31 @@ namespace Microsoft.AspNet.Identity.Test public void EnsureDefaultTokenProviders() { var services = new ServiceCollection(); - services.AddIdentity().AddDefaultTokenProviders(); + services.AddIdentity().AddDefaultTokenProviders(); var provider = services.BuildServiceProvider(); - var tokenProviders = provider.GetRequiredService>>(); + var tokenProviders = provider.GetRequiredService>>(); Assert.Equal(3, tokenProviders.Count()); } - private class MyUberThingy : IUserValidator, IPasswordValidator, IRoleValidator, IUserStore, IRoleStore + private class MyUberThingy : IUserValidator, IPasswordValidator, IRoleValidator, IUserStore, IRoleStore { - public Task CreateAsync(IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task CreateAsync(TestRole role, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task CreateAsync(IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task CreateAsync(TestUser user, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task DeleteAsync(IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task DeleteAsync(TestRole role, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task DeleteAsync(IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task DeleteAsync(TestUser user, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } @@ -136,97 +136,97 @@ namespace Microsoft.AspNet.Identity.Test throw new NotImplementedException(); } - public Task FindByIdAsync(string userId, CancellationToken cancellationToken = default(CancellationToken)) + public Task FindByIdAsync(string userId, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken = default(CancellationToken)) + public Task FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task GetNormalizedRoleNameAsync(IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task GetNormalizedRoleNameAsync(TestRole role, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task GetNormalizedUserNameAsync(IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task GetNormalizedUserNameAsync(TestUser user, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task GetRoleIdAsync(IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task GetRoleIdAsync(TestRole role, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task GetRoleNameAsync(IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task GetRoleNameAsync(TestRole role, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task GetUserIdAsync(IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task GetUserIdAsync(TestUser user, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task GetUserNameAsync(IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task GetUserNameAsync(TestUser user, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task SetNormalizedRoleNameAsync(IdentityRole role, string normalizedName, CancellationToken cancellationToken = default(CancellationToken)) + public Task SetNormalizedRoleNameAsync(TestRole role, string normalizedName, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task SetNormalizedUserNameAsync(IdentityUser user, string normalizedName, CancellationToken cancellationToken = default(CancellationToken)) + public Task SetNormalizedUserNameAsync(TestUser user, string normalizedName, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task SetRoleNameAsync(IdentityRole role, string roleName, CancellationToken cancellationToken = default(CancellationToken)) + public Task SetRoleNameAsync(TestRole role, string roleName, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task SetUserNameAsync(IdentityUser user, string userName, CancellationToken cancellationToken = default(CancellationToken)) + public Task SetUserNameAsync(TestUser user, string userName, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task UpdateAsync(IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task UpdateAsync(TestRole role, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task UpdateAsync(IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task UpdateAsync(TestUser user, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); } - public Task ValidateAsync(RoleManager manager, IdentityRole role) + public Task ValidateAsync(RoleManager manager, TestRole role) { throw new NotImplementedException(); } - public Task ValidateAsync(UserManager manager, IdentityUser user) + public Task ValidateAsync(UserManager manager, TestUser user) { throw new NotImplementedException(); } - public Task ValidateAsync(UserManager manager, IdentityUser user, string password) + public Task ValidateAsync(UserManager manager, TestUser user, string password) { throw new NotImplementedException(); } - Task IRoleStore.FindByIdAsync(string roleId, CancellationToken cancellationToken) + Task IRoleStore.FindByIdAsync(string roleId, CancellationToken cancellationToken) { throw new NotImplementedException(); } - Task IRoleStore.FindByNameAsync(string roleName, CancellationToken cancellationToken) + Task IRoleStore.FindByNameAsync(string roleName, CancellationToken cancellationToken) { throw new NotImplementedException(); } diff --git a/test/Microsoft.AspNet.Identity.Test/IdentityOptionsTest.cs b/test/Microsoft.AspNet.Identity.Test/IdentityOptionsTest.cs index d9db33816d..b293dd61e6 100644 --- a/test/Microsoft.AspNet.Identity.Test/IdentityOptionsTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/IdentityOptionsTest.cs @@ -65,7 +65,7 @@ namespace Microsoft.AspNet.Identity.Test Assert.Equal(roleClaimType, config.Get("identity:claimsidentity:roleclaimtype")); var services = new ServiceCollection(); - services.AddIdentity(); + services.AddIdentity(); services.ConfigureIdentity(config.GetSubKey("identity")); var accessor = services.BuildServiceProvider().GetRequiredService>(); Assert.NotNull(accessor); @@ -96,7 +96,7 @@ namespace Microsoft.AspNet.Identity.Test var config = new Configuration(new MemoryConfigurationSource(dic)); var services = new ServiceCollection(); services.ConfigureIdentity(config.GetSubKey("identity")); - services.AddIdentity(o => { o.User.RequireUniqueEmail = false; o.Lockout.MaxFailedAccessAttempts++; }); + services.AddIdentity(o => { o.User.RequireUniqueEmail = false; o.Lockout.MaxFailedAccessAttempts++; }); var accessor = services.BuildServiceProvider().GetRequiredService>(); Assert.NotNull(accessor); var options = accessor.Options; @@ -116,7 +116,7 @@ namespace Microsoft.AspNet.Identity.Test { var services = new ServiceCollection() .ConfigureOptions(); - services.AddIdentity(); + services.AddIdentity(); var serviceProvider = services.BuildServiceProvider(); var setup = serviceProvider.GetRequiredService>(); @@ -137,7 +137,7 @@ namespace Microsoft.AspNet.Identity.Test var services = new ServiceCollection() .AddOptions() .ConfigureIdentity(options => options.User.RequireUniqueEmail = true); - services.AddIdentity(); + services.AddIdentity(); var serviceProvider = services.BuildServiceProvider(); var optionsGetter = serviceProvider.GetRequiredService>(); diff --git a/test/Microsoft.AspNet.Identity.Test/PasswordValidatorTest.cs b/test/Microsoft.AspNet.Identity.Test/PasswordValidatorTest.cs index f8c37de273..d2a1965561 100644 --- a/test/Microsoft.AspNet.Identity.Test/PasswordValidatorTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/PasswordValidatorTest.cs @@ -26,7 +26,7 @@ namespace Microsoft.AspNet.Identity.Test public async Task ValidateThrowsWithNullTest() { // Setup - var validator = new PasswordValidator(); + var validator = new PasswordValidator(); // Act // Assert @@ -42,8 +42,8 @@ namespace Microsoft.AspNet.Identity.Test public async Task FailsIfTooShortTests(string input) { const string error = "Passwords must be at least 6 characters."; - var manager = MockHelpers.TestUserManager(); - var valid = new PasswordValidator(); + var manager = MockHelpers.TestUserManager(); + var valid = new PasswordValidator(); manager.Options.Password.RequireUppercase = false; manager.Options.Password.RequireNonLetterOrDigit = false; manager.Options.Password.RequireLowercase = false; @@ -56,8 +56,8 @@ namespace Microsoft.AspNet.Identity.Test [InlineData("aaaaaaaaaaa")] public async Task SuccessIfLongEnoughTests(string input) { - var manager = MockHelpers.TestUserManager(); - var valid = new PasswordValidator(); + var manager = MockHelpers.TestUserManager(); + var valid = new PasswordValidator(); manager.Options.Password.RequireUppercase = false; manager.Options.Password.RequireNonLetterOrDigit = false; manager.Options.Password.RequireLowercase = false; @@ -70,8 +70,8 @@ namespace Microsoft.AspNet.Identity.Test [InlineData("aaaaaaaaaaa")] public async Task FailsWithoutRequiredNonAlphanumericTests(string input) { - var manager = MockHelpers.TestUserManager(); - var valid = new PasswordValidator(); + var manager = MockHelpers.TestUserManager(); + var valid = new PasswordValidator(); manager.Options.Password.RequireUppercase = false; manager.Options.Password.RequireNonLetterOrDigit = true; manager.Options.Password.RequireLowercase = false; @@ -87,8 +87,8 @@ namespace Microsoft.AspNet.Identity.Test [InlineData("!!!!!!")] public async Task SucceedsWithRequiredNonAlphanumericTests(string input) { - var manager = MockHelpers.TestUserManager(); - var valid = new PasswordValidator(); + var manager = MockHelpers.TestUserManager(); + var valid = new PasswordValidator(); manager.Options.Password.RequireUppercase = false; manager.Options.Password.RequireNonLetterOrDigit = true; manager.Options.Password.RequireLowercase = false; @@ -111,8 +111,8 @@ namespace Microsoft.AspNet.Identity.Test const string lowerError = "Passwords must have at least one lowercase ('a'-'z')."; const string digitError = "Passwords must have at least one digit ('0'-'9')."; const string lengthError = "Passwords must be at least 6 characters."; - var manager = MockHelpers.TestUserManager(); - var valid = new PasswordValidator(); + var manager = MockHelpers.TestUserManager(); + var valid = new PasswordValidator(); var errors = new List(); if ((errorMask & Errors.Length) != Errors.None) { diff --git a/test/Microsoft.AspNet.Identity.Test/SecurityStampValidatorTest.cs b/test/Microsoft.AspNet.Identity.Test/SecurityStampValidatorTest.cs index 976d5b2b72..ea06afcf00 100644 --- a/test/Microsoft.AspNet.Identity.Test/SecurityStampValidatorTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/SecurityStampValidatorTest.cs @@ -35,23 +35,23 @@ namespace Microsoft.AspNet.Identity.Test [InlineData(false)] public async Task OnValidatePrincipalTestSuccess(bool isPersistent) { - var user = new IdentityUser("test"); - var userManager = MockHelpers.MockUserManager(); - var claimsManager = new Mock>(); + var user = new TestUser("test"); + var userManager = MockHelpers.MockUserManager(); + var claimsManager = new Mock>(); var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero }; var options = new Mock>(); options.Setup(a => a.Options).Returns(identityOptions); var httpContext = new Mock(); var contextAccessor = new Mock(); contextAccessor.Setup(a => a.HttpContext).Returns(httpContext.Object); - var signInManager = new Mock>(userManager.Object, + var signInManager = new Mock>(userManager.Object, contextAccessor.Object, claimsManager.Object, options.Object, null); signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny(), user.Id)).ReturnsAsync(user).Verifiable(); signInManager.Setup(s => s.SignInAsync(user, isPersistent, null)).Returns(Task.FromResult(0)).Verifiable(); var services = new ServiceCollection(); services.AddInstance(options.Object); services.AddInstance(signInManager.Object); - services.AddInstance(new SecurityStampValidator()); + services.AddInstance(new SecurityStampValidator()); httpContext.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); @@ -72,22 +72,22 @@ namespace Microsoft.AspNet.Identity.Test [Fact] public async Task OnValidateIdentityRejectsWhenValidateSecurityStampFails() { - var user = new IdentityUser("test"); - var userManager = MockHelpers.MockUserManager(); - var claimsManager = new Mock>(); + var user = new TestUser("test"); + var userManager = MockHelpers.MockUserManager(); + var claimsManager = new Mock>(); var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero }; var options = new Mock>(); options.Setup(a => a.Options).Returns(identityOptions); var httpContext = new Mock(); var contextAccessor = new Mock(); contextAccessor.Setup(a => a.HttpContext).Returns(httpContext.Object); - var signInManager = new Mock>(userManager.Object, + var signInManager = new Mock>(userManager.Object, contextAccessor.Object, claimsManager.Object, options.Object, null); signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny(), user.Id)).ReturnsAsync(null).Verifiable(); var services = new ServiceCollection(); services.AddInstance(options.Object); services.AddInstance(signInManager.Object); - services.AddInstance(new SecurityStampValidator()); + services.AddInstance(new SecurityStampValidator()); httpContext.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); @@ -107,22 +107,22 @@ namespace Microsoft.AspNet.Identity.Test [Fact] public async Task OnValidateIdentityRejectsWhenNoIssuedUtc() { - var user = new IdentityUser("test"); + var user = new TestUser("test"); var httpContext = new Mock(); - var userManager = MockHelpers.MockUserManager(); - var claimsManager = new Mock>(); + var userManager = MockHelpers.MockUserManager(); + var claimsManager = new Mock>(); var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero }; var options = new Mock>(); options.Setup(a => a.Options).Returns(identityOptions); var contextAccessor = new Mock(); contextAccessor.Setup(a => a.HttpContext).Returns(httpContext.Object); - var signInManager = new Mock>(userManager.Object, + var signInManager = new Mock>(userManager.Object, contextAccessor.Object, claimsManager.Object, options.Object, null); signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny(), user.Id)).ReturnsAsync(null).Verifiable(); var services = new ServiceCollection(); services.AddInstance(options.Object); services.AddInstance(signInManager.Object); - services.AddInstance(new SecurityStampValidator()); + services.AddInstance(new SecurityStampValidator()); httpContext.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); @@ -142,23 +142,23 @@ namespace Microsoft.AspNet.Identity.Test [Fact] public async Task OnValidateIdentityDoesNotRejectsWhenNotExpired() { - var user = new IdentityUser("test"); + var user = new TestUser("test"); var httpContext = new Mock(); - var userManager = MockHelpers.MockUserManager(); - var claimsManager = new Mock>(); + var userManager = MockHelpers.MockUserManager(); + var claimsManager = new Mock>(); var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.FromDays(1) }; var options = new Mock>(); options.Setup(a => a.Options).Returns(identityOptions); var contextAccessor = new Mock(); contextAccessor.Setup(a => a.HttpContext).Returns(httpContext.Object); - var signInManager = new Mock>(userManager.Object, + var signInManager = new Mock>(userManager.Object, contextAccessor.Object, claimsManager.Object, options.Object, null); signInManager.Setup(s => s.ValidateSecurityStampAsync(It.IsAny(), user.Id)).Throws(new Exception("Shouldn't be called")); signInManager.Setup(s => s.SignInAsync(user, false, null)).Throws(new Exception("Shouldn't be called")); var services = new ServiceCollection(); services.AddInstance(options.Object); services.AddInstance(signInManager.Object); - services.AddInstance(new SecurityStampValidator()); + services.AddInstance(new SecurityStampValidator()); httpContext.Setup(c => c.RequestServices).Returns(services.BuildServiceProvider()); var id = new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationScheme); id.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); diff --git a/test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs b/test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs index 948f53588e..c64811dc07 100644 --- a/test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs @@ -68,14 +68,14 @@ namespace Microsoft.AspNet.Identity.Test [Fact] public void ConstructorNullChecks() { - Assert.Throws("userManager", () => new SignInManager(null, null, null, null, null)); - var userManager = MockHelpers.MockUserManager().Object; - Assert.Throws("contextAccessor", () => new SignInManager(userManager, null, null, null)); + Assert.Throws("userManager", () => new SignInManager(null, null, null, null, null)); + var userManager = MockHelpers.MockUserManager().Object; + Assert.Throws("contextAccessor", () => new SignInManager(userManager, null, null, null)); var contextAccessor = new Mock(); - Assert.Throws("contextAccessor", () => new SignInManager(userManager, contextAccessor.Object, null, null)); + Assert.Throws("contextAccessor", () => new SignInManager(userManager, contextAccessor.Object, null, null)); var context = new Mock(); contextAccessor.Setup(a => a.HttpContext).Returns(context.Object); - Assert.Throws("claimsFactory", () => new SignInManager(userManager, contextAccessor.Object, null, null)); + Assert.Throws("claimsFactory", () => new SignInManager(userManager, contextAccessor.Object, null, null)); } //TODO: Mock fails in K (this works fine in net45) diff --git a/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs b/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs index d1c01f17fd..b94319359c 100644 --- a/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs @@ -7,6 +7,7 @@ using System.Linq; using System.Security.Claims; using System.Threading; using System.Threading.Tasks; +using Microsoft.AspNet.Identity.Test; using Microsoft.Framework.DependencyInjection; using Moq; using Xunit; @@ -20,7 +21,7 @@ namespace Microsoft.AspNet.Identity.Test { var services = new ServiceCollection() .AddTransient, NoopUserStore>(); - services.AddIdentity(); + services.AddIdentity(); var manager = services.BuildServiceProvider().GetRequiredService>(); Assert.NotNull(manager.PasswordHasher); Assert.NotNull(manager.Store); @@ -544,8 +545,8 @@ namespace Microsoft.AspNet.Identity.Test [Fact] public async Task SecurityStampMethodsFailWhenStoreNotImplemented() { - var store = new Mock>(); - store.Setup(x => x.GetUserIdAsync(It.IsAny(), It.IsAny())).Returns(Task.FromResult(Guid.NewGuid().ToString())); + var store = new Mock>(); + store.Setup(x => x.GetUserIdAsync(It.IsAny(), It.IsAny())).Returns(Task.FromResult(Guid.NewGuid().ToString())); var manager = MockHelpers.TestUserManager(store.Object); Assert.False(manager.SupportsUserSecurityStamp); await Assert.ThrowsAsync(() => manager.UpdateSecurityStampAsync(null)); @@ -636,8 +637,8 @@ namespace Microsoft.AspNet.Identity.Test [Fact] public async Task ResetTokenCallNoopForTokenValueZero() { - var user = new IdentityUser() { UserName = Guid.NewGuid().ToString()}; - var store = new Mock>(); + var user = new TestUser() { UserName = Guid.NewGuid().ToString()}; + var store = new Mock>(); store.Setup(x => x.ResetAccessFailedCountAsync(user, It.IsAny())).Returns(() => { throw new Exception(); @@ -1372,7 +1373,7 @@ namespace Microsoft.AspNet.Identity.Test var describer = new TestErrorDescriber(); services.AddInstance(describer) .AddInstance>(store.Object) - .AddIdentity(); + .AddIdentity(); var manager = services.BuildServiceProvider().GetRequiredService>(); diff --git a/test/Shared/ApplicationUser.cs b/test/Shared/ApplicationUser.cs deleted file mode 100644 index ea0a2afbf6..0000000000 --- a/test/Shared/ApplicationUser.cs +++ /dev/null @@ -1,7 +0,0 @@ -// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. -// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. - -namespace Microsoft.AspNet.Identity.Test -{ - public class ApplicationUser : IdentityUser { } -} \ No newline at end of file diff --git a/test/Shared/TestRole.cs b/test/Shared/TestRole.cs index 83866f3732..90bcd17cea 100644 --- a/test/Shared/TestRole.cs +++ b/test/Shared/TestRole.cs @@ -1,11 +1,70 @@ // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. +using System; +using System.Collections.Generic; + namespace Microsoft.AspNet.Identity.Test { - public class TestRole + /// + /// Represents a Role entity + /// + public class TestRole : TestRole { - public string Id { get; private set; } - public string Name { get; set; } + /// + /// Constructor + /// + public TestRole() + { + Id = Guid.NewGuid().ToString(); + } + + /// + /// Constructor + /// + /// + public TestRole(string roleName) : this() + { + Name = roleName; + } + } + + /// + /// Represents a Role entity + /// + /// + public class TestRole where TKey : IEquatable + { + public TestRole() { } + + /// + /// Constructor + /// + /// + public TestRole(string roleName) : this() + { + Name = roleName; + } + + /// + /// Role id + /// + public virtual TKey Id { get; set; } + + /// + /// Navigation property for claims in the role + /// + public virtual ICollection> Claims { get; private set; } = new List>(); + + /// + /// Role name + /// + public virtual string Name { get; set; } + public virtual string NormalizedName { get; set; } + + /// + /// A random value that should change whenever a role is persisted to the store + /// + public virtual string ConcurrencyStamp { get; set; } = Guid.NewGuid().ToString(); } } \ No newline at end of file diff --git a/test/Shared/TestRoleClaim.cs b/test/Shared/TestRoleClaim.cs new file mode 100644 index 0000000000..475566d19c --- /dev/null +++ b/test/Shared/TestRoleClaim.cs @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; + +namespace Microsoft.AspNet.Identity.Test +{ + public class TestRoleClaim : TestRoleClaim { } + + /// + /// EntityType that represents one specific role claim + /// + /// + public class TestRoleClaim where TKey : IEquatable + { + /// + /// Primary key + /// + public virtual int Id { get; set; } + + /// + /// User Id for the role this claim belongs to + /// + public virtual TKey RoleId { get; set; } + + /// + /// Claim type + /// + public virtual string ClaimType { get; set; } + + /// + /// Claim value + /// + public virtual string ClaimValue { get; set; } + } +} \ No newline at end of file diff --git a/test/Shared/TestUser.cs b/test/Shared/TestUser.cs index 40436a8361..510bbc4f28 100644 --- a/test/Shared/TestUser.cs +++ b/test/Shared/TestUser.cs @@ -2,18 +2,104 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Collections.Generic; namespace Microsoft.AspNet.Identity.Test { - public class TestUser + public class TestUser : TestUser { public TestUser() { Id = Guid.NewGuid().ToString(); } - public string Id { get; private set; } - public string UserName { get; set; } - public string Email { get; set; } + public TestUser(string userName) : this() + { + UserName = userName; + } } -} \ No newline at end of file + + public class TestUser where TKey : IEquatable + { + public TestUser() { } + + public TestUser(string userName) : this() + { + UserName = userName; + } + + public virtual TKey Id { get; set; } + public virtual string UserName { get; set; } + public virtual string NormalizedUserName { get; set; } + + /// + /// Email + /// + public virtual string Email { get; set; } + + public virtual string NormalizedEmail { get; set; } + + /// + /// True if the email is confirmed, default is false + /// + public virtual bool EmailConfirmed { get; set; } + + /// + /// The salted/hashed form of the user password + /// + public virtual string PasswordHash { get; set; } + + /// + /// A random value that should change whenever a users credentials change (password changed, login removed) + /// + public virtual string SecurityStamp { get; set; } + + /// + /// A random value that should change whenever a user is persisted to the store + /// + public virtual string ConcurrencyStamp { get; set; } = Guid.NewGuid().ToString(); + + /// + /// PhoneNumber for the user + /// + public virtual string PhoneNumber { get; set; } + + /// + /// True if the phone number is confirmed, default is false + /// + public virtual bool PhoneNumberConfirmed { get; set; } + + /// + /// Is two factor enabled for the user + /// + public virtual bool TwoFactorEnabled { get; set; } + + /// + /// DateTime in UTC when lockout ends, any time in the past is considered not locked out. + /// + public virtual DateTimeOffset? LockoutEnd { get; set; } + + /// + /// Is lockout enabled for this user + /// + public virtual bool LockoutEnabled { get; set; } + + /// + /// Used to record failures for the purposes of lockout + /// + public virtual int AccessFailedCount { get; set; } + + /// + /// Navigation property for users in the role + /// + public virtual ICollection> Roles { get; private set; } = new List>(); + /// + /// Navigation property for users claims + /// + public virtual ICollection> Claims { get; private set; } = new List>(); + /// + /// Navigation property for users logins + /// + public virtual ICollection> Logins { get; private set; } = new List>(); + } +} diff --git a/test/Shared/TestUserClaim.cs b/test/Shared/TestUserClaim.cs new file mode 100644 index 0000000000..642c353c41 --- /dev/null +++ b/test/Shared/TestUserClaim.cs @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; + +namespace Microsoft.AspNet.Identity.Test +{ + public class TestUserClaim : TestUserClaim { } + + /// + /// EntityType that represents one specific user claim + /// + /// + public class TestUserClaim where TKey : IEquatable + { + /// + /// Primary key + /// + public virtual int Id { get; set; } + + /// + /// User Id for the user who owns this claim + /// + public virtual TKey UserId { get; set; } + + /// + /// Claim type + /// + public virtual string ClaimType { get; set; } + + /// + /// Claim value + /// + public virtual string ClaimValue { get; set; } + } +} \ No newline at end of file diff --git a/test/Shared/TestUserLogin.cs b/test/Shared/TestUserLogin.cs new file mode 100644 index 0000000000..b8f670a981 --- /dev/null +++ b/test/Shared/TestUserLogin.cs @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; + +namespace Microsoft.AspNet.Identity.Test +{ + public class TestUserLogin : TestUserLogin { } + + /// + /// Entity type for a user's login (i.e. facebook, google) + /// + /// + public class TestUserLogin where TKey : IEquatable + { + /// + /// The login provider for the login (i.e. facebook, google) + /// + public virtual string LoginProvider { get; set; } + + /// + /// Key representing the login for the provider + /// + public virtual string ProviderKey { get; set; } + + /// + /// Display name for the login + /// + public virtual string ProviderDisplayName { get; set; } + + /// + /// User Id for the user who owns this login + /// + public virtual TKey UserId { get; set; } + } +} \ No newline at end of file diff --git a/test/Shared/TestUserRole.cs b/test/Shared/TestUserRole.cs new file mode 100644 index 0000000000..28a6c49aec --- /dev/null +++ b/test/Shared/TestUserRole.cs @@ -0,0 +1,26 @@ +// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; + +namespace Microsoft.AspNet.Identity.Test +{ + public class TestUserRole : TestUserRole { } + + /// + /// EntityType that represents a user belonging to a role + /// + /// + public class TestUserRole where TKey : IEquatable + { + /// + /// UserId for the user that is in the role + /// + public virtual TKey UserId { get; set; } + + /// + /// RoleId for the role + /// + public virtual TKey RoleId { get; set; } + } +} \ No newline at end of file diff --git a/test/Shared/UserManagerTestBase.cs b/test/Shared/UserManagerTestBase.cs index cf94c2539d..af2ee856ce 100644 --- a/test/Shared/UserManagerTestBase.cs +++ b/test/Shared/UserManagerTestBase.cs @@ -11,18 +11,19 @@ using Microsoft.AspNet.Testing; using Microsoft.Framework.DependencyInjection; using Microsoft.Framework.Logging; using Xunit; +using System.Linq.Expressions; namespace Microsoft.AspNet.Identity.Test { // Common functionality tests that all verifies user manager functionality regardless of store implementation public abstract class UserManagerTestBase : UserManagerTestBase - where TUser : IdentityUser, new() - where TRole : IdentityRole, new() + where TUser : class + where TRole : class { } public abstract class UserManagerTestBase - where TUser : IdentityUser, new() - where TRole : IdentityRole, new() + where TUser : class + where TRole : class where TKey : IEquatable { protected TestLoggerFactory loggerFactory; @@ -82,15 +83,18 @@ namespace Microsoft.AspNet.Identity.Test protected abstract void AddUserStore(IServiceCollection services, object context = null); protected abstract void AddRoleStore(IServiceCollection services, object context = null); - protected TUser CreateTestUser(string namePrefix = "") - { - return new TUser() { UserName = namePrefix + Guid.NewGuid().ToString() }; - } + protected abstract void SetUserPasswordHash(TUser user, string hashedPassword); - protected TRole CreateRole(string namePrefix = "") - { - return new TRole() { Name = namePrefix + Guid.NewGuid().ToString() }; - } + protected abstract TUser CreateTestUser(string namePrefix = "", string email = "", string phoneNumber = "", + bool lockoutEnabled = false, DateTimeOffset? lockoutEnd = null, bool useNamePrefixAsUserName = false); + + protected abstract TRole CreateTestRole(string roleNamePrefix = "", bool useRoleNamePrefixAsRoleName = false); + + protected abstract Expression> UserNameEqualsPredicate(string userName); + protected abstract Expression> UserNameStartsWithPredicate(string userName); + + protected abstract Expression> RoleNameEqualsPredicate(string roleName); + protected abstract Expression> RoleNameStartsWithPredicate(string roleName); [Fact] public async Task CanDeleteUser() @@ -98,12 +102,13 @@ namespace Microsoft.AspNet.Identity.Test var manager = CreateManager(); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "CreateAsync", user.Id.ToString()); + var userId = await manager.GetUserIdAsync(user); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "CreateAsync", userId); IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "DeleteAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "DeleteAsync", userId); - Assert.Null(await manager.FindByIdAsync(user.Id.ToString())); + Assert.Null(await manager.FindByIdAsync(userId)); } [Fact] @@ -111,13 +116,13 @@ namespace Microsoft.AspNet.Identity.Test { var manager = CreateManager(); var name = Guid.NewGuid().ToString(); - var user = new TUser() { UserName = name }; + var user = CreateTestUser(name); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var newName = Guid.NewGuid().ToString(); Assert.Null(await manager.FindByNameAsync(newName)); - user.UserName = newName; + IdentityResultAssert.IsSuccess(await manager.SetUserNameAsync(user, newName)); IdentityResultAssert.IsSuccess(await manager.UpdateAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "UpdateAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "UpdateAsync", await manager.GetUserIdAsync(user)); Assert.NotNull(await manager.FindByNameAsync(newName)); Assert.Null(await manager.FindByNameAsync(name)); } @@ -126,7 +131,7 @@ namespace Microsoft.AspNet.Identity.Test public async Task CanSetUserName() { var manager = CreateManager(); - var user = new TUser() { UserName = "UpdateAsync" }; + var user = CreateTestUser("UpdateAsync"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.Null(await manager.FindByNameAsync("New")); IdentityResultAssert.IsSuccess(await manager.SetUserNameAsync(user, "New")); @@ -138,13 +143,14 @@ namespace Microsoft.AspNet.Identity.Test public async Task CanUpdatePasswordUsingHasher() { var manager = CreateManager(); - var user = new TUser() { UserName = "UpdatePassword" }; + var user = CreateTestUser("UpdatePassword"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); Assert.True(await manager.CheckPasswordAsync(user, "password")); + var userId = await manager.GetUserIdAsync(user); string expectedLog = string.Format("{0} : {1}", "CheckPasswordAsync", true.ToString()); IdentityResultAssert.VerifyLogMessage(manager.Logger, expectedLog); - user.PasswordHash = manager.PasswordHasher.HashPassword(user, "New"); + SetUserPasswordHash(user, manager.PasswordHasher.HashPassword(user, "New")); IdentityResultAssert.IsSuccess(await manager.UpdateAsync(user)); Assert.False(await manager.CheckPasswordAsync(user, "password")); expectedLog = string.Format("{0} : {1}", "CheckPasswordAsync", false.ToString()); @@ -158,7 +164,7 @@ namespace Microsoft.AspNet.Identity.Test var manager = CreateManager(); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - Assert.NotNull(await manager.FindByIdAsync(user.Id.ToString())); + Assert.NotNull(await manager.FindByIdAsync(await manager.GetUserIdAsync(user))); } [Fact] @@ -180,7 +186,7 @@ namespace Microsoft.AspNet.Identity.Test manager.UserValidators.Clear(); manager.UserValidators.Add(new AlwaysBadValidator()); IdentityResultAssert.IsFailure(await manager.UpdateAsync(user), AlwaysBadValidator.ErrorMessage); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "UpdateAsync", user.Id.ToString(), AlwaysBadValidator.ErrorMessage); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "UpdateAsync", await manager.GetUserIdAsync(user), AlwaysBadValidator.ErrorMessage); } [Fact] @@ -213,7 +219,7 @@ namespace Microsoft.AspNet.Identity.Test public async Task UserValidatorBlocksInvalidEmailsWhenRequiresUniqueEmail(string email) { var manager = CreateManager(); - var user = new TUser() { UserName = "UpdateBlocked", Email = email }; + var user = CreateTestUser("UpdateBlocked", email); manager.Options.User.RequireUniqueEmail = true; IdentityResultAssert.IsFailure(await manager.CreateAsync(user), IdentityErrorDescriber.Default.InvalidEmail(email)); } @@ -229,7 +235,7 @@ namespace Microsoft.AspNet.Identity.Test manager.PasswordValidators.Add(new AlwaysBadValidator()); IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), AlwaysBadValidator.ErrorMessage); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "AddPasswordAsync", user.Id.ToString(), AlwaysBadValidator.ErrorMessage); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "AddPasswordAsync", await manager.GetUserIdAsync(user), AlwaysBadValidator.ErrorMessage); } [Fact] @@ -256,7 +262,7 @@ namespace Microsoft.AspNet.Identity.Test manager.PasswordValidators.Add(new AlwaysBadValidator()); IdentityResultAssert.IsFailure(await manager.ChangePasswordAsync(user, "password", "new"), AlwaysBadValidator.ErrorMessage); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangePasswordAsync", user.Id.ToString(), AlwaysBadValidator.ErrorMessage); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangePasswordAsync", await manager.GetUserIdAsync(user), AlwaysBadValidator.ErrorMessage); } [Fact] @@ -273,10 +279,11 @@ namespace Microsoft.AspNet.Identity.Test public async Task CanCreateUserNoPassword() { var manager = CreateManager(); - IdentityResultAssert.IsSuccess(await manager.CreateAsync(new TUser() { UserName = "CreateUserTest" })); - var user = await manager.FindByNameAsync("CreateUserTest"); + var username = "CreateUserTest" + Guid.NewGuid(); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(CreateTestUser(username, useNamePrefixAsUserName: true))); + var user = await manager.FindByNameAsync(username); Assert.NotNull(user); - Assert.Null(user.PasswordHash); + Assert.False(await manager.HasPasswordAsync(user)); var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(0, logins.Count()); @@ -289,11 +296,10 @@ namespace Microsoft.AspNet.Identity.Test const string provider = "ZzAuth"; const string display = "display"; var user = CreateTestUser(); - var providerKey = user.Id.ToString(); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - user = await manager.FindByNameAsync(user.UserName); + var providerKey = await manager.GetUserIdAsync(user); IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, new UserLoginInfo(provider, providerKey, display))); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddLoginAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddLoginAsync", await manager.GetUserIdAsync(user)); var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(1, logins.Count()); @@ -307,12 +313,13 @@ namespace Microsoft.AspNet.Identity.Test { var manager = CreateManager(); var user = CreateTestUser(); - var login = new UserLoginInfo("Provider", user.Id.ToString(), "display"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var userId = await manager.GetUserIdAsync(user); + var login = new UserLoginInfo("Provider", userId, "display"); IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); Assert.False(await manager.HasPasswordAsync(user)); IdentityResultAssert.IsSuccess(await manager.AddPasswordAsync(user, "password")); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddPasswordAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddPasswordAsync", userId); Assert.True(await manager.HasPasswordAsync(user)); var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); @@ -330,7 +337,7 @@ namespace Microsoft.AspNet.Identity.Test Assert.True(await manager.HasPasswordAsync(user)); IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), "User already has a password set."); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "AddPasswordAsync", user.Id.ToString(), IdentityErrorDescriber.Default.UserAlreadyHasPassword()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "AddPasswordAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.UserAlreadyHasPassword()); } [Fact] @@ -338,9 +345,10 @@ namespace Microsoft.AspNet.Identity.Test { var manager = CreateManager(); var user = CreateTestUser(); - var login = new UserLoginInfo("Provider", user.Id.ToString(), "display"); var result = await manager.CreateAsync(user); Assert.NotNull(user); + var userId = await manager.GetUserIdAsync(user); + var login = new UserLoginInfo("Provider", userId, "display"); IdentityResultAssert.IsSuccess(result); IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); Assert.Equal(user, await manager.FindByLoginAsync(login.LoginProvider, login.ProviderKey)); @@ -350,30 +358,31 @@ namespace Microsoft.AspNet.Identity.Test Assert.Equal(login.LoginProvider, logins.Last().LoginProvider); Assert.Equal(login.ProviderKey, logins.Last().ProviderKey); Assert.Equal(login.ProviderDisplayName, logins.Last().ProviderDisplayName); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); IdentityResultAssert.IsSuccess(await manager.RemoveLoginAsync(user, login.LoginProvider, login.ProviderKey)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "RemoveLoginAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "RemoveLoginAsync", userId); Assert.Null(await manager.FindByLoginAsync(login.LoginProvider, login.ProviderKey)); logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(0, logins.Count()); - Assert.NotEqual(stamp, user.SecurityStamp); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] public async Task CanRemovePassword() { var manager = CreateManager(); - var user = CreateTestUser(); + var user = CreateTestUser("CanRemovePassword"); const string password = "password"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); + var username = await manager.GetUserNameAsync(user); IdentityResultAssert.IsSuccess(await manager.RemovePasswordAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "RemovePasswordAsync", user.Id.ToString()); - var u = await manager.FindByNameAsync(user.UserName); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "RemovePasswordAsync", await manager.GetUserIdAsync(user)); + var u = await manager.FindByNameAsync(username); Assert.NotNull(u); - Assert.Null(u.PasswordHash); - Assert.NotEqual(stamp, user.SecurityStamp); + Assert.False(await manager.HasPasswordAsync(user)); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -384,13 +393,13 @@ namespace Microsoft.AspNet.Identity.Test const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user, password, newPassword)); Assert.False(await manager.CheckPasswordAsync(user, password)); Assert.True(await manager.CheckPasswordAsync(user, newPassword)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ChangePasswordAsync", user.Id.ToString()); - Assert.NotEqual(stamp, user.SecurityStamp); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ChangePasswordAsync", await manager.GetUserIdAsync(user)); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact(Skip = "Temporarily skipping")] @@ -404,11 +413,12 @@ namespace Microsoft.AspNet.Identity.Test { IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c)); } - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddClaimsAsync", user.Id.ToString()); + var userId = await manager.GetUserIdAsync(user); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddClaimsAsync", userId); var userClaims = await manager.GetClaimsAsync(user); Assert.Equal(3, userClaims.Count); IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[0])); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "RemoveClaimsAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "RemoveClaimsAsync", userId); userClaims = await manager.GetClaimsAsync(user); Assert.Equal(2, userClaims.Count); IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[1])); @@ -460,7 +470,7 @@ namespace Microsoft.AspNet.Identity.Test Claim claim = new Claim("c", "b"); Claim oldClaim = userClaims.FirstOrDefault(); IdentityResultAssert.IsSuccess(await manager.ReplaceClaimAsync(user, oldClaim, claim)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ReplaceClaimAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ReplaceClaimAsync", await manager.GetUserIdAsync(user)); var newUserClaims = await manager.GetClaimsAsync(user); Assert.Equal(1, newUserClaims.Count); Claim newClaim = newUserClaims.FirstOrDefault(); @@ -505,43 +515,40 @@ namespace Microsoft.AspNet.Identity.Test IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); var result = await manager.ChangePasswordAsync(user, "bogus", "newpassword"); IdentityResultAssert.IsFailure(result, "Incorrect password."); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangePasswordAsync", user.Id.ToString(), IdentityErrorDescriber.Default.PasswordMismatch()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangePasswordAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.PasswordMismatch()); } [Fact] public async Task AddDupeUserNameFails() { var manager = CreateManager(); - var user = CreateTestUser(); - var user2 = new TUser() { UserName = user.UserName }; + var username = "AddDupeUserNameFails" + Guid.NewGuid(); + var user = CreateTestUser(username, useNamePrefixAsUserName: true); + var user2 = CreateTestUser(username, useNamePrefixAsUserName: true); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), IdentityErrorDescriber.Default.DuplicateUserName(user.UserName)); + IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), IdentityErrorDescriber.Default.DuplicateUserName(username)); } [Fact] public async Task AddDupeEmailAllowedByDefault() { var manager = CreateManager(); - var user = CreateTestUser(); - var user2 = CreateTestUser(); - user.Email = "yup@yup.com"; - user2.Email = "yup@yup.com"; + var user = CreateTestUser(email: "yup@yup.com"); + var user2 = CreateTestUser(email: "yup@yup.com"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user2, await manager.GetEmailAsync(user))); } [Fact] - public async Task AddDupeEmailFallsWhenUniqueEmailRequired() + public async Task AddDupeEmailFailsWhenUniqueEmailRequired() { var manager = CreateManager(); manager.Options.User.RequireUniqueEmail = true; - var user = CreateTestUser(); - var user2 = CreateTestUser(); - string email = user.UserName + "@yup.com"; - user.Email = email; - user2.Email = email; + var user = CreateTestUser(email: "FooUser@yup.com"); + var user2 = CreateTestUser(email: "FooUser@yup.com"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), IdentityErrorDescriber.Default.DuplicateEmail(user.Email)); + IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), IdentityErrorDescriber.Default.DuplicateEmail("FooUser@yup.com")); } [Fact] @@ -549,13 +556,13 @@ namespace Microsoft.AspNet.Identity.Test { var manager = CreateManager(); var user = CreateTestUser(); - Assert.Null(user.SecurityStamp); + Assert.Null(await manager.GetSecurityStampAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "UpdateSecurityStampAsync", user.Id.ToString()); - Assert.NotEqual(stamp, user.SecurityStamp); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "UpdateSecurityStampAsync", await manager.GetUserIdAsync(user)); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -568,17 +575,16 @@ namespace Microsoft.AspNet.Identity.Test IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); var result = await manager.AddLoginAsync(user, login); IdentityResultAssert.IsFailure(result, IdentityErrorDescriber.Default.LoginAlreadyAssociated()); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "AddLoginAsync", user.Id.ToString(), IdentityErrorDescriber.Default.LoginAlreadyAssociated()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "AddLoginAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.LoginAlreadyAssociated()); } // Email tests [Fact] public async Task CanFindByEmail() { + var email = "foouser@test.com"; var manager = CreateManager(); - var user = CreateTestUser(); - var email = user.UserName + "@test.com"; - user.Email = email; + var user = CreateTestUser(email: email); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var fetch = await manager.FindByEmailAsync(email); Assert.Equal(user, fetch); @@ -588,13 +594,16 @@ namespace Microsoft.AspNet.Identity.Test public async Task CanFindUsersViaUserQuerable() { var mgr = CreateManager(); - var users = GenerateUsers("CanFindUsersViaUserQuerable", 3); - foreach (var u in users) + if (mgr.SupportsQueryableUsers) { - IdentityResultAssert.IsSuccess(await mgr.CreateAsync(u)); + var users = GenerateUsers("CanFindUsersViaUserQuerable", 4); + foreach (var u in users) + { + IdentityResultAssert.IsSuccess(await mgr.CreateAsync(u)); + } + Assert.Equal(users.Count, mgr.Users.Count(UserNameStartsWithPredicate("CanFindUsersViaUserQuerable"))); + Assert.Null(mgr.Users.FirstOrDefault(UserNameEqualsPredicate("bogus"))); } - var usersQ = mgr.Users.Where(u => u.UserName.StartsWith("CanFindUsersViaUserQuerable")); - Assert.Null(mgr.Users.FirstOrDefault(u => u.UserName == "bogus")); } [Fact] @@ -610,14 +619,14 @@ namespace Microsoft.AspNet.Identity.Test { public string Name { get; } = "Static"; - public Task GenerateAsync(string purpose, UserManager manager, TUser user) + public async Task GenerateAsync(string purpose, UserManager manager, TUser user) { - return Task.FromResult(MakeToken(purpose, user)); + return MakeToken(purpose, await manager.GetUserIdAsync(user)); } - public Task ValidateAsync(string purpose, string token, UserManager manager, TUser user) + public async Task ValidateAsync(string purpose, string token, UserManager manager, TUser user) { - return Task.FromResult(token == MakeToken(purpose, user)); + return token == MakeToken(purpose, await manager.GetUserIdAsync(user)); } public Task NotifyAsync(string token, UserManager manager, TUser user) @@ -630,9 +639,9 @@ namespace Microsoft.AspNet.Identity.Test return Task.FromResult(true); } - private static string MakeToken(string purpose, TUser user) + private static string MakeToken(string purpose, string userId) { - return string.Join(":", user.Id, purpose, "ImmaToken"); + return string.Join(":", userId, purpose, "ImmaToken"); } } @@ -646,16 +655,17 @@ namespace Microsoft.AspNet.Identity.Test const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); var token = await manager.GeneratePasswordResetTokenAsync(user); Assert.NotNull(token); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "GeneratePasswordResetTokenAsync", user.Id.ToString()); + var userId = await manager.GetUserIdAsync(user); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "GeneratePasswordResetTokenAsync", userId); IdentityResultAssert.IsSuccess(await manager.ResetPasswordAsync(user, token, newPassword)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ResetPasswordAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ResetPasswordAsync", userId); Assert.False(await manager.CheckPasswordAsync(user, password)); Assert.True(await manager.CheckPasswordAsync(user, newPassword)); - Assert.NotEqual(stamp, user.SecurityStamp); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -668,16 +678,16 @@ namespace Microsoft.AspNet.Identity.Test const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); var token = await manager.GeneratePasswordResetTokenAsync(user); Assert.NotNull(token); manager.PasswordValidators.Add(new AlwaysBadValidator()); IdentityResultAssert.IsFailure(await manager.ResetPasswordAsync(user, token, newPassword), AlwaysBadValidator.ErrorMessage); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ResetPasswordAsync", user.Id.ToString(), AlwaysBadValidator.ErrorMessage); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ResetPasswordAsync", await manager.GetUserIdAsync(user), AlwaysBadValidator.ErrorMessage); Assert.True(await manager.CheckPasswordAsync(user, password)); - Assert.Equal(stamp, user.SecurityStamp); + Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -690,12 +700,12 @@ namespace Microsoft.AspNet.Identity.Test const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); IdentityResultAssert.IsFailure(await manager.ResetPasswordAsync(user, "bogus", newPassword), "Invalid token."); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ResetPasswordAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ResetPasswordAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.InvalidToken()); Assert.True(await manager.CheckPasswordAsync(user, password)); - Assert.Equal(stamp, user.SecurityStamp); + Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -707,15 +717,16 @@ namespace Microsoft.AspNet.Identity.Test var user2 = CreateTestUser(); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); + var userId = await manager.GetUserIdAsync(user); var token = await manager.GenerateUserTokenAsync(user, "Static", "test"); var expectedLog = string.Format("{0} : {1}", "GenerateUserTokenAsync", "Succeeded"); IdentityResultAssert.VerifyLogMessage(manager.Logger, expectedLog); Assert.True(await manager.VerifyUserTokenAsync(user, "Static", "test", token)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "VerifyUserTokenAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "VerifyUserTokenAsync", userId); Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test2", token)); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "VerifyUserTokenAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "VerifyUserTokenAsync", userId, IdentityErrorDescriber.Default.InvalidToken()); Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test", token + "a")); Assert.False(await manager.VerifyUserTokenAsync(user2, "Static", "test", token)); @@ -728,13 +739,14 @@ namespace Microsoft.AspNet.Identity.Test manager.RegisterTokenProvider(new StaticTokenProvider()); manager.Options.EmailConfirmationTokenProvider = "Static"; var user = CreateTestUser(); - Assert.False(user.EmailConfirmed); + Assert.False(await manager.IsEmailConfirmedAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var token = await manager.GenerateEmailConfirmationTokenAsync(user); Assert.NotNull(token); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "GenerateEmailConfirmationTokenAsync", user.Id.ToString()); + var userId = await manager.GetUserIdAsync(user); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "GenerateEmailConfirmationTokenAsync", userId); IdentityResultAssert.IsSuccess(await manager.ConfirmEmailAsync(user, token)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ConfirmEmailAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ConfirmEmailAsync", userId); Assert.True(await manager.IsEmailConfirmedAsync(user)); IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, null)); Assert.False(await manager.IsEmailConfirmedAsync(user)); @@ -747,19 +759,19 @@ namespace Microsoft.AspNet.Identity.Test manager.RegisterTokenProvider(new StaticTokenProvider()); manager.Options.EmailConfirmationTokenProvider = "Static"; var user = CreateTestUser(); - Assert.False(user.EmailConfirmed); + Assert.False(await manager.IsEmailConfirmedAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, "bogus"), "Invalid token."); Assert.False(await manager.IsEmailConfirmedAsync(user)); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ConfirmEmailAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ConfirmEmailAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.InvalidToken()); } [Fact] public async Task ConfirmTokenFailsAfterPasswordChange() { var manager = CreateManager(); - var user = new TUser() { UserName = "test" }; - Assert.False(user.EmailConfirmed); + var user = CreateTestUser(namePrefix: "Test"); + Assert.False(await manager.IsEmailConfirmedAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); var token = await manager.GenerateEmailConfirmationTokenAsync(user); Assert.NotNull(token); @@ -780,7 +792,6 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); Assert.False(await mgr.IsLockedOutAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.True(await mgr.IsLockedOutAsync(user)); @@ -798,7 +809,6 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); Assert.False(await mgr.IsLockedOutAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); @@ -820,14 +830,13 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); Assert.False(await mgr.IsLockedOutAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user)); IdentityResultAssert.IsSuccess(await mgr.ResetAccessFailedCountAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "ResetAccessFailedCountAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "ResetAccessFailedCountAsync", await mgr.GetUserIdAsync(user)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); @@ -846,14 +855,12 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.False(await mgr.GetLockoutEnabledAsync(user)); - Assert.False(user.LockoutEnabled); IdentityResultAssert.IsSuccess(await mgr.SetLockoutEnabledAsync(user, true)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); - IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "SetLockoutEnabledAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "SetLockoutEnabledAsync", await mgr.GetUserIdAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "AccessFailedAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "AccessFailedAsync", await mgr.GetUserIdAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user)); @@ -871,12 +878,10 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user, new DateTimeOffset())); Assert.False(await mgr.IsLockedOutAsync(user)); - IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "SetLockoutEndDateAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(mgr.Logger, "SetLockoutEndDateAsync", await mgr.GetUserIdAsync(user)); Assert.Equal(new DateTimeOffset(), await mgr.GetLockoutEndDateAsync(user)); - Assert.Equal(new DateTimeOffset(), user.LockoutEnd); } [Fact] @@ -886,7 +891,6 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.False(await mgr.GetLockoutEnabledAsync(user)); - Assert.False(user.LockoutEnabled); IdentityResultAssert.IsFailure(await mgr.SetLockoutEndDateAsync(user, new DateTimeOffset()), "Lockout is not enabled for this user."); Assert.False(await mgr.IsLockedOutAsync(user)); @@ -897,11 +901,9 @@ namespace Microsoft.AspNet.Identity.Test { var mgr = CreateManager(); mgr.Options.Lockout.EnabledByDefault = true; - var user = CreateTestUser(); - user.LockoutEnd = DateTimeOffset.UtcNow.AddSeconds(-1); + var user = CreateTestUser(lockoutEnd: DateTimeOffset.UtcNow.AddSeconds(-1)); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); Assert.False(await mgr.IsLockedOutAsync(user)); } @@ -913,7 +915,6 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow.AddSeconds(-1))); Assert.False(await mgr.IsLockedOutAsync(user)); } @@ -923,11 +924,10 @@ namespace Microsoft.AspNet.Identity.Test { var mgr = CreateManager(); mgr.Options.Lockout.EnabledByDefault = true; - var user = CreateTestUser(); - user.LockoutEnd = DateTimeOffset.UtcNow.AddMinutes(5); + var lockoutEnd = DateTimeOffset.UtcNow.AddMinutes(5); + var user = CreateTestUser(lockoutEnd: lockoutEnd); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); Assert.True(await mgr.IsLockedOutAsync(user)); } @@ -939,7 +939,6 @@ namespace Microsoft.AspNet.Identity.Test var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); - Assert.True(user.LockoutEnabled); var lockoutEnd = new DateTimeOffset(DateTime.Now.AddMinutes(30).ToLocalTime()); IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user, lockoutEnd)); Assert.True(await mgr.IsLockedOutAsync(user)); @@ -952,10 +951,11 @@ namespace Microsoft.AspNet.Identity.Test public async Task CanCreateRoleTest() { var manager = CreateRoleManager(); - var role = CreateRole("create"); - Assert.False(await manager.RoleExistsAsync(role.Name)); + var roleName = "create" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); + Assert.False(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); - Assert.True(await manager.RoleExistsAsync(role.Name)); + Assert.True(await manager.RoleExistsAsync(roleName)); } private class AlwaysBadValidator : IUserValidator, IRoleValidator, @@ -985,7 +985,7 @@ namespace Microsoft.AspNet.Identity.Test var manager = CreateRoleManager(); manager.RoleValidators.Clear(); manager.RoleValidators.Add(new AlwaysBadValidator()); - IdentityResultAssert.IsFailure(await manager.CreateAsync(CreateRole("blocked")), + IdentityResultAssert.IsFailure(await manager.CreateAsync(CreateTestRole("blocked")), AlwaysBadValidator.ErrorMessage); } @@ -996,7 +996,7 @@ namespace Microsoft.AspNet.Identity.Test manager.RoleValidators.Clear(); manager.RoleValidators.Add(new AlwaysBadValidator()); manager.RoleValidators.Add(new AlwaysBadValidator()); - var result = await manager.CreateAsync(CreateRole("blocked")); + var result = await manager.CreateAsync(CreateTestRole("blocked")); IdentityResultAssert.IsFailure(result, AlwaysBadValidator.ErrorMessage); Assert.Equal(2, result.Errors.Count()); } @@ -1005,39 +1005,41 @@ namespace Microsoft.AspNet.Identity.Test public async Task BadValidatorBlocksRoleUpdate() { var manager = CreateRoleManager(); - var role = CreateRole("poorguy"); + var role = CreateTestRole("poorguy"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); var error = AlwaysBadValidator.ErrorMessage; manager.RoleValidators.Clear(); manager.RoleValidators.Add(new AlwaysBadValidator()); IdentityResultAssert.IsFailure(await manager.UpdateAsync(role), error); - IdentityResultAssert.VerifyRoleManagerFailureLog(manager.Logger, "UpdateAsync", role.Id.ToString(), AlwaysBadValidator.ErrorMessage); + IdentityResultAssert.VerifyRoleManagerFailureLog(manager.Logger, "UpdateAsync", await manager.GetRoleIdAsync(role), AlwaysBadValidator.ErrorMessage); } [Fact] public async Task CanDeleteRole() { var manager = CreateRoleManager(); - var role = CreateRole("delete"); - Assert.False(await manager.RoleExistsAsync(role.Name)); + var roleName = "delete" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName:true); + Assert.False(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.True(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.DeleteAsync(role)); - Assert.False(await manager.RoleExistsAsync(role.Name)); - IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "DeleteAsync", role.Id.ToString()); + Assert.False(await manager.RoleExistsAsync(roleName)); + IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "DeleteAsync", await manager.GetRoleIdAsync(role)); } [Fact] public async Task CanAddRemoveRoleClaim() { var manager = CreateRoleManager(); - var role = CreateRole("ClaimsAddRemove"); + var role = CreateTestRole("ClaimsAddRemove"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); Claim[] claims = { new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3") }; foreach (Claim c in claims) { IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(role, c)); } - IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "AddClaimAsync", role.Id.ToString()); + IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "AddClaimAsync", await manager.GetRoleIdAsync(role)); var roleClaims = await manager.GetClaimsAsync(role); Assert.Equal(3, roleClaims.Count); IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(role, claims[0])); @@ -1050,41 +1052,43 @@ namespace Microsoft.AspNet.Identity.Test roleClaims = await manager.GetClaimsAsync(role); Assert.Equal(0, roleClaims.Count); - IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "RemoveClaimAsync", role.Id.ToString()); + IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "RemoveClaimAsync", await manager.GetRoleIdAsync(role)); } [Fact] public async Task CanRoleFindById() { var manager = CreateRoleManager(); - var role = CreateRole("FindByIdAsync"); - Assert.Null(await manager.FindByIdAsync(role.Id.ToString())); + var role = CreateTestRole("FindByIdAsync"); + Assert.Null(await manager.FindByIdAsync(await manager.GetRoleIdAsync(role))); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); - Assert.Equal(role, await manager.FindByIdAsync(role.Id.ToString())); + Assert.Equal(role, await manager.FindByIdAsync(await manager.GetRoleIdAsync(role))); } [Fact] public async Task CanRoleFindByName() { var manager = CreateRoleManager(); - var role = CreateRole("FindByNameAsync"); - Assert.Null(await manager.FindByNameAsync(role.Name)); - Assert.False(await manager.RoleExistsAsync(role.Name)); + var roleName = "FindByNameAsync" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); + Assert.Null(await manager.FindByNameAsync(roleName)); + Assert.False(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); - Assert.Equal(role, await manager.FindByNameAsync(role.Name)); + Assert.Equal(role, await manager.FindByNameAsync(roleName)); } [Fact] public async Task CanUpdateRoleName() { var manager = CreateRoleManager(); - var role = CreateRole("update"); - Assert.False(await manager.RoleExistsAsync(role.Name)); + var roleName = "update" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); + Assert.False(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); - Assert.True(await manager.RoleExistsAsync(role.Name)); + Assert.True(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.SetRoleNameAsync(role, "Changed")); IdentityResultAssert.IsSuccess(await manager.UpdateAsync(role)); - IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "UpdateAsync", role.Id.ToString()); + IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "UpdateAsync", await manager.GetRoleIdAsync(role)); Assert.False(await manager.RoleExistsAsync("update")); Assert.Equal(role, await manager.FindByNameAsync("Changed")); } @@ -1093,39 +1097,43 @@ namespace Microsoft.AspNet.Identity.Test public async Task CanQueryableRoles() { var manager = CreateRoleManager(); - var roles = GenerateRoles("CanQuerableRolesTest", 4); - foreach (var r in roles) + if (manager.SupportsQueryableRoles) { - IdentityResultAssert.IsSuccess(await manager.CreateAsync(r)); + var roles = GenerateRoles("CanQuerableRolesTest", 4); + foreach (var r in roles) + { + IdentityResultAssert.IsSuccess(await manager.CreateAsync(r)); + } + Assert.Equal(roles.Count, manager.Roles.Count(RoleNameStartsWithPredicate("CanQuerableRolesTest"))); + Assert.Null(manager.Roles.FirstOrDefault(RoleNameEqualsPredicate("bogus"))); } - Assert.Equal(roles.Count, manager.Roles.Count(r => r.Name.StartsWith("CanQuerableRolesTest"))); - var r1 = manager.Roles.FirstOrDefault(r => r.Name.StartsWith("CanQuerableRolesTest1")); - Assert.Equal(roles[1], r1); } - [Fact] + // Enable when delete on cascade is supported in EF + // [Fact] public async Task DeleteRoleNonEmptySucceedsTest() { // Need fail if not empty? var context = CreateTestContext(); var userMgr = CreateManager(context); var roleMgr = CreateRoleManager(context); - var role = CreateRole(); - Assert.False(await roleMgr.RoleExistsAsync(role.Name)); + var roleName = "delete" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName:true); + Assert.False(await roleMgr.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); - IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); + IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, roleName)); var roles = await userMgr.GetRolesAsync(user); Assert.Equal(1, roles.Count()); IdentityResultAssert.IsSuccess(await roleMgr.DeleteAsync(role)); - Assert.Null(await roleMgr.FindByNameAsync(role.Name)); - Assert.False(await roleMgr.RoleExistsAsync(role.Name)); + Assert.Null(await roleMgr.FindByNameAsync(roleName)); + Assert.False(await roleMgr.RoleExistsAsync(roleName)); // REVIEW: We should throw if deleteing a non empty role? roles = await userMgr.GetRolesAsync(user); // REVIEW: This depends on cascading deletes - //Assert.Equal(0, roles.Count()); + Assert.Equal(0, roles.Count()); } // TODO: cascading deletes? navigation properties not working @@ -1136,11 +1144,11 @@ namespace Microsoft.AspNet.Identity.Test //// var userMgr = CreateManager(); //// var roleMgr = CreateRoleManager(); //// var role = CreateRole("deleteNonEmpty"); - //// Assert.False(await roleMgr.RoleExistsAsync(role.Name)); + //// Assert.False(await roleMgr.RoleExistsAsync(roleName)); //// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); //// var user = new TUser() { UserName = "t"); //// IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); - //// IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); + //// IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, roleName)); //// IdentityResultAssert.IsSuccess(await userMgr.DeleteAsync(user)); //// role = roleMgr.FindByIdAsync(role.Id); ////} @@ -1149,13 +1157,13 @@ namespace Microsoft.AspNet.Identity.Test public async Task CreateRoleFailsIfExists() { var manager = CreateRoleManager(); - var role = CreateRole("dupeRole"); - Assert.False(await manager.RoleExistsAsync(role.Name)); + var roleName = "dupeRole" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); + Assert.False(await manager.RoleExistsAsync(roleName)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); - IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "CreateAsync", role.Id.ToString()); - Assert.True(await manager.RoleExistsAsync(role.Name)); - var role2 = CreateRole(); - role2.Name = role.Name; + IdentityResultAssert.VerifyRoleManagerSuccessLog(manager.Logger, "CreateAsync", await manager.GetRoleIdAsync(role)); + Assert.True(await manager.RoleExistsAsync(roleName)); + var role2 = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); IdentityResultAssert.IsFailure(await manager.CreateAsync(role2)); } @@ -1165,19 +1173,19 @@ namespace Microsoft.AspNet.Identity.Test var context = CreateTestContext(); var manager = CreateManager(context); var roleManager = CreateRoleManager(context); - var role = CreateRole("addUserTest"); + var roleName = "AddUserTest" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role)); TUser[] users = { - new TUser() { UserName = "1"}, new TUser() { UserName = "2"}, new TUser() { UserName = "3"}, - new TUser() { UserName = "4"} + CreateTestUser("1"),CreateTestUser("2"),CreateTestUser("3"),CreateTestUser("4"), }; foreach (var u in users) { IdentityResultAssert.IsSuccess(await manager.CreateAsync(u)); - IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(u, role.Name)); - Assert.True(await manager.IsInRoleAsync(u, role.Name)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddToRoleAsync", u.Id.ToString()); + IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(u, roleName)); + Assert.True(await manager.IsInRoleAsync(u, roleName)); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddToRoleAsync", await manager.GetUserIdAsync(u)); } } @@ -1199,8 +1207,8 @@ namespace Microsoft.AspNet.Identity.Test IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); foreach (var u in users) { - IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(u, r.Name)); - Assert.True(await userManager.IsInRoleAsync(u, r.Name)); + IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(u, await roleManager.GetRoleNameAsync(r))); + Assert.True(await userManager.IsInRoleAsync(u, await roleManager.GetRoleNameAsync(r))); } } @@ -1210,7 +1218,8 @@ namespace Microsoft.AspNet.Identity.Test Assert.Equal(roles.Count, rs.Count); foreach (var r in roles) { - Assert.True(rs.Any(role => role == r.Name)); + var expectedRoleName = await roleManager.GetRoleNameAsync(r); + Assert.True(rs.Any(role => role == expectedRoleName)); } } } @@ -1227,12 +1236,12 @@ namespace Microsoft.AspNet.Identity.Test foreach (var r in roles) { IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); - IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(user, r.Name)); - Assert.True(await userManager.IsInRoleAsync(user, r.Name)); + IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(user, await roleManager.GetRoleNameAsync(r))); + Assert.True(await userManager.IsInRoleAsync(user, await roleManager.GetRoleNameAsync(r))); } - IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(user, roles[2].Name)); - IdentityResultAssert.VerifyUserManagerSuccessLog(userManager.Logger, "RemoveFromRoleAsync", user.Id.ToString()); - Assert.False(await userManager.IsInRoleAsync(user, roles[2].Name)); + IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(user, await roleManager.GetRoleNameAsync(roles[2]))); + IdentityResultAssert.VerifyUserManagerSuccessLog(userManager.Logger, "RemoveFromRoleAsync", await userManager.GetUserIdAsync(user)); + Assert.False(await userManager.IsInRoleAsync(user, await roleManager.GetRoleNameAsync(roles[2]))); } [Fact] @@ -1246,17 +1255,17 @@ namespace Microsoft.AspNet.Identity.Test { IdentityResultAssert.IsSuccess(await userManager.CreateAsync(u)); } - var r = CreateRole("r1"); + var r = CreateTestRole("r1"); IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); foreach (var u in users) { - IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(u, r.Name)); - Assert.True(await userManager.IsInRoleAsync(u, r.Name)); + IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(u, await roleManager.GetRoleNameAsync(r))); + Assert.True(await userManager.IsInRoleAsync(u, await roleManager.GetRoleNameAsync(r))); } foreach (var u in users) { - IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(u, r.Name)); - Assert.False(await userManager.IsInRoleAsync(u, r.Name)); + IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(u, await roleManager.GetRoleNameAsync(r))); + Assert.False(await userManager.IsInRoleAsync(u, await roleManager.GetRoleNameAsync(r))); } } @@ -1266,13 +1275,14 @@ namespace Microsoft.AspNet.Identity.Test var context = CreateTestContext(); var userMgr = CreateManager(context); var roleMgr = CreateRoleManager(context); - var role = CreateRole("addUserDupeTest"); + var roleName = "addUserDupeTest" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName:true); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - var result = await userMgr.RemoveFromRoleAsync(user, role.Name); - IdentityResultAssert.IsFailure(result, IdentityErrorDescriber.Default.UserNotInRole(role.Name)); - IdentityResultAssert.VerifyUserManagerFailureLog(userMgr.Logger, "RemoveFromRoleAsync", user.Id.ToString(), IdentityErrorDescriber.Default.UserNotInRole(role.Name)); + var result = await userMgr.RemoveFromRoleAsync(user, roleName); + IdentityResultAssert.IsFailure(result, IdentityErrorDescriber.Default.UserNotInRole(roleName)); + IdentityResultAssert.VerifyUserManagerFailureLog(userMgr.Logger, "RemoveFromRoleAsync", await userMgr.GetUserIdAsync(user), IdentityErrorDescriber.Default.UserNotInRole(roleName)); } [Fact] @@ -1281,88 +1291,87 @@ namespace Microsoft.AspNet.Identity.Test var context = CreateTestContext(); var userMgr = CreateManager(context); var roleMgr = CreateRoleManager(context); - var role = CreateRole("addUserDupeTest"); + var roleName = "addUserDupeTest" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); - Assert.True(await userMgr.IsInRoleAsync(user, role.Name)); - IdentityResultAssert.IsFailure(await userMgr.AddToRoleAsync(user, role.Name), IdentityErrorDescriber.Default.UserAlreadyInRole(role.Name)); - IdentityResultAssert.VerifyUserManagerFailureLog(userMgr.Logger, "AddToRoleAsync", user.Id.ToString(), IdentityErrorDescriber.Default.UserAlreadyInRole(role.Name)); + IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, roleName)); + Assert.True(await userMgr.IsInRoleAsync(user, roleName)); + IdentityResultAssert.IsFailure(await userMgr.AddToRoleAsync(user, roleName), IdentityErrorDescriber.Default.UserAlreadyInRole(roleName)); + IdentityResultAssert.VerifyUserManagerFailureLog(userMgr.Logger, "AddToRoleAsync", await userMgr.GetUserIdAsync(user), IdentityErrorDescriber.Default.UserAlreadyInRole(roleName)); } [Fact] public async Task CanFindRoleByNameWithManager() { var roleMgr = CreateRoleManager(); - var role = CreateRole("findRoleByNameTest"); + var roleName = "findRoleByNameTest" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - Assert.Equal(role.Id, (await roleMgr.FindByNameAsync(role.Name)).Id); + Assert.NotNull(await roleMgr.FindByNameAsync(roleName)); } [Fact] public async Task CanFindRoleWithManager() { var roleMgr = CreateRoleManager(); - var role = CreateRole("findRoleTest"); + var roleName = "findRoleTest" + Guid.NewGuid().ToString(); + var role = CreateTestRole(roleName, useRoleNamePrefixAsRoleName: true); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - Assert.Equal(role.Name, (await roleMgr.FindByIdAsync(role.Id.ToString())).Name); + Assert.Equal(roleName, await roleMgr.GetRoleNameAsync(await roleMgr.FindByNameAsync(roleName))); } [Fact] public async Task SetPhoneNumberTest() { var manager = CreateManager(); - var user = CreateTestUser(); - user.PhoneNumber = "123-456-7890"; + var user = CreateTestUser(phoneNumber: "123-456-7890"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); Assert.Equal(await manager.GetPhoneNumberAsync(user), "123-456-7890"); IdentityResultAssert.IsSuccess(await manager.SetPhoneNumberAsync(user, "111-111-1111")); Assert.Equal(await manager.GetPhoneNumberAsync(user), "111-111-1111"); - Assert.NotEqual(stamp, user.SecurityStamp); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] public async Task CanChangePhoneNumber() { var manager = CreateManager(); - var user = CreateTestUser(); - user.PhoneNumber = "123-456-7890"; + var user = CreateTestUser(phoneNumber: "123-456-7890"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); var token1 = await manager.GenerateChangePhoneNumberTokenAsync(user, "111-111-1111"); IdentityResultAssert.IsSuccess(await manager.ChangePhoneNumberAsync(user, "111-111-1111", token1)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ChangePhoneNumberAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ChangePhoneNumberAsync", await manager.GetUserIdAsync(user)); Assert.True(await manager.IsPhoneNumberConfirmedAsync(user)); Assert.Equal(await manager.GetPhoneNumberAsync(user), "111-111-1111"); - Assert.NotEqual(stamp, user.SecurityStamp); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] public async Task ChangePhoneNumberFailsWithWrongToken() { var manager = CreateManager(); - var user = CreateTestUser(); - user.PhoneNumber = "123-456-7890"; + var user = CreateTestUser(phoneNumber: "123-456-7890"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); IdentityResultAssert.IsFailure(await manager.ChangePhoneNumberAsync(user, "111-111-1111", "bogus"), "Invalid token."); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangePhoneNumberAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangePhoneNumberAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.InvalidToken()); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); Assert.Equal(await manager.GetPhoneNumberAsync(user), "123-456-7890"); - Assert.Equal(stamp, user.SecurityStamp); + Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] public async Task ChangePhoneNumberFailsWithWrongPhoneNumber() { var manager = CreateManager(); - var user = CreateTestUser(); - user.PhoneNumber = "123-456-7890"; + var user = CreateTestUser(phoneNumber: "123-456-7890"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); @@ -1371,7 +1380,7 @@ namespace Microsoft.AspNet.Identity.Test "Invalid token."); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); Assert.Equal(await manager.GetPhoneNumberAsync(user), "123-456-7890"); - Assert.Equal(stamp, user.SecurityStamp); + Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -1382,63 +1391,67 @@ namespace Microsoft.AspNet.Identity.Test IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); const string num1 = "111-123-4567"; const string num2 = "111-111-1111"; + var userId = await manager.GetUserIdAsync(user); var token1 = await manager.GenerateChangePhoneNumberTokenAsync(user, num1); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "GenerateChangePhoneNumberTokenAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "GenerateChangePhoneNumberTokenAsync", userId); var token2 = await manager.GenerateChangePhoneNumberTokenAsync(user, num2); Assert.NotEqual(token1, token2); Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num1)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "VerifyChangePhoneNumberTokenAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "VerifyChangePhoneNumberTokenAsync", userId); Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num2)); Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num1)); Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num2)); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "VerifyChangePhoneNumberTokenAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "VerifyChangePhoneNumberTokenAsync", userId, IdentityErrorDescriber.Default.InvalidToken()); } [Fact] public async Task CanChangeEmail() { var manager = CreateManager(); - var user = CreateTestUser(); - user.Email = user.UserName + "@diddly.bop"; + var user = CreateTestUser("foouser"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var email = await manager.GetUserNameAsync(user) + "@diddly.bop"; + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, email)); Assert.False(await manager.IsEmailConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); - string newEmail = user.UserName + "@en.vec"; + var newEmail = await manager.GetUserNameAsync(user) + "@en.vec"; var token1 = await manager.GenerateChangeEmailTokenAsync(user, newEmail); IdentityResultAssert.IsSuccess(await manager.ChangeEmailAsync(user, newEmail, token1)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ChangeEmailAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "ChangeEmailAsync", await manager.GetUserIdAsync(user)); Assert.True(await manager.IsEmailConfirmedAsync(user)); Assert.Equal(await manager.GetEmailAsync(user), newEmail); - Assert.NotEqual(stamp, user.SecurityStamp); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] public async Task ChangeEmailFailsWithWrongToken() { var manager = CreateManager(); - var user = CreateTestUser(); - user.Email = user.UserName + "@diddly.bop"; - string oldEmail = user.Email; + var user = CreateTestUser("foouser"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var email = await manager.GetUserNameAsync(user) + "@diddly.bop"; + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, email)); + string oldEmail = email; Assert.False(await manager.IsEmailConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); IdentityResultAssert.IsFailure(await manager.ChangeEmailAsync(user, "whatevah@foo.barf", "bogus"), "Invalid token."); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangeEmailAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "ChangeEmailAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.InvalidToken()); Assert.False(await manager.IsEmailConfirmedAsync(user)); Assert.Equal(await manager.GetEmailAsync(user), oldEmail); - Assert.Equal(stamp, user.SecurityStamp); + Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] public async Task ChangeEmailFailsWithEmail() { var manager = CreateManager(); - var user = CreateTestUser(); - user.Email = user.UserName + "@diddly.bop"; - string oldEmail = user.Email; + var user = CreateTestUser("foouser"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var email = await manager.GetUserNameAsync(user) + "@diddly.bop"; + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, email)); + string oldEmail = email; Assert.False(await manager.IsEmailConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); var token1 = await manager.GenerateChangeEmailTokenAsync(user, "forgot@alrea.dy"); @@ -1446,7 +1459,7 @@ namespace Microsoft.AspNet.Identity.Test "Invalid token."); Assert.False(await manager.IsEmailConfirmedAsync(user)); Assert.Equal(await manager.GetEmailAsync(user), oldEmail); - Assert.Equal(stamp, user.SecurityStamp); + Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); } [Fact] @@ -1454,13 +1467,16 @@ namespace Microsoft.AspNet.Identity.Test { var manager = CreateManager(); string factorId = "Email"; //default - var user = CreateTestUser(); - user.Email = user.UserName + "@foo.com"; - user.EmailConfirmed = true; + var user = CreateTestUser("foouser"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - var stamp = user.SecurityStamp; + var email = await manager.GetUserNameAsync(user) + "@diddly.bop"; + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, email)); + var token = await manager.GenerateEmailConfirmationTokenAsync(user); + await manager.ConfirmEmailAsync(user, token); + + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); - var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + token = await manager.GenerateTwoFactorTokenAsync(user, factorId); Assert.NotNull(token); IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); @@ -1472,10 +1488,10 @@ namespace Microsoft.AspNet.Identity.Test var manager = CreateManager(); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); IdentityResultAssert.IsSuccess(await manager.SetTwoFactorEnabledAsync(user, true)); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "SetTwoFactorEnabledAsync", user.Id.ToString()); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "SetTwoFactorEnabledAsync", await manager.GetUserIdAsync(user)); Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); Assert.True(await manager.GetTwoFactorEnabledAsync(user)); } @@ -1511,21 +1527,23 @@ namespace Microsoft.AspNet.Identity.Test var manager = CreateManager(); var user = CreateTestUser(); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var userId = await manager.GetUserIdAsync(user); var factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.False(factors.Any()); IdentityResultAssert.IsSuccess(await manager.SetPhoneNumberAsync(user, "111-111-1111")); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "SetPhoneNumberAsync", user.Id.ToString()); - user.PhoneNumberConfirmed = true; + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "SetPhoneNumberAsync", userId); + var token = await manager.GenerateChangePhoneNumberTokenAsync(user, "111-111-1111"); + IdentityResultAssert.IsSuccess(await manager.ChangePhoneNumberAsync(user, "111-111-1111", token)); await manager.UpdateAsync(user); factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.Equal(1, factors.Count()); Assert.Equal("Phone", factors[0]); IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, "test@test.com")); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "SetEmailAsync", user.Id.ToString()); - user.EmailConfirmed = true; - await manager.UpdateAsync(user); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "SetEmailAsync", userId); + token = await manager.GenerateEmailConfirmationTokenAsync(user); + await manager.ConfirmEmailAsync(user, token); factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.Equal(2, factors.Count()); @@ -1541,10 +1559,9 @@ namespace Microsoft.AspNet.Identity.Test { var manager = CreateManager(); var factorId = "Phone"; // default - var user = CreateTestUser(); - user.PhoneNumber = "4251234567"; + var user = CreateTestUser(phoneNumber: "4251234567"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - var stamp = user.SecurityStamp; + var stamp = await manager.GetSecurityStampAsync(user); Assert.NotNull(stamp); var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); Assert.NotNull(token); @@ -1556,8 +1573,7 @@ namespace Microsoft.AspNet.Identity.Test public async Task VerifyTokenFromWrongTokenProviderFails() { var manager = CreateManager(); - var user = CreateTestUser(); - user.PhoneNumber = "4251234567"; + var user = CreateTestUser(phoneNumber: "4251234567"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var token = await manager.GenerateTwoFactorTokenAsync(user, "Phone"); Assert.NotNull(token); @@ -1568,19 +1584,17 @@ namespace Microsoft.AspNet.Identity.Test public async Task VerifyWithWrongSmsTokenFails() { var manager = CreateManager(); - var user = CreateTestUser(); - user.PhoneNumber = "4251234567"; + var user = CreateTestUser(phoneNumber: "4251234567"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Phone", "bogus")); - IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "VerifyTwoFactorTokenAsync", user.Id.ToString(), IdentityErrorDescriber.Default.InvalidToken()); + IdentityResultAssert.VerifyUserManagerFailureLog(manager.Logger, "VerifyTwoFactorTokenAsync", await manager.GetUserIdAsync(user), IdentityErrorDescriber.Default.InvalidToken()); } [Fact] public async Task NullableDateTimeOperationTest() { var userMgr = CreateManager(); - var user = CreateTestUser(); - user.LockoutEnabled = true; + var user = CreateTestUser(lockoutEnabled: true); IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); Assert.Null(await userMgr.GetLockoutEndDateAsync(user)); @@ -1622,10 +1636,12 @@ namespace Microsoft.AspNet.Identity.Test var manager = CreateManager(context); var roleManager = CreateRoleManager(context); var roles = GenerateRoles("UsersInRole", 4); + var roleNameList = new List(); foreach (var role in roles) { IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role)); + roleNameList.Add(await roleManager.GetRoleNameAsync(role)); } for (int i = 0; i < 6; i++) @@ -1635,14 +1651,14 @@ namespace Microsoft.AspNet.Identity.Test if ((i % 2) == 0) { - IdentityResultAssert.IsSuccess(await manager.AddToRolesAsync(user, roles.Select(x => x.Name).AsEnumerable())); - IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddToRolesAsync", user.Id.ToString()); + IdentityResultAssert.IsSuccess(await manager.AddToRolesAsync(user, roleNameList)); + IdentityResultAssert.VerifyUserManagerSuccessLog(manager.Logger, "AddToRolesAsync", await manager.GetUserIdAsync(user)); } } foreach (var role in roles) { - Assert.Equal(3, (await manager.GetUsersInRoleAsync(role.Name)).Count); + Assert.Equal(3, (await manager.GetUsersInRoleAsync(await roleManager.GetRoleNameAsync(role))).Count); } Assert.Equal(0, (await manager.GetUsersInRoleAsync("123456")).Count); @@ -1663,7 +1679,7 @@ namespace Microsoft.AspNet.Identity.Test var roles = new List(count); for (var i = 0; i < count; i++) { - roles.Add(CreateRole(namePrefix + i)); + roles.Add(CreateTestRole(namePrefix + i)); } return roles; }