diff --git a/src/Microsoft.AspNet.Identity.Entity/IdentityRole.cs b/src/Microsoft.AspNet.Identity.Entity/EntityRole.cs similarity index 85% rename from src/Microsoft.AspNet.Identity.Entity/IdentityRole.cs rename to src/Microsoft.AspNet.Identity.Entity/EntityRole.cs index 343f3b1877..78d170080d 100644 --- a/src/Microsoft.AspNet.Identity.Entity/IdentityRole.cs +++ b/src/Microsoft.AspNet.Identity.Entity/EntityRole.cs @@ -6,12 +6,12 @@ namespace Microsoft.AspNet.Identity.Entity /// /// Represents a Role entity /// - public class IdentityRole : IdentityRole + public class EntityRole : EntityRole { /// /// Constructor /// - public IdentityRole() + public EntityRole() { Id = Guid.NewGuid().ToString(); } @@ -20,7 +20,7 @@ namespace Microsoft.AspNet.Identity.Entity /// Constructor /// /// - public IdentityRole(string roleName) + public EntityRole(string roleName) : this() { Name = roleName; @@ -32,14 +32,14 @@ namespace Microsoft.AspNet.Identity.Entity /// /// /// - public class IdentityRole + public class EntityRole where TUserRole : IdentityUserRole where TKey : IEquatable { /// /// Constructor /// - public IdentityRole() + public EntityRole() { Users = new List(); } @@ -60,3 +60,4 @@ namespace Microsoft.AspNet.Identity.Entity public virtual string Name { get; set; } } } + diff --git a/src/Microsoft.AspNet.Identity.Entity/IdentityUser.cs b/src/Microsoft.AspNet.Identity.Entity/EntityUser.cs similarity index 87% rename from src/Microsoft.AspNet.Identity.Entity/IdentityUser.cs rename to src/Microsoft.AspNet.Identity.Entity/EntityUser.cs index c0c94ef814..62bfced5d4 100644 --- a/src/Microsoft.AspNet.Identity.Entity/IdentityUser.cs +++ b/src/Microsoft.AspNet.Identity.Entity/EntityUser.cs @@ -1,35 +1,34 @@ - -using System; +using System; using System.Collections.Generic; -using System.Collections.ObjectModel; namespace Microsoft.AspNet.Identity.Entity { - public class IdentityUser : IdentityUser + public class EntityUser : EntityUser { - public IdentityUser() + public EntityUser() { Id = Guid.NewGuid().ToString(); } - public IdentityUser(string userName) : this() + public EntityUser(string userName) + : this() { UserName = userName; } } - public class IdentityUser + public class EntityUser where TLogin : IdentityUserLogin where TRole : IdentityUserRole where TClaim : IdentityUserClaim where TKey : IEquatable { - public IdentityUser() + public EntityUser() { Claims = new List(); Roles = new List(); Logins = new List(); - + } public virtual TKey Id { get; set; } @@ -73,7 +72,7 @@ namespace Microsoft.AspNet.Identity.Entity /// /// DateTime in UTC when lockout ends, any time in the past is considered not locked out. /// - public virtual DateTime? LockoutEndDateUtc { get; set; } + public virtual DateTime? LockoutEnd { get; set; } /// /// Is lockout enabled for this user @@ -102,3 +101,4 @@ namespace Microsoft.AspNet.Identity.Entity } } + diff --git a/src/Microsoft.AspNet.Identity.Entity/IdentityContext.cs b/src/Microsoft.AspNet.Identity.Entity/IdentityContext.cs index b6130ff910..ea85f4ab96 100644 --- a/src/Microsoft.AspNet.Identity.Entity/IdentityContext.cs +++ b/src/Microsoft.AspNet.Identity.Entity/IdentityContext.cs @@ -1,21 +1,20 @@ using System; using Microsoft.Data.Entity; using Microsoft.Data.InMemory; -using Microsoft.Data.SqlServer; using Microsoft.Data.Entity.Metadata; namespace Microsoft.AspNet.Identity.Entity { public class IdentityContext : - IdentityContext + IdentityContext { public IdentityContext(EntityConfiguration config) : base(config) { } public IdentityContext() { } } public class IdentityContext : EntityContext - where TUser : IdentityUser - where TRole : IdentityRole /*, TUserRole*/ + where TUser : EntityUser + where TRole : EntityRole /*, TUserRole*/ where TUserLogin : IdentityUserLogin where TUserRole : IdentityUserRole where TUserClaim : IdentityUserClaim @@ -48,13 +47,15 @@ namespace Microsoft.AspNet.Identity.Entity //.ToTable("AspNetRoles"); builder.Entity() - .Key(r => new {r.UserId, r.RoleId}) + .Key(u => u.Id) + //TODO: .Key(r => new { r.UserId, r.RoleId }) .ForeignKeys(fk => fk.ForeignKey(f => f.UserId)) .ForeignKeys(fk => fk.ForeignKey(f => f.RoleId)); //.ToTable("AspNetUserRoles"); builder.Entity() - .Key(l => new {l.LoginProvider, l.ProviderKey, l.UserId}) + .Key(u => u.Id) + //TODO: .Key(l => new { l.LoginProvider, l.ProviderKey, l.UserId }) .ForeignKeys(fk => fk.ForeignKey(f => f.UserId)); //.ToTable("AspNetUserLogins"); diff --git a/src/Microsoft.AspNet.Identity.Entity/Microsoft.AspNet.Identity.Entity.kproj b/src/Microsoft.AspNet.Identity.Entity/Microsoft.AspNet.Identity.Entity.kproj index dd81f6eafc..6910b8ed44 100644 --- a/src/Microsoft.AspNet.Identity.Entity/Microsoft.AspNet.Identity.Entity.kproj +++ b/src/Microsoft.AspNet.Identity.Entity/Microsoft.AspNet.Identity.Entity.kproj @@ -20,12 +20,18 @@ +<<<<<<< HEAD +======= + + + +>>>>>>> POCO diff --git a/src/Microsoft.AspNet.Identity.Entity/RoleStore.cs b/src/Microsoft.AspNet.Identity.Entity/RoleStore.cs index 853fddb1cb..fc8fc5139d 100644 --- a/src/Microsoft.AspNet.Identity.Entity/RoleStore.cs +++ b/src/Microsoft.AspNet.Identity.Entity/RoleStore.cs @@ -9,7 +9,7 @@ namespace Microsoft.AspNet.Identity.Entity { public class RoleStore : IQueryableRoleStore - where TRole : IdentityRole + where TRole : EntityRole where TKey : IEquatable { private bool _disposed; @@ -41,7 +41,8 @@ namespace Microsoft.AspNet.Identity.Entity public virtual Task GetRoleAggregate(Expression> filter, CancellationToken cancellationToken = default(CancellationToken)) { - return Roles.SingleOrDefaultAsync(filter, cancellationToken); + // TODO: return Roles.SingleOrDefaultAsync(filter, cancellationToken); + return Task.FromResult(Roles.SingleOrDefault(filter)); } public async virtual Task CreateAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken)) @@ -82,14 +83,38 @@ namespace Microsoft.AspNet.Identity.Entity public Task GetRoleIdAsync(TRole role, CancellationToken cancellationToken = new CancellationToken()) { + cancellationToken.ThrowIfCancellationRequested(); + ThrowIfDisposed(); + if (role == null) + { + throw new ArgumentNullException("role"); + } return Task.FromResult(role.Id); } public Task GetRoleNameAsync(TRole role, CancellationToken cancellationToken = new CancellationToken()) { + cancellationToken.ThrowIfCancellationRequested(); + ThrowIfDisposed(); + if (role == null) + { + throw new ArgumentNullException("role"); + } return Task.FromResult(role.Name); } + public Task SetRoleNameAsync(TRole role, string roleName, CancellationToken cancellationToken = new CancellationToken()) + { + cancellationToken.ThrowIfCancellationRequested(); + ThrowIfDisposed(); + if (role == null) + { + throw new ArgumentNullException("role"); + } + role.Name = roleName; + return Task.FromResult(0); + } + public virtual TKey ConvertId(string userId) { @@ -97,7 +122,7 @@ namespace Microsoft.AspNet.Identity.Entity } /// - /// FindByLoginAsync a role by id + /// Find a role by id /// /// /// @@ -107,12 +132,11 @@ namespace Microsoft.AspNet.Identity.Entity cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); var roleId = ConvertId(id); - return Roles.SingleOrDefaultAsync(r => r.Id.Equals(roleId), cancellationToken); - //return GetRoleAggregate(u => u.Id.Equals(id)); + return GetRoleAggregate(u => u.Id.Equals(roleId), cancellationToken); } /// - /// FindByLoginAsync a role by name + /// Find a role by name /// /// /// @@ -121,8 +145,7 @@ namespace Microsoft.AspNet.Identity.Entity { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); - return Roles.SingleOrDefaultAsync(r => r.Name.ToUpper() == name.ToUpper(), cancellationToken); - //return GetRoleAggregate(u => u.Name.ToUpper() == name.ToUpper()); + return GetRoleAggregate(u => u.Name.ToUpper() == name.ToUpper(), cancellationToken); } private void ThrowIfDisposed() diff --git a/src/Microsoft.AspNet.Identity.Entity/UserStore.cs b/src/Microsoft.AspNet.Identity.Entity/UserStore.cs index b20e9fbad8..e01693cdc6 100644 --- a/src/Microsoft.AspNet.Identity.Entity/UserStore.cs +++ b/src/Microsoft.AspNet.Identity.Entity/UserStore.cs @@ -11,7 +11,12 @@ using Microsoft.Data.Entity; namespace Microsoft.AspNet.Identity.Entity { public class UserStore : - UserStore + UserStore + { + public UserStore(EntityContext context) : base(context) { } + } + + public class UserStore : UserStore where TUser:EntityUser { public UserStore(EntityContext context) : base(context) { } } @@ -28,8 +33,8 @@ namespace Microsoft.AspNet.Identity.Entity IUserTwoFactorStore, IUserLockoutStore where TKey : IEquatable - where TUser : IdentityUser - where TRole : IdentityRole + where TUser : EntityUser + where TRole : EntityRole where TUserLogin : IdentityUserLogin, new() where TUserRole : IdentityUserRole, new() where TUserClaim : IdentityUserClaim, new() @@ -60,7 +65,8 @@ namespace Microsoft.AspNet.Identity.Entity protected virtual Task GetUserAggregate(Expression> filter, CancellationToken cancellationToken = default(CancellationToken)) { - return Users.SingleOrDefaultAsync(filter, cancellationToken); + return Task.FromResult(Users.SingleOrDefault(filter)); + // TODO: return Users.SingleOrDefaultAsync(filter, cancellationToken); //Include(u => u.Roles) //.Include(u => u.Claims) //.Include(u => u.Logins) @@ -142,7 +148,7 @@ namespace Microsoft.AspNet.Identity.Entity } /// - /// FindByLoginAsync a user by id + /// Find a user by id /// /// /// @@ -152,12 +158,11 @@ namespace Microsoft.AspNet.Identity.Entity cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); var id = ConvertUserId(userId); - return Users.SingleOrDefaultAsync(u => u.Id.Equals(id), cancellationToken); - // TODO: return GetUserAggregate(u => u.Id.Equals(userId), cancellationToken); + return GetUserAggregate(u => u.Id.Equals(id), cancellationToken); } /// - /// FindByLoginAsync a user by name + /// Find a user by name /// /// /// @@ -166,8 +171,7 @@ namespace Microsoft.AspNet.Identity.Entity { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); - return Users.SingleOrDefaultAsync(u => u.UserName.ToUpper() == userName.ToUpper(), cancellationToken); - // TODO: return GetUserAggregate(u => u.UserName.ToUpper() == userName.ToUpper(), cancellationToken); + return GetUserAggregate(u => u.UserName.ToUpper() == userName.ToUpper(), cancellationToken); } public IQueryable Users @@ -205,7 +209,19 @@ namespace Microsoft.AspNet.Identity.Entity { throw new ArgumentNullException("user"); } - throw new NotImplementedException(); + if (login == null) + { + throw new ArgumentNullException("login"); + } + var provider = login.LoginProvider; + var key = login.ProviderKey; + var entry = user.Logins.SingleOrDefault(l => l.LoginProvider == provider && l.ProviderKey == key); + if (entry != null) + { + user.Logins.Remove(entry); + Context.Set().Remove(entry); + } + return Task.FromResult(0); } public virtual Task> GetLoginsAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) @@ -468,8 +484,8 @@ namespace Microsoft.AspNet.Identity.Entity throw new ArgumentNullException("user"); } return - Task.FromResult(user.LockoutEndDateUtc.HasValue - ? new DateTimeOffset(DateTime.SpecifyKind(user.LockoutEndDateUtc.Value, DateTimeKind.Utc)) + Task.FromResult(user.LockoutEnd.HasValue + ? new DateTimeOffset(DateTime.SpecifyKind(user.LockoutEnd.Value, DateTimeKind.Utc)) : new DateTimeOffset()); } @@ -488,7 +504,7 @@ namespace Microsoft.AspNet.Identity.Entity { throw new ArgumentNullException("user"); } - user.LockoutEndDateUtc = lockoutEnd == DateTimeOffset.MinValue ? (DateTime?)null : lockoutEnd.UtcDateTime; + user.LockoutEnd = lockoutEnd == DateTimeOffset.MinValue ? (DateTime?)null : lockoutEnd.UtcDateTime; return Task.FromResult(0); } @@ -705,7 +721,17 @@ namespace Microsoft.AspNet.Identity.Entity //{ // throw new ArgumentException(IdentityResources.ValueCannotBeNullOrEmpty, "roleName"); //} - throw new NotImplementedException(); + var roleEntity = Context.Set().SingleOrDefault(r => r.Name.ToUpper() == roleName.ToUpper()); + if (roleEntity != null) + { + var userRole = user.Roles.FirstOrDefault(r => roleEntity.Id.Equals(r.RoleId)); + if (userRole != null) + { + user.Roles.Remove(userRole); + roleEntity.Users.Remove(userRole); + } + } + return Task.FromResult(0); } /// @@ -722,7 +748,11 @@ namespace Microsoft.AspNet.Identity.Entity { throw new ArgumentNullException("user"); } - throw new NotImplementedException(); + var query = from userRoles in user.Roles + join roles in Context.Set() + on userRoles.RoleId equals roles.Id + select roles.Name; + return Task.FromResult>(query.ToList()); } /// @@ -744,7 +774,11 @@ namespace Microsoft.AspNet.Identity.Entity //{ // throw new ArgumentException(IdentityResources.ValueCannotBeNullOrEmpty, "roleName"); //} - throw new NotImplementedException(); + var any = + Context.Set().Where(r => r.Name.ToUpper() == roleName.ToUpper()) + .Where(r => r.Users.Any(ur => ur.UserId.Equals(user.Id))) + .Count() > 0; + return Task.FromResult(any); } /// diff --git a/src/Microsoft.AspNet.Identity.Entity/project.json b/src/Microsoft.AspNet.Identity.Entity/project.json index 709a3031c5..ee99bd301e 100644 --- a/src/Microsoft.AspNet.Identity.Entity/project.json +++ b/src/Microsoft.AspNet.Identity.Entity/project.json @@ -7,7 +7,6 @@ "Microsoft.AspNet.Logging": "0.1-alpha-*", "Microsoft.Data.Entity": "0.1-alpha-*", "Microsoft.Data.Relational": "0.1-alpha-*", - "Microsoft.Data.SqlServer": "0.1-pre-*", "Microsoft.Data.InMemory": "0.1-alpha-*", "System.Security.Claims" : "0.1-alpha-*" }, diff --git a/src/Microsoft.AspNet.Identity.InMemory/InMemoryRole.cs b/src/Microsoft.AspNet.Identity.InMemory/InMemoryRole.cs deleted file mode 100644 index 524df35610..0000000000 --- a/src/Microsoft.AspNet.Identity.InMemory/InMemoryRole.cs +++ /dev/null @@ -1,16 +0,0 @@ -using System; - -namespace Microsoft.AspNet.Identity.InMemory -{ - public class InMemoryRole - { - public InMemoryRole(string roleName) - { - Id = Guid.NewGuid().ToString(); - Name = roleName; - } - - public virtual string Id { get; set; } - public virtual string Name { get; set; } - } -} \ No newline at end of file diff --git a/src/Microsoft.AspNet.Identity.InMemory/InMemoryRoleStore.cs b/src/Microsoft.AspNet.Identity.InMemory/InMemoryRoleStore.cs index 65745ca9bb..60e1b36566 100644 --- a/src/Microsoft.AspNet.Identity.InMemory/InMemoryRoleStore.cs +++ b/src/Microsoft.AspNet.Identity.InMemory/InMemoryRoleStore.cs @@ -6,7 +6,7 @@ using System.Threading.Tasks; namespace Microsoft.AspNet.Identity.InMemory { - public class InMemoryRoleStore : IQueryableRoleStore where TRole : InMemoryRole + public class InMemoryRoleStore : IQueryableRoleStore where TRole : IdentityRole { private readonly Dictionary _roles = new Dictionary(); @@ -37,6 +37,12 @@ namespace Microsoft.AspNet.Identity.InMemory return Task.FromResult(role.Name); } + public Task SetRoleNameAsync(TRole role, string roleName, CancellationToken cancellationToken = new CancellationToken()) + { + role.Name = roleName; + return Task.FromResult(0); + } + public Task UpdateAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken)) { _roles[role.Id] = role; diff --git a/src/Microsoft.AspNet.Identity.InMemory/InMemoryUserStore.cs b/src/Microsoft.AspNet.Identity.InMemory/InMemoryUserStore.cs index a3914ab559..9ea7b6e5e9 100644 --- a/src/Microsoft.AspNet.Identity.InMemory/InMemoryUserStore.cs +++ b/src/Microsoft.AspNet.Identity.InMemory/InMemoryUserStore.cs @@ -18,7 +18,7 @@ namespace Microsoft.AspNet.Identity.InMemory IUserPhoneNumberStore, IQueryableUserStore, IUserTwoFactorStore - where TUser : InMemoryUser + where TUser : IdentityUser { private readonly Dictionary _logins = new Dictionary(new LoginComparer()); @@ -32,18 +32,25 @@ namespace Microsoft.AspNet.Identity.InMemory public Task> GetClaimsAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { - return Task.FromResult(user.Claims); + var claims = user.Claims.Select(c => new Claim(c.ClaimType, c.ClaimValue)).ToList(); + return Task.FromResult>(claims); } public Task AddClaimAsync(TUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken)) { - user.Claims.Add(claim); + user.Claims.Add(new IdentityUserClaim { ClaimType = claim.Type, ClaimValue = claim.Value, UserId = user.Id }); return Task.FromResult(0); } public Task RemoveClaimAsync(TUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken)) { - user.Claims.Remove(claim); + var entity = + user.Claims.FirstOrDefault( + uc => uc.UserId == user.Id && uc.ClaimType == claim.Type && uc.ClaimValue == claim.Value); + if (entity != null) + { + user.Claims.Remove(entity); + } return Task.FromResult(0); } @@ -117,27 +124,35 @@ namespace Microsoft.AspNet.Identity.InMemory public Task AddLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) { - user.Logins.Add(login); + user.Logins.Add(new IdentityUserLogin + { + UserId = user.Id, + LoginProvider = login.LoginProvider, + ProviderKey = login.ProviderKey + }); _logins[login] = user; return Task.FromResult(0); } public Task RemoveLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) { - var logs = - user.Logins.Where(l => l.ProviderKey == login.ProviderKey && l.LoginProvider == login.LoginProvider) - .ToList(); - foreach (var l in logs) + var loginEntity = + user.Logins.SingleOrDefault( + l => + l.ProviderKey == login.ProviderKey && l.LoginProvider == login.LoginProvider && + l.UserId == user.Id); + if (loginEntity != null) { - user.Logins.Remove(l); - _logins[l] = null; + user.Logins.Remove(loginEntity); } + _logins[login] = null; return Task.FromResult(0); } public Task> GetLoginsAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { - return Task.FromResult(user.Logins); + var logins = user.Logins.Select(l => new UserLoginInfo(l.LoginProvider, l.ProviderKey)).ToList(); + return Task.FromResult>(logins); } public Task FindByLoginAsync(UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) @@ -245,26 +260,32 @@ namespace Microsoft.AspNet.Identity.InMemory return Task.FromResult(0); } + // RoleId == roleName for InMemory public Task AddToRoleAsync(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken)) { - user.Roles.Add(role); + user.Roles.Add(new IdentityUserRole { RoleId = role, UserId = user.Id }); return Task.FromResult(0); } + // RoleId == roleName for InMemory public Task RemoveFromRoleAsync(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken)) { - user.Roles.Remove(role); + var roleEntity = user.Roles.SingleOrDefault(ur => ur.RoleId == role); + if (roleEntity != null) + { + user.Roles.Remove(roleEntity); + } return Task.FromResult(0); } public Task> GetRolesAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { - return Task.FromResult(user.Roles); + return Task.FromResult>(user.Roles.Select(ur => ur.RoleId).ToList()); } public Task IsInRoleAsync(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken)) { - return Task.FromResult(user.Roles.Contains(role)); + return Task.FromResult(user.Roles.Any(ur => ur.RoleId == role)); } public Task SetSecurityStampAsync(TUser user, string stamp, CancellationToken cancellationToken = default(CancellationToken)) diff --git a/src/Microsoft.AspNet.Identity.InMemory/Microsoft.AspNet.Identity.InMemory.kproj b/src/Microsoft.AspNet.Identity.InMemory/Microsoft.AspNet.Identity.InMemory.kproj index fcd0ed2ffb..f4f1b108f4 100644 --- a/src/Microsoft.AspNet.Identity.InMemory/Microsoft.AspNet.Identity.InMemory.kproj +++ b/src/Microsoft.AspNet.Identity.InMemory/Microsoft.AspNet.Identity.InMemory.kproj @@ -20,9 +20,7 @@ - - diff --git a/src/Microsoft.AspNet.Identity.Security/SignInManager.cs b/src/Microsoft.AspNet.Identity.Security/SignInManager.cs index fac5469cc9..2cd1d9fadb 100644 --- a/src/Microsoft.AspNet.Identity.Security/SignInManager.cs +++ b/src/Microsoft.AspNet.Identity.Security/SignInManager.cs @@ -1,9 +1,7 @@ -using System; -using System.Collections.Generic; +using Microsoft.AspNet.Abstractions; +using Microsoft.AspNet.Abstractions.Security; using System.Security.Claims; using System.Threading.Tasks; -using Microsoft.AspNet.Abstractions; -using Microsoft.AspNet.Abstractions.Security; namespace Microsoft.AspNet.Identity.Security { @@ -26,10 +24,10 @@ namespace Microsoft.AspNet.Identity.Security { return null; } - return await UserManager.CreateIdentity(user, AuthenticationType); + return await UserManager.CreateIdentityAsync(user, AuthenticationType); } - public virtual async Task SignIn(TUser user, bool isPersistent, bool rememberBrowser) + public virtual async Task SignInAsync(TUser user, bool isPersistent, bool rememberBrowser) { if (Context == null) { @@ -143,7 +141,7 @@ namespace Microsoft.AspNet.Identity.Security } if (await UserManager.CheckPasswordAsync(user, password)) { - await SignIn(user, isPersistent, false); + await SignInAsync(user, isPersistent, false); return SignInStatus.Success; //TODO: return await SignInOrTwoFactor(user, isPersistent); } diff --git a/src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs b/src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs index 5181f879dc..a8d37d6bd3 100644 --- a/src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs +++ b/src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs @@ -1,5 +1,4 @@ using System; -using System.Globalization; using System.Security.Claims; using System.Threading; using System.Threading.Tasks; diff --git a/src/Microsoft.AspNet.Identity/IClaimsIdentityFactory.cs b/src/Microsoft.AspNet.Identity/IClaimsIdentityFactory.cs index 9dd3c6b0cd..d286ef6105 100644 --- a/src/Microsoft.AspNet.Identity/IClaimsIdentityFactory.cs +++ b/src/Microsoft.AspNet.Identity/IClaimsIdentityFactory.cs @@ -6,14 +6,14 @@ using System.Threading.Tasks; namespace Microsoft.AspNet.Identity { /// - /// Interface for creating a ClaimsIdentity from an IUser + /// Interface for creating a ClaimsIdentity from an user /// /// public interface IClaimsIdentityFactory where TUser : class { /// - /// CreateAsync a ClaimsIdentity from an user using a UserManager + /// Create a ClaimsIdentity from an user using a UserManager /// /// /// diff --git a/src/Microsoft.AspNet.Identity/IPasswordValidator.cs b/src/Microsoft.AspNet.Identity/IPasswordValidator.cs index 21bff33261..f3e5d29f7c 100644 --- a/src/Microsoft.AspNet.Identity/IPasswordValidator.cs +++ b/src/Microsoft.AspNet.Identity/IPasswordValidator.cs @@ -9,7 +9,7 @@ namespace Microsoft.AspNet.Identity public interface IPasswordValidator { /// - /// ValidateAsync the item + /// Validate the item /// /// Task ValidateAsync(string password, CancellationToken cancellationToken = default(CancellationToken)); diff --git a/src/Microsoft.AspNet.Identity/IQueryableRoleStore.cs b/src/Microsoft.AspNet.Identity/IQueryableRoleStore.cs index 3c49d04c32..c8e6f4e79c 100644 --- a/src/Microsoft.AspNet.Identity/IQueryableRoleStore.cs +++ b/src/Microsoft.AspNet.Identity/IQueryableRoleStore.cs @@ -9,7 +9,7 @@ namespace Microsoft.AspNet.Identity public interface IQueryableRoleStore : IRoleStore where TRole : class { /// - /// IQueryable users + /// IQueryable roles /// IQueryable Roles { get; } } diff --git a/src/Microsoft.AspNet.Identity/IQueryableUserStore.cs b/src/Microsoft.AspNet.Identity/IQueryableUserStore.cs index 43af7e86f9..dbd592ea68 100644 --- a/src/Microsoft.AspNet.Identity/IQueryableUserStore.cs +++ b/src/Microsoft.AspNet.Identity/IQueryableUserStore.cs @@ -6,7 +6,6 @@ namespace Microsoft.AspNet.Identity /// Interface that exposes an IQueryable users /// /// - /// public interface IQueryableUserStore : IUserStore where TUser : class { /// diff --git a/src/Microsoft.AspNet.Identity/IRoleStore.cs b/src/Microsoft.AspNet.Identity/IRoleStore.cs index 91449f0c05..4c3cff2984 100644 --- a/src/Microsoft.AspNet.Identity/IRoleStore.cs +++ b/src/Microsoft.AspNet.Identity/IRoleStore.cs @@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity Task CreateAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken)); /// - /// UpdateAsync a role + /// Update a role /// /// /// @@ -50,6 +50,15 @@ namespace Microsoft.AspNet.Identity /// Task GetRoleNameAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken)); + /// + /// Set a role's name + /// + /// + /// + /// + /// + Task SetRoleNameAsync(TRole role, string roleName, CancellationToken cancellationToken = default(CancellationToken)); + /// /// Finds a role by id /// @@ -59,7 +68,7 @@ namespace Microsoft.AspNet.Identity Task FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken)); /// - /// FindByLoginAsync a role by name + /// Find a role by name /// /// /// diff --git a/src/Microsoft.AspNet.Identity/IdentityRole.cs b/src/Microsoft.AspNet.Identity/IdentityRole.cs new file mode 100644 index 0000000000..0800bc2643 --- /dev/null +++ b/src/Microsoft.AspNet.Identity/IdentityRole.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; + +namespace Microsoft.AspNet.Identity +{ + /// + /// Represents a Role entity + /// + public class IdentityRole : IdentityRole + { + /// + /// Constructor + /// + public IdentityRole() + { + Id = Guid.NewGuid().ToString(); + } + + /// + /// Constructor + /// + /// + public IdentityRole(string roleName) + : this() + { + Name = roleName; + } + } + + /// + /// Represents a Role entity + /// + /// + public class IdentityRole where TKey : IEquatable + { + /// + /// Constructor + /// + public IdentityRole() + { + Users = new List>(); + } + + /// + /// Navigation property for users in the role + /// + public virtual ICollection> Users { get; private set; } + + /// + /// Role id + /// + public virtual TKey Id { get; set; } + + /// + /// Role name + /// + public virtual string Name { get; set; } + } +} diff --git a/src/Microsoft.AspNet.Identity.InMemory/InMemoryUser.cs b/src/Microsoft.AspNet.Identity/IdentityUser.cs similarity index 63% rename from src/Microsoft.AspNet.Identity.InMemory/InMemoryUser.cs rename to src/Microsoft.AspNet.Identity/IdentityUser.cs index 9d9cd8b3cd..f42c6e6f2f 100644 --- a/src/Microsoft.AspNet.Identity.InMemory/InMemoryUser.cs +++ b/src/Microsoft.AspNet.Identity/IdentityUser.cs @@ -1,27 +1,33 @@ -using System; +using System; using System.Collections.Generic; -using System.Security.Claims; -namespace Microsoft.AspNet.Identity.InMemory +namespace Microsoft.AspNet.Identity { - public class InMemoryUser + public class IdentityUser : IdentityUser { - private readonly IList _claims; - private readonly IList _logins; - private readonly IList _roles; - - public InMemoryUser() + public IdentityUser() { Id = Guid.NewGuid().ToString(); - _logins = new List(); - _claims = new List(); - _roles = new List(); } - public InMemoryUser(string name) : this() + public IdentityUser(string userName) : this() { - UserName = name; + UserName = userName; } + } + + public class IdentityUser + where TKey : IEquatable + { + public IdentityUser() + { + Claims = new List>(); + Roles = new List>(); + Logins = new List>(); + } + + public virtual TKey Id { get; set; } + public virtual string UserName { get; set; } /// /// Email @@ -73,22 +79,20 @@ namespace Microsoft.AspNet.Identity.InMemory /// public virtual int AccessFailedCount { get; set; } - public IList Logins - { - get { return _logins; } - } + /// + /// Roles for the user + /// + public virtual ICollection> Roles { get; private set; } - public IList Claims - { - get { return _claims; } - } + /// + /// Claims for the user + /// + public virtual ICollection> Claims { get; private set; } - public IList Roles - { - get { return _roles; } - } + /// + /// Associated logins for the user + /// + public virtual ICollection> Logins { get; private set; } - public virtual string Id { get; set; } - public virtual string UserName { get; set; } } -} \ No newline at end of file +} diff --git a/src/Microsoft.AspNet.Identity.Entity/IdentityUserClaim.cs b/src/Microsoft.AspNet.Identity/IdentityUserClaim.cs similarity index 95% rename from src/Microsoft.AspNet.Identity.Entity/IdentityUserClaim.cs rename to src/Microsoft.AspNet.Identity/IdentityUserClaim.cs index 6f79fe9dbf..d769acc1bc 100644 --- a/src/Microsoft.AspNet.Identity.Entity/IdentityUserClaim.cs +++ b/src/Microsoft.AspNet.Identity/IdentityUserClaim.cs @@ -1,6 +1,6 @@ using System; -namespace Microsoft.AspNet.Identity.Entity +namespace Microsoft.AspNet.Identity { public class IdentityUserClaim : IdentityUserClaim { } diff --git a/src/Microsoft.AspNet.Identity.Entity/IdentityUserLogin.cs b/src/Microsoft.AspNet.Identity/IdentityUserLogin.cs similarity index 84% rename from src/Microsoft.AspNet.Identity.Entity/IdentityUserLogin.cs rename to src/Microsoft.AspNet.Identity/IdentityUserLogin.cs index 27b46988ad..2b42648f04 100644 --- a/src/Microsoft.AspNet.Identity.Entity/IdentityUserLogin.cs +++ b/src/Microsoft.AspNet.Identity/IdentityUserLogin.cs @@ -1,6 +1,6 @@ using System; -namespace Microsoft.AspNet.Identity.Entity +namespace Microsoft.AspNet.Identity { public class IdentityUserLogin : IdentityUserLogin { } @@ -10,6 +10,13 @@ namespace Microsoft.AspNet.Identity.Entity /// public class IdentityUserLogin where TKey : IEquatable { + // TODO: Remove + public virtual string Id + { + get; + set; + } + /// /// The login provider for the login (i.e. facebook, google) /// diff --git a/src/Microsoft.AspNet.Identity.Entity/IdentityUserRole.cs b/src/Microsoft.AspNet.Identity/IdentityUserRole.cs similarity index 80% rename from src/Microsoft.AspNet.Identity.Entity/IdentityUserRole.cs rename to src/Microsoft.AspNet.Identity/IdentityUserRole.cs index c7f5da5d15..ae2f0d1a4b 100644 --- a/src/Microsoft.AspNet.Identity.Entity/IdentityUserRole.cs +++ b/src/Microsoft.AspNet.Identity/IdentityUserRole.cs @@ -1,6 +1,6 @@ using System; -namespace Microsoft.AspNet.Identity.Entity +namespace Microsoft.AspNet.Identity { public class IdentityUserRole : IdentityUserRole { } @@ -10,6 +10,13 @@ namespace Microsoft.AspNet.Identity.Entity /// public class IdentityUserRole where TKey : IEquatable { + // TODO: Remove + public virtual string Id + { + get; + set; + } + /// /// UserId for the user that is in the role /// diff --git a/src/Microsoft.AspNet.Identity/RoleManager.cs b/src/Microsoft.AspNet.Identity/RoleManager.cs index 0a9b00cfa2..7746bcb124 100644 --- a/src/Microsoft.AspNet.Identity/RoleManager.cs +++ b/src/Microsoft.AspNet.Identity/RoleManager.cs @@ -157,7 +157,7 @@ namespace Microsoft.AspNet.Identity throw new ArgumentNullException("roleName"); } - return await FindByName(roleName, cancellationToken) != null; + return await FindByNameAsync(roleName, cancellationToken) != null; } /// @@ -184,13 +184,27 @@ namespace Microsoft.AspNet.Identity return await Store.GetRoleNameAsync(role, cancellationToken); } + /// + /// Set the name of the role + /// + /// + /// + /// + /// + public virtual async Task SetRoleNameAsync(TRole role, string name, CancellationToken cancellationToken = default(CancellationToken)) + { + ThrowIfDisposed(); + await Store.SetRoleNameAsync(role, name, cancellationToken); + return IdentityResult.Success; + } + /// /// Return the role id for a role /// /// /// /// - public virtual async Task GetRoleId(TRole role, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task GetRoleIdAsync(TRole role, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); return await Store.GetRoleIdAsync(role, cancellationToken); @@ -202,7 +216,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task FindByName(string roleName, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task FindByNameAsync(string roleName, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (roleName == null) diff --git a/src/Microsoft.AspNet.Identity/RoleValidator.cs b/src/Microsoft.AspNet.Identity/RoleValidator.cs index afb547b0eb..89896d551e 100644 --- a/src/Microsoft.AspNet.Identity/RoleValidator.cs +++ b/src/Microsoft.AspNet.Identity/RoleValidator.cs @@ -48,8 +48,8 @@ namespace Microsoft.AspNet.Identity } else { - var owner = await manager.FindByName(roleName); - if (owner != null && !string.Equals(await manager.GetRoleId(owner), await manager.GetRoleId(role))) + var owner = await manager.FindByNameAsync(roleName); + if (owner != null && !string.Equals(await manager.GetRoleIdAsync(owner), await manager.GetRoleIdAsync(role))) { errors.Add(String.Format(CultureInfo.CurrentCulture, Resources.DuplicateName, roleName)); } diff --git a/src/Microsoft.AspNet.Identity/UserManager.cs b/src/Microsoft.AspNet.Identity/UserManager.cs index 3b005bf6c1..c5cf9da653 100644 --- a/src/Microsoft.AspNet.Identity/UserManager.cs +++ b/src/Microsoft.AspNet.Identity/UserManager.cs @@ -311,7 +311,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual Task CreateIdentity(TUser user, string authenticationType, CancellationToken cancellationToken = default(CancellationToken)) + public virtual Task CreateIdentityAsync(TUser user, string authenticationType, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (user == null) @@ -329,7 +329,7 @@ namespace Microsoft.AspNet.Identity } /// - /// CreateAsync a user with no password + /// Create a user with no password /// /// /// @@ -352,7 +352,7 @@ namespace Microsoft.AspNet.Identity } /// - /// UpdateAsync a user + /// Update a user /// /// /// @@ -374,7 +374,7 @@ namespace Microsoft.AspNet.Identity } /// - /// DeleteAsync a user + /// Delete a user /// /// /// @@ -391,7 +391,7 @@ namespace Microsoft.AspNet.Identity } /// - /// FindByLoginAsync a user by id + /// Find a user by id /// /// /// @@ -403,7 +403,7 @@ namespace Microsoft.AspNet.Identity } /// - /// FindByLoginAsync a user by name + /// Find a user by name /// /// /// @@ -430,10 +430,11 @@ namespace Microsoft.AspNet.Identity } /// - /// CreateAsync a user and associates it with the given password (if one is provided) + /// Create a user and associates it with the given password /// /// /// + /// /// public virtual async Task CreateAsync(TUser user, string password, CancellationToken cancellationToken = default(CancellationToken)) { @@ -478,7 +479,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task SetUserName(TUser user, string userName, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task SetUserNameAsync(TUser user, string userName, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (user == null) @@ -508,7 +509,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task FindByUserNamePassword(string userName, string password, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task FindByUserNamePasswordAsync(string userName, string password, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var user = await FindByNameAsync(userName, cancellationToken); @@ -699,7 +700,7 @@ namespace Microsoft.AspNet.Identity public virtual async Task UpdateSecurityStampAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); - var securityStore = GetSecurityStore(); + GetSecurityStore(); if (user == null) { throw new ArgumentNullException("user"); @@ -791,7 +792,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task RemoveLogin(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task RemoveLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var loginStore = GetLoginStore(); @@ -811,11 +812,11 @@ namespace Microsoft.AspNet.Identity /// /// Associate a login with a user /// - /// + /// /// /// /// - public virtual async Task AddLogin(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task AddLoginAsync(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var loginStore = GetLoginStore(); @@ -842,7 +843,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task> GetLogins(TUser user, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task> GetLoginsAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var loginStore = GetLoginStore(); @@ -1030,6 +1031,7 @@ namespace Microsoft.AspNet.Identity /// Get a user's email /// /// + /// /// public virtual async Task GetEmailAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { @@ -1047,6 +1049,7 @@ namespace Microsoft.AspNet.Identity /// /// /// + /// /// public virtual async Task SetEmailAsync(TUser user, string email, CancellationToken cancellationToken = default(CancellationToken)) { @@ -1066,6 +1069,7 @@ namespace Microsoft.AspNet.Identity /// FindByLoginAsync a user by his email /// /// + /// /// public virtual Task FindByEmailAsync(string email, CancellationToken cancellationToken = default(CancellationToken)) { @@ -1237,7 +1241,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task GenerateChangePhoneNumberToken(TUser user, string phoneNumber) + public virtual async Task GenerateChangePhoneNumberTokenAsync(TUser user, string phoneNumber) { ThrowIfDisposed(); return @@ -1336,7 +1340,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task> GetValidTwoFactorProviders(TUser user, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task> GetValidTwoFactorProvidersAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (user == null) @@ -1443,7 +1447,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task GetTwoFactorEnabled(TUser user, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task GetTwoFactorEnabledAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var store = GetUserTwoFactorStore(); @@ -1477,14 +1481,14 @@ namespace Microsoft.AspNet.Identity // SMS/Email methods /// - /// SendAsync an email to the user + /// Send an email to the user /// /// /// /// /// /// - public virtual async Task SendEmail(TUser user, string subject, string body, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task SendEmailAsync(TUser user, string subject, string body, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (user == null) @@ -1504,13 +1508,13 @@ namespace Microsoft.AspNet.Identity } /// - /// SendAsync a user a sms message + /// Send a user a sms message /// /// /// /// /// - public virtual async Task SendSms(TUser user, string message, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task SendSmsAsync(TUser user, string message, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (user == null) @@ -1566,6 +1570,7 @@ namespace Microsoft.AspNet.Identity /// /// /// + /// /// public virtual async Task SetLockoutEnabledAsync(TUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken)) { @@ -1583,6 +1588,7 @@ namespace Microsoft.AspNet.Identity /// Returns whether the user allows lockout /// /// + /// /// public virtual async Task GetLockoutEnabledAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { @@ -1601,7 +1607,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task GetLockoutEndDate(TUser user, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task GetLockoutEndDateAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var store = GetUserLockoutStore(); @@ -1609,7 +1615,7 @@ namespace Microsoft.AspNet.Identity { throw new ArgumentNullException("user"); } - return await store.GetLockoutEndDateAsync(user); + return await store.GetLockoutEndDateAsync(user, cancellationToken); } /// @@ -1619,7 +1625,7 @@ namespace Microsoft.AspNet.Identity /// /// /// - public virtual async Task SetLockoutEndDate(TUser user, DateTimeOffset lockoutEnd, CancellationToken cancellationToken = default(CancellationToken)) + public virtual async Task SetLockoutEndDateAsync(TUser user, DateTimeOffset lockoutEnd, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); var store = GetUserLockoutStore(); @@ -1685,6 +1691,7 @@ namespace Microsoft.AspNet.Identity /// Returns the number of failed access attempts for the user /// /// + /// /// public virtual async Task GetAccessFailedCountAsync(TUser user, CancellationToken cancellationToken = default(CancellationToken)) { diff --git a/test/Microsoft.AspNet.Identity.Entity.Test/Microsoft.AspNet.Identity.Entity.Test.kproj b/test/Microsoft.AspNet.Identity.Entity.Test/Microsoft.AspNet.Identity.Entity.Test.kproj index 51db503c41..70eaf7fdb2 100644 --- a/test/Microsoft.AspNet.Identity.Entity.Test/Microsoft.AspNet.Identity.Entity.Test.kproj +++ b/test/Microsoft.AspNet.Identity.Entity.Test/Microsoft.AspNet.Identity.Entity.Test.kproj @@ -22,6 +22,8 @@ + + diff --git a/test/Microsoft.AspNet.Identity.Entity.Test/RoleStoreTest.cs b/test/Microsoft.AspNet.Identity.Entity.Test/RoleStoreTest.cs new file mode 100644 index 0000000000..cc6ad0130e --- /dev/null +++ b/test/Microsoft.AspNet.Identity.Entity.Test/RoleStoreTest.cs @@ -0,0 +1,63 @@ +using System; +using System.Threading.Tasks; +using Xunit; + +namespace Microsoft.AspNet.Identity.Entity.Test +{ + public class RoleStoreTest + { + [Fact] + public async Task RoleStoreMethodsThrowWhenDisposedTest() + { + var store = new RoleStore(new IdentityContext()); + store.Dispose(); + await Assert.ThrowsAsync(async () => await store.FindByIdAsync(null)); + await Assert.ThrowsAsync(async () => await store.FindByNameAsync(null)); + await Assert.ThrowsAsync(async () => await store.GetRoleIdAsync(null)); + await Assert.ThrowsAsync(async () => await store.GetRoleNameAsync(null)); + await Assert.ThrowsAsync(async () => await store.SetRoleNameAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.CreateAsync(null)); + await Assert.ThrowsAsync(async () => await store.UpdateAsync(null)); + await Assert.ThrowsAsync(async () => await store.DeleteAsync(null)); + } + + [Fact] + public async Task RoleStorePublicNullCheckTest() + { + Assert.Throws("context", () => new RoleStore(null)); + var store = new RoleStore(new IdentityContext()); + await Assert.ThrowsAsync("role", async () => await store.GetRoleIdAsync(null)); + await Assert.ThrowsAsync("role", async () => await store.GetRoleNameAsync(null)); + await Assert.ThrowsAsync("role", async () => await store.SetRoleNameAsync(null, null)); + await Assert.ThrowsAsync("role", async () => await store.CreateAsync(null)); + await Assert.ThrowsAsync("role", async () => await store.UpdateAsync(null)); + await Assert.ThrowsAsync("role", async () => await store.DeleteAsync(null)); + } + + [Fact] + public async Task CanUpdateRoleName() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("UpdateRoleName"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.Null(await manager.FindByNameAsync("New")); + role.Name = "New"; + IdentityResultAssert.IsSuccess(await manager.UpdateAsync(role)); + Assert.NotNull(await manager.FindByNameAsync("New")); + Assert.Null(await manager.FindByNameAsync("UpdateAsync")); + } + + [Fact] + public async Task CanSetUserName() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("UpdateRoleName"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.Null(await manager.FindByNameAsync("New")); + IdentityResultAssert.IsSuccess(await manager.SetRoleNameAsync(role, "New")); + Assert.NotNull(await manager.FindByNameAsync("New")); + Assert.Null(await manager.FindByNameAsync("UpdateAsync")); + } + + } +} diff --git a/test/Microsoft.AspNet.Identity.Entity.Test/TestIdentityFactory.cs b/test/Microsoft.AspNet.Identity.Entity.Test/TestIdentityFactory.cs new file mode 100644 index 0000000000..d2a71d764d --- /dev/null +++ b/test/Microsoft.AspNet.Identity.Entity.Test/TestIdentityFactory.cs @@ -0,0 +1,101 @@ +using Microsoft.AspNet.Testing; +using Microsoft.Data.Entity; +using Microsoft.Data.Entity.Metadata; +using Microsoft.Data.Entity.Storage; +using Microsoft.Data.InMemory; +using System; +using System.Linq; +using System.Security.Claims; +using System.Threading; +using System.Threading.Tasks; +using Xunit; + +namespace Microsoft.AspNet.Identity.Entity.Test +{ + public static class TestIdentityFactory + { + public static EntityContext CreateContext() + { + var configuration = new EntityConfigurationBuilder() + //.UseModel(model) + .UseDataStore(new InMemoryDataStore()) + .BuildConfiguration(); + + var db = new IdentityContext(configuration); + // var sql = db.Configuration.DataStore as SqlServerDataStore; + // if (sql != null) + // { + //#if NET45 + // var builder = new DbConnectionStringBuilder {ConnectionString = sql.ConnectionString}; + // var targetDatabase = builder["Database"].ToString(); + + // // Connect to master, check if database exists, and create if not + // builder.Add("Database", "master"); + // using (var masterConnection = new SqlConnection(builder.ConnectionString)) + // { + // masterConnection.Open(); + + // var masterCommand = masterConnection.CreateCommand(); + // masterCommand.CommandText = "SELECT COUNT(*) FROM sys.databases WHERE [name]=N'" + targetDatabase + + // "'"; + // if ((int?) masterCommand.ExecuteScalar() < 1) + // { + // masterCommand.CommandText = "CREATE DATABASE [" + targetDatabase + "]"; + // masterCommand.ExecuteNonQuery(); + + // using (var conn = new SqlConnection(sql.ConnectionString)) + // { + // conn.Open(); + // var command = conn.CreateCommand(); + // command.CommandText = @" + //CREATE TABLE [dbo].[AspNetUsers] ( + //[Id] NVARCHAR (128) NOT NULL, + //[Email] NVARCHAR (256) NULL, + //[EmailConfirmed] BIT NOT NULL, + //[PasswordHash] NVARCHAR (MAX) NULL, + //[SecurityStamp] NVARCHAR (MAX) NULL, + //[PhoneNumber] NVARCHAR (MAX) NULL, + //[PhoneNumberConfirmed] BIT NOT NULL, + //[TwoFactorEnabled] BIT NOT NULL, + //[LockoutEndDateUtc] DATETIME NULL, + //[LockoutEnabled] BIT NOT NULL, + //[AccessFailedCount] INT NOT NULL, + //[UserName] NVARCHAR (256) NOT NULL + //) "; + // //CONSTRAINT [PK_dbo.AspNetUsers] PRIMARY KEY CLUSTERED ([Id] ASC) + // command.ExecuteNonQuery(); + // } + // } + // } + //#else + // throw new NotSupportedException("SQL Server is not yet supported when running against K10."); + //#endif + //} + + + // TODO: CreateAsync DB? + return db; + } + + + public static UserManager CreateManager(EntityContext context) + { + return new UserManager(new UserStore(context)); + } + + public static UserManager CreateManager() + { + return CreateManager(CreateContext()); + } + + public static RoleManager CreateRoleManager(EntityContext context) + { + return new RoleManager(new RoleStore(context)); + } + + public static RoleManager CreateRoleManager() + { + return CreateRoleManager(CreateContext()); + } + } +} diff --git a/test/Microsoft.AspNet.Identity.Entity.Test/UserStoreTest.cs b/test/Microsoft.AspNet.Identity.Entity.Test/UserStoreTest.cs index d921752c1a..aa1eb7e0fe 100644 --- a/test/Microsoft.AspNet.Identity.Entity.Test/UserStoreTest.cs +++ b/test/Microsoft.AspNet.Identity.Entity.Test/UserStoreTest.cs @@ -1,1624 +1,1630 @@ -//using Microsoft.AspNet.DependencyInjection.Fallback; -//using Microsoft.AspNet.Testing; -//using Microsoft.Data.Entity; -//using Microsoft.Data.Entity.Metadata; -//using Microsoft.Data.Entity.Storage; -//using Microsoft.Data.InMemory; -//using System; -//using System.Linq; -//using System.Security.Claims; -//using System.Threading; -//using System.Threading.Tasks; -//using Xunit; - -//namespace Microsoft.AspNet.Identity.Entity.Test -//{ -// public class UserStoreTest -// { -// [Fact] -// public async Task Can_share_instance_between_contexts_with_sugar_experience2() -// { -// using (var db = new IdentityContext()) -// { -// db.Users.Add(new IdentityUser { UserName = "John Doe" }); -// await db.SaveChangesAsync(); -// } - -// using (var db = new IdentityContext()) -// { -// var data = db.Users.ToList(); -// Assert.Equal(1, data.Count); -// Assert.Equal("John Doe", data[0].UserName); -// } -// } - -// [Fact] -// public async Task Can_share_instance_between_contexts_with_sugar_experience() -// { -// using (var db = new SimpleContext()) -// { -// db.Artists.Add(new SimpleContext.Artist { Name = "John Doe" }); -// await db.SaveChangesAsync(); -// } - -// using (var db = new SimpleContext()) -// { -// var data = db.Artists.ToList(); -// Assert.Equal(1, data.Count); -// Assert.Equal("John Doe", data[0].Name); -// } -// } - -// [Fact] -// public async Task Can_create_two_artists() -// { -// using (var db = new SimpleContext()) -// { -// db.Artists.Add(new SimpleContext.Artist { Name = "John Doe", ArtistId = Guid.NewGuid().ToString() }); -// await db.SaveChangesAsync(); -// db.Artists.Add(new SimpleContext.Artist { Name = "Second guy", ArtistId = Guid.NewGuid().ToString() }); -// await db.SaveChangesAsync(); -// } -// } - -// private class SimpleContext : EntityContext -// { -// public EntitySet Artists { get; set; } - -// protected override void OnConfiguring(EntityConfigurationBuilder builder) -// { -// builder.UseDataStore(new InMemoryDataStore()); -// } - -// protected override void OnModelCreating(ModelBuilder builder) -// { -// builder.Entity().Key(a => a.ArtistId); -// } - -// public class Artist// : ArtistBase -// { -// public string ArtistId { get; set; } -// public string Name { get; set; } -// } - -// public class ArtistBase -// { -// public TKey ArtistId { get; set; } -// public string Name { get; set; } -// } -// } - -// [Fact] -// public async Task Foo() -// { -// using (var db = new IdentityContext()) -// { -// db.Users.Add(new IdentityUser("A")); -// await db.SaveChangesAsync(); -// } - -// using (var db = new IdentityContext()) -// { -// var data = db.Users.ToList(); -// Assert.Equal(1, data.Count); -// Assert.Equal("A", data[0].UserName); -// } -// } - -// [Fact] -// public async Task CanDeleteUser() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("DeleteAsync"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user)); -// Assert.Null(await manager.FindByIdAsync(user.Id)); -// } - -// //[Fact] -// //public async Task CanUpdateUserName() -// //{ -// // var manager = CreateManager(); -// // var user = new IdentityUser("UpdateAsync"); -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// // Assert.Null(await manager.FindByNameAsync("New")); -// // user.UserName = "New"; -// // IdentityResultAssert.IsSuccess(await manager.UpdateAsync(user)); -// // Assert.NotNull(await manager.FindByNameAsync("New")); -// // Assert.Null(await manager.FindByNameAsync("UpdateAsync")); -// //} - -// [Fact] -// public async Task UserValidatorCanBlockCreate() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("CreateBlocked"); -// manager.UserValidator = new AlwaysBadValidator(); -// IdentityResultAssert.IsFailure(await manager.CreateAsync(user), AlwaysBadValidator.ErrorMessage); -// } - -// //[Fact] -// //public async Task UserValidatorCanBlockUpdate() -// //{ -// // var manager = CreateManager(); -// // var user = new IdentityUser("UpdateBlocked"); -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// // manager.UserValidator = new AlwaysBadValidator(); -// // IdentityResultAssert.IsFailure(await manager.UpdateAsync(user), AlwaysBadValidator.ErrorMessage); -// //} - -// // [Theory] -// // [InlineData("")] -// // [InlineData(null)] -// // public async Task UserValidatorBlocksShortEmailsWhenRequiresUniqueEmail(string email) -// // { -// // var manager = CreateManager(); -// // var user = new IdentityUser("UpdateBlocked") {Email = email}; -// // manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; -// // IdentityResultAssert.IsFailure(await manager.CreateAsync(user), "Email cannot be null or empty."); -// // } - -// //#if NET45 -// // [Theory] -// // [InlineData("@@afd")] -// // [InlineData("bogus")] -// // public async Task UserValidatorBlocksInvalidEmailsWhenRequiresUniqueEmail(string email) -// // { -// // var manager = CreateManager(); -// // var user = new IdentityUser("UpdateBlocked") {Email = email}; -// // manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; -// // IdentityResultAssert.IsFailure(await manager.CreateAsync(user), "Email '" + email + "' is invalid."); -// // } -// //#endif - -// // [Fact] -// // public async Task PasswordValidatorCanBlockAddPassword() -// // { -// // var manager = CreateManager(); -// // var user = new IdentityUser("AddPasswordBlocked"); -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// // manager.PasswordValidator = new AlwaysBadValidator(); -// // IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user.Id, "password"), -// // AlwaysBadValidator.ErrorMessage); -// // } - -// [Fact] -// public async Task PasswordValidatorCanBlockChangePassword() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("ChangePasswordBlocked"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); -// manager.PasswordValidator = new AlwaysBadValidator(); -// IdentityResultAssert.IsFailure(await manager.ChangePasswordAsync(user.Id, "password", "new"), -// AlwaysBadValidator.ErrorMessage); -// } - -// [Fact] -// public async Task CanCreateUserNoPassword() -// { -// var manager = CreateManager(); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityUser("CreateUserTest"))); -// var user = await manager.FindByNameAsync("CreateUserTest"); -// Assert.NotNull(user); -// Assert.Null(user.PasswordHash); -// var logins = await manager.GetLoginsAsync(user.Id); -// Assert.NotNull(logins); -// Assert.Equal(0, logins.Count()); -// } - -// [Fact] -// public async Task CanCreateUserAddLogin() -// { -// var manager = CreateManager(); -// const string userName = "CreateExternalUserTest"; -// const string provider = "ZzAuth"; -// const string providerKey = "HaoKey"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityUser(userName))); -// var user = await manager.FindByNameAsync(userName); -// Assert.NotNull(user); -// var login = new UserLoginInfo(provider, providerKey); -// IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user.Id, login)); -// var logins = await manager.GetLoginsAsync(user.Id); -// Assert.NotNull(logins); -// Assert.Equal(1, logins.Count()); -// Assert.Equal(provider, logins.First().LoginProvider); -// Assert.Equal(providerKey, logins.First().ProviderKey); -// } - -// [Fact] -// public async Task CanCreateUserLoginAndAddPassword() -// { -// var manager = CreateManager(); -// var login = new UserLoginInfo("Provider", "key"); -// var user = new IdentityUser("CreateUserLoginAddPasswordTest"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user.Id, login)); -// Assert.False(await manager.HasPasswordAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await manager.AddPasswordAsync(user.Id, "password")); -// Assert.True(await manager.HasPasswordAsync(user.Id)); -// var logins = await manager.GetLoginsAsync(user.Id); -// Assert.NotNull(logins); -// Assert.Equal(1, logins.Count()); -// Assert.Equal(user, await manager.FindByLoginAsync(login)); -// Assert.Equal(user, await manager.FindByLoginAsync(user.UserName, "password")); -// } - -// [Fact] -// public async Task AddPasswordFailsIfAlreadyHave() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("CannotAddAnotherPassword"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "Password")); -// Assert.True(await manager.HasPasswordAsync(user.Id)); -// IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user.Id, "password"), -// "User already has a password set."); -// } - -// [Fact] -// public async Task CanCreateUserAddRemoveLogin() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("CreateUserAddRemoveLoginTest"); -// var login = new UserLoginInfo("Provider", "key"); -// var result = await manager.CreateAsync(user); -// Assert.NotNull(user); -// IdentityResultAssert.IsSuccess(result); -// IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user.Id, login)); -// Assert.Equal(user, await manager.FindByLoginAsync(login)); -// var logins = await manager.GetLoginsAsync(user.Id); -// Assert.NotNull(logins); -// Assert.Equal(1, logins.Count()); -// Assert.Equal(login.LoginProvider, logins.Last().LoginProvider); -// Assert.Equal(login.ProviderKey, logins.Last().ProviderKey); -// var stamp = user.SecurityStamp; -// IdentityResultAssert.IsSuccess(await manager.RemoveLoginAsync(user.Id, login)); -// Assert.Null(await manager.FindByLoginAsync(login)); -// logins = await manager.GetLoginsAsync(user.Id); -// Assert.NotNull(logins); -// Assert.Equal(0, logins.Count()); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task CanRemovePassword() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("RemovePasswordTest"); -// const string password = "password"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// var stamp = user.SecurityStamp; -// IdentityResultAssert.IsSuccess(await manager.RemovePasswordAsync(user.Id)); -// var u = await manager.FindByNameAsync(user.UserName); -// Assert.NotNull(u); -// Assert.Null(u.PasswordHash); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task CanChangePassword() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("ChangePasswordTest"); -// const string password = "password"; -// const string newPassword = "newpassword"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// Assert.Equal(manager.Users.Count(), 1); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user.Id, password, newPassword)); -// Assert.Null(await manager.FindByLoginAsync(user.UserName, password)); -// Assert.Equal(user, await manager.FindByLoginAsync(user.UserName, newPassword)); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task CanAddRemoveUserClaim() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("ClaimsAddRemove"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// Claim[] claims = { new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3") }; -// foreach (var c in claims) -// { -// IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user.Id, c)); -// } -// var userClaims = await manager.GetClaimsAsync(user.Id); -// Assert.Equal(3, userClaims.Count); -// IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user.Id, claims[0])); -// userClaims = await manager.GetClaimsAsync(user.Id); -// Assert.Equal(2, userClaims.Count); -// IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user.Id, claims[1])); -// userClaims = await manager.GetClaimsAsync(user.Id); -// Assert.Equal(1, userClaims.Count); -// IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user.Id, claims[2])); -// userClaims = await manager.GetClaimsAsync(user.Id); -// Assert.Equal(0, userClaims.Count); -// } - -// [Fact] -// public async Task ChangePasswordFallsIfPasswordWrong() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("user"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); -// var result = await manager.ChangePasswordAsync(user.Id, "bogus", "newpassword"); -// IdentityResultAssert.IsFailure(result, "Incorrect password."); -// } - -// [Fact] -// public async Task AddDupeUserNameFails() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("dupe"); -// var user2 = new IdentityUser("dupe"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), "Name dupe is already taken."); -// } - -// [Fact] -// public async Task AddDupeEmailAllowedByDefault() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("dupe") { Email = "yup@yup.com" }; -// var user2 = new IdentityUser("dupeEmail") { Email = "yup@yup.com" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); -// } - -// [Fact] -// public async Task AddDupeEmailFallsWhenUniqueEmailRequired() -// { -// var manager = CreateManager(); -// manager.UserValidator = new UserValidator { RequireUniqueEmail = true }; -// var user = new IdentityUser("dupe") { Email = "yup@yup.com" }; -// var user2 = new IdentityUser("dupeEmail") { Email = "yup@yup.com" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), "Email 'yup@yup.com' is already taken."); -// } - -// [Fact] -// public async Task UpdateSecurityStampActuallyChanges() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("stampMe"); -// Assert.Null(user.SecurityStamp); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user.Id)); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task AddDupeLoginFails() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("DupeLogin"); -// var login = new UserLoginInfo("provder", "key"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user.Id, login)); -// var result = await manager.AddLoginAsync(user.Id, login); -// IdentityResultAssert.IsFailure(result, "A user with that external login already exists."); -// } - -// // Email tests -// [Fact] -// public async Task CanFindByEmail() -// { -// var manager = CreateManager(); -// const string userName = "EmailTest"; -// const string email = "email@test.com"; -// var user = new IdentityUser(userName) { Email = email }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var fetch = await manager.FindByEmailAsync(email); -// Assert.Equal(user, fetch); -// } - -// [Fact] -// public async Task CanFindUsersViaUserQuerable() -// { -// var mgr = CreateManager(); -// var users = new[] -// { -// new IdentityUser("user1"), -// new IdentityUser("user2"), -// new IdentityUser("user3") -// }; -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(u)); -// } -// var usersQ = mgr.Users; -// Assert.Equal(3, usersQ.Count()); -// Assert.NotNull(usersQ.FirstOrDefault(u => u.UserName == "user1")); -// Assert.NotNull(usersQ.FirstOrDefault(u => u.UserName == "user2")); -// Assert.NotNull(usersQ.FirstOrDefault(u => u.UserName == "user3")); -// Assert.Null(usersQ.FirstOrDefault(u => u.UserName == "bogus")); -// } - -// [Fact] -// public async Task ClaimsIdentityCreatesExpectedClaims() -// { -// var context = CreateContext(); -// var manager = CreateManager(context); -// var role = CreateRoleManager(context); -// var user = new IdentityUser("Hao"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await role.CreateAsync(new IdentityRole("Admin"))); -// IdentityResultAssert.IsSuccess(await role.CreateAsync(new IdentityRole("Local"))); -// IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user.Id, "Admin")); -// IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user.Id, "Local")); -// Claim[] userClaims = -// { -// new Claim("Whatever", "Value"), -// new Claim("Whatever2", "Value2") -// }; -// foreach (var c in userClaims) -// { -// IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user.Id, c)); -// } - -// var identity = await manager.CreateIdentity(user, "test"); -// var claimsFactory = manager.ClaimsIdentityFactory as ClaimsIdentityFactory; -// Assert.NotNull(claimsFactory); -// var claims = identity.Claims; -// Assert.NotNull(claims); -// Assert.True( -// claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName)); -// Assert.True(claims.Any(c => c.Type == claimsFactory.UserIdClaimType && c.Value == user.Id)); -// Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Admin")); -// Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Local")); -// foreach (var cl in userClaims) -// { -// Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value)); -// } -// } - -// [Fact] -// public async Task ConfirmEmailFalseByDefaultTest() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("test"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// Assert.False(await manager.IsEmailConfirmedAsync(user.Id)); -// } - -// // TODO: No token provider implementations yet -// private class StaticTokenProvider : IUserTokenProvider -// { -// public Task GenerateAsync(string purpose, UserManager manager, -// IdentityUser user, CancellationToken token) -// { -// return Task.FromResult(MakeToken(purpose, user)); -// } - -// public Task ValidateAsync(string purpose, string token, UserManager manager, -// IdentityUser user, CancellationToken cancellationToken) -// { -// return Task.FromResult(token == MakeToken(purpose, user)); -// } - -// public Task NotifyAsync(string token, UserManager manager, IdentityUser user, CancellationToken cancellationToken) -// { -// return Task.FromResult(0); -// } - -// public Task IsValidProviderForUserAsync(UserManager manager, IdentityUser user, CancellationToken token) -// { -// return Task.FromResult(true); -// } - -// private static string MakeToken(string purpose, IdentityUser user) -// { -// return string.Join(":", user.Id, purpose, "ImmaToken"); -// } -// } - -// [Fact] -// public async Task CanResetPasswordWithStaticTokenProvider() -// { -// var manager = CreateManager(); -// manager.UserTokenProvider = new StaticTokenProvider(); -// var user = new IdentityUser("ResetPasswordTest"); -// const string password = "password"; -// const string newPassword = "newpassword"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// var token = await manager.GeneratePasswordResetTokenAsync(user.Id); -// Assert.NotNull(token); -// IdentityResultAssert.IsSuccess(await manager.ResetPassword(user.Id, token, newPassword)); -// Assert.Null(await manager.FindByLoginAsync(user.UserName, password)); -// Assert.Equal(user, await manager.FindByLoginAsync(user.UserName, newPassword)); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task PasswordValidatorCanBlockResetPasswordWithStaticTokenProvider() -// { -// var manager = CreateManager(); -// manager.UserTokenProvider = new StaticTokenProvider(); -// var user = new IdentityUser("ResetPasswordTest"); -// const string password = "password"; -// const string newPassword = "newpassword"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// var token = await manager.GeneratePasswordResetTokenAsync(user.Id); -// Assert.NotNull(token); -// manager.PasswordValidator = new AlwaysBadValidator(); -// IdentityResultAssert.IsFailure(await manager.ResetPassword(user.Id, token, newPassword), -// AlwaysBadValidator.ErrorMessage); -// Assert.NotNull(await manager.FindByLoginAsync(user.UserName, password)); -// Assert.Equal(user, await manager.FindByLoginAsync(user.UserName, password)); -// Assert.Equal(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task ResetPasswordWithStaticTokenProviderFailsWithWrongToken() -// { -// var manager = CreateManager(); -// manager.UserTokenProvider = new StaticTokenProvider(); -// var user = new IdentityUser("ResetPasswordTest"); -// const string password = "password"; -// const string newPassword = "newpassword"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// IdentityResultAssert.IsFailure(await manager.ResetPassword(user.Id, "bogus", newPassword), "Invalid token."); -// Assert.NotNull(await manager.FindByLoginAsync(user.UserName, password)); -// Assert.Equal(user, await manager.FindByLoginAsync(user.UserName, password)); -// Assert.Equal(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task CanGenerateAndVerifyUserTokenWithStaticTokenProvider() -// { -// var manager = CreateManager(); -// manager.UserTokenProvider = new StaticTokenProvider(); -// var user = new IdentityUser("UserTokenTest"); -// var user2 = new IdentityUser("UserTokenTest2"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); -// var token = await manager.GenerateUserTokenAsync("test", user.Id); -// Assert.True(await manager.VerifyUserTokenAsync(user.Id, "test", token)); -// Assert.False(await manager.VerifyUserTokenAsync(user.Id, "test2", token)); -// Assert.False(await manager.VerifyUserTokenAsync(user.Id, "test", token + "a")); -// Assert.False(await manager.VerifyUserTokenAsync(user2.Id, "test", token)); -// } - -// [Fact] -// public async Task CanConfirmEmailWithStaticToken() -// { -// var manager = CreateManager(); -// manager.UserTokenProvider = new StaticTokenProvider(); -// var user = new IdentityUser("test"); -// Assert.False(user.EmailConfirmed); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var token = await manager.GenerateEmailConfirmationTokenAsync(user.Id); -// Assert.NotNull(token); -// IdentityResultAssert.IsSuccess(await manager.ConfirmEmailAsync(user.Id, token)); -// Assert.True(await manager.IsEmailConfirmedAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user.Id, null)); -// Assert.False(await manager.IsEmailConfirmedAsync(user.Id)); -// } - -// [Fact] -// public async Task ConfirmEmailWithStaticTokenFailsWithWrongToken() -// { -// var manager = CreateManager(); -// manager.UserTokenProvider = new StaticTokenProvider(); -// var user = new IdentityUser("test"); -// Assert.False(user.EmailConfirmed); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user.Id, "bogus"), "Invalid token."); -// Assert.False(await manager.IsEmailConfirmedAsync(user.Id)); -// } - -// // TODO: Can't reenable til we have a SecurityStamp linked token provider -// //[Fact] -// //public async Task ConfirmTokenFailsAfterPasswordChange() -// //{ -// // var manager = CreateManager(); -// // var user = new IdentityUser("test"); -// // Assert.False(user.EmailConfirmed); -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); -// // var token = await manager.GenerateEmailConfirmationTokenAsync(user.Id); -// // Assert.NotNull(token); -// // IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user.Id, "password", "newpassword")); -// // IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user.Id, token), "Invalid token."); -// // Assert.False(await manager.IsEmailConfirmedAsync(user.Id)); -// //} - -// // Lockout tests - -// [Fact] -// public async Task SingleFailureLockout() -// { -// var mgr = CreateManager(); -// mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); -// mgr.UserLockoutEnabledByDefault = true; -// var user = new IdentityUser("fastLockout"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.True(await mgr.IsLockedOutAsync(user.Id)); -// Assert.True(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user.Id)); -// } - -// [Fact] -// public async Task TwoFailureLockout() -// { -// var mgr = CreateManager(); -// mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); -// mgr.UserLockoutEnabledByDefault = true; -// mgr.MaxFailedAccessAttemptsBeforeLockout = 2; -// var user = new IdentityUser("twoFailureLockout"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.True(await mgr.IsLockedOutAsync(user.Id)); -// Assert.True(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user.Id)); -// } - -// [Fact] -// public async Task ResetAccessCountPreventsLockout() -// { -// var mgr = CreateManager(); -// mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); -// mgr.UserLockoutEnabledByDefault = true; -// mgr.MaxFailedAccessAttemptsBeforeLockout = 2; -// var user = new IdentityUser("resetLockout"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.ResetAccessFailedCountAsync(user.Id)); -// Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user.Id)); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user.Id)); -// } - -// [Fact] -// public async Task CanEnableLockoutManuallyAndLockout() -// { -// var mgr = CreateManager(); -// mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); -// mgr.MaxFailedAccessAttemptsBeforeLockout = 2; -// var user = new IdentityUser("manualLockout"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.False(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.False(user.LockoutEnabled); -// IdentityResultAssert.IsSuccess(await mgr.SetLockoutEnabledAsync(user.Id, true)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// Assert.False(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user.Id)); -// IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user.Id)); -// Assert.True(await mgr.IsLockedOutAsync(user.Id)); -// Assert.True(await mgr.GetLockoutEndDateAsync(user.Id) > DateTimeOffset.UtcNow.AddMinutes(55)); -// Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user.Id)); -// } - -// [Fact] -// public async Task UserNotLockedOutWithNullDateTimeAndIsSetToNullDate() -// { -// var mgr = CreateManager(); -// mgr.UserLockoutEnabledByDefault = true; -// var user = new IdentityUser("LockoutTest"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user.Id, new DateTimeOffset())); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// Assert.Equal(new DateTimeOffset(), await mgr.GetLockoutEndDateAsync(user.Id)); -// Assert.Null(user.LockoutEndDateUtc); -// } - -// [Fact] -// public async Task LockoutFailsIfNotEnabled() -// { -// var mgr = CreateManager(); -// var user = new IdentityUser("LockoutNotEnabledTest"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.False(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.False(user.LockoutEnabled); -// IdentityResultAssert.IsFailure(await mgr.SetLockoutEndDateAsync(user.Id, new DateTimeOffset()), -// "Lockout is not enabled for this user."); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// } - -// [Fact] -// public async Task LockoutEndToUtcNowMinus1SecInUserShouldNotBeLockedOut() -// { -// var mgr = CreateManager(); -// mgr.UserLockoutEnabledByDefault = true; -// var user = new IdentityUser("LockoutUtcNowTest") { LockoutEndDateUtc = DateTime.UtcNow.AddSeconds(-1) }; -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// } - -// [Fact] -// public async Task LockoutEndToUtcNowSubOneSecondWithManagerShouldNotBeLockedOut() -// { -// var mgr = CreateManager(); -// mgr.UserLockoutEnabledByDefault = true; -// var user = new IdentityUser("LockoutUtcNowTest"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user.Id, DateTimeOffset.UtcNow.AddSeconds(-1))); -// Assert.False(await mgr.IsLockedOutAsync(user.Id)); -// } - -// [Fact] -// public async Task LockoutEndToUtcNowPlus5ShouldBeLockedOut() -// { -// var mgr = CreateManager(); -// mgr.UserLockoutEnabledByDefault = true; -// var user = new IdentityUser("LockoutUtcNowTest") { LockoutEndDateUtc = DateTime.UtcNow.AddMinutes(5) }; -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// Assert.True(await mgr.IsLockedOutAsync(user.Id)); -// } - -// [Fact] -// public async Task UserLockedOutWithDateTimeLocalKindNowPlus30() -// { -// var mgr = CreateManager(); -// mgr.UserLockoutEnabledByDefault = true; -// var user = new IdentityUser("LockoutTest"); -// IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); -// Assert.True(await mgr.GetLockoutEnabledAsync(user.Id)); -// Assert.True(user.LockoutEnabled); -// var lockoutEnd = new DateTimeOffset(DateTime.Now.AddMinutes(30).ToLocalTime()); -// IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user.Id, lockoutEnd)); -// Assert.True(await mgr.IsLockedOutAsync(user.Id)); -// var end = await mgr.GetLockoutEndDateAsync(user.Id); -// Assert.Equal(lockoutEnd, end); -// } - -// // Role Tests -// [Fact] -// public async Task CanCreateRoleTest() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("create"); -// Assert.False(await manager.RoleExistsAsync(role.Name)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// Assert.True(await manager.RoleExistsAsync(role.Name)); -// } - -// private class AlwaysBadValidator : IUserValidator, IRoleValidator, -// IPasswordValidator -// { -// public const string ErrorMessage = "I'm Bad."; - -// public Task ValidateAsync(string password, CancellationToken token) -// { -// return Task.FromResult(IdentityResult.Failed(ErrorMessage)); -// } - -// public Task ValidateAsync(RoleManager manager, IdentityRole role, CancellationToken token) -// { -// return Task.FromResult(IdentityResult.Failed(ErrorMessage)); -// } - -// public Task ValidateAsync(UserManager manager, IdentityUser user, CancellationToken token) -// { -// return Task.FromResult(IdentityResult.Failed(ErrorMessage)); -// } -// } - -// [Fact] -// public async Task BadValidatorBlocksCreateRole() -// { -// var manager = CreateRoleManager(); -// manager.RoleValidator = new AlwaysBadValidator(); -// IdentityResultAssert.IsFailure(await manager.CreateAsync(new IdentityRole("blocked")), -// AlwaysBadValidator.ErrorMessage); -// } - -// [Fact] -// public async Task BadValidatorBlocksRoleUpdate() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("poorguy"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// var error = AlwaysBadValidator.ErrorMessage; -// manager.RoleValidator = new AlwaysBadValidator(); -// IdentityResultAssert.IsFailure(await manager.UpdateAsync(role), error); -// } - -// [Fact] -// public async Task CanDeleteRoleTest() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("delete"); -// Assert.False(await manager.RoleExistsAsync(role.Name)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// IdentityResultAssert.IsSuccess(await manager.DeleteAsync(role)); -// Assert.False(await manager.RoleExistsAsync(role.Name)); -// } - -// [Fact] -// public async Task CanRoleFindByIdTest() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("FindByIdAsync"); -// Assert.Null(await manager.FindByIdAsync(role.Id)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// Assert.Equal(role, await manager.FindByIdAsync(role.Id)); -// } - -// [Fact] -// public async Task CanRoleFindByName() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("FindByNameAsync"); -// Assert.Null(await manager.FindByNameAsync(role.Name)); -// Assert.False(await manager.RoleExistsAsync(role.Name)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// Assert.Equal(role, await manager.FindByNameAsync(role.Name)); -// } - -// [Fact] -// public async Task CanUpdateRoleNameTest() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("update"); -// Assert.False(await manager.RoleExistsAsync(role.Name)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// Assert.True(await manager.RoleExistsAsync(role.Name)); -// role.Name = "Changed"; -// IdentityResultAssert.IsSuccess(await manager.UpdateAsync(role)); -// Assert.False(await manager.RoleExistsAsync("update")); -// Assert.Equal(role, await manager.FindByNameAsync(role.Name)); -// } - -// [Fact] -// public async Task CanQuerableRolesTest() -// { -// var manager = CreateRoleManager(); -// IdentityRole[] roles = -// { -// new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"), -// new IdentityRole("r4") -// }; -// foreach (var r in roles) -// { -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(r)); -// } -// Assert.Equal(roles.Length, manager.Roles.Count()); -// var r1 = manager.Roles.FirstOrDefault(r => r.Name == "r1"); -// Assert.Equal(roles[0], r1); -// } - -// //[Fact] -// //public async Task DeleteRoleNonEmptySucceedsTest() -// //{ -// // // 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.Id, role.Name)); -// // 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? -// // var roles = await userMgr.GetRolesAsync(user.Id); - -// // // In memory this doesn't work since there's no concept of cascading deletes -// // //Assert.Equal(0, roles.Count()); -// //} - -// ////[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.Id, role.Name)); -// //// IdentityResultAssert.IsSuccess(await userMgr.DeleteAsync(user)); -// //// role = roleMgr.FindByIdAsync(role.Id); -// ////} - -// [Fact] -// public async Task CreateRoleFailsIfExists() -// { -// var manager = CreateRoleManager(); -// var role = new IdentityRole("dupeRole"); -// Assert.False(await manager.RoleExistsAsync(role.Name)); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); -// Assert.True(await manager.RoleExistsAsync(role.Name)); -// var role2 = new IdentityRole("dupeRole"); -// IdentityResultAssert.IsFailure(await manager.CreateAsync(role2)); -// } - -// [Fact] -// public async Task CanAddUsersToRole() -// { -// var context = CreateContext(); -// var manager = CreateManager(context); -// var roleManager = CreateRoleManager(context); -// var role = new IdentityRole("addUserTest"); -// IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role)); -// IdentityUser[] users = -// { -// new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"), -// new IdentityUser("4") -// }; -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(u)); -// IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(u.Id, role.Name)); -// Assert.True(await manager.IsInRoleAsync(u.Id, role.Name)); -// } -// } - -// [Fact] -// public async Task CanGetRolesForUser() -// { -// var context = CreateContext(); -// var userManager = CreateManager(context); -// var roleManager = CreateRoleManager(context); -// IdentityUser[] users = -// { -// new IdentityUser("u1"), new IdentityUser("u2"), new IdentityUser("u3"), -// new IdentityUser("u4") -// }; -// IdentityRole[] roles = -// { -// new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"), -// new IdentityRole("r4") -// }; -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await userManager.CreateAsync(u)); -// } -// foreach (var r in roles) -// { -// IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(u.Id, r.Name)); -// Assert.True(await userManager.IsInRoleAsync(u.Id, r.Name)); -// } -// } - -// foreach (var u in users) -// { -// var rs = await userManager.GetRolesAsync(u.Id); -// Assert.Equal(roles.Length, rs.Count); -// foreach (var r in roles) -// { -// Assert.True(rs.Any(role => role == r.Name)); -// } -// } -// } - - -// [Fact] -// public async Task RemoveUserFromRoleWithMultipleRoles() -// { -// var context = CreateContext(); -// var userManager = CreateManager(context); -// var roleManager = CreateRoleManager(context); -// var user = new IdentityUser("MultiRoleUser"); -// IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); -// IdentityRole[] roles = -// { -// new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"), -// new IdentityRole("r4") -// }; -// foreach (var r in roles) -// { -// IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); -// IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(user.Id, r.Name)); -// Assert.True(await userManager.IsInRoleAsync(user.Id, r.Name)); -// } -// IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(user.Id, roles[2].Name)); -// Assert.False(await userManager.IsInRoleAsync(user.Id, roles[2].Name)); -// } - -// [Fact] -// public async Task CanRemoveUsersFromRole() -// { -// var context = CreateContext(); -// var userManager = CreateManager(context); -// var roleManager = CreateRoleManager(context); -// IdentityUser[] users = -// { -// new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"), -// new IdentityUser("4") -// }; -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await userManager.CreateAsync(u)); -// } -// var r = new IdentityRole("r1"); -// IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await userManager.AddToRoleAsync(u.Id, r.Name)); -// Assert.True(await userManager.IsInRoleAsync(u.Id, r.Name)); -// } -// foreach (var u in users) -// { -// IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(u.Id, r.Name)); -// Assert.False(await userManager.IsInRoleAsync(u.Id, r.Name)); -// } -// } - -// [Fact] -// public async Task RemoveUserNotInRoleFails() -// { -// var context = CreateContext(); -// var userMgr = CreateManager(context); -// var roleMgr = CreateRoleManager(context); -// var role = new IdentityRole("addUserDupeTest"); -// var user = new IdentityUser("user1"); -// IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); -// var result = await userMgr.RemoveFromRoleAsync(user.Id, role.Name); -// IdentityResultAssert.IsFailure(result, "User is not in role."); -// } - -// [Fact] -// public async Task AddUserToRoleFailsIfAlreadyInRole() -// { -// var context = CreateContext(); -// var userMgr = CreateManager(context); -// var roleMgr = CreateRoleManager(context); -// var role = new IdentityRole("addUserDupeTest"); -// var user = new IdentityUser("user1"); -// IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); -// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); -// IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user.Id, role.Name)); -// Assert.True(await userMgr.IsInRoleAsync(user.Id, role.Name)); -// IdentityResultAssert.IsFailure(await userMgr.AddToRoleAsync(user.Id, role.Name), "User already in role."); -// } - -// [Fact] -// public async Task CanFindRoleByNameWithManager() -// { -// var roleMgr = CreateRoleManager(); -// var role = new IdentityRole("findRoleByNameTest"); -// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); -// Assert.Equal(role.Id, (await roleMgr.FindByNameAsync(role.Name)).Id); -// } - -// [Fact] -// public async Task CanFindRoleWithManager() -// { -// var roleMgr = CreateRoleManager(); -// var role = new IdentityRole("findRoleTest"); -// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); -// Assert.Equal(role, await roleMgr.FindByIdAsync(role.Id)); -// } - -// [Fact] -// public async Task SetPhoneNumberTest() -// { -// var manager = CreateManager(); -// var userName = "PhoneTest"; -// var user = new IdentityUser(userName); -// user.PhoneNumber = "123-456-7890"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var stamp = await manager.GetSecurityStampAsync(user.Id); -// Assert.Equal(await manager.GetPhoneNumberAsync(user.Id), "123-456-7890"); -// IdentityResultAssert.IsSuccess(await manager.SetPhoneNumberAsync(user.Id, "111-111-1111")); -// Assert.Equal(await manager.GetPhoneNumberAsync(user.Id), "111-111-1111"); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task CanChangePhoneNumber() -// { -// var manager = CreateManager(); -// const string userName = "PhoneTest"; -// var user = new IdentityUser(userName) { PhoneNumber = "123-456-7890" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// Assert.False(await manager.IsPhoneNumberConfirmedAsync(user.Id)); -// var stamp = await manager.GetSecurityStampAsync(user.Id); -// var token1 = await manager.GenerateChangePhoneNumberToken(user.Id, "111-111-1111"); -// IdentityResultAssert.IsSuccess(await manager.ChangePhoneNumberAsync(user.Id, "111-111-1111", token1)); -// Assert.True(await manager.IsPhoneNumberConfirmedAsync(user.Id)); -// Assert.Equal(await manager.GetPhoneNumberAsync(user.Id), "111-111-1111"); -// Assert.NotEqual(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task ChangePhoneNumberFailsWithWrongToken() -// { -// var manager = CreateManager(); -// const string userName = "PhoneTest"; -// var user = new IdentityUser(userName) { PhoneNumber = "123-456-7890" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// Assert.False(await manager.IsPhoneNumberConfirmedAsync(user.Id)); -// var stamp = await manager.GetSecurityStampAsync(user.Id); -// IdentityResultAssert.IsFailure(await manager.ChangePhoneNumberAsync(user.Id, "111-111-1111", "bogus"), -// "Invalid token."); -// Assert.False(await manager.IsPhoneNumberConfirmedAsync(user.Id)); -// Assert.Equal(await manager.GetPhoneNumberAsync(user.Id), "123-456-7890"); -// Assert.Equal(stamp, user.SecurityStamp); -// } - -// [Fact] -// public async Task CanVerifyPhoneNumber() -// { -// var manager = CreateManager(); -// const string userName = "VerifyPhoneTest"; -// var user = new IdentityUser(userName); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// const string num1 = "111-123-4567"; -// const string num2 = "111-111-1111"; -// var token1 = await manager.GenerateChangePhoneNumberToken(user.Id, num1); -// var token2 = await manager.GenerateChangePhoneNumberToken(user.Id, num2); -// Assert.NotEqual(token1, token2); -// Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user.Id, token1, num1)); -// Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user.Id, token2, num2)); -// Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user.Id, token2, num1)); -// Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user.Id, token1, num2)); -// } - -// private class EmailTokenProvider : IUserTokenProvider -// { -// public Task GenerateAsync(string purpose, UserManager manager, IdentityUser user, CancellationToken token) -// { -// return Task.FromResult(MakeToken(purpose)); -// } - -// public Task ValidateAsync(string purpose, string token, UserManager manager, -// IdentityUser user, CancellationToken cancellationToken) -// { -// return Task.FromResult(token == MakeToken(purpose)); -// } - -// public Task NotifyAsync(string token, UserManager manager, IdentityUser user, CancellationToken cancellationToken) -// { -// return manager.SendEmail(user.Id, token, token); -// } - -// public async Task IsValidProviderForUserAsync(UserManager manager, IdentityUser user, CancellationToken token) -// { -// return !string.IsNullOrEmpty(await manager.GetEmailAsync(user.Id)); -// } - -// private static string MakeToken(string purpose) -// { -// return "email:" + purpose; -// } -// } - -// private class SmsTokenProvider : IUserTokenProvider -// { -// public Task GenerateAsync(string purpose, UserManager manager, IdentityUser user, CancellationToken token) -// { -// return Task.FromResult(MakeToken(purpose)); -// } - -// public Task ValidateAsync(string purpose, string token, UserManager manager, -// IdentityUser user, CancellationToken cancellationToken) -// { -// return Task.FromResult(token == MakeToken(purpose)); -// } - -// public Task NotifyAsync(string token, UserManager manager, IdentityUser user, CancellationToken cancellationToken) -// { -// return manager.SendSms(user.Id, token); -// } - -// public async Task IsValidProviderForUserAsync(UserManager manager, IdentityUser user, CancellationToken token) -// { -// return !string.IsNullOrEmpty(await manager.GetPhoneNumberAsync(user.Id)); -// } - -// private static string MakeToken(string purpose) -// { -// return "sms:" + purpose; -// } -// } - -// [Fact] -// public async Task CanEmailTwoFactorToken() -// { -// var manager = CreateManager(); -// var messageService = new TestMessageService(); -// manager.EmailService = messageService; -// const string factorId = "EmailCode"; -// manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); -// var user = new IdentityUser("EmailCodeTest") { Email = "foo@foo.com" }; -// const string password = "password"; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId); -// Assert.NotNull(token); -// Assert.Null(messageService.Message); -// IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user.Id, factorId, token)); -// Assert.NotNull(messageService.Message); -// Assert.Equal(token, messageService.Message.Subject); -// Assert.Equal(token, messageService.Message.Body); -// Assert.True(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token)); -// } - -// [Fact] -// public async Task NotifyWithUnknownProviderFails() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("NotifyFail"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// await -// ExceptionAssert.ThrowsAsync( -// async () => await manager.NotifyTwoFactorTokenAsync(user.Id, "Bogus", "token"), -// "No IUserTwoFactorProvider for 'Bogus' is registered."); -// } - - -// //[Fact] -// //public async Task EmailTokenFactorWithFormatTest() -// //{ -// // var manager = CreateManager(); -// // var messageService = new TestMessageService(); -// // manager.EmailService = messageService; -// // const string factorId = "EmailCode"; -// // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider -// // { -// // Subject = "Security Code", -// // BodyFormat = "Your code is: {0}" -// // }); -// // var user = new IdentityUser("EmailCodeTest") { Email = "foo@foo.com" }; -// // const string password = "password"; -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); -// // var stamp = user.SecurityStamp; -// // Assert.NotNull(stamp); -// // var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId); -// // Assert.NotNull(token); -// // Assert.Null(messageService.Message); -// // IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user.Id, factorId, token)); -// // Assert.NotNull(messageService.Message); -// // Assert.Equal("Security Code", messageService.Message.Subject); -// // Assert.Equal("Your code is: " + token, messageService.Message.Body); -// // Assert.True(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token)); -// //} - -// //[Fact] -// //public async Task EmailFactorFailsAfterSecurityStampChangeTest() -// //{ -// // var manager = CreateManager(); -// // const string factorId = "EmailCode"; -// // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); -// // var user = new IdentityUser("EmailCodeTest") { Email = "foo@foo.com" }; -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// // var stamp = user.SecurityStamp; -// // Assert.NotNull(stamp); -// // var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId); -// // Assert.NotNull(token); -// // IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user.Id)); -// // Assert.False(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token)); -// //} - -// [Fact] -// public async Task EnableTwoFactorChangesSecurityStamp() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("TwoFactorEnabledTest"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// IdentityResultAssert.IsSuccess(await manager.SetTwoFactorEnabledAsync(user.Id, true)); -// Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user.Id)); -// Assert.True(await manager.GetTwoFactorEnabledAsync(user.Id)); -// } - -// [Fact] -// public async Task CanSendSms() -// { -// var manager = CreateManager(); -// var messageService = new TestMessageService(); -// manager.SmsService = messageService; -// var user = new IdentityUser("SmsTest") { PhoneNumber = "4251234567" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// await manager.SendSms(user.Id, "Hi"); -// Assert.NotNull(messageService.Message); -// Assert.Equal("Hi", messageService.Message.Body); -// } - -// [Fact] -// public async Task CanSendEmail() -// { -// var manager = CreateManager(); -// var messageService = new TestMessageService(); -// manager.EmailService = messageService; -// var user = new IdentityUser("EmailTest") { Email = "foo@foo.com" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// await manager.SendEmail(user.Id, "Hi", "Body"); -// Assert.NotNull(messageService.Message); -// Assert.Equal("Hi", messageService.Message.Subject); -// Assert.Equal("Body", messageService.Message.Body); -// } - -// [Fact] -// public async Task CanSmsTwoFactorToken() -// { -// var manager = CreateManager(); -// var messageService = new TestMessageService(); -// manager.SmsService = messageService; -// const string factorId = "PhoneCode"; -// manager.RegisterTwoFactorProvider(factorId, new SmsTokenProvider()); -// var user = new IdentityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var stamp = user.SecurityStamp; -// Assert.NotNull(stamp); -// var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId); -// Assert.NotNull(token); -// Assert.Null(messageService.Message); -// IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user.Id, factorId, token)); -// Assert.NotNull(messageService.Message); -// Assert.Equal(token, messageService.Message.Body); -// Assert.True(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token)); -// } - -// //[Fact] -// //public async Task PhoneTokenFactorFormatTest() -// //{ -// // var manager = CreateManager(); -// // var messageService = new TestMessageService(); -// // manager.SmsService = messageService; -// // const string factorId = "PhoneCode"; -// // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider -// // { -// // MessageFormat = "Your code is: {0}" -// // }); -// // var user = new IdentityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// // var stamp = user.SecurityStamp; -// // Assert.NotNull(stamp); -// // var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId); -// // Assert.NotNull(token); -// // Assert.Null(messageService.Message); -// // IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user.Id, factorId, token)); -// // Assert.NotNull(messageService.Message); -// // Assert.Equal("Your code is: " + token, messageService.Message.Body); -// // Assert.True(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token)); -// //} - -// [Fact] -// public async Task GenerateTwoFactorWithUnknownFactorProviderWillThrow() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("PhoneCodeTest"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// const string error = "No IUserTwoFactorProvider for 'bogus' is registered."; -// await -// ExceptionAssert.ThrowsAsync( -// () => manager.GenerateTwoFactorTokenAsync(user.Id, "bogus"), error); -// await ExceptionAssert.ThrowsAsync( -// () => manager.VerifyTwoFactorTokenAsync(user.Id, "bogus", "bogus"), error); -// } - -// [Fact] -// public async Task GetValidTwoFactorTestEmptyWithNoProviders() -// { -// var manager = CreateManager(); -// var user = new IdentityUser("test"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var factors = await manager.GetValidTwoFactorProviders(user.Id); -// Assert.NotNull(factors); -// Assert.True(!factors.Any()); -// } - -// [Fact] -// public async Task GetValidTwoFactorTest() -// { -// var manager = CreateManager(); -// manager.RegisterTwoFactorProvider("phone", new SmsTokenProvider()); -// manager.RegisterTwoFactorProvider("email", new EmailTokenProvider()); -// var user = new IdentityUser("test"); -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var factors = await manager.GetValidTwoFactorProviders(user.Id); -// Assert.NotNull(factors); -// Assert.True(!factors.Any()); -// IdentityResultAssert.IsSuccess(await manager.SetPhoneNumberAsync(user.Id, "111-111-1111")); -// factors = await manager.GetValidTwoFactorProviders(user.Id); -// Assert.NotNull(factors); -// Assert.True(factors.Count() == 1); -// Assert.Equal("phone", factors[0]); -// IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user.Id, "test@test.com")); -// factors = await manager.GetValidTwoFactorProviders(user.Id); -// Assert.NotNull(factors); -// Assert.True(factors.Count() == 2); -// IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user.Id, null)); -// factors = await manager.GetValidTwoFactorProviders(user.Id); -// Assert.NotNull(factors); -// Assert.True(factors.Count() == 1); -// Assert.Equal("phone", factors[0]); -// } - -// //[Fact] -// //public async Task PhoneFactorFailsAfterSecurityStampChangeTest() -// //{ -// // var manager = CreateManager(); -// // var factorId = "PhoneCode"; -// // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider()); -// // var user = new IdentityUser("PhoneCodeTest"); -// // user.PhoneNumber = "4251234567"; -// // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// // var stamp = user.SecurityStamp; -// // Assert.NotNull(stamp); -// // var token = await manager.GenerateTwoFactorTokenAsync(user.Id, factorId); -// // Assert.NotNull(token); -// // IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user.Id)); -// // Assert.False(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, token)); -// //} - -// [Fact] -// public async Task VerifyTokenFromWrongTokenProviderFails() -// { -// var manager = CreateManager(); -// manager.RegisterTwoFactorProvider("PhoneCode", new SmsTokenProvider()); -// manager.RegisterTwoFactorProvider("EmailCode", new EmailTokenProvider()); -// var user = new IdentityUser("WrongTokenProviderTest") { PhoneNumber = "4251234567" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// var token = await manager.GenerateTwoFactorTokenAsync(user.Id, "PhoneCode"); -// Assert.NotNull(token); -// Assert.False(await manager.VerifyTwoFactorTokenAsync(user.Id, "EmailCode", token)); -// } - -// [Fact] -// public async Task VerifyWithWrongSmsTokenFails() -// { -// var manager = CreateManager(); -// const string factorId = "PhoneCode"; -// manager.RegisterTwoFactorProvider(factorId, new SmsTokenProvider()); -// var user = new IdentityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; -// IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); -// Assert.False(await manager.VerifyTwoFactorTokenAsync(user.Id, factorId, "bogus")); -// } - -// private class DataStoreConfig : ContextConfiguration -// { -// private readonly DataStore _store; - -// public DataStoreConfig(DataStore store) -// { -// _store = store; -// } - -// public override DataStore DataStore -// { -// get { return _store; } -// } - -// } - -// private static EntityContext CreateContext() -// { -// var configuration = new EntityConfigurationBuilder() -// //.UseModel(model) -// .UseDataStore(new InMemoryDataStore()) -// .BuildConfiguration(); - -// var db = new IdentityContext(configuration); -// // var sql = db.Configuration.DataStore as SqlServerDataStore; -// // if (sql != null) -// // { -// //#if NET45 -// // var builder = new DbConnectionStringBuilder {ConnectionString = sql.ConnectionString}; -// // var targetDatabase = builder["Database"].ToString(); - -// // // Connect to master, check if database exists, and create if not -// // builder.Add("Database", "master"); -// // using (var masterConnection = new SqlConnection(builder.ConnectionString)) -// // { -// // masterConnection.Open(); - -// // var masterCommand = masterConnection.CreateCommand(); -// // masterCommand.CommandText = "SELECT COUNT(*) FROM sys.databases WHERE [name]=N'" + targetDatabase + -// // "'"; -// // if ((int?) masterCommand.ExecuteScalar() < 1) -// // { -// // masterCommand.CommandText = "CREATE DATABASE [" + targetDatabase + "]"; -// // masterCommand.ExecuteNonQuery(); - -// // using (var conn = new SqlConnection(sql.ConnectionString)) -// // { -// // conn.Open(); -// // var command = conn.CreateCommand(); -// // command.CommandText = @" -// //CREATE TABLE [dbo].[AspNetUsers] ( -// //[Id] NVARCHAR (128) NOT NULL, -// //[Email] NVARCHAR (256) NULL, -// //[EmailConfirmed] BIT NOT NULL, -// //[PasswordHash] NVARCHAR (MAX) NULL, -// //[SecurityStamp] NVARCHAR (MAX) NULL, -// //[PhoneNumber] NVARCHAR (MAX) NULL, -// //[PhoneNumberConfirmed] BIT NOT NULL, -// //[TwoFactorEnabled] BIT NOT NULL, -// //[LockoutEndDateUtc] DATETIME NULL, -// //[LockoutEnabled] BIT NOT NULL, -// //[AccessFailedCount] INT NOT NULL, -// //[UserName] NVARCHAR (256) NOT NULL -// //) "; -// // //CONSTRAINT [PK_dbo.AspNetUsers] PRIMARY KEY CLUSTERED ([Id] ASC) -// // command.ExecuteNonQuery(); -// // } -// // } -// // } -// //#else -// // throw new NotSupportedException("SQL Server is not yet supported when running against K10."); -// //#endif -// //} - - -// // TODO: CreateAsync DB? -// return db; -// } - - -// private static UserManager CreateManager(EntityContext context) -// { -// return new UserManager(new UserStore(context)); -// } - -// private static UserManager CreateManager() -// { -// return CreateManager(CreateContext()); -// } - -// private static RoleManager CreateRoleManager(EntityContext context) -// { -// return new RoleManager(new RoleStore(context)); -// } - -// private static RoleManager CreateRoleManager() -// { -// return CreateRoleManager(CreateContext()); -// } - -// public class TestMessageService : IIdentityMessageService -// { -// public IdentityMessage Message { get; set; } - -// public Task SendAsync(IdentityMessage message, CancellationToken token) -// { -// Message = message; -// return Task.FromResult(0); -// } -// } -// } -//} +using Microsoft.AspNet.Testing; +using Microsoft.Data.Entity; +using Microsoft.Data.Entity.Metadata; +using Microsoft.Data.Entity.Storage; +using Microsoft.Data.InMemory; +using System; +using System.Linq; +using System.Security.Claims; +using System.Threading; +using System.Threading.Tasks; +using Xunit; + +namespace Microsoft.AspNet.Identity.Entity.Test +{ + public class UserStoreTest + { + [Fact] + public async Task UserStoreMethodsThrowWhenDisposedTest() + { + var store = new UserStore(new IdentityContext()); + store.Dispose(); + await Assert.ThrowsAsync(async () => await store.AddClaimAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.AddLoginAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.AddToRoleAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.GetClaimsAsync(null)); + await Assert.ThrowsAsync(async () => await store.GetLoginsAsync(null)); + await Assert.ThrowsAsync(async () => await store.GetRolesAsync(null)); + await Assert.ThrowsAsync(async () => await store.IsInRoleAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.RemoveClaimAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.RemoveLoginAsync(null, null)); + await Assert.ThrowsAsync( + async () => await store.RemoveFromRoleAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.RemoveClaimAsync(null, null)); + await Assert.ThrowsAsync(async () => await store.FindByLoginAsync(null)); + await Assert.ThrowsAsync(async () => await store.FindByIdAsync(null)); + await Assert.ThrowsAsync(async () => await store.FindByNameAsync(null)); + await Assert.ThrowsAsync(async () => await store.CreateAsync(null)); + await Assert.ThrowsAsync(async () => await store.UpdateAsync(null)); + await Assert.ThrowsAsync(async () => await store.DeleteAsync(null)); + await Assert.ThrowsAsync( + async () => await store.SetEmailConfirmedAsync(null, true)); + await Assert.ThrowsAsync(async () => await store.GetEmailConfirmedAsync(null)); + await Assert.ThrowsAsync( + async () => await store.SetPhoneNumberConfirmedAsync(null, true)); + await Assert.ThrowsAsync( + async () => await store.GetPhoneNumberConfirmedAsync(null)); + } + + [Fact] + public async Task UserStorePublicNullCheckTest() + { + Assert.Throws("context", () => new UserStore(null)); + var store = new UserStore(new IdentityContext()); + await Assert.ThrowsAsync("user", async () => await store.GetUserIdAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.GetUserNameAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.SetUserNameAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.CreateAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.UpdateAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.DeleteAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.AddClaimAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.RemoveClaimAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.GetClaimsAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.GetLoginsAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.GetRolesAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.AddLoginAsync(null, null)); + await + Assert.ThrowsAsync("user", async () => await store.RemoveLoginAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.AddToRoleAsync(null, null)); + await + Assert.ThrowsAsync("user", + async () => await store.RemoveFromRoleAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.IsInRoleAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.GetPasswordHashAsync(null)); + await + Assert.ThrowsAsync("user", + async () => await store.SetPasswordHashAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.GetSecurityStampAsync(null)); + await Assert.ThrowsAsync("user", + async () => await store.SetSecurityStampAsync(null, null)); + await Assert.ThrowsAsync("claim", + async () => await store.AddClaimAsync(new EntityUser("fake"), null)); + await Assert.ThrowsAsync("claim", + async () => await store.RemoveClaimAsync(new EntityUser("fake"), null)); + await Assert.ThrowsAsync("login", + async () => await store.AddLoginAsync(new EntityUser("fake"), null)); + await Assert.ThrowsAsync("login", + async () => await store.RemoveLoginAsync(new EntityUser("fake"), null)); + await Assert.ThrowsAsync("login", async () => await store.FindByLoginAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.GetEmailConfirmedAsync(null)); + await Assert.ThrowsAsync("user", + async () => await store.SetEmailConfirmedAsync(null, true)); + await Assert.ThrowsAsync("user", async () => await store.GetEmailAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.SetEmailAsync(null, null)); + await Assert.ThrowsAsync("user", async () => await store.GetPhoneNumberAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.SetPhoneNumberAsync(null, null)); + await Assert.ThrowsAsync("user", + async () => await store.GetPhoneNumberConfirmedAsync(null)); + await Assert.ThrowsAsync("user", + async () => await store.SetPhoneNumberConfirmedAsync(null, true)); + await Assert.ThrowsAsync("user", async () => await store.GetTwoFactorEnabledAsync(null)); + await Assert.ThrowsAsync("user", + async () => await store.SetTwoFactorEnabledAsync(null, true)); + await Assert.ThrowsAsync("user", async () => await store.GetAccessFailedCountAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.GetLockoutEnabledAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.SetLockoutEnabledAsync(null, false)); + await Assert.ThrowsAsync("user", async () => await store.GetLockoutEndDateAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.SetLockoutEndDateAsync(null, new DateTimeOffset())); + await Assert.ThrowsAsync("user", async () => await store.ResetAccessFailedCountAsync(null)); + await Assert.ThrowsAsync("user", async () => await store.IncrementAccessFailedCountAsync(null)); + // TODO: + //ExceptionAssert.ThrowsArgumentNullOrEmpty( + // async () => store.AddToRoleAsync(new EntityUser("fake"), null)), "roleName"); + //ExceptionAssert.ThrowsArgumentNullOrEmpty( + // async () => store.RemoveFromRoleAsync(new EntityUser("fake"), null)), "roleName"); + //ExceptionAssert.ThrowsArgumentNullOrEmpty( + // async () => store.IsInRoleAsync(new EntityUser("fake"), null)), "roleName"); + } + + [Fact] + public async Task Can_share_instance_between_contexts_with_sugar_experience2() + { + using (var db = new IdentityContext()) + { + db.Users.Add(new EntityUser { UserName = "John Doe" }); + await db.SaveChangesAsync(); + } + + using (var db = new IdentityContext()) + { + var data = db.Users.ToList(); + Assert.Equal(1, data.Count); + Assert.Equal("John Doe", data[0].UserName); + } + } + + [Fact] + public async Task Can_create_two_artists() + { + using (var db = new SimpleContext()) + { + db.Artists.Add(new SimpleContext.Artist { Name = "John Doe", ArtistId = Guid.NewGuid().ToString() }); + await db.SaveChangesAsync(); + db.Artists.Add(new SimpleContext.Artist { Name = "Second guy", ArtistId = Guid.NewGuid().ToString() }); + await db.SaveChangesAsync(); + } + } + + private class SimpleContext : EntityContext + { + public EntitySet Artists { get; set; } + + protected override void OnConfiguring(EntityConfigurationBuilder builder) + { + builder.UseDataStore(new InMemoryDataStore()); + } + + protected override void OnModelCreating(ModelBuilder builder) + { + builder.Entity().Key(a => a.ArtistId); + } + + public class Artist// : ArtistBase + { + public string ArtistId { get; set; } + public string Name { get; set; } + } + + public class ArtistBase + { + public TKey ArtistId { get; set; } + public string Name { get; set; } + } + } + + [Fact] + public async Task CanDeleteUser() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("DeleteAsync"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user)); + Assert.Null(await manager.FindByIdAsync(user.Id)); + } + + [Fact] + public async Task CanUpdateUserName() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("UpdateAsync"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Assert.Null(await manager.FindByNameAsync("New")); + user.UserName = "New"; + IdentityResultAssert.IsSuccess(await manager.UpdateAsync(user)); + Assert.NotNull(await manager.FindByNameAsync("New")); + Assert.Null(await manager.FindByNameAsync("UpdateAsync")); + } + + [Fact] + public async Task CanSetUserName() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("UpdateAsync"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Assert.Null(await manager.FindByNameAsync("New")); + IdentityResultAssert.IsSuccess(await manager.SetUserNameAsync(user, "New")); + Assert.NotNull(await manager.FindByNameAsync("New")); + Assert.Null(await manager.FindByNameAsync("UpdateAsync")); + } + + [Fact] + public async Task UserValidatorCanBlockCreate() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("CreateBlocked"); + manager.UserValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.CreateAsync(user), AlwaysBadValidator.ErrorMessage); + } + + [Fact] + public async Task UserValidatorCanBlockUpdate() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("UpdateBlocked"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + manager.UserValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.UpdateAsync(user), AlwaysBadValidator.ErrorMessage); + } + + [Theory] + [InlineData("")] + [InlineData(null)] + public async Task UserValidatorBlocksShortEmailsWhenRequiresUniqueEmail(string email) + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("UpdateBlocked") { Email = email }; + manager.UserValidator = new UserValidator { RequireUniqueEmail = true }; + IdentityResultAssert.IsFailure(await manager.CreateAsync(user), "Email cannot be null or empty."); + } + +#if NET45 + [Theory] + [InlineData("@@afd")] + [InlineData("bogus")] + public async Task UserValidatorBlocksInvalidEmailsWhenRequiresUniqueEmail(string email) + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("UpdateBlocked") { Email = email }; + manager.UserValidator = new UserValidator { RequireUniqueEmail = true }; + IdentityResultAssert.IsFailure(await manager.CreateAsync(user), "Email '" + email + "' is invalid."); + } +#endif + + [Fact] + public async Task PasswordValidatorCanBlockAddPassword() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("AddPasswordBlocked"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + manager.PasswordValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), + AlwaysBadValidator.ErrorMessage); + } + + [Fact] + public async Task PasswordValidatorCanBlockChangePassword() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("ChangePasswordBlocked"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); + manager.PasswordValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.ChangePasswordAsync(user, "password", "new"), + AlwaysBadValidator.ErrorMessage); + } + + [Fact] + public async Task CanCreateUserNoPassword() + { + var manager = TestIdentityFactory.CreateManager(); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(new EntityUser("CreateUserTest"))); + var user = await manager.FindByNameAsync("CreateUserTest"); + Assert.NotNull(user); + Assert.Null(user.PasswordHash); + var logins = await manager.GetLoginsAsync(user); + Assert.NotNull(logins); + Assert.Equal(0, logins.Count()); + } + + [Fact] + public async Task CanCreateUserAddLogin() + { + var manager = TestIdentityFactory.CreateManager(); + const string userName = "CreateExternalUserTest"; + const string provider = "ZzAuth"; + const string providerKey = "HaoKey"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(new EntityUser(userName))); + var user = await manager.FindByNameAsync(userName); + Assert.NotNull(user); + var login = new UserLoginInfo(provider, providerKey); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); + var logins = await manager.GetLoginsAsync(user); + Assert.NotNull(logins); + Assert.Equal(1, logins.Count()); + Assert.Equal(provider, logins.First().LoginProvider); + Assert.Equal(providerKey, logins.First().ProviderKey); + } + + [Fact] + public async Task CanCreateUserLoginAndAddPassword() + { + var manager = TestIdentityFactory.CreateManager(); + var login = new UserLoginInfo("Provider", "key"); + var user = new EntityUser("CreateUserLoginAddPasswordTest"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); + Assert.False(await manager.HasPasswordAsync(user)); + IdentityResultAssert.IsSuccess(await manager.AddPasswordAsync(user, "password")); + Assert.True(await manager.HasPasswordAsync(user)); + var logins = await manager.GetLoginsAsync(user); + Assert.NotNull(logins); + Assert.Equal(1, logins.Count()); + Assert.Equal(user, await manager.FindByLoginAsync(login)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, "password")); + } + + [Fact] + public async Task AddPasswordFailsIfAlreadyHave() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("CannotAddAnotherPassword"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "Password")); + Assert.True(await manager.HasPasswordAsync(user)); + IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), + "User already has a password set."); + } + + [Fact] + public async Task CanCreateUserAddRemoveLogin() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("CreateUserAddRemoveLoginTest"); + var login = new UserLoginInfo("Provider", "key"); + var result = await manager.CreateAsync(user); + Assert.NotNull(user); + IdentityResultAssert.IsSuccess(result); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); + Assert.Equal(user, await manager.FindByLoginAsync(login)); + var logins = await manager.GetLoginsAsync(user); + Assert.NotNull(logins); + Assert.Equal(1, logins.Count()); + Assert.Equal(login.LoginProvider, logins.Last().LoginProvider); + Assert.Equal(login.ProviderKey, logins.Last().ProviderKey); + var stamp = user.SecurityStamp; + IdentityResultAssert.IsSuccess(await manager.RemoveLoginAsync(user, login)); + Assert.Null(await manager.FindByLoginAsync(login)); + logins = await manager.GetLoginsAsync(user); + Assert.NotNull(logins); + Assert.Equal(0, logins.Count()); + Assert.NotEqual(stamp, user.SecurityStamp); + } + + [Fact] + public async Task CanRemovePassword() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("RemovePasswordTest"); + const string password = "password"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + var stamp = user.SecurityStamp; + IdentityResultAssert.IsSuccess(await manager.RemovePasswordAsync(user)); + var u = await manager.FindByNameAsync(user.UserName); + Assert.NotNull(u); + Assert.Null(u.PasswordHash); + Assert.NotEqual(stamp, user.SecurityStamp); + } + + [Fact] + public async Task CanChangePassword() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("ChangePasswordTest"); + const string password = "password"; + const string newPassword = "newpassword"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + Assert.Equal(manager.Users.Count(), 1); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user, password, newPassword)); + Assert.Null(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, newPassword)); + Assert.NotEqual(stamp, user.SecurityStamp); + } + + [Fact] + public async Task CanAddRemoveUserClaim() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("ClaimsAddRemove"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Claim[] claims = { new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3") }; + foreach (var c in claims) + { + IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c)); + } + var userClaims = await manager.GetClaimsAsync(user); + Assert.Equal(3, userClaims.Count); + IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[0])); + userClaims = await manager.GetClaimsAsync(user); + Assert.Equal(2, userClaims.Count); + IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[1])); + userClaims = await manager.GetClaimsAsync(user); + Assert.Equal(1, userClaims.Count); + IdentityResultAssert.IsSuccess(await manager.RemoveClaimAsync(user, claims[2])); + userClaims = await manager.GetClaimsAsync(user); + Assert.Equal(0, userClaims.Count); + } + + [Fact] + public async Task ChangePasswordFallsIfPasswordWrong() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("user"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); + var result = await manager.ChangePasswordAsync(user, "bogus", "newpassword"); + IdentityResultAssert.IsFailure(result, "Incorrect password."); + } + + [Fact] + public async Task AddDupeUserNameFails() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("dupe"); + var user2 = new EntityUser("dupe"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), "Name dupe is already taken."); + } + + [Fact] + public async Task AddDupeEmailAllowedByDefault() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("dupe") { Email = "yup@yup.com" }; + var user2 = new EntityUser("dupeEmail") { Email = "yup@yup.com" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); + } + + [Fact] + public async Task AddDupeEmailFallsWhenUniqueEmailRequired() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserValidator = new UserValidator { RequireUniqueEmail = true }; + var user = new EntityUser("dupe") { Email = "yup@yup.com" }; + var user2 = new EntityUser("dupeEmail") { Email = "yup@yup.com" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), "Email 'yup@yup.com' is already taken."); + } + + [Fact] + public async Task UpdateSecurityStampActuallyChanges() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("stampMe"); + Assert.Null(user.SecurityStamp); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); + Assert.NotEqual(stamp, user.SecurityStamp); + } + + [Fact] + public async Task AddDupeLoginFails() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("DupeLogin"); + var login = new UserLoginInfo("provder", "key"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); + var result = await manager.AddLoginAsync(user, login); + IdentityResultAssert.IsFailure(result, "A user with that external login already exists."); + } + + // Email tests + [Fact] + public async Task CanFindByEmail() + { + var manager = TestIdentityFactory.CreateManager(); + const string userName = "EmailTest"; + const string email = "email@test.com"; + var user = new EntityUser(userName) { Email = email }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var fetch = await manager.FindByEmailAsync(email); + Assert.Equal(user, fetch); + } + + [Fact] + public async Task CanFindUsersViaUserQuerable() + { + var mgr = TestIdentityFactory.CreateManager(); + var users = new[] + { + new EntityUser("user1"), + new EntityUser("user2"), + new EntityUser("user3") + }; + foreach (var u in users) + { + IdentityResultAssert.IsSuccess(await mgr.CreateAsync(u)); + } + var usersQ = mgr.Users; + Assert.Equal(3, usersQ.Count()); + Assert.NotNull(usersQ.FirstOrDefault(u => u.UserName == "user1")); + Assert.NotNull(usersQ.FirstOrDefault(u => u.UserName == "user2")); + Assert.NotNull(usersQ.FirstOrDefault(u => u.UserName == "user3")); + Assert.Null(usersQ.FirstOrDefault(u => u.UserName == "bogus")); + } + + [Fact] + public async Task ClaimsIdentityCreatesExpectedClaims() + { + var context = TestIdentityFactory.CreateContext(); + var manager = TestIdentityFactory.CreateManager(context); + var role = TestIdentityFactory.CreateRoleManager(context); + var user = new EntityUser("Hao"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await role.CreateAsync(new EntityRole("Admin"))); + IdentityResultAssert.IsSuccess(await role.CreateAsync(new EntityRole("Local"))); + IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, "Admin")); + IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, "Local")); + Claim[] userClaims = + { + new Claim("Whatever", "Value"), + new Claim("Whatever2", "Value2") + }; + foreach (var c in userClaims) + { + IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c)); + } + + var identity = await manager.CreateIdentityAsync(user, "test"); + var claimsFactory = (ClaimsIdentityFactory)manager.ClaimsIdentityFactory; + Assert.NotNull(claimsFactory); + var claims = identity.Claims.ToList(); + Assert.NotNull(claims); + Assert.True( + claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName)); + Assert.True(claims.Any(c => c.Type == claimsFactory.UserIdClaimType && c.Value == user.Id)); + Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Admin")); + Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Local")); + foreach (var cl in userClaims) + { + Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value)); + } + } + + [Fact] + public async Task ConfirmEmailFalseByDefaultTest() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("test"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Assert.False(await manager.IsEmailConfirmedAsync(user)); + } + + // TODO: No token provider implementations yet + private class StaticTokenProvider : IUserTokenProvider + { + public Task GenerateAsync(string purpose, UserManager manager, + EntityUser user, CancellationToken token) + { + return Task.FromResult(MakeToken(purpose, user)); + } + + public Task ValidateAsync(string purpose, string token, UserManager manager, + EntityUser user, CancellationToken cancellationToken) + { + return Task.FromResult(token == MakeToken(purpose, user)); + } + + public Task NotifyAsync(string token, UserManager manager, EntityUser user, CancellationToken cancellationToken) + { + return Task.FromResult(0); + } + + public Task IsValidProviderForUserAsync(UserManager manager, EntityUser user, CancellationToken token) + { + return Task.FromResult(true); + } + + private static string MakeToken(string purpose, EntityUser user) + { + return string.Join(":", user.Id, purpose, "ImmaToken"); + } + } + + [Fact] + public async Task CanResetPasswordWithStaticTokenProvider() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserTokenProvider = new StaticTokenProvider(); + var user = new EntityUser("ResetPasswordTest"); + const string password = "password"; + const string newPassword = "newpassword"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + var token = await manager.GeneratePasswordResetTokenAsync(user); + Assert.NotNull(token); + IdentityResultAssert.IsSuccess(await manager.ResetPassword(user, token, newPassword)); + Assert.Null(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, newPassword)); + Assert.NotEqual(stamp, user.SecurityStamp); + } + + [Fact] + public async Task PasswordValidatorCanBlockResetPasswordWithStaticTokenProvider() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserTokenProvider = new StaticTokenProvider(); + var user = new EntityUser("ResetPasswordTest"); + const string password = "password"; + const string newPassword = "newpassword"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + var token = await manager.GeneratePasswordResetTokenAsync(user); + Assert.NotNull(token); + manager.PasswordValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.ResetPassword(user, token, newPassword), + AlwaysBadValidator.ErrorMessage); + Assert.NotNull(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(stamp, user.SecurityStamp); + } + + [Fact] + public async Task ResetPasswordWithStaticTokenProviderFailsWithWrongToken() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserTokenProvider = new StaticTokenProvider(); + var user = new EntityUser("ResetPasswordTest"); + const string password = "password"; + const string newPassword = "newpassword"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + IdentityResultAssert.IsFailure(await manager.ResetPassword(user, "bogus", newPassword), "Invalid token."); + Assert.NotNull(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(stamp, user.SecurityStamp); + } + + [Fact] + public async Task CanGenerateAndVerifyUserTokenWithStaticTokenProvider() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserTokenProvider = new StaticTokenProvider(); + var user = new EntityUser("UserTokenTest"); + var user2 = new EntityUser("UserTokenTest2"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); + var token = await manager.GenerateUserTokenAsync("test", user); + Assert.True(await manager.VerifyUserTokenAsync(user, "test", token)); + Assert.False(await manager.VerifyUserTokenAsync(user, "test2", token)); + Assert.False(await manager.VerifyUserTokenAsync(user, "test", token + "a")); + Assert.False(await manager.VerifyUserTokenAsync(user2, "test", token)); + } + + [Fact] + public async Task CanConfirmEmailWithStaticToken() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserTokenProvider = new StaticTokenProvider(); + var user = new EntityUser("test"); + Assert.False(user.EmailConfirmed); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var token = await manager.GenerateEmailConfirmationTokenAsync(user); + Assert.NotNull(token); + IdentityResultAssert.IsSuccess(await manager.ConfirmEmailAsync(user, token)); + Assert.True(await manager.IsEmailConfirmedAsync(user)); + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, null)); + Assert.False(await manager.IsEmailConfirmedAsync(user)); + } + + [Fact] + public async Task ConfirmEmailWithStaticTokenFailsWithWrongToken() + { + var manager = TestIdentityFactory.CreateManager(); + manager.UserTokenProvider = new StaticTokenProvider(); + var user = new EntityUser("test"); + Assert.False(user.EmailConfirmed); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, "bogus"), "Invalid token."); + Assert.False(await manager.IsEmailConfirmedAsync(user)); + } + + // TODO: Can't reenable til we have a SecurityStamp linked token provider + //[Fact] + //public async Task ConfirmTokenFailsAfterPasswordChange() + //{ + // var manager = TestIdentityFactory.CreateManager(); + // var user = new EntityUser("test"); + // Assert.False(user.EmailConfirmed); + // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); + // var token = await manager.GenerateEmailConfirmationTokenAsync(user); + // Assert.NotNull(token); + // IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user, "password", "newpassword")); + // IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, token), "Invalid token."); + // Assert.False(await manager.IsEmailConfirmedAsync(user)); + //} + + // Lockout tests + + [Fact] + public async Task SingleFailureLockout() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); + mgr.UserLockoutEnabledByDefault = true; + var user = new EntityUser("fastLockout"); + 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)); + Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); + } + + [Fact] + public async Task TwoFailureLockout() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); + mgr.UserLockoutEnabledByDefault = true; + mgr.MaxFailedAccessAttemptsBeforeLockout = 2; + var user = new EntityUser("twoFailureLockout"); + 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.AccessFailedAsync(user)); + Assert.True(await mgr.IsLockedOutAsync(user)); + Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); + } + + [Fact] + public async Task ResetAccessCountPreventsLockout() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); + mgr.UserLockoutEnabledByDefault = true; + mgr.MaxFailedAccessAttemptsBeforeLockout = 2; + var user = new EntityUser("resetLockout"); + 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)); + Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); + Assert.False(await mgr.IsLockedOutAsync(user)); + Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + 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)); + } + + [Fact] + public async Task CanEnableLockoutManuallyAndLockout() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); + mgr.MaxFailedAccessAttemptsBeforeLockout = 2; + var user = new EntityUser("manualLockout"); + 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); + 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.AccessFailedAsync(user)); + Assert.True(await mgr.IsLockedOutAsync(user)); + Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); + } + + [Fact] + public async Task UserNotLockedOutWithNullDateTimeAndIsSetToNullDate() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.UserLockoutEnabledByDefault = true; + var user = new EntityUser("LockoutTest"); + 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)); + Assert.Equal(new DateTimeOffset(), await mgr.GetLockoutEndDateAsync(user)); + Assert.Null(user.LockoutEnd); + } + + [Fact] + public async Task LockoutFailsIfNotEnabled() + { + var mgr = TestIdentityFactory.CreateManager(); + var user = new EntityUser("LockoutNotEnabledTest"); + 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)); + } + + [Fact] + public async Task LockoutEndToUtcNowMinus1SecInUserShouldNotBeLockedOut() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.UserLockoutEnabledByDefault = true; + var user = new EntityUser("LockoutUtcNowTest") { LockoutEnd = DateTime.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)); + } + + [Fact] + public async Task LockoutEndToUtcNowSubOneSecondWithManagerShouldNotBeLockedOut() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.UserLockoutEnabledByDefault = true; + var user = new EntityUser("LockoutUtcNowTest"); + 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)); + } + + [Fact] + public async Task LockoutEndToUtcNowPlus5ShouldBeLockedOut() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.UserLockoutEnabledByDefault = true; + var user = new EntityUser("LockoutUtcNowTest") { LockoutEnd = DateTime.UtcNow.AddMinutes(5) }; + IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); + Assert.True(await mgr.GetLockoutEnabledAsync(user)); + Assert.True(user.LockoutEnabled); + Assert.True(await mgr.IsLockedOutAsync(user)); + } + + [Fact] + public async Task UserLockedOutWithDateTimeLocalKindNowPlus30() + { + var mgr = TestIdentityFactory.CreateManager(); + mgr.UserLockoutEnabledByDefault = true; + var user = new EntityUser("LockoutTest"); + 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)); + var end = await mgr.GetLockoutEndDateAsync(user); + Assert.Equal(lockoutEnd, end); + } + + // Role Tests + [Fact] + public async Task CanCreateRoleTest() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("create"); + Assert.False(await manager.RoleExistsAsync(role.Name)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.True(await manager.RoleExistsAsync(role.Name)); + } + + private class AlwaysBadValidator : IUserValidator, IRoleValidator, + IPasswordValidator + { + public const string ErrorMessage = "I'm Bad."; + + public Task ValidateAsync(string password, CancellationToken token) + { + return Task.FromResult(IdentityResult.Failed(ErrorMessage)); + } + + public Task ValidateAsync(RoleManager manager, EntityRole role, CancellationToken token) + { + return Task.FromResult(IdentityResult.Failed(ErrorMessage)); + } + + public Task ValidateAsync(UserManager manager, EntityUser user, CancellationToken token) + { + return Task.FromResult(IdentityResult.Failed(ErrorMessage)); + } + } + + [Fact] + public async Task BadValidatorBlocksCreateRole() + { + var manager = TestIdentityFactory.CreateRoleManager(); + manager.RoleValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.CreateAsync(new EntityRole("blocked")), + AlwaysBadValidator.ErrorMessage); + } + + [Fact] + public async Task BadValidatorBlocksRoleUpdate() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("poorguy"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + var error = AlwaysBadValidator.ErrorMessage; + manager.RoleValidator = new AlwaysBadValidator(); + IdentityResultAssert.IsFailure(await manager.UpdateAsync(role), error); + } + + [Fact] + public async Task CanDeleteRoleTest() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("delete"); + Assert.False(await manager.RoleExistsAsync(role.Name)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + IdentityResultAssert.IsSuccess(await manager.DeleteAsync(role)); + Assert.False(await manager.RoleExistsAsync(role.Name)); + } + + [Fact] + public async Task CanRoleFindByIdTest() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("FindByIdAsync"); + Assert.Null(await manager.FindByIdAsync(role.Id)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.Equal(role, await manager.FindByIdAsync(role.Id)); + } + + [Fact] + public async Task CanRoleFindByName() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("FindByNameAsync"); + Assert.Null(await manager.FindByNameAsync(role.Name)); + Assert.False(await manager.RoleExistsAsync(role.Name)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.Equal(role, await manager.FindByNameAsync(role.Name)); + } + + [Fact] + public async Task CanUpdateRoleNameTest() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("update"); + Assert.False(await manager.RoleExistsAsync(role.Name)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.True(await manager.RoleExistsAsync(role.Name)); + role.Name = "Changed"; + IdentityResultAssert.IsSuccess(await manager.UpdateAsync(role)); + Assert.False(await manager.RoleExistsAsync("update")); + Assert.Equal(role, await manager.FindByNameAsync(role.Name)); + } + + [Fact] + public async Task CanQuerableRolesTest() + { + var manager = TestIdentityFactory.CreateRoleManager(); + EntityRole[] roles = + { + new EntityRole("r1"), new EntityRole("r2"), new EntityRole("r3"), + new EntityRole("r4") + }; + foreach (var r in roles) + { + IdentityResultAssert.IsSuccess(await manager.CreateAsync(r)); + } + Assert.Equal(roles.Length, manager.Roles.Count()); + var r1 = manager.Roles.FirstOrDefault(r => r.Name == "r1"); + Assert.Equal(roles[0], r1); + } + + //[Fact] + //public async Task DeleteRoleNonEmptySucceedsTest() + //{ + // // Need fail if not empty? + // var userMgr = TestIdentityFactory.CreateManager(); + // var roleMgr = TestIdentityFactory.CreateRoleManager(); + // var role = new EntityRole("deleteNonEmpty"); + // Assert.False(await roleMgr.RoleExistsAsync(role.Name)); + // IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); + // var user = new EntityUser("t"); + // IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); + // IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); + // 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? + // var roles = await userMgr.GetRolesAsync(user); + + // // In memory this doesn't work since there's no concept of cascading deletes + // //Assert.Equal(0, roles.Count()); + //} + + ////[Fact] + ////public async Task DeleteUserRemovesFromRoleTest() + ////{ + //// // Need fail if not empty? + //// var userMgr = TestIdentityFactory.CreateManager(); + //// var roleMgr = TestIdentityFactory.CreateRoleManager(); + //// var role = new EntityRole("deleteNonEmpty"); + //// Assert.False(await roleMgr.RoleExistsAsync(role.Name)); + //// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); + //// var user = new EntityUser("t"); + //// IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); + //// IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); + //// IdentityResultAssert.IsSuccess(await userMgr.DeleteAsync(user)); + //// role = roleMgr.FindByIdAsync(role.Id); + ////} + + [Fact] + public async Task CreateRoleFailsIfExists() + { + var manager = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("dupeRole"); + Assert.False(await manager.RoleExistsAsync(role.Name)); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); + Assert.True(await manager.RoleExistsAsync(role.Name)); + var role2 = new EntityRole("dupeRole"); + IdentityResultAssert.IsFailure(await manager.CreateAsync(role2)); + } + + [Fact] + public async Task CanAddUsersToRole() + { + var context = TestIdentityFactory.CreateContext(); + var manager = TestIdentityFactory.CreateManager(context); + var roleManager = TestIdentityFactory.CreateRoleManager(context); + var role = new EntityRole("addUserTest"); + IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role)); + EntityUser[] users = + { + new EntityUser("1"), new EntityUser("2"), new EntityUser("3"), + new EntityUser("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)); + } + } + + [Fact] + public async Task CanGetRolesForUser() + { + var context = TestIdentityFactory.CreateContext(); + var userManager = TestIdentityFactory.CreateManager(context); + var roleManager = TestIdentityFactory.CreateRoleManager(context); + EntityUser[] users = + { + new EntityUser("u1"), new EntityUser("u2"), new EntityUser("u3"), + new EntityUser("u4") + }; + EntityRole[] roles = + { + new EntityRole("r1"), new EntityRole("r2"), new EntityRole("r3"), + new EntityRole("r4") + }; + foreach (var u in users) + { + IdentityResultAssert.IsSuccess(await userManager.CreateAsync(u)); + } + foreach (var r in roles) + { + 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)); + } + } + + foreach (var u in users) + { + var rs = await userManager.GetRolesAsync(u); + Assert.Equal(roles.Length, rs.Count); + foreach (var r in roles) + { + Assert.True(rs.Any(role => role == r.Name)); + } + } + } + + + [Fact] + public async Task RemoveUserFromRoleWithMultipleRoles() + { + var context = TestIdentityFactory.CreateContext(); + var userManager = TestIdentityFactory.CreateManager(context); + var roleManager = TestIdentityFactory.CreateRoleManager(context); + var user = new EntityUser("MultiRoleUser"); + IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); + EntityRole[] roles = + { + new EntityRole("r1"), new EntityRole("r2"), new EntityRole("r3"), + new EntityRole("r4") + }; + 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.RemoveFromRoleAsync(user, roles[2].Name)); + Assert.False(await userManager.IsInRoleAsync(user, roles[2].Name)); + } + + [Fact] + public async Task CanRemoveUsersFromRole() + { + var context = TestIdentityFactory.CreateContext(); + var userManager = TestIdentityFactory.CreateManager(context); + var roleManager = TestIdentityFactory.CreateRoleManager(context); + EntityUser[] users = + { + new EntityUser("1"), new EntityUser("2"), new EntityUser("3"), + new EntityUser("4") + }; + foreach (var u in users) + { + IdentityResultAssert.IsSuccess(await userManager.CreateAsync(u)); + } + var r = new EntityRole("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)); + } + foreach (var u in users) + { + IdentityResultAssert.IsSuccess(await userManager.RemoveFromRoleAsync(u, r.Name)); + Assert.False(await userManager.IsInRoleAsync(u, r.Name)); + } + } + + [Fact] + public async Task RemoveUserNotInRoleFails() + { + var context = TestIdentityFactory.CreateContext(); + var userMgr = TestIdentityFactory.CreateManager(context); + var roleMgr = TestIdentityFactory.CreateRoleManager(context); + var role = new EntityRole("addUserDupeTest"); + var user = new EntityUser("user1"); + IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); + IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); + var result = await userMgr.RemoveFromRoleAsync(user, role.Name); + IdentityResultAssert.IsFailure(result, "User is not in role."); + } + + [Fact] + public async Task AddUserToUnknownRoleFails() + { + var manager = TestIdentityFactory.CreateManager(); + var u = new EntityUser("u1"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(u)); + await Assert.ThrowsAsync( + async () => await manager.AddToRoleAsync(u, "bogus")); + } + + [Fact] + public async Task AddUserToRoleFailsIfAlreadyInRole() + { + var context = TestIdentityFactory.CreateContext(); + var userMgr = TestIdentityFactory.CreateManager(context); + var roleMgr = TestIdentityFactory.CreateRoleManager(context); + var role = new EntityRole("addUserDupeTest"); + var user = new EntityUser("user1"); + 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), "User already in role."); + } + + [Fact] + public async Task CanFindRoleByNameWithManager() + { + var roleMgr = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("findRoleByNameTest"); + IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); + Assert.Equal(role.Id, (await roleMgr.FindByNameAsync(role.Name)).Id); + } + + [Fact] + public async Task CanFindRoleWithManager() + { + var roleMgr = TestIdentityFactory.CreateRoleManager(); + var role = new EntityRole("findRoleTest"); + IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); + Assert.Equal(role, await roleMgr.FindByIdAsync(role.Id)); + } + + [Fact] + public async Task SetPhoneNumberTest() + { + var manager = TestIdentityFactory.CreateManager(); + const string userName = "PhoneTest"; + var user = new EntityUser(userName) {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); + } + +#if NET45 + [Fact] + public async Task CanChangePhoneNumber() + { + var manager = TestIdentityFactory.CreateManager(); + const string userName = "PhoneTest"; + var user = new EntityUser(userName) { 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)); + Assert.True(await manager.IsPhoneNumberConfirmedAsync(user)); + Assert.Equal(await manager.GetPhoneNumberAsync(user), "111-111-1111"); + Assert.NotEqual(stamp, user.SecurityStamp); + } + + [Fact] + public async Task ChangePhoneNumberFailsWithWrongToken() + { + var manager = TestIdentityFactory.CreateManager(); + const string userName = "PhoneTest"; + var user = new EntityUser(userName) { 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."); + Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); + Assert.Equal(await manager.GetPhoneNumberAsync(user), "123-456-7890"); + Assert.Equal(stamp, user.SecurityStamp); + } + + [Fact] + public async Task CanVerifyPhoneNumber() + { + var manager = TestIdentityFactory.CreateManager(); + const string userName = "VerifyPhoneTest"; + var user = new EntityUser(userName); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + const string num1 = "111-123-4567"; + const string num2 = "111-111-1111"; + var token1 = await manager.GenerateChangePhoneNumberTokenAsync(user, num1); + var token2 = await manager.GenerateChangePhoneNumberTokenAsync(user, num2); + Assert.NotEqual(token1, token2); + Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num1)); + Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num2)); + Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num1)); + Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num2)); + } +#endif + + private class EmailTokenProvider : IUserTokenProvider + { + public Task GenerateAsync(string purpose, UserManager manager, EntityUser user, CancellationToken token) + { + return Task.FromResult(MakeToken(purpose)); + } + + public Task ValidateAsync(string purpose, string token, UserManager manager, + EntityUser user, CancellationToken cancellationToken) + { + return Task.FromResult(token == MakeToken(purpose)); + } + + public Task NotifyAsync(string token, UserManager manager, EntityUser user, CancellationToken cancellationToken) + { + return manager.SendEmailAsync(user, token, token); + } + + public async Task IsValidProviderForUserAsync(UserManager manager, EntityUser user, CancellationToken token) + { + return !string.IsNullOrEmpty(await manager.GetEmailAsync(user)); + } + + private static string MakeToken(string purpose) + { + return "email:" + purpose; + } + } + + private class SmsTokenProvider : IUserTokenProvider + { + public Task GenerateAsync(string purpose, UserManager manager, EntityUser user, CancellationToken token) + { + return Task.FromResult(MakeToken(purpose)); + } + + public Task ValidateAsync(string purpose, string token, UserManager manager, + EntityUser user, CancellationToken cancellationToken) + { + return Task.FromResult(token == MakeToken(purpose)); + } + + public Task NotifyAsync(string token, UserManager manager, EntityUser user, CancellationToken cancellationToken) + { + return manager.SendSmsAsync(user, token); + } + + public async Task IsValidProviderForUserAsync(UserManager manager, EntityUser user, CancellationToken token) + { + return !string.IsNullOrEmpty(await manager.GetPhoneNumberAsync(user)); + } + + private static string MakeToken(string purpose) + { + return "sms:" + purpose; + } + } + + [Fact] + public async Task CanEmailTwoFactorToken() + { + var manager = TestIdentityFactory.CreateManager(); + var messageService = new TestMessageService(); + manager.EmailService = messageService; + const string factorId = "EmailCode"; + manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); + var user = new EntityUser("EmailCodeTest") { Email = "foo@foo.com" }; + const string password = "password"; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + Assert.NotNull(token); + Assert.Null(messageService.Message); + IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user, factorId, token)); + Assert.NotNull(messageService.Message); + Assert.Equal(token, messageService.Message.Subject); + Assert.Equal(token, messageService.Message.Body); + Assert.True(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); + } + + [Fact] + public async Task NotifyWithUnknownProviderFails() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("NotifyFail"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + await + ExceptionAssert.ThrowsAsync( + async () => await manager.NotifyTwoFactorTokenAsync(user, "Bogus", "token"), + "No IUserTwoFactorProvider for 'Bogus' is registered."); + } + + + //[Fact] + //public async Task EmailTokenFactorWithFormatTest() + //{ + // var manager = TestIdentityFactory.CreateManager(); + // var messageService = new TestMessageService(); + // manager.EmailService = messageService; + // const string factorId = "EmailCode"; + // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider + // { + // Subject = "Security Code", + // BodyFormat = "Your code is: {0}" + // }); + // var user = new EntityUser("EmailCodeTest") { Email = "foo@foo.com" }; + // const string password = "password"; + // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); + // var stamp = user.SecurityStamp; + // Assert.NotNull(stamp); + // var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + // Assert.NotNull(token); + // Assert.Null(messageService.Message); + // IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user, factorId, token)); + // Assert.NotNull(messageService.Message); + // Assert.Equal("Security Code", messageService.Message.Subject); + // Assert.Equal("Your code is: " + token, messageService.Message.Body); + // Assert.True(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); + //} + + //[Fact] + //public async Task EmailFactorFailsAfterSecurityStampChangeTest() + //{ + // var manager = TestIdentityFactory.CreateManager(); + // const string factorId = "EmailCode"; + // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); + // var user = new EntityUser("EmailCodeTest") { Email = "foo@foo.com" }; + // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + // var stamp = user.SecurityStamp; + // Assert.NotNull(stamp); + // var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + // Assert.NotNull(token); + // IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); + // Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); + //} + + [Fact] + public async Task EnableTwoFactorChangesSecurityStamp() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("TwoFactorEnabledTest"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + IdentityResultAssert.IsSuccess(await manager.SetTwoFactorEnabledAsync(user, true)); + Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); + Assert.True(await manager.GetTwoFactorEnabledAsync(user)); + } + + [Fact] + public async Task CanSendSms() + { + var manager = TestIdentityFactory.CreateManager(); + var messageService = new TestMessageService(); + manager.SmsService = messageService; + var user = new EntityUser("SmsTest") { PhoneNumber = "4251234567" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + await manager.SendSmsAsync(user, "Hi"); + Assert.NotNull(messageService.Message); + Assert.Equal("Hi", messageService.Message.Body); + } + + [Fact] + public async Task CanSendEmail() + { + var manager = TestIdentityFactory.CreateManager(); + var messageService = new TestMessageService(); + manager.EmailService = messageService; + var user = new EntityUser("EmailTest") { Email = "foo@foo.com" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + await manager.SendEmailAsync(user, "Hi", "Body"); + Assert.NotNull(messageService.Message); + Assert.Equal("Hi", messageService.Message.Subject); + Assert.Equal("Body", messageService.Message.Body); + } + + [Fact] + public async Task CanSmsTwoFactorToken() + { + var manager = TestIdentityFactory.CreateManager(); + var messageService = new TestMessageService(); + manager.SmsService = messageService; + const string factorId = "PhoneCode"; + manager.RegisterTwoFactorProvider(factorId, new SmsTokenProvider()); + var user = new EntityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var stamp = user.SecurityStamp; + Assert.NotNull(stamp); + var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + Assert.NotNull(token); + Assert.Null(messageService.Message); + IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user, factorId, token)); + Assert.NotNull(messageService.Message); + Assert.Equal(token, messageService.Message.Body); + Assert.True(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); + } + + //[Fact] + //public async Task PhoneTokenFactorFormatTest() + //{ + // var manager = TestIdentityFactory.CreateManager(); + // var messageService = new TestMessageService(); + // manager.SmsService = messageService; + // const string factorId = "PhoneCode"; + // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider + // { + // MessageFormat = "Your code is: {0}" + // }); + // var user = new EntityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; + // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + // var stamp = user.SecurityStamp; + // Assert.NotNull(stamp); + // var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + // Assert.NotNull(token); + // Assert.Null(messageService.Message); + // IdentityResultAssert.IsSuccess(await manager.NotifyTwoFactorTokenAsync(user, factorId, token)); + // Assert.NotNull(messageService.Message); + // Assert.Equal("Your code is: " + token, messageService.Message.Body); + // Assert.True(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); + //} + + [Fact] + public async Task GenerateTwoFactorWithUnknownFactorProviderWillThrow() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("PhoneCodeTest"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + const string error = "No IUserTwoFactorProvider for 'bogus' is registered."; + await + ExceptionAssert.ThrowsAsync( + () => manager.GenerateTwoFactorTokenAsync(user, "bogus"), error); + await ExceptionAssert.ThrowsAsync( + () => manager.VerifyTwoFactorTokenAsync(user, "bogus", "bogus"), error); + } + + [Fact] + public async Task GetValidTwoFactorTestEmptyWithNoProviders() + { + var manager = TestIdentityFactory.CreateManager(); + var user = new EntityUser("test"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var factors = await manager.GetValidTwoFactorProvidersAsync(user); + Assert.NotNull(factors); + Assert.True(!factors.Any()); + } + + [Fact] + public async Task GetValidTwoFactorTest() + { + var manager = TestIdentityFactory.CreateManager(); + manager.RegisterTwoFactorProvider("phone", new SmsTokenProvider()); + manager.RegisterTwoFactorProvider("email", new EmailTokenProvider()); + var user = new EntityUser("test"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var factors = await manager.GetValidTwoFactorProvidersAsync(user); + Assert.NotNull(factors); + Assert.True(!factors.Any()); + IdentityResultAssert.IsSuccess(await manager.SetPhoneNumberAsync(user, "111-111-1111")); + factors = await manager.GetValidTwoFactorProvidersAsync(user); + Assert.NotNull(factors); + Assert.True(factors.Count() == 1); + Assert.Equal("phone", factors[0]); + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, "test@test.com")); + factors = await manager.GetValidTwoFactorProvidersAsync(user); + Assert.NotNull(factors); + Assert.True(factors.Count() == 2); + IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, null)); + factors = await manager.GetValidTwoFactorProvidersAsync(user); + Assert.NotNull(factors); + Assert.True(factors.Count() == 1); + Assert.Equal("phone", factors[0]); + } + + //[Fact] + //public async Task PhoneFactorFailsAfterSecurityStampChangeTest() + //{ + // var manager = TestIdentityFactory.CreateManager(); + // var factorId = "PhoneCode"; + // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider()); + // var user = new EntityUser("PhoneCodeTest"); + // user.PhoneNumber = "4251234567"; + // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + // var stamp = user.SecurityStamp; + // Assert.NotNull(stamp); + // var token = await manager.GenerateTwoFactorTokenAsync(user, factorId); + // Assert.NotNull(token); + // IdentityResultAssert.IsSuccess(await manager.UpdateSecurityStampAsync(user)); + // Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); + //} + + [Fact] + public async Task VerifyTokenFromWrongTokenProviderFails() + { + var manager = TestIdentityFactory.CreateManager(); + manager.RegisterTwoFactorProvider("PhoneCode", new SmsTokenProvider()); + manager.RegisterTwoFactorProvider("EmailCode", new EmailTokenProvider()); + var user = new EntityUser("WrongTokenProviderTest") { PhoneNumber = "4251234567" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + var token = await manager.GenerateTwoFactorTokenAsync(user, "PhoneCode"); + Assert.NotNull(token); + Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "EmailCode", token)); + } + + [Fact] + public async Task VerifyWithWrongSmsTokenFails() + { + var manager = TestIdentityFactory.CreateManager(); + const string factorId = "PhoneCode"; + manager.RegisterTwoFactorProvider(factorId, new SmsTokenProvider()); + var user = new EntityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, "bogus")); + } + + private class DataStoreConfig : ContextConfiguration + { + private readonly DataStore _store; + + public DataStoreConfig(DataStore store) + { + _store = store; + } + + public override DataStore DataStore + { + get { return _store; } + } + + } + + public class TestMessageService : IIdentityMessageService + { + public IdentityMessage Message { get; set; } + + public Task SendAsync(IdentityMessage message, CancellationToken token) + { + Message = message; + return Task.FromResult(0); + } + } + } +} diff --git a/test/Microsoft.AspNet.Identity.Entity.Test/project.json b/test/Microsoft.AspNet.Identity.Entity.Test/project.json index 5d750e1406..d959fe3618 100644 --- a/test/Microsoft.AspNet.Identity.Entity.Test/project.json +++ b/test/Microsoft.AspNet.Identity.Entity.Test/project.json @@ -50,5 +50,6 @@ } }, "commands": { + "test": "Xunit.KRunner" } } \ No newline at end of file diff --git a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs index 6e55f782b1..507923e817 100644 --- a/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs +++ b/test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs @@ -14,7 +14,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanDeleteUser() { var manager = CreateManager(); - var user = new InMemoryUser("DeleteAsync"); + var user = new IdentityUser("DeleteAsync"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.DeleteAsync(user)); Assert.Null(await manager.FindByIdAsync(user.Id)); @@ -24,7 +24,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanUpdateUserName() { var manager = CreateManager(); - var user = new InMemoryUser("UpdateAsync"); + var user = new IdentityUser("UpdateAsync"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.Null(await manager.FindByNameAsync("New")); user.UserName = "New"; @@ -33,11 +33,32 @@ namespace Microsoft.AspNet.Identity.InMemory.Test Assert.Null(await manager.FindByNameAsync("UpdateAsync")); } + [Fact] + public async Task CanSetUserName() + { + var manager = CreateManager(); + var user = new IdentityUser("UpdateAsync"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Assert.Null(await manager.FindByNameAsync("New")); + IdentityResultAssert.IsSuccess(await manager.SetUserNameAsync(user, "New")); + Assert.NotNull(await manager.FindByNameAsync("New")); + Assert.Null(await manager.FindByNameAsync("UpdateAsync")); + } + + [Fact] + public async Task CanFindById() + { + var manager = CreateManager(); + var user = new IdentityUser("FindByid"); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); + Assert.NotNull(await manager.FindByIdAsync(user.Id)); + } + [Fact] public async Task UserValidatorCanBlockCreate() { var manager = CreateManager(); - var user = new InMemoryUser("CreateBlocked"); + var user = new IdentityUser("CreateBlocked"); manager.UserValidator = new AlwaysBadValidator(); IdentityResultAssert.IsFailure(await manager.CreateAsync(user), AlwaysBadValidator.ErrorMessage); } @@ -46,7 +67,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task UserValidatorCanBlockUpdate() { var manager = CreateManager(); - var user = new InMemoryUser("UpdateBlocked"); + var user = new IdentityUser("UpdateBlocked"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); manager.UserValidator = new AlwaysBadValidator(); IdentityResultAssert.IsFailure(await manager.UpdateAsync(user), AlwaysBadValidator.ErrorMessage); @@ -58,8 +79,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task UserValidatorBlocksShortEmailsWhenRequiresUniqueEmail(string email) { var manager = CreateManager(); - var user = new InMemoryUser("UpdateBlocked") {Email = email}; - manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; + var user = new IdentityUser("UpdateBlocked") {Email = email}; + manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; IdentityResultAssert.IsFailure(await manager.CreateAsync(user), "Email cannot be null or empty."); } @@ -70,8 +91,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task UserValidatorBlocksInvalidEmailsWhenRequiresUniqueEmail(string email) { var manager = CreateManager(); - var user = new InMemoryUser("UpdateBlocked") {Email = email}; - manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; + var user = new IdentityUser("UpdateBlocked") {Email = email}; + manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; IdentityResultAssert.IsFailure(await manager.CreateAsync(user), "Email '" + email + "' is invalid."); } #endif @@ -80,7 +101,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task PasswordValidatorCanBlockAddPassword() { var manager = CreateManager(); - var user = new InMemoryUser("AddPasswordBlocked"); + var user = new IdentityUser("AddPasswordBlocked"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); manager.PasswordValidator = new AlwaysBadValidator(); IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), @@ -91,7 +112,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task PasswordValidatorCanBlockChangePassword() { var manager = CreateManager(); - var user = new InMemoryUser("ChangePasswordBlocked"); + var user = new IdentityUser("ChangePasswordBlocked"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); manager.PasswordValidator = new AlwaysBadValidator(); IdentityResultAssert.IsFailure(await manager.ChangePasswordAsync(user, "password", "new"), @@ -102,11 +123,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanCreateUserNoPassword() { var manager = CreateManager(); - IdentityResultAssert.IsSuccess(await manager.CreateAsync(new InMemoryUser("CreateUserTest"))); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityUser("CreateUserTest"))); var user = await manager.FindByNameAsync("CreateUserTest"); Assert.NotNull(user); Assert.Null(user.PasswordHash); - var logins = await manager.GetLogins(user); + var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(0, logins.Count()); } @@ -118,11 +139,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test const string userName = "CreateExternalUserTest"; const string provider = "ZzAuth"; const string providerKey = "HaoKey"; - IdentityResultAssert.IsSuccess(await manager.CreateAsync(new InMemoryUser(userName))); + IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityUser(userName))); var user = await manager.FindByNameAsync(userName); var login = new UserLoginInfo(provider, providerKey); - IdentityResultAssert.IsSuccess(await manager.AddLogin(user, login)); - var logins = await manager.GetLogins(user); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); + var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(1, logins.Count()); Assert.Equal(provider, logins.First().LoginProvider); @@ -134,24 +155,24 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); var login = new UserLoginInfo("Provider", "key"); - var user = new InMemoryUser("CreateUserLoginAddPasswordTest"); + var user = new IdentityUser("CreateUserLoginAddPasswordTest"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - IdentityResultAssert.IsSuccess(await manager.AddLogin(user, login)); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); Assert.False(await manager.HasPasswordAsync(user)); IdentityResultAssert.IsSuccess(await manager.AddPasswordAsync(user, "password")); Assert.True(await manager.HasPasswordAsync(user)); - var logins = await manager.GetLogins(user); + var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(1, logins.Count()); Assert.Equal(user, await manager.FindByLoginAsync(login)); - Assert.Equal(user, await manager.FindByUserNamePassword(user.UserName, "password")); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, "password")); } [Fact] public async Task AddPasswordFailsIfAlreadyHave() { var manager = CreateManager(); - var user = new InMemoryUser("CannotAddAnotherPassword"); + var user = new IdentityUser("CannotAddAnotherPassword"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "Password")); Assert.True(await manager.HasPasswordAsync(user)); IdentityResultAssert.IsFailure(await manager.AddPasswordAsync(user, "password"), @@ -162,22 +183,22 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanCreateUserAddRemoveLogin() { var manager = CreateManager(); - var user = new InMemoryUser("CreateUserAddRemoveLoginTest"); + var user = new IdentityUser("CreateUserAddRemoveLoginTest"); var login = new UserLoginInfo("Provider", "key"); var result = await manager.CreateAsync(user); Assert.NotNull(user); IdentityResultAssert.IsSuccess(result); - IdentityResultAssert.IsSuccess(await manager.AddLogin(user, login)); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); Assert.Equal(user, await manager.FindByLoginAsync(login)); - var logins = await manager.GetLogins(user); + var logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(1, logins.Count()); Assert.Equal(login.LoginProvider, logins.Last().LoginProvider); Assert.Equal(login.ProviderKey, logins.Last().ProviderKey); var stamp = user.SecurityStamp; - IdentityResultAssert.IsSuccess(await manager.RemoveLogin(user, login)); + IdentityResultAssert.IsSuccess(await manager.RemoveLoginAsync(user, login)); Assert.Null(await manager.FindByLoginAsync(login)); - logins = await manager.GetLogins(user); + logins = await manager.GetLoginsAsync(user); Assert.NotNull(logins); Assert.Equal(0, logins.Count()); Assert.NotEqual(stamp, user.SecurityStamp); @@ -187,7 +208,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanRemovePassword() { var manager = CreateManager(); - var user = new InMemoryUser("RemovePasswordTest"); + var user = new IdentityUser("RemovePasswordTest"); const string password = "password"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); var stamp = user.SecurityStamp; @@ -202,15 +223,15 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanChangePassword() { var manager = CreateManager(); - var user = new InMemoryUser("ChangePasswordTest"); + var user = new IdentityUser("ChangePasswordTest"); const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); var stamp = user.SecurityStamp; Assert.NotNull(stamp); IdentityResultAssert.IsSuccess(await manager.ChangePasswordAsync(user, password, newPassword)); - Assert.Null(await manager.FindByUserNamePassword(user.UserName, password)); - Assert.Equal(user, await manager.FindByUserNamePassword(user.UserName, newPassword)); + Assert.Null(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, newPassword)); Assert.NotEqual(stamp, user.SecurityStamp); } @@ -218,7 +239,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanAddRemoveUserClaim() { var manager = CreateManager(); - var user = new InMemoryUser("ClaimsAddRemove"); + var user = new IdentityUser("ClaimsAddRemove"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Claim[] claims = {new Claim("c", "v"), new Claim("c2", "v2"), new Claim("c2", "v3")}; foreach (Claim c in claims) @@ -242,7 +263,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task ChangePasswordFallsIfPasswordWrong() { var manager = CreateManager(); - var user = new InMemoryUser("user"); + var user = new IdentityUser("user"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); var result = await manager.ChangePasswordAsync(user, "bogus", "newpassword"); IdentityResultAssert.IsFailure(result, "Incorrect password."); @@ -252,8 +273,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task AddDupeUserNameFails() { var manager = CreateManager(); - var user = new InMemoryUser("dupe"); - var user2 = new InMemoryUser("dupe"); + var user = new IdentityUser("dupe"); + var user2 = new IdentityUser("dupe"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), "Name dupe is already taken."); } @@ -262,8 +283,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task AddDupeEmailAllowedByDefault() { var manager = CreateManager(); - var user = new InMemoryUser("dupe") {Email = "yup@yup.com"}; - var user2 = new InMemoryUser("dupeEmail") {Email = "yup@yup.com"}; + var user = new IdentityUser("dupe") {Email = "yup@yup.com"}; + var user2 = new IdentityUser("dupeEmail") {Email = "yup@yup.com"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); } @@ -272,9 +293,9 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task AddDupeEmailFallsWhenUniqueEmailRequired() { var manager = CreateManager(); - manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; - var user = new InMemoryUser("dupe") {Email = "yup@yup.com"}; - var user2 = new InMemoryUser("dupeEmail") {Email = "yup@yup.com"}; + manager.UserValidator = new UserValidator {RequireUniqueEmail = true}; + var user = new IdentityUser("dupe") {Email = "yup@yup.com"}; + var user2 = new IdentityUser("dupeEmail") {Email = "yup@yup.com"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsFailure(await manager.CreateAsync(user2), "Email 'yup@yup.com' is already taken."); } @@ -283,7 +304,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task UpdateSecurityStampActuallyChanges() { var manager = CreateManager(); - var user = new InMemoryUser("stampMe"); + var user = new IdentityUser("stampMe"); Assert.Null(user.SecurityStamp); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var stamp = user.SecurityStamp; @@ -296,11 +317,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task AddDupeLoginFails() { var manager = CreateManager(); - var user = new InMemoryUser("DupeLogin"); + var user = new IdentityUser("DupeLogin"); var login = new UserLoginInfo("provder", "key"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - IdentityResultAssert.IsSuccess(await manager.AddLogin(user, login)); - var result = await manager.AddLogin(user, login); + IdentityResultAssert.IsSuccess(await manager.AddLoginAsync(user, login)); + var result = await manager.AddLoginAsync(user, login); IdentityResultAssert.IsFailure(result, "A user with that external login already exists."); } @@ -311,7 +332,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var manager = CreateManager(); const string userName = "EmailTest"; const string email = "email@test.com"; - var user = new InMemoryUser(userName) {Email = email}; + var user = new IdentityUser(userName) {Email = email}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var fetch = await manager.FindByEmailAsync(email); Assert.Equal(user, fetch); @@ -323,11 +344,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var mgr = CreateManager(); var users = new[] { - new InMemoryUser("user1"), - new InMemoryUser("user2"), - new InMemoryUser("user3") + new IdentityUser("user1"), + new IdentityUser("user2"), + new IdentityUser("user3") }; - foreach (InMemoryUser u in users) + foreach (IdentityUser u in users) { IdentityResultAssert.IsSuccess(await mgr.CreateAsync(u)); } @@ -344,10 +365,10 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); var role = CreateRoleManager(); - var user = new InMemoryUser("Hao"); + var user = new IdentityUser("Hao"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - IdentityResultAssert.IsSuccess(await role.CreateAsync(new InMemoryRole("Admin"))); - IdentityResultAssert.IsSuccess(await role.CreateAsync(new InMemoryRole("Local"))); + IdentityResultAssert.IsSuccess(await role.CreateAsync(new IdentityRole("Admin"))); + IdentityResultAssert.IsSuccess(await role.CreateAsync(new IdentityRole("Local"))); IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, "Admin")); IdentityResultAssert.IsSuccess(await manager.AddToRoleAsync(user, "Local")); Claim[] userClaims = @@ -360,10 +381,10 @@ namespace Microsoft.AspNet.Identity.InMemory.Test IdentityResultAssert.IsSuccess(await manager.AddClaimAsync(user, c)); } - var identity = await manager.CreateIdentity(user, "test"); - var claimsFactory = manager.ClaimsIdentityFactory as ClaimsIdentityFactory; + var identity = await manager.CreateIdentityAsync(user, "test"); + var claimsFactory = (ClaimsIdentityFactory)manager.ClaimsIdentityFactory; Assert.NotNull(claimsFactory); - var claims = identity.Claims; + var claims = identity.Claims.ToList(); Assert.NotNull(claims); Assert.True( claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName)); @@ -380,37 +401,37 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task ConfirmEmailFalseByDefaultTest() { var manager = CreateManager(); - var user = new InMemoryUser("test"); + var user = new IdentityUser("test"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.IsEmailConfirmedAsync(user)); } // TODO: No token provider implementations yet - private class StaticTokenProvider : IUserTokenProvider + private class StaticTokenProvider : IUserTokenProvider { - public Task GenerateAsync(string purpose, UserManager manager, - InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task GenerateAsync(string purpose, UserManager manager, + IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(MakeToken(purpose, user)); } - public Task ValidateAsync(string purpose, string token, UserManager manager, - InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task ValidateAsync(string purpose, string token, UserManager manager, + IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(token == MakeToken(purpose, user)); } - public Task NotifyAsync(string token, UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task NotifyAsync(string token, UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(0); } - public Task IsValidProviderForUserAsync(UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task IsValidProviderForUserAsync(UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(true); } - private static string MakeToken(string purpose, InMemoryUser user) + private static string MakeToken(string purpose, IdentityUser user) { return string.Join(":", user.Id, purpose, "ImmaToken"); } @@ -421,7 +442,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); manager.UserTokenProvider = new StaticTokenProvider(); - var user = new InMemoryUser("ResetPasswordTest"); + var user = new IdentityUser("ResetPasswordTest"); const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); @@ -430,8 +451,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var token = await manager.GeneratePasswordResetTokenAsync(user); Assert.NotNull(token); IdentityResultAssert.IsSuccess(await manager.ResetPassword(user, token, newPassword)); - Assert.Null(await manager.FindByUserNamePassword(user.UserName, password)); - Assert.Equal(user, await manager.FindByUserNamePassword(user.UserName, newPassword)); + Assert.Null(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, newPassword)); Assert.NotEqual(stamp, user.SecurityStamp); } @@ -440,7 +461,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); manager.UserTokenProvider = new StaticTokenProvider(); - var user = new InMemoryUser("ResetPasswordTest"); + var user = new IdentityUser("ResetPasswordTest"); const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); @@ -451,8 +472,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test manager.PasswordValidator = new AlwaysBadValidator(); IdentityResultAssert.IsFailure(await manager.ResetPassword(user, token, newPassword), AlwaysBadValidator.ErrorMessage); - Assert.NotNull(await manager.FindByUserNamePassword(user.UserName, password)); - Assert.Equal(user, await manager.FindByUserNamePassword(user.UserName, password)); + Assert.NotNull(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, password)); Assert.Equal(stamp, user.SecurityStamp); } @@ -461,15 +482,15 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); manager.UserTokenProvider = new StaticTokenProvider(); - var user = new InMemoryUser("ResetPasswordTest"); + var user = new IdentityUser("ResetPasswordTest"); const string password = "password"; const string newPassword = "newpassword"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); var stamp = user.SecurityStamp; Assert.NotNull(stamp); IdentityResultAssert.IsFailure(await manager.ResetPassword(user, "bogus", newPassword), "Invalid token."); - Assert.NotNull(await manager.FindByUserNamePassword(user.UserName, password)); - Assert.Equal(user, await manager.FindByUserNamePassword(user.UserName, password)); + Assert.NotNull(await manager.FindByUserNamePasswordAsync(user.UserName, password)); + Assert.Equal(user, await manager.FindByUserNamePasswordAsync(user.UserName, password)); Assert.Equal(stamp, user.SecurityStamp); } @@ -478,8 +499,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); manager.UserTokenProvider = new StaticTokenProvider(); - var user = new InMemoryUser("UserTokenTest"); - var user2 = new InMemoryUser("UserTokenTest2"); + var user = new IdentityUser("UserTokenTest"); + var user2 = new IdentityUser("UserTokenTest2"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user2)); var token = await manager.GenerateUserTokenAsync("test", user); @@ -494,7 +515,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); manager.UserTokenProvider = new StaticTokenProvider(); - var user = new InMemoryUser("test"); + var user = new IdentityUser("test"); Assert.False(user.EmailConfirmed); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var token = await manager.GenerateEmailConfirmationTokenAsync(user); @@ -510,7 +531,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); manager.UserTokenProvider = new StaticTokenProvider(); - var user = new InMemoryUser("test"); + var user = new IdentityUser("test"); Assert.False(user.EmailConfirmed); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); IdentityResultAssert.IsFailure(await manager.ConfirmEmailAsync(user, "bogus"), "Invalid token."); @@ -522,7 +543,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test //public async Task ConfirmTokenFailsAfterPasswordChange() //{ // var manager = CreateManager(); - // var user = new InMemoryUser("test"); + // var user = new IdentityUser("test"); // Assert.False(user.EmailConfirmed); // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, "password")); // var token = await manager.GenerateEmailConfirmationTokenAsync(user); @@ -540,14 +561,14 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var mgr = CreateManager(); mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); mgr.UserLockoutEnabledByDefault = true; - var user = new InMemoryUser("fastLockout"); + var user = new IdentityUser("fastLockout"); 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)); - Assert.True(await mgr.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); } @@ -558,18 +579,18 @@ namespace Microsoft.AspNet.Identity.InMemory.Test mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); mgr.UserLockoutEnabledByDefault = true; mgr.MaxFailedAccessAttemptsBeforeLockout = 2; - var user = new InMemoryUser("twoFailureLockout"); + var user = new IdentityUser("twoFailureLockout"); 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.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.True(await mgr.IsLockedOutAsync(user)); - Assert.True(await mgr.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); } @@ -580,22 +601,22 @@ namespace Microsoft.AspNet.Identity.InMemory.Test mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); mgr.UserLockoutEnabledByDefault = true; mgr.MaxFailedAccessAttemptsBeforeLockout = 2; - var user = new InMemoryUser("resetLockout"); + var user = new IdentityUser("resetLockout"); 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.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user)); IdentityResultAssert.IsSuccess(await mgr.ResetAccessFailedCountAsync(user)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); - Assert.False(await mgr.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); - Assert.False(await mgr.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user)); } @@ -605,7 +626,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var mgr = CreateManager(); mgr.DefaultAccountLockoutTimeSpan = TimeSpan.FromHours(1); mgr.MaxFailedAccessAttemptsBeforeLockout = 2; - var user = new InMemoryUser("manualLockout"); + var user = new IdentityUser("manualLockout"); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.False(await mgr.GetLockoutEnabledAsync(user)); Assert.False(user.LockoutEnabled); @@ -615,11 +636,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test Assert.False(await mgr.IsLockedOutAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.False(await mgr.IsLockedOutAsync(user)); - Assert.False(await mgr.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(1, await mgr.GetAccessFailedCountAsync(user)); IdentityResultAssert.IsSuccess(await mgr.AccessFailedAsync(user)); Assert.True(await mgr.IsLockedOutAsync(user)); - Assert.True(await mgr.GetLockoutEndDate(user) > DateTimeOffset.UtcNow.AddMinutes(55)); + Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); Assert.Equal(0, await mgr.GetAccessFailedCountAsync(user)); } @@ -628,13 +649,13 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var mgr = CreateManager(); mgr.UserLockoutEnabledByDefault = true; - var user = new InMemoryUser("LockoutTest"); + var user = new IdentityUser("LockoutTest"); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); Assert.True(user.LockoutEnabled); - IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDate(user, new DateTimeOffset())); + IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user, new DateTimeOffset())); Assert.False(await mgr.IsLockedOutAsync(user)); - Assert.Equal(new DateTimeOffset(), await mgr.GetLockoutEndDate(user)); + Assert.Equal(new DateTimeOffset(), await mgr.GetLockoutEndDateAsync(user)); Assert.Equal(new DateTimeOffset(), user.LockoutEnd); } @@ -642,11 +663,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task LockoutFailsIfNotEnabled() { var mgr = CreateManager(); - var user = new InMemoryUser("LockoutNotEnabledTest"); + var user = new IdentityUser("LockoutNotEnabledTest"); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.False(await mgr.GetLockoutEnabledAsync(user)); Assert.False(user.LockoutEnabled); - IdentityResultAssert.IsFailure(await mgr.SetLockoutEndDate(user, new DateTimeOffset()), + IdentityResultAssert.IsFailure(await mgr.SetLockoutEndDateAsync(user, new DateTimeOffset()), "Lockout is not enabled for this user."); Assert.False(await mgr.IsLockedOutAsync(user)); } @@ -656,7 +677,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var mgr = CreateManager(); mgr.UserLockoutEnabledByDefault = true; - var user = new InMemoryUser("LockoutUtcNowTest") {LockoutEnd = DateTimeOffset.UtcNow.AddSeconds(-1)}; + var user = new IdentityUser("LockoutUtcNowTest") {LockoutEnd = DateTimeOffset.UtcNow.AddSeconds(-1)}; IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); Assert.True(user.LockoutEnabled); @@ -668,11 +689,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var mgr = CreateManager(); mgr.UserLockoutEnabledByDefault = true; - var user = new InMemoryUser("LockoutUtcNowTest"); + var user = new IdentityUser("LockoutUtcNowTest"); IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); Assert.True(user.LockoutEnabled); - IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDate(user, DateTimeOffset.UtcNow.AddSeconds(-1))); + IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow.AddSeconds(-1))); Assert.False(await mgr.IsLockedOutAsync(user)); } @@ -681,7 +702,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var mgr = CreateManager(); mgr.UserLockoutEnabledByDefault = true; - var user = new InMemoryUser("LockoutUtcNowTest") {LockoutEnd = DateTimeOffset.UtcNow.AddMinutes(5)}; + var user = new IdentityUser("LockoutUtcNowTest") {LockoutEnd = DateTimeOffset.UtcNow.AddMinutes(5)}; IdentityResultAssert.IsSuccess(await mgr.CreateAsync(user)); Assert.True(await mgr.GetLockoutEnabledAsync(user)); Assert.True(user.LockoutEnabled); @@ -693,14 +714,14 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var mgr = CreateManager(); mgr.UserLockoutEnabledByDefault = true; - var user = new InMemoryUser("LockoutTest"); + var user = new IdentityUser("LockoutTest"); 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.SetLockoutEndDate(user, lockoutEnd)); + IdentityResultAssert.IsSuccess(await mgr.SetLockoutEndDateAsync(user, lockoutEnd)); Assert.True(await mgr.IsLockedOutAsync(user)); - var end = await mgr.GetLockoutEndDate(user); + var end = await mgr.GetLockoutEndDateAsync(user); Assert.Equal(lockoutEnd, end); } @@ -709,13 +730,13 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanCreateRoleTest() { var manager = CreateRoleManager(); - var role = new InMemoryRole("create"); + var role = new IdentityRole("create"); Assert.False(await manager.RoleExistsAsync(role.Name)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); Assert.True(await manager.RoleExistsAsync(role.Name)); } - private class AlwaysBadValidator : IUserValidator, IRoleValidator, + private class AlwaysBadValidator : IUserValidator, IRoleValidator, IPasswordValidator { public const string ErrorMessage = "I'm Bad."; @@ -725,12 +746,12 @@ namespace Microsoft.AspNet.Identity.InMemory.Test return Task.FromResult(IdentityResult.Failed(ErrorMessage)); } - public Task ValidateAsync(RoleManager manager, InMemoryRole role, CancellationToken cancellationToken = default(CancellationToken)) + public Task ValidateAsync(RoleManager manager, IdentityRole role, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(IdentityResult.Failed(ErrorMessage)); } - public Task ValidateAsync(UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task ValidateAsync(UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(IdentityResult.Failed(ErrorMessage)); } @@ -741,7 +762,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateRoleManager(); manager.RoleValidator = new AlwaysBadValidator(); - IdentityResultAssert.IsFailure(await manager.CreateAsync(new InMemoryRole("blocked")), + IdentityResultAssert.IsFailure(await manager.CreateAsync(new IdentityRole("blocked")), AlwaysBadValidator.ErrorMessage); } @@ -749,7 +770,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task BadValidatorBlocksRoleUpdate() { var manager = CreateRoleManager(); - var role = new InMemoryRole("poorguy"); + var role = new IdentityRole("poorguy"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); var error = AlwaysBadValidator.ErrorMessage; manager.RoleValidator = new AlwaysBadValidator(); @@ -760,7 +781,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanDeleteRoleTest() { var manager = CreateRoleManager(); - var role = new InMemoryRole("delete"); + var role = new IdentityRole("delete"); Assert.False(await manager.RoleExistsAsync(role.Name)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); IdentityResultAssert.IsSuccess(await manager.DeleteAsync(role)); @@ -771,7 +792,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanRoleFindByIdTest() { var manager = CreateRoleManager(); - var role = new InMemoryRole("FindByIdAsync"); + var role = new IdentityRole("FindByIdAsync"); Assert.Null(await manager.FindByIdAsync(role.Id)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); Assert.Equal(role, await manager.FindByIdAsync(role.Id)); @@ -781,35 +802,35 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanRoleFindByName() { var manager = CreateRoleManager(); - var role = new InMemoryRole("FindByNameAsync"); - Assert.Null(await manager.FindByName(role.Name)); + var role = new IdentityRole("FindByNameAsync"); + Assert.Null(await manager.FindByNameAsync(role.Name)); Assert.False(await manager.RoleExistsAsync(role.Name)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); - Assert.Equal(role, await manager.FindByName(role.Name)); + Assert.Equal(role, await manager.FindByNameAsync(role.Name)); } [Fact] public async Task CanUpdateRoleNameTest() { var manager = CreateRoleManager(); - var role = new InMemoryRole("update"); + var role = new IdentityRole("update"); Assert.False(await manager.RoleExistsAsync(role.Name)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); Assert.True(await manager.RoleExistsAsync(role.Name)); role.Name = "Changed"; IdentityResultAssert.IsSuccess(await manager.UpdateAsync(role)); Assert.False(await manager.RoleExistsAsync("update")); - Assert.Equal(role, await manager.FindByName(role.Name)); + Assert.Equal(role, await manager.FindByNameAsync(role.Name)); } [Fact] public async Task CanQuerableRolesTest() { var manager = CreateRoleManager(); - InMemoryRole[] roles = + IdentityRole[] roles = { - new InMemoryRole("r1"), new InMemoryRole("r2"), new InMemoryRole("r3"), - new InMemoryRole("r4") + new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"), + new IdentityRole("r4") }; foreach (var r in roles) { @@ -826,10 +847,10 @@ namespace Microsoft.AspNet.Identity.InMemory.Test // // Need fail if not empty? // var userMgr = CreateManager(); // var roleMgr = CreateRoleManager(); - // var role = new InMemoryRole("deleteNonEmpty"); + // var role = new IdentityRole("deleteNonEmpty"); // Assert.False(await roleMgr.RoleExistsAsync(role.Name)); // IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - // var user = new InMemoryUser("t"); + // var user = new IdentityUser("t"); // IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); // IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); // IdentityResultAssert.IsSuccess(await roleMgr.DeleteAsync(role)); @@ -848,10 +869,10 @@ namespace Microsoft.AspNet.Identity.InMemory.Test //// // Need fail if not empty? //// var userMgr = CreateManager(); //// var roleMgr = CreateRoleManager(); - //// var role = new InMemoryRole("deleteNonEmpty"); + //// var role = new IdentityRole("deleteNonEmpty"); //// Assert.False(await roleMgr.RoleExistsAsync(role.Name)); //// IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - //// var user = new InMemoryUser("t"); + //// var user = new IdentityUser("t"); //// IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); //// IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); //// IdentityResultAssert.IsSuccess(await userMgr.DeleteAsync(user)); @@ -862,11 +883,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CreateRoleFailsIfExists() { var manager = CreateRoleManager(); - var role = new InMemoryRole("dupeRole"); + var role = new IdentityRole("dupeRole"); Assert.False(await manager.RoleExistsAsync(role.Name)); IdentityResultAssert.IsSuccess(await manager.CreateAsync(role)); Assert.True(await manager.RoleExistsAsync(role.Name)); - var role2 = new InMemoryRole("dupeRole"); + var role2 = new IdentityRole("dupeRole"); IdentityResultAssert.IsFailure(await manager.CreateAsync(role2)); } @@ -875,12 +896,12 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); var roleManager = CreateRoleManager(); - var role = new InMemoryRole("addUserTest"); + var role = new IdentityRole("addUserTest"); IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(role)); - InMemoryUser[] users = + IdentityUser[] users = { - new InMemoryUser("1"), new InMemoryUser("2"), new InMemoryUser("3"), - new InMemoryUser("4") + new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"), + new IdentityUser("4") }; foreach (var u in users) { @@ -895,15 +916,15 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var userManager = CreateManager(); var roleManager = CreateRoleManager(); - InMemoryUser[] users = + IdentityUser[] users = { - new InMemoryUser("u1"), new InMemoryUser("u2"), new InMemoryUser("u3"), - new InMemoryUser("u4") + new IdentityUser("u1"), new IdentityUser("u2"), new IdentityUser("u3"), + new IdentityUser("u4") }; - InMemoryRole[] roles = + IdentityRole[] roles = { - new InMemoryRole("r1"), new InMemoryRole("r2"), new InMemoryRole("r3"), - new InMemoryRole("r4") + new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"), + new IdentityRole("r4") }; foreach (var u in users) { @@ -936,12 +957,12 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var userManager = CreateManager(); var roleManager = CreateRoleManager(); - var user = new InMemoryUser("MultiRoleUser"); + var user = new IdentityUser("MultiRoleUser"); IdentityResultAssert.IsSuccess(await userManager.CreateAsync(user)); - InMemoryRole[] roles = + IdentityRole[] roles = { - new InMemoryRole("r1"), new InMemoryRole("r2"), new InMemoryRole("r3"), - new InMemoryRole("r4") + new IdentityRole("r1"), new IdentityRole("r2"), new IdentityRole("r3"), + new IdentityRole("r4") }; foreach (var r in roles) { @@ -958,16 +979,16 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var userManager = CreateManager(); var roleManager = CreateRoleManager(); - InMemoryUser[] users = + IdentityUser[] users = { - new InMemoryUser("1"), new InMemoryUser("2"), new InMemoryUser("3"), - new InMemoryUser("4") + new IdentityUser("1"), new IdentityUser("2"), new IdentityUser("3"), + new IdentityUser("4") }; foreach (var u in users) { IdentityResultAssert.IsSuccess(await userManager.CreateAsync(u)); } - var r = new InMemoryRole("r1"); + var r = new IdentityRole("r1"); IdentityResultAssert.IsSuccess(await roleManager.CreateAsync(r)); foreach (var u in users) { @@ -986,8 +1007,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var userMgr = CreateManager(); var roleMgr = CreateRoleManager(); - var role = new InMemoryRole("addUserDupeTest"); - var user = new InMemoryUser("user1"); + var role = new IdentityRole("addUserDupeTest"); + var user = new IdentityUser("user1"); IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); var result = await userMgr.RemoveFromRoleAsync(user, role.Name); @@ -999,8 +1020,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var userMgr = CreateManager(); var roleMgr = CreateRoleManager(); - var role = new InMemoryRole("addUserDupeTest"); - var user = new InMemoryUser("user1"); + var role = new IdentityRole("addUserDupeTest"); + var user = new IdentityUser("user1"); IdentityResultAssert.IsSuccess(await userMgr.CreateAsync(user)); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); IdentityResultAssert.IsSuccess(await userMgr.AddToRoleAsync(user, role.Name)); @@ -1012,16 +1033,16 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task CanFindRoleByNameWithManager() { var roleMgr = CreateRoleManager(); - var role = new InMemoryRole("findRoleByNameTest"); + var role = new IdentityRole("findRoleByNameTest"); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); - Assert.Equal(role.Id, (await roleMgr.FindByName(role.Name)).Id); + Assert.Equal(role.Id, (await roleMgr.FindByNameAsync(role.Name)).Id); } [Fact] public async Task CanFindRoleWithManager() { var roleMgr = CreateRoleManager(); - var role = new InMemoryRole("findRoleTest"); + var role = new IdentityRole("findRoleTest"); IdentityResultAssert.IsSuccess(await roleMgr.CreateAsync(role)); Assert.Equal(role.Name, (await roleMgr.FindByIdAsync(role.Id)).Name); } @@ -1031,7 +1052,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); var userName = "PhoneTest"; - var user = new InMemoryUser(userName); + var user = new IdentityUser(userName); user.PhoneNumber = "123-456-7890"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); @@ -1041,16 +1062,17 @@ namespace Microsoft.AspNet.Identity.InMemory.Test Assert.NotEqual(stamp, user.SecurityStamp); } +#if NET45 [Fact] public async Task CanChangePhoneNumber() { var manager = CreateManager(); const string userName = "PhoneTest"; - var user = new InMemoryUser(userName) {PhoneNumber = "123-456-7890"}; + var user = new IdentityUser(userName) {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.GenerateChangePhoneNumberToken(user, "111-111-1111"); + var token1 = await manager.GenerateChangePhoneNumberTokenAsync(user, "111-111-1111"); IdentityResultAssert.IsSuccess(await manager.ChangePhoneNumberAsync(user, "111-111-1111", token1)); Assert.True(await manager.IsPhoneNumberConfirmedAsync(user)); Assert.Equal(await manager.GetPhoneNumberAsync(user), "111-111-1111"); @@ -1062,7 +1084,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); const string userName = "PhoneTest"; - var user = new InMemoryUser(userName) {PhoneNumber = "123-456-7890"}; + var user = new IdentityUser(userName) {PhoneNumber = "123-456-7890"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); var stamp = await manager.GetSecurityStampAsync(user); @@ -1078,38 +1100,39 @@ namespace Microsoft.AspNet.Identity.InMemory.Test { var manager = CreateManager(); const string userName = "VerifyPhoneTest"; - var user = new InMemoryUser(userName); + var user = new IdentityUser(userName); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); const string num1 = "111-123-4567"; const string num2 = "111-111-1111"; - var token1 = await manager.GenerateChangePhoneNumberToken(user, num1); - var token2 = await manager.GenerateChangePhoneNumberToken(user, num2); + var token1 = await manager.GenerateChangePhoneNumberTokenAsync(user, num1); + var token2 = await manager.GenerateChangePhoneNumberTokenAsync(user, num2); Assert.NotEqual(token1, token2); Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num1)); Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num2)); Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num1)); Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num2)); } +#endif - private class EmailTokenProvider : IUserTokenProvider + private class EmailTokenProvider : IUserTokenProvider { - public Task GenerateAsync(string purpose, UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task GenerateAsync(string purpose, UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(MakeToken(purpose)); } - public Task ValidateAsync(string purpose, string token, UserManager manager, - InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task ValidateAsync(string purpose, string token, UserManager manager, + IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(token == MakeToken(purpose)); } - public Task NotifyAsync(string token, UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task NotifyAsync(string token, UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { - return manager.SendEmail(user, token, token); + return manager.SendEmailAsync(user, token, token); } - public async Task IsValidProviderForUserAsync(UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public async Task IsValidProviderForUserAsync(UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return !string.IsNullOrEmpty(await manager.GetEmailAsync(user)); } @@ -1120,25 +1143,25 @@ namespace Microsoft.AspNet.Identity.InMemory.Test } } - private class SmsTokenProvider : IUserTokenProvider + private class SmsTokenProvider : IUserTokenProvider { - public Task GenerateAsync(string purpose, UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task GenerateAsync(string purpose, UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(MakeToken(purpose)); } - public Task ValidateAsync(string purpose, string token, UserManager manager, - InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task ValidateAsync(string purpose, string token, UserManager manager, + IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(token == MakeToken(purpose)); } - public Task NotifyAsync(string token, UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public Task NotifyAsync(string token, UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { - return manager.SendSms(user, token, cancellationToken); + return manager.SendSmsAsync(user, token, cancellationToken); } - public async Task IsValidProviderForUserAsync(UserManager manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken)) + public async Task IsValidProviderForUserAsync(UserManager manager, IdentityUser user, CancellationToken cancellationToken = default(CancellationToken)) { return !string.IsNullOrEmpty(await manager.GetPhoneNumberAsync(user, cancellationToken)); } @@ -1157,7 +1180,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test manager.EmailService = messageService; const string factorId = "EmailCode"; manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); - var user = new InMemoryUser("EmailCodeTest") {Email = "foo@foo.com"}; + var user = new IdentityUser("EmailCodeTest") {Email = "foo@foo.com"}; const string password = "password"; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); var stamp = user.SecurityStamp; @@ -1176,7 +1199,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task NotifyWithUnknownProviderFails() { var manager = CreateManager(); - var user = new InMemoryUser("NotifyFail"); + var user = new IdentityUser("NotifyFail"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); await ExceptionAssert.ThrowsAsync( @@ -1192,12 +1215,12 @@ namespace Microsoft.AspNet.Identity.InMemory.Test // var messageService = new TestMessageService(); // manager.EmailService = messageService; // const string factorId = "EmailCode"; - // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider + // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider // { // Subject = "Security Code", // BodyFormat = "Your code is: {0}" // }); - // var user = new InMemoryUser("EmailCodeTest") { Email = "foo@foo.com" }; + // var user = new IdentityUser("EmailCodeTest") { Email = "foo@foo.com" }; // const string password = "password"; // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user, password)); // var stamp = user.SecurityStamp; @@ -1217,8 +1240,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test //{ // var manager = CreateManager(); // const string factorId = "EmailCode"; - // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); - // var user = new InMemoryUser("EmailCodeTest") { Email = "foo@foo.com" }; + // manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider()); + // var user = new IdentityUser("EmailCodeTest") { Email = "foo@foo.com" }; // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); // var stamp = user.SecurityStamp; // Assert.NotNull(stamp); @@ -1232,13 +1255,13 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task EnableTwoFactorChangesSecurityStamp() { var manager = CreateManager(); - var user = new InMemoryUser("TwoFactorEnabledTest"); + var user = new IdentityUser("TwoFactorEnabledTest"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var stamp = user.SecurityStamp; Assert.NotNull(stamp); IdentityResultAssert.IsSuccess(await manager.SetTwoFactorEnabledAsync(user, true)); Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); - Assert.True(await manager.GetTwoFactorEnabled(user)); + Assert.True(await manager.GetTwoFactorEnabledAsync(user)); } [Fact] @@ -1247,9 +1270,9 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var manager = CreateManager(); var messageService = new TestMessageService(); manager.SmsService = messageService; - var user = new InMemoryUser("SmsTest") {PhoneNumber = "4251234567"}; + var user = new IdentityUser("SmsTest") {PhoneNumber = "4251234567"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - await manager.SendSms(user, "Hi"); + await manager.SendSmsAsync(user, "Hi"); Assert.NotNull(messageService.Message); Assert.Equal("Hi", messageService.Message.Body); } @@ -1260,9 +1283,9 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var manager = CreateManager(); var messageService = new TestMessageService(); manager.EmailService = messageService; - var user = new InMemoryUser("EmailTest") {Email = "foo@foo.com"}; + var user = new IdentityUser("EmailTest") {Email = "foo@foo.com"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - await manager.SendEmail(user, "Hi", "Body"); + await manager.SendEmailAsync(user, "Hi", "Body"); Assert.NotNull(messageService.Message); Assert.Equal("Hi", messageService.Message.Subject); Assert.Equal("Body", messageService.Message.Body); @@ -1276,7 +1299,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test manager.SmsService = messageService; const string factorId = "PhoneCode"; manager.RegisterTwoFactorProvider(factorId, new SmsTokenProvider()); - var user = new InMemoryUser("PhoneCodeTest") {PhoneNumber = "4251234567"}; + var user = new IdentityUser("PhoneCodeTest") {PhoneNumber = "4251234567"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var stamp = user.SecurityStamp; Assert.NotNull(stamp); @@ -1296,11 +1319,11 @@ namespace Microsoft.AspNet.Identity.InMemory.Test // var messageService = new TestMessageService(); // manager.SmsService = messageService; // const string factorId = "PhoneCode"; - // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider + // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider // { // MessageFormat = "Your code is: {0}" // }); - // var user = new InMemoryUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; + // var user = new IdentityUser("PhoneCodeTest") { PhoneNumber = "4251234567" }; // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); // var stamp = user.SecurityStamp; // Assert.NotNull(stamp); @@ -1317,7 +1340,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task GenerateTwoFactorWithUnknownFactorProviderWillThrow() { var manager = CreateManager(); - var user = new InMemoryUser("PhoneCodeTest"); + var user = new IdentityUser("PhoneCodeTest"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); const string error = "No IUserTwoFactorProvider for 'bogus' is registered."; await @@ -1331,9 +1354,9 @@ namespace Microsoft.AspNet.Identity.InMemory.Test public async Task GetValidTwoFactorTestEmptyWithNoProviders() { var manager = CreateManager(); - var user = new InMemoryUser("test"); + var user = new IdentityUser("test"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - var factors = await manager.GetValidTwoFactorProviders(user); + var factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.True(!factors.Any()); } @@ -1344,22 +1367,22 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var manager = CreateManager(); manager.RegisterTwoFactorProvider("phone", new SmsTokenProvider()); manager.RegisterTwoFactorProvider("email", new EmailTokenProvider()); - var user = new InMemoryUser("test"); + var user = new IdentityUser("test"); IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); - var factors = await manager.GetValidTwoFactorProviders(user); + var factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.True(!factors.Any()); IdentityResultAssert.IsSuccess(await manager.SetPhoneNumberAsync(user, "111-111-1111")); - factors = await manager.GetValidTwoFactorProviders(user); + factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.True(factors.Count() == 1); Assert.Equal("phone", factors[0]); IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, "test@test.com")); - factors = await manager.GetValidTwoFactorProviders(user); + factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.True(factors.Count() == 2); IdentityResultAssert.IsSuccess(await manager.SetEmailAsync(user, null)); - factors = await manager.GetValidTwoFactorProviders(user); + factors = await manager.GetValidTwoFactorProvidersAsync(user); Assert.NotNull(factors); Assert.True(factors.Count() == 1); Assert.Equal("phone", factors[0]); @@ -1370,8 +1393,8 @@ namespace Microsoft.AspNet.Identity.InMemory.Test //{ // var manager = CreateManager(); // var factorId = "PhoneCode"; - // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider()); - // var user = new InMemoryUser("PhoneCodeTest"); + // manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider()); + // var user = new IdentityUser("PhoneCodeTest"); // user.PhoneNumber = "4251234567"; // IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); // var stamp = user.SecurityStamp; @@ -1388,7 +1411,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var manager = CreateManager(); manager.RegisterTwoFactorProvider("PhoneCode", new SmsTokenProvider()); manager.RegisterTwoFactorProvider("EmailCode", new EmailTokenProvider()); - var user = new InMemoryUser("WrongTokenProviderTest") {PhoneNumber = "4251234567"}; + var user = new IdentityUser("WrongTokenProviderTest") {PhoneNumber = "4251234567"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); var token = await manager.GenerateTwoFactorTokenAsync(user, "PhoneCode"); Assert.NotNull(token); @@ -1401,19 +1424,19 @@ namespace Microsoft.AspNet.Identity.InMemory.Test var manager = CreateManager(); const string factorId = "PhoneCode"; manager.RegisterTwoFactorProvider(factorId, new SmsTokenProvider()); - var user = new InMemoryUser("PhoneCodeTest") {PhoneNumber = "4251234567"}; + var user = new IdentityUser("PhoneCodeTest") {PhoneNumber = "4251234567"}; IdentityResultAssert.IsSuccess(await manager.CreateAsync(user)); Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, "bogus")); } - private static UserManager CreateManager() + private static UserManager CreateManager() { - return new UserManager(new InMemoryUserStore()); + return new UserManager(new InMemoryUserStore()); } - private static RoleManager CreateRoleManager() + private static RoleManager CreateRoleManager() { - return new RoleManager(new InMemoryRoleStore()); + return new RoleManager(new InMemoryRoleStore()); } public class TestMessageService : IIdentityMessageService diff --git a/test/Microsoft.AspNet.Identity.Security.Test/SignInManagerTest.cs b/test/Microsoft.AspNet.Identity.Security.Test/SignInManagerTest.cs index baa80813c5..e210e8e377 100644 --- a/test/Microsoft.AspNet.Identity.Security.Test/SignInManagerTest.cs +++ b/test/Microsoft.AspNet.Identity.Security.Test/SignInManagerTest.cs @@ -32,7 +32,7 @@ namespace Microsoft.AspNet.Identity.Security.Test var helper = new SignInManager { UserManager = userManager, AuthenticationType = authType, Context = context.Object }; // Act - await helper.SignIn(user, false, false); + await helper.SignInAsync(user, false, false); // Assert identityFactory.VerifyAll(); @@ -65,7 +65,7 @@ namespace Microsoft.AspNet.Identity.Security.Test manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable(); manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable(); manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable(); - manager.Setup(m => m.CreateIdentity(user, "Microsoft.AspNet.Identity", CancellationToken.None)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable(); + manager.Setup(m => m.CreateIdentityAsync(user, "Microsoft.AspNet.Identity", CancellationToken.None)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable(); var context = new Mock(); var response = new Mock(); context.Setup(c => c.Response).Returns(response.Object).Verifiable(); @@ -129,6 +129,16 @@ namespace Microsoft.AspNet.Identity.Security.Test Assert.Equal(SignInStatus.Failure, result); } + [Fact] + public async Task SignInWithNoContextDoesNotBlowUp() + { + // Setup + var helper = new SignInManager(); + + // Act + await helper.SignInAsync(null, false, false); + } + [Fact] public async Task CreateUserIdentityReturnsNullNoUserManager() { diff --git a/test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs b/test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs index 3b33e49b68..27a7e5da5f 100644 --- a/test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs @@ -53,7 +53,7 @@ namespace Microsoft.AspNet.Identity.Test // Assert Assert.NotNull(identity); Assert.Equal(authType, identity.AuthenticationType); - var claims = identity.Claims; + var claims = identity.Claims.ToList(); Assert.NotNull(claims); Assert.True( claims.Any(c => c.Type == factory.UserNameClaimType && c.Value == user.UserName)); @@ -66,48 +66,5 @@ namespace Microsoft.AspNet.Identity.Test } } #endif - - //[Fact] - //public async Task ClaimsIdentityTest() - //{ - // var db = UnitTestHelper.CreateDefaultDb(); - // var manager = new UserManager(new UserStore(db)); - // var role = new RoleManager(new RoleStore(db)); - // var user = new TestUser("Hao"); - // UnitTestHelper.IsSuccess(await manager.CreateAsync(user)); - // UnitTestHelper.IsSuccess(await role.CreateAsync(new IdentityRole("Admin"))); - // UnitTestHelper.IsSuccess(await role.CreateAsync(new IdentityRole("Local"))); - // UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(user.Id, "Admin")); - // UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(user.Id, "Local")); - // Claim[] userClaims = - // { - // new Claim("Whatever", "Value"), - // new Claim("Whatever2", "Value2") - // }; - // foreach (var c in userClaims) - // { - // UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c)); - // } - - // var identity = await manager.CreateIdentityAsync(user, "test"); - // var claimsFactory = manager.ClaimsIdentityFactory as ClaimsIdentityFactory; - // Assert.NotNull(claimsFactory); - // var claims = identity.Claims; - // Assert.NotNull(claims); - // Assert.True( - // claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName)); - // Assert.True(claims.Any(c => c.Type == claimsFactory.UserIdClaimType && c.Value == user.Id)); - // Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Admin")); - // Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Local")); - // Assert.True( - // claims.Any( - // c => - // c.Type == ClaimsIdentityFactory.IdentityProviderClaimType && - // c.Value == ClaimsIdentityFactory.DefaultIdentityProviderClaimValue)); - // foreach (var cl in userClaims) - // { - // Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value)); - // } - //} } } \ No newline at end of file diff --git a/test/Microsoft.AspNet.Identity.Test/NoopRoleStore.cs b/test/Microsoft.AspNet.Identity.Test/NoopRoleStore.cs index a504c9c56b..be8ff29c5c 100644 --- a/test/Microsoft.AspNet.Identity.Test/NoopRoleStore.cs +++ b/test/Microsoft.AspNet.Identity.Test/NoopRoleStore.cs @@ -20,6 +20,11 @@ namespace Microsoft.AspNet.Identity.Test return Task.FromResult(null); } + public Task SetRoleNameAsync(TestRole role, string roleName, CancellationToken cancellationToken = new CancellationToken()) + { + return Task.FromResult(0); + } + public Task FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(null); diff --git a/test/Microsoft.AspNet.Identity.Test/RoleManagerTest.cs b/test/Microsoft.AspNet.Identity.Test/RoleManagerTest.cs index 61b4144936..7c4687605b 100644 --- a/test/Microsoft.AspNet.Identity.Test/RoleManagerTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/RoleManagerTest.cs @@ -39,7 +39,7 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("role", async () => await manager.CreateAsync(null)); await Assert.ThrowsAsync("role", async () => await manager.UpdateAsync(null)); await Assert.ThrowsAsync("role", async () => await manager.DeleteAsync(null)); - await Assert.ThrowsAsync("roleName", async () => await manager.FindByName(null)); + await Assert.ThrowsAsync("roleName", async () => await manager.FindByNameAsync(null)); await Assert.ThrowsAsync("roleName", async () => await manager.RoleExistsAsync(null)); } @@ -49,7 +49,7 @@ namespace Microsoft.AspNet.Identity.Test var manager = new RoleManager(new NoopRoleStore()); manager.Dispose(); await Assert.ThrowsAsync(() => manager.FindByIdAsync(null)); - await Assert.ThrowsAsync(() => manager.FindByName(null)); + await Assert.ThrowsAsync(() => manager.FindByNameAsync(null)); await Assert.ThrowsAsync(() => manager.RoleExistsAsync(null)); await Assert.ThrowsAsync(() => manager.CreateAsync(null)); await Assert.ThrowsAsync(() => manager.UpdateAsync(null)); @@ -83,6 +83,11 @@ namespace Microsoft.AspNet.Identity.Test throw new NotImplementedException(); } + public Task SetRoleNameAsync(TestRole role, string roleName, CancellationToken cancellationToken = new CancellationToken()) + { + throw new NotImplementedException(); + } + public Task FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); diff --git a/test/Microsoft.AspNet.Identity.Test/TestServices.cs b/test/Microsoft.AspNet.Identity.Test/TestServices.cs index acc1f1d59c..e8665e3258 100644 --- a/test/Microsoft.AspNet.Identity.Test/TestServices.cs +++ b/test/Microsoft.AspNet.Identity.Test/TestServices.cs @@ -1,8 +1,5 @@ -using System; -using System.Collections.Generic; -using System.Runtime.CompilerServices; using Microsoft.AspNet.DependencyInjection; -using Microsoft.AspNet.DependencyInjection.Fallback; +using System.Collections.Generic; namespace Microsoft.AspNet.Identity.Test { diff --git a/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs b/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs index f023efcd8e..383b19883e 100644 --- a/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs +++ b/test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs @@ -1,12 +1,11 @@ +using Microsoft.AspNet.DependencyInjection.Fallback; +using Moq; using System; using System.Collections.Generic; using System.Linq; using System.Security.Claims; using System.Threading; using System.Threading.Tasks; -using Microsoft.AspNet.DependencyInjection.Fallback; -using Microsoft.AspNet.Testing; -using Moq; using Xunit; namespace Microsoft.AspNet.Identity.Test @@ -15,7 +14,7 @@ namespace Microsoft.AspNet.Identity.Test { private class TestManager : UserManager { - public IUserStore StorePublic { get { return base.Store; } } + public IUserStore StorePublic { get { return Store; } } public TestManager(IServiceProvider provider) : base(provider) { } } @@ -102,7 +101,7 @@ namespace Microsoft.AspNet.Identity.Test userManager.UserValidator = validator.Object; // Act - var result = await userManager.SetUserName(user, "foo"); + var result = await userManager.SetUserNameAsync(user, "foo"); // Assert Assert.True(result.Succeeded); @@ -156,7 +155,7 @@ namespace Microsoft.AspNet.Identity.Test public async Task FindWithUnknownUserAndPasswordReturnsNull() { var manager = new UserManager(new EmptyStore()); - Assert.Null(await manager.FindByUserNamePassword("bogus", "whatevs")); + Assert.Null(await manager.FindByUserNamePasswordAsync("bogus", "whatevs")); } [Fact] @@ -219,12 +218,14 @@ namespace Microsoft.AspNet.Identity.Test Assert.False(manager.SupportsUserSecurityStamp); await Assert.ThrowsAsync(() => manager.UpdateSecurityStampAsync(null)); await Assert.ThrowsAsync(() => manager.GetSecurityStampAsync(null)); +#if NET45 await Assert.ThrowsAsync( () => manager.VerifyChangePhoneNumberTokenAsync(null, "1", "111-111-1111")); await Assert.ThrowsAsync( - () => manager.GenerateChangePhoneNumberToken(null, "111-111-1111")); + () => manager.GenerateChangePhoneNumberTokenAsync(null, "111-111-1111")); +#endif } [Fact] @@ -232,9 +233,9 @@ namespace Microsoft.AspNet.Identity.Test { var manager = new UserManager(new NoopUserStore()); Assert.False(manager.SupportsUserLogin); - await Assert.ThrowsAsync(async () => await manager.AddLogin(null, null)); - await Assert.ThrowsAsync(async () => await manager.RemoveLogin(null, null)); - await Assert.ThrowsAsync(async () => await manager.GetLogins(null)); + await Assert.ThrowsAsync(async () => await manager.AddLoginAsync(null, null)); + await Assert.ThrowsAsync(async () => await manager.RemoveLoginAsync(null, null)); + await Assert.ThrowsAsync(async () => await manager.GetLoginsAsync(null)); await Assert.ThrowsAsync(async () => await manager.FindByLoginAsync(null)); } @@ -253,7 +254,7 @@ namespace Microsoft.AspNet.Identity.Test { var manager = new UserManager(new NoopUserStore()); Assert.False(manager.SupportsUserTwoFactor); - await Assert.ThrowsAsync(async () => await manager.GetTwoFactorEnabled(null)); + await Assert.ThrowsAsync(async () => await manager.GetTwoFactorEnabledAsync(null)); await Assert.ThrowsAsync(async () => await manager.SetTwoFactorEnabledAsync(null, true)); } @@ -314,7 +315,7 @@ namespace Microsoft.AspNet.Identity.Test Assert.Throws(() => manager.PasswordHasher = null); await Assert.ThrowsAsync("user", - async () => await manager.CreateIdentity(null, "whatever")); + async () => await manager.CreateIdentityAsync(null, "whatever")); await Assert.ThrowsAsync("user", async () => await manager.CreateAsync(null)); await Assert.ThrowsAsync("user", async () => await manager.CreateAsync(null, null)); await @@ -324,10 +325,10 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("user", async () => await manager.DeleteAsync(null)); await Assert.ThrowsAsync("claim", async () => await manager.AddClaimAsync(null, null)); await Assert.ThrowsAsync("userName", async () => await manager.FindByNameAsync(null)); - await Assert.ThrowsAsync("userName", async () => await manager.FindByUserNamePassword(null, null)); - await Assert.ThrowsAsync("login", async () => await manager.AddLogin(null, null)); + await Assert.ThrowsAsync("userName", async () => await manager.FindByUserNamePasswordAsync(null, null)); + await Assert.ThrowsAsync("login", async () => await manager.AddLoginAsync(null, null)); await - Assert.ThrowsAsync("login", async () => await manager.RemoveLogin(null, null)); + Assert.ThrowsAsync("login", async () => await manager.RemoveLoginAsync(null, null)); await Assert.ThrowsAsync("email", async () => await manager.FindByEmailAsync(null)); Assert.Throws("twoFactorProvider", () => manager.RegisterTwoFactorProvider(null, null)); @@ -341,10 +342,14 @@ namespace Microsoft.AspNet.Identity.Test { UserTokenProvider = new NoOpTokenProvider() }; + await Assert.ThrowsAsync("user", + async () => await manager.GetUserNameAsync(null)); + await Assert.ThrowsAsync("user", + async () => await manager.SetUserNameAsync(null, "bogus")); await Assert.ThrowsAsync("user", async () => await manager.AddClaimAsync(null, new Claim("a", "b"))); await Assert.ThrowsAsync("user", - async () => await manager.AddLogin(null, new UserLoginInfo("", ""))); + async () => await manager.AddLoginAsync(null, new UserLoginInfo("", ""))); await Assert.ThrowsAsync("user", async () => await manager.AddPasswordAsync(null, null)); await Assert.ThrowsAsync("user", @@ -354,7 +359,7 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("user", async () => await manager.GetClaimsAsync(null)); await Assert.ThrowsAsync("user", - async () => await manager.GetLogins(null)); + async () => await manager.GetLoginsAsync(null)); await Assert.ThrowsAsync("user", async () => await manager.GetRolesAsync(null)); await Assert.ThrowsAsync("user", @@ -362,7 +367,7 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("user", async () => await manager.RemoveClaimAsync(null, new Claim("a", "b"))); await Assert.ThrowsAsync("user", - async () => await manager.RemoveLogin(null, new UserLoginInfo("", ""))); + async () => await manager.RemoveLoginAsync(null, new UserLoginInfo("", ""))); await Assert.ThrowsAsync("user", async () => await manager.RemovePasswordAsync(null)); await Assert.ThrowsAsync("user", @@ -398,7 +403,7 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("user", async () => await manager.SetPhoneNumberAsync(null, null)); await Assert.ThrowsAsync("user", - async () => await manager.GetTwoFactorEnabled(null)); + async () => await manager.GetTwoFactorEnabledAsync(null)); await Assert.ThrowsAsync("user", async () => await manager.SetTwoFactorEnabledAsync(null, true)); await Assert.ThrowsAsync("user", @@ -408,7 +413,7 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("user", async () => await manager.NotifyTwoFactorTokenAsync(null, null, null)); await Assert.ThrowsAsync("user", - async () => await manager.GetValidTwoFactorProviders(null)); + async () => await manager.GetValidTwoFactorProvidersAsync(null)); await Assert.ThrowsAsync("user", async () => await manager.VerifyUserTokenAsync(null, null, null)); await Assert.ThrowsAsync("user", @@ -422,11 +427,15 @@ namespace Microsoft.AspNet.Identity.Test await Assert.ThrowsAsync("user", async () => await manager.SetLockoutEnabledAsync(null, false)); await Assert.ThrowsAsync("user", - async () => await manager.SetLockoutEndDate(null, DateTimeOffset.UtcNow)); + async () => await manager.SetLockoutEndDateAsync(null, DateTimeOffset.UtcNow)); await Assert.ThrowsAsync("user", - async () => await manager.GetLockoutEndDate(null)); + async () => await manager.GetLockoutEndDateAsync(null)); await Assert.ThrowsAsync("user", async () => await manager.IsLockedOutAsync(null)); + await Assert.ThrowsAsync("user", + async () => await manager.SendEmailAsync(null, null, null)); + await Assert.ThrowsAsync("user", + async () => await manager.SendSmsAsync(null, null)); } [Fact] @@ -436,26 +445,26 @@ namespace Microsoft.AspNet.Identity.Test manager.Dispose(); Assert.Throws(() => manager.ClaimsIdentityFactory); await Assert.ThrowsAsync(() => manager.AddClaimAsync(null, null)); - await Assert.ThrowsAsync(() => manager.AddLogin(null, null)); + await Assert.ThrowsAsync(() => manager.AddLoginAsync(null, null)); await Assert.ThrowsAsync(() => manager.AddPasswordAsync(null, null)); await Assert.ThrowsAsync(() => manager.AddToRoleAsync(null, null)); await Assert.ThrowsAsync(() => manager.ChangePasswordAsync(null, null, null)); await Assert.ThrowsAsync(() => manager.GetClaimsAsync(null)); - await Assert.ThrowsAsync(() => manager.GetLogins(null)); + await Assert.ThrowsAsync(() => manager.GetLoginsAsync(null)); await Assert.ThrowsAsync(() => manager.GetRolesAsync(null)); await Assert.ThrowsAsync(() => manager.IsInRoleAsync(null, null)); await Assert.ThrowsAsync(() => manager.RemoveClaimAsync(null, null)); - await Assert.ThrowsAsync(() => manager.RemoveLogin(null, null)); + await Assert.ThrowsAsync(() => manager.RemoveLoginAsync(null, null)); await Assert.ThrowsAsync(() => manager.RemovePasswordAsync(null)); await Assert.ThrowsAsync(() => manager.RemoveFromRoleAsync(null, null)); await Assert.ThrowsAsync(() => manager.RemoveClaimAsync(null, null)); - await Assert.ThrowsAsync(() => manager.FindByUserNamePassword(null, null)); + await Assert.ThrowsAsync(() => manager.FindByUserNamePasswordAsync(null, null)); await Assert.ThrowsAsync(() => manager.FindByLoginAsync(null)); await Assert.ThrowsAsync(() => manager.FindByIdAsync(null)); await Assert.ThrowsAsync(() => manager.FindByNameAsync(null)); await Assert.ThrowsAsync(() => manager.CreateAsync(null)); await Assert.ThrowsAsync(() => manager.CreateAsync(null, null)); - await Assert.ThrowsAsync(() => manager.CreateIdentity(null, null)); + await Assert.ThrowsAsync(() => manager.CreateIdentityAsync(null, null)); await Assert.ThrowsAsync(() => manager.UpdateAsync(null)); await Assert.ThrowsAsync(() => manager.DeleteAsync(null)); await Assert.ThrowsAsync(() => manager.UpdateSecurityStampAsync(null));