huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Identity.Security not enough to prevent infection 

- Viral cancellationToken API infection everywhere
- Add Identity.Security SignInManager which depends on Abstractions
This commit is contained in:
Hao Kung 2014-04-02 12:25:52 -07:00
parent 0dcb918084
commit 8549d83b7c
41 changed files with 1192 additions and 491 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Identity.sln
View File

@ -27,6 +27,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AspNet.Identity.T
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Aspnet.Identity.InMemory.Test.net45", "test\Microsoft.Aspnet.Identity.InMemory.Test\Microsoft.Aspnet.Identity.InMemory.Test.net45.csproj", "{9102E676-B509-4A78-AD66-A479C50FD1C3}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AspNet.Identity.Security.k10", "src\Microsoft.AspNet.Identity.Security\Microsoft.AspNet.Identity.Security.k10.csproj", "{DE98C383-A3D7-47EC-AE37-C7F707F16486}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AspNet.Identity.Security.net45", "src\Microsoft.AspNet.Identity.Security\Microsoft.AspNet.Identity.Security.net45.csproj", "{BD765B85-9839-4901-B231-E49465596A75}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AspNet.Identity.Security.Test.net45", "test\Microsoft.AspNet.Identity.Security.Test\Microsoft.AspNet.Identity.Security.Test.net45.csproj", "{30A2C4BB-86AB-4971-BC63-4761E8CE7D0F}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -65,6 +71,18 @@ Global
{9102E676-B509-4A78-AD66-A479C50FD1C3}.Debug|Any CPU.Build.0 = Debug|Any CPU
{9102E676-B509-4A78-AD66-A479C50FD1C3}.Release|Any CPU.ActiveCfg = Release|Any CPU
{9102E676-B509-4A78-AD66-A479C50FD1C3}.Release|Any CPU.Build.0 = Release|Any CPU
{DE98C383-A3D7-47EC-AE37-C7F707F16486}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{DE98C383-A3D7-47EC-AE37-C7F707F16486}.Debug|Any CPU.Build.0 = Debug|Any CPU
{DE98C383-A3D7-47EC-AE37-C7F707F16486}.Release|Any CPU.ActiveCfg = Release|Any CPU
{DE98C383-A3D7-47EC-AE37-C7F707F16486}.Release|Any CPU.Build.0 = Release|Any CPU
{BD765B85-9839-4901-B231-E49465596A75}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{BD765B85-9839-4901-B231-E49465596A75}.Debug|Any CPU.Build.0 = Debug|Any CPU
{BD765B85-9839-4901-B231-E49465596A75}.Release|Any CPU.ActiveCfg = Release|Any CPU
{BD765B85-9839-4901-B231-E49465596A75}.Release|Any CPU.Build.0 = Release|Any CPU
{30A2C4BB-86AB-4971-BC63-4761E8CE7D0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{30A2C4BB-86AB-4971-BC63-4761E8CE7D0F}.Debug|Any CPU.Build.0 = Debug|Any CPU
{30A2C4BB-86AB-4971-BC63-4761E8CE7D0F}.Release|Any CPU.ActiveCfg = Release|Any CPU
{30A2C4BB-86AB-4971-BC63-4761E8CE7D0F}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@ -74,11 +92,14 @@ Global
{77CEDA6C-A833-455D-8357-649BFD944724} = {0F647068-6602-4E24-B1DC-8ED91481A50A}
{E00E23B0-79B8-41E1-9998-57FECA1F2535} = {52D59F18-62D2-4D17-8CF2-BE192445AF8E}
{9102E676-B509-4A78-AD66-A479C50FD1C3} = {52D59F18-62D2-4D17-8CF2-BE192445AF8E}
{30A2C4BB-86AB-4971-BC63-4761E8CE7D0F} = {52D59F18-62D2-4D17-8CF2-BE192445AF8E}
{B72401D7-47F6-4A98-89D5-CCBFEFC5B2B8} = {F6B0C0E9-C346-49D0-B583-95B6CE04BB1B}
{E52361C9-1F0B-4229-86A0-E5C7C12A5429} = {F6B0C0E9-C346-49D0-B583-95B6CE04BB1B}
{054B3FFA-7196-466F-9A8A-593FFE037A69} = {F6B0C0E9-C346-49D0-B583-95B6CE04BB1B}
{BD765B85-9839-4901-B231-E49465596A75} = {F6B0C0E9-C346-49D0-B583-95B6CE04BB1B}
{6211450F-FFB8-431F-84E2-9A7620875260} = {77CEDA6C-A833-455D-8357-649BFD944724}
{D32483A4-B617-480C-81E6-49CD596B9A34} = {77CEDA6C-A833-455D-8357-649BFD944724}
{D2E7A146-C39F-4302-8EA3-BFA8C1082939} = {77CEDA6C-A833-455D-8357-649BFD944724}
{DE98C383-A3D7-47EC-AE37-C7F707F16486} = {77CEDA6C-A833-455D-8357-649BFD944724}
EndGlobalSection
EndGlobal

11
src/Microsoft.AspNet.Identity.InMemory/InMemoryRoleStore.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity.InMemory
@ -9,13 +10,13 @@ namespace Microsoft.AspNet.Identity.InMemory
{
private readonly Dictionary<string, InMemoryRole> _roles = new Dictionary<string, InMemoryRole>();
public Task Create(InMemoryRole role)
public Task Create(InMemoryRole role, CancellationToken cancellationToken = default(CancellationToken))
{
_roles[role.Id] = role;
return Task.FromResult(0);
}
public Task Delete(InMemoryRole role)
public Task Delete(InMemoryRole role, CancellationToken cancellationToken = default(CancellationToken))
{
if (role == null || !_roles.ContainsKey(role.Id))
{
@ -25,13 +26,13 @@ namespace Microsoft.AspNet.Identity.InMemory
return Task.FromResult(0);
}
public Task Update(InMemoryRole role)
public Task Update(InMemoryRole role, CancellationToken cancellationToken = default(CancellationToken))
{
_roles[role.Id] = role;
return Task.FromResult(0);
}
public Task<InMemoryRole> FindById(string roleId)
public Task<InMemoryRole> FindById(string roleId, CancellationToken cancellationToken = default(CancellationToken))
{
if (_roles.ContainsKey(roleId))
{
@ -40,7 +41,7 @@ namespace Microsoft.AspNet.Identity.InMemory
return Task.FromResult<InMemoryRole>(null);
}
public Task<InMemoryRole> FindByName(string roleName)
public Task<InMemoryRole> FindByName(string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
return
Task.FromResult(

79
src/Microsoft.AspNet.Identity.InMemory/InMemoryUserStore.cs
View File

@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity.InMemory
@ -29,99 +30,99 @@ namespace Microsoft.AspNet.Identity.InMemory
get { return _users.Values.AsQueryable(); }
}
public Task<IList<Claim>> GetClaims(TUser user)
public Task<IList<Claim>> GetClaims(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.Claims);
}
public Task AddClaim(TUser user, Claim claim)
public Task AddClaim(TUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
user.Claims.Add(claim);
return Task.FromResult(0);
}
public Task RemoveClaim(TUser user, Claim claim)
public Task RemoveClaim(TUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
user.Claims.Remove(claim);
return Task.FromResult(0);
}
public Task SetEmail(TUser user, string email)
public Task SetEmail(TUser user, string email, CancellationToken cancellationToken = default(CancellationToken))
{
user.Email = email;
return Task.FromResult(0);
}
public Task<string> GetEmail(TUser user)
public Task<string> GetEmail(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.Email);
}
public Task<bool> GetEmailConfirmed(TUser user)
public Task<bool> GetEmailConfirmed(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.EmailConfirmed);
}
public Task SetEmailConfirmed(TUser user, bool confirmed)
public Task SetEmailConfirmed(TUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken))
{
user.EmailConfirmed = confirmed;
return Task.FromResult(0);
}
public Task<TUser> FindByEmail(string email)
public Task<TUser> FindByEmail(string email, CancellationToken cancellationToken = default(CancellationToken))
{
return
Task.FromResult(
Users.FirstOrDefault(u => String.Equals(u.Email, email, StringComparison.OrdinalIgnoreCase)));
}
public Task<DateTimeOffset> GetLockoutEndDate(TUser user)
public Task<DateTimeOffset> GetLockoutEndDate(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.LockoutEnd);
}
public Task SetLockoutEndDate(TUser user, DateTimeOffset lockoutEnd)
public Task SetLockoutEndDate(TUser user, DateTimeOffset lockoutEnd, CancellationToken cancellationToken = default(CancellationToken))
{
user.LockoutEnd = lockoutEnd;
return Task.FromResult(0);
}
public Task<int> IncrementAccessFailedCount(TUser user)
public Task<int> IncrementAccessFailedCount(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
user.AccessFailedCount++;
return Task.FromResult(user.AccessFailedCount);
}
public Task ResetAccessFailedCount(TUser user)
public Task ResetAccessFailedCount(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
user.AccessFailedCount = 0;
return Task.FromResult(0);
}
public Task<int> GetAccessFailedCount(TUser user)
public Task<int> GetAccessFailedCount(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.AccessFailedCount);
}
public Task<bool> GetLockoutEnabled(TUser user)
public Task<bool> GetLockoutEnabled(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.LockoutEnabled);
}
public Task SetLockoutEnabled(TUser user, bool enabled)
public Task SetLockoutEnabled(TUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken))
{
user.LockoutEnabled = enabled;
return Task.FromResult(0);
}
public Task AddLogin(TUser user, UserLoginInfo login)
public Task AddLogin(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
user.Logins.Add(login);
_logins[login] = user;
return Task.FromResult(0);
}
public Task RemoveLogin(TUser user, UserLoginInfo login)
public Task RemoveLogin(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
var logs =
user.Logins.Where(l => l.ProviderKey == login.ProviderKey && l.LoginProvider == login.LoginProvider)
@ -134,12 +135,12 @@ namespace Microsoft.AspNet.Identity.InMemory
return Task.FromResult(0);
}
public Task<IList<UserLoginInfo>> GetLogins(TUser user)
public Task<IList<UserLoginInfo>> GetLogins(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.Logins);
}
public Task<TUser> Find(UserLoginInfo login)
public Task<TUser> Find(UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
if (_logins.ContainsKey(login))
{
@ -148,19 +149,19 @@ namespace Microsoft.AspNet.Identity.InMemory
return Task.FromResult<TUser>(null);
}
public Task Create(TUser user)
public Task Create(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
_users[user.Id] = user;
return Task.FromResult(0);
}
public Task Update(TUser user)
public Task Update(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
_users[user.Id] = user;
return Task.FromResult(0);
}
public Task<TUser> FindById(string userId)
public Task<TUser> FindById(string userId, CancellationToken cancellationToken = default(CancellationToken))
{
if (_users.ContainsKey(userId))
{
@ -173,14 +174,14 @@ namespace Microsoft.AspNet.Identity.InMemory
{
}
public Task<TUser> FindByName(string userName)
public Task<TUser> FindByName(string userName, CancellationToken cancellationToken = default(CancellationToken))
{
return
Task.FromResult(
Users.FirstOrDefault(u => String.Equals(u.UserName, userName, StringComparison.OrdinalIgnoreCase)));
}
public Task Delete(TUser user)
public Task Delete(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
if (user == null || !_users.ContainsKey(user.Id))
{
@ -190,84 +191,84 @@ namespace Microsoft.AspNet.Identity.InMemory
return Task.FromResult(0);
}
public Task SetPasswordHash(TUser user, string passwordHash)
public Task SetPasswordHash(TUser user, string passwordHash, CancellationToken cancellationToken = default(CancellationToken))
{
user.PasswordHash = passwordHash;
return Task.FromResult(0);
}
public Task<string> GetPasswordHash(TUser user)
public Task<string> GetPasswordHash(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.PasswordHash);
}
public Task<bool> HasPassword(TUser user)
public Task<bool> HasPassword(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.PasswordHash != null);
}
public Task SetPhoneNumber(TUser user, string phoneNumber)
public Task SetPhoneNumber(TUser user, string phoneNumber, CancellationToken cancellationToken = default(CancellationToken))
{
user.PhoneNumber = phoneNumber;
return Task.FromResult(0);
}
public Task<string> GetPhoneNumber(TUser user)
public Task<string> GetPhoneNumber(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.PhoneNumber);
}
public Task<bool> GetPhoneNumberConfirmed(TUser user)
public Task<bool> GetPhoneNumberConfirmed(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.PhoneNumberConfirmed);
}
public Task SetPhoneNumberConfirmed(TUser user, bool confirmed)
public Task SetPhoneNumberConfirmed(TUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken))
{
user.PhoneNumberConfirmed = confirmed;
return Task.FromResult(0);
}
public Task AddToRole(TUser user, string role)
public Task AddToRole(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken))
{
user.Roles.Add(role);
return Task.FromResult(0);
}
public Task RemoveFromRole(TUser user, string role)
public Task RemoveFromRole(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken))
{
user.Roles.Remove(role);
return Task.FromResult(0);
}
public Task<IList<string>> GetRoles(TUser user)
public Task<IList<string>> GetRoles(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.Roles);
}
public Task<bool> IsInRole(TUser user, string role)
public Task<bool> IsInRole(TUser user, string role, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.Roles.Contains(role));
}
public Task SetSecurityStamp(TUser user, string stamp)
public Task SetSecurityStamp(TUser user, string stamp, CancellationToken cancellationToken = default(CancellationToken))
{
user.SecurityStamp = stamp;
return Task.FromResult(0);
}
public Task<string> GetSecurityStamp(TUser user)
public Task<string> GetSecurityStamp(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.SecurityStamp);
}
public Task SetTwoFactorEnabled(TUser user, bool enabled)
public Task SetTwoFactorEnabled(TUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken))
{
user.TwoFactorEnabled = enabled;
return Task.FromResult(0);
}
public Task<bool> GetTwoFactorEnabled(TUser user)
public Task<bool> GetTwoFactorEnabled(TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(user.TwoFactorEnabled);
}

164
src/Microsoft.AspNet.Identity.Security/SignInManager.cs Normal file
View File

@ -0,0 +1,164 @@
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNet.Abstractions;
using Microsoft.AspNet.Abstractions.Security;
namespace Microsoft.AspNet.Identity.Security
{
public class SignInManager<TUser, TKey>
where TUser : class, IUser<TKey>
where TKey : IEquatable<TKey>
{
private string _authType;
public string AuthenticationType
{
get { return _authType ?? "Microsoft.AspNet.Identity"; }
set { _authType = value; }
}
public UserManager<TUser, TKey> UserManager { get; set; }
public HttpContext Context { get; set; }
public virtual async Task<ClaimsIdentity> CreateUserIdentity(TUser user)
{
if (UserManager == null)
{
return null;
}
return await UserManager.CreateIdentity(user, AuthenticationType);
}
public virtual async Task SignIn(TUser user, bool isPersistent, bool rememberBrowser)
{
if (Context == null)
{
return;
}
// TODO: all the two factor logic/external/rememberBrowser
var userIdentity = await CreateUserIdentity(user);
Context.Response.SignIn(userIdentity, new AuthenticationProperties { IsPersistent = isPersistent });
}
//public virtual async Task<bool> SendTwoFactorCode(string provider)
//{
// var userId = await GetVerifiedUserId();
// if (userId == null)
// {
// return false;
// }
// var token = await UserManager.GenerateTwoFactorToken(userId, provider);
// // See IdentityConfig.cs to plug in Email/SMS services to actually send the code
// await UserManager.NotifyTwoFactorToken(userId, provider, token);
// return true;
//}
//public Task<TKey> GetVerifiedUserId()
//{
// //var result = await AuthenticationManager.Authenticate(DefaultAuthenticationTypes.TwoFactorCookie);
// //if (result != null && result.Identity != null && !String.IsNullOrEmpty(result.Identity.GetUserId()))
// //{
// // return result.Identity.GetUserId();
// //}
// return Task.FromResult(default(TKey));
//}
//public async Task<bool> HasBeenVerified()
//{
// return await GetVerifiedUserId() != null;
//}
//public virtual async Task<SignInStatus> TwoFactorSignIn(string provider, string code, bool isPersistent, bool rememberBrowser)
//{
// var userId = await GetVerifiedUserId();
// if (userId == null)
// {
// return SignInStatus.Failure;
// }
// var user = await UserManager.FindById(userId);
// if (user == null)
// {
// return SignInStatus.Failure;
// }
// if (await UserManager.IsLockedOut(user.Id))
// {
// return SignInStatus.LockedOut;
// }
// if (await UserManager.VerifyTwoFactorToken(user.Id, provider, code))
// {
// // When token is verified correctly, clear the access failed count used for lockout
// await UserManager.ResetAccessFailedCount(user.Id);
// await SignIn(user, isPersistent, rememberBrowser);
// return SignInStatus.Success;
// }
// // If the token is incorrect, record the failure which also may cause the user to be locked out
// await UserManager.AccessFailed(user.Id);
// return SignInStatus.Failure;
//}
//public async Task<SignInStatus> ExternalSignIn(ExternalLoginInfo loginInfo, bool isPersistent)
//{
// var user = await UserManager.Find(loginInfo.Login);
// if (user == null)
// {
// return SignInStatus.Failure;
// }
// if (await UserManager.IsLockedOut(user.Id))
// {
// return SignInStatus.LockedOut;
// }
// return await SignInOrTwoFactor(user, isPersistent);
//}
//private async Task<SignInStatus> SignInOrTwoFactor(TUser user, bool isPersistent)
//{
// if (await UserManager.GetTwoFactorEnabled(user.Id))
// //&& !await AuthenticationManager.TwoFactorBrowserRemembered(user.Id))
// {
// //var identity = new ClaimsIdentity(DefaultAuthenticationTypes.TwoFactorCookie);
// //identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id));
// //AuthenticationManager.SignIn(identity);
// return SignInStatus.RequiresTwoFactorAuthentication;
// }
// await SignIn(user, isPersistent, false);
// return SignInStatus.Success;
//}
public virtual async Task<SignInStatus> PasswordSignIn(string userName, string password, bool isPersistent, bool shouldLockout)
{
if (UserManager == null)
{
return SignInStatus.Failure;
}
var user = await UserManager.FindByName(userName);
if (user == null)
{
return SignInStatus.Failure;
}
if (await UserManager.IsLockedOut(user.Id))
{
return SignInStatus.LockedOut;
}
if (await UserManager.CheckPassword(user, password))
{
await SignIn(user, isPersistent, false);
return SignInStatus.Success;
//TODO: return await SignInOrTwoFactor(user, isPersistent);
}
if (shouldLockout)
{
// If lockout is requested, increment access failed count which might lock out the user
await UserManager.AccessFailed(user.Id);
if (await UserManager.IsLockedOut(user.Id))
{
return SignInStatus.LockedOut;
}
}
return SignInStatus.Failure;
}
}
}

11
src/Microsoft.AspNet.Identity.Security/SignInStatus.cs Normal file
View File

@ -0,0 +1,11 @@
namespace Microsoft.AspNet.Identity.Security
{
public enum SignInStatus
{
Success,
LockedOut,
RequiresTwoFactorAuthentication,
Failure
}
}

31
src/Microsoft.AspNet.Identity.Security/project.json Normal file
View File

@ -0,0 +1,31 @@
{
"version": "0.1-alpha-*",
"dependencies": {
"Microsoft.AspNet.DependencyInjection" : "0.1-alpha-*",
"System.Security.Claims" : "0.1-alpha-*",
"Microsoft.AspNet.Abstractions" : "0.1-alpha-*",
"Microsoft.AspNet.Identity" : "0.1-alpha-*",
"Microsoft.AspNet.Security.DataProtection" : "0.1-alpha-*"
},
"configurations": {
"net45": {},
"k10": {
"dependencies": {
"System.Collections": "4.0.0.0",
"System.ComponentModel": "4.0.0.0",
"System.Diagnostics.Debug": "4.0.10.0",
"System.Diagnostics.Tools": "4.0.0.0",
"System.Globalization": "4.0.10.0",
"System.Linq": "4.0.0.0",
"System.Linq.Expressions": "4.0.0.0",
"System.Reflection": "4.0.10.0",
"System.Resources.ResourceManager": "4.0.0.0",
"System.Runtime": "4.0.20.0",
"System.Runtime.Extensions": "4.0.10.0",
"System.Security.Principal": "4.0.0.0",
"System.Text.Encoding": "4.0.20.0",
"System.Threading.Tasks": "4.0.10.0"
}
}
}
}

26
src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs
View File

@ -1,5 +1,7 @@
using System;
using System.Globalization;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -57,7 +59,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="authenticationType"></param>
/// <returns></returns>
public virtual async Task<ClaimsIdentity> Create(UserManager<TUser, TKey> manager, TUser user,
string authenticationType)
string authenticationType, CancellationToken cancellationToken = default(CancellationToken))
{
if (manager == null)
{
@ -68,15 +70,15 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("user");
}
var id = new ClaimsIdentity(authenticationType, UserNameClaimType, RoleClaimType);
id.AddClaim(new Claim(UserIdClaimType, ConvertIdToString(user.Id), ClaimValueTypes.String));
id.AddClaim(new Claim(UserIdClaimType, Convert.ToString(user.Id, CultureInfo.InvariantCulture), ClaimValueTypes.String));
id.AddClaim(new Claim(UserNameClaimType, user.UserName, ClaimValueTypes.String));
if (manager.SupportsUserSecurityStamp)
{
id.AddClaim(new Claim(SecurityStampClaimType, await manager.GetSecurityStamp(user.Id)));
id.AddClaim(new Claim(SecurityStampClaimType, await manager.GetSecurityStamp(user.Id, cancellationToken)));
}
if (manager.SupportsUserRole)
{
var roles = await manager.GetRoles(user.Id);
var roles = await manager.GetRoles(user.Id, cancellationToken);
foreach (var roleName in roles)
{
id.AddClaim(new Claim(RoleClaimType, roleName, ClaimValueTypes.String));
@ -84,23 +86,9 @@ namespace Microsoft.AspNet.Identity
}
if (manager.SupportsUserClaim)
{
id.AddClaims(await manager.GetClaims(user.Id));
id.AddClaims(await manager.GetClaims(user.Id, cancellationToken));
}
return id;
}
/// <summary>
/// Convert the key to a string, by default just calls .ToString()
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public virtual string ConvertIdToString(TKey key)
{
if (key == null || key.Equals(default(TKey)))
{
return null;
}
return key.ToString();
}
}
}

4
src/Microsoft.AspNet.Identity/IClaimsIdentityFactory.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -19,7 +20,8 @@ namespace Microsoft.AspNet.Identity
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="authenticationType"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<ClaimsIdentity> Create(UserManager<TUser, TKey> manager, TUser user, string authenticationType);
Task<ClaimsIdentity> Create(UserManager<TUser, TKey> manager, TUser user, string authenticationType, CancellationToken cancellationToken = default(CancellationToken));
}
}

6
src/Microsoft.AspNet.Identity/IIdentityMessageService.cs
View File

@ -1,4 +1,5 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
{
@ -11,7 +12,8 @@ namespace Microsoft.AspNet.Identity
/// This method should send the message
/// </summary>
/// <param name="message"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Send(IdentityMessage message);
Task Send(IdentityMessage message, CancellationToken cancellationToken = default(CancellationToken));
}
}

3
src/Microsoft.AspNet.Identity/IPasswordValidator.cs
View File

@ -1,3 +1,4 @@
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -11,6 +12,6 @@ namespace Microsoft.AspNet.Identity
/// Validate the item
/// </summary>
/// <returns></returns>
Task<IdentityResult> Validate(string password);
Task<IdentityResult> Validate(string password, CancellationToken cancellationToken = default(CancellationToken));
}
}

16
src/Microsoft.AspNet.Identity/IRoleStore.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -14,35 +15,40 @@ namespace Microsoft.AspNet.Identity
/// Insert a new role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Create(TRole role);
Task Create(TRole role, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Update a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Update(TRole role);
Task Update(TRole role, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Delete a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Delete(TRole role);
Task Delete(TRole role, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Finds a role by id
/// </summary>
/// <param name="roleId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TRole> FindById(TKey roleId);
Task<TRole> FindById(TKey roleId, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Find a role by name
/// </summary>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TRole> FindByName(string roleName);
Task<TRole> FindByName(string roleName, CancellationToken cancellationToken = default(CancellationToken));
}
}

4
src/Microsoft.AspNet.Identity/IRoleValidator.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -17,7 +18,8 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="role"></param>
/// <param name="manager"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> Validate(RoleManager<TRole, TKey> manager, TRole role);
Task<IdentityResult> Validate(RoleManager<TRole, TKey> manager, TRole role, CancellationToken cancellationToken = default(CancellationToken));
}
}

10
src/Microsoft.AspNet.Identity/IUserClaimStore.cs
View File

@ -1,5 +1,6 @@
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -15,23 +16,26 @@ namespace Microsoft.AspNet.Identity
/// Returns the claims for the user with the issuer set
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<Claim>> GetClaims(TUser user);
Task<IList<Claim>> GetClaims(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Add a new user claim
/// </summary>
/// <param name="user"></param>
/// <param name="claim"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddClaim(TUser user, Claim claim);
Task AddClaim(TUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Remove a user claim
/// </summary>
/// <param name="user"></param>
/// <param name="claim"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveClaim(TUser user, Claim claim);
Task RemoveClaim(TUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken));
}
}

18
src/Microsoft.AspNet.Identity/IUserEmailStore.cs
View File

@ -1,4 +1,5 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
{
@ -14,36 +15,41 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="email"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetEmail(TUser user, string email);
Task SetEmail(TUser user, string email, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Get the user email
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetEmail(TUser user);
Task<string> GetEmail(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns true if the user email is confirmed
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetEmailConfirmed(TUser user);
Task<bool> GetEmailConfirmed(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Sets whether the user email is confirmed
/// </summary>
/// <param name="user"></param>
/// <param name="confirmed"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetEmailConfirmed(TUser user, bool confirmed);
Task SetEmailConfirmed(TUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns the user associated with this email
/// </summary>
/// <param name="email"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindByEmail(string email);
Task<TUser> FindByEmail(string email, CancellationToken cancellationToken = default(CancellationToken));
}
}

22
src/Microsoft.AspNet.Identity/IUserLockoutStore.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -15,52 +16,59 @@ namespace Microsoft.AspNet.Identity
/// not locked out.
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<DateTimeOffset> GetLockoutEndDate(TUser user);
Task<DateTimeOffset> GetLockoutEndDate(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Locks a user out until the specified end date (set to a past date, to unlock a user)
/// </summary>
/// <param name="user"></param>
/// <param name="lockoutEnd"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetLockoutEndDate(TUser user, DateTimeOffset lockoutEnd);
Task SetLockoutEndDate(TUser user, DateTimeOffset lockoutEnd, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Used to record when an attempt to access the user has failed
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<int> IncrementAccessFailedCount(TUser user);
Task<int> IncrementAccessFailedCount(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Used to reset the account access count, typically after the account is successfully accessed
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task ResetAccessFailedCount(TUser user);
Task ResetAccessFailedCount(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns the current number of failed access attempts. This number usually will be reset whenever the password is
/// verified or the account is locked out.
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<int> GetAccessFailedCount(TUser user);
Task<int> GetAccessFailedCount(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns whether the user can be locked out.
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetLockoutEnabled(TUser user);
Task<bool> GetLockoutEnabled(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Sets whether the user can be locked out.
/// </summary>
/// <param name="user"></param>
/// <param name="enabled"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetLockoutEnabled(TUser user, bool enabled);
Task SetLockoutEnabled(TUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken));
}
}

14
src/Microsoft.AspNet.Identity/IUserLoginStore.cs
View File

@ -1,4 +1,5 @@
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -15,28 +16,33 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="login"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddLogin(TUser user, UserLoginInfo login);
Task AddLogin(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Removes the user login with the specified combination if it exists, returns true if found and removed
/// </summary>
/// <param name="user"></param>
/// <param name="login"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveLogin(TUser user, UserLoginInfo login);
Task RemoveLogin(TUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns the linked accounts for this user
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<UserLoginInfo>> GetLogins(TUser user);
Task<IList<UserLoginInfo>> GetLogins(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns the user associated with this login
/// </summary>
/// <param name="login"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> Find(UserLoginInfo login);
Task<TUser> Find(UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken));
}
}

12
src/Microsoft.AspNet.Identity/IUserPasswordStore.cs
View File

@ -1,4 +1,5 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
{
@ -14,21 +15,24 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="passwordHash"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetPasswordHash(TUser user, string passwordHash);
Task SetPasswordHash(TUser user, string passwordHash, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Get the user password hash
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetPasswordHash(TUser user);
Task<string> GetPasswordHash(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns true if a user has a password set
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> HasPassword(TUser user);
Task<bool> HasPassword(TUser user, CancellationToken cancellationToken = default(CancellationToken));
}
}

15
src/Microsoft.AspNet.Identity/IUserPhoneNumberStore.cs
View File

@ -1,4 +1,5 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
{
@ -14,29 +15,33 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="phoneNumber"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetPhoneNumber(TUser user, string phoneNumber);
Task SetPhoneNumber(TUser user, string phoneNumber, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Get the user phoneNumber
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetPhoneNumber(TUser user);
Task<string> GetPhoneNumber(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns true if the user phone number is confirmed
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetPhoneNumberConfirmed(TUser user);
Task<bool> GetPhoneNumberConfirmed(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Sets whether the user phone number is confirmed
/// </summary>
/// <param name="user"></param>
/// <param name="confirmed"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetPhoneNumberConfirmed(TUser user, bool confirmed);
Task SetPhoneNumberConfirmed(TUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken));
}
}

13
src/Microsoft.AspNet.Identity/IUserRoleStore.cs
View File

@ -1,4 +1,5 @@
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -15,30 +16,34 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddToRole(TUser user, string roleName);
Task AddToRole(TUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Removes the role for the user
/// </summary>
/// <param name="user"></param>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveFromRole(TUser user, string roleName);
Task RemoveFromRole(TUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns the roles for this user
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IList<string>> GetRoles(TUser user);
Task<IList<string>> GetRoles(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns true if a user is in a role
/// </summary>
/// <param name="user"></param>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> IsInRole(TUser user, string roleName);
Task<bool> IsInRole(TUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken));
}
}

9
src/Microsoft.AspNet.Identity/IUserSecurityStampStore.cs
View File

@ -1,4 +1,5 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
{
@ -14,14 +15,16 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="stamp"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetSecurityStamp(TUser user, string stamp);
Task SetSecurityStamp(TUser user, string stamp, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Get the user security stamp
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> GetSecurityStamp(TUser user);
Task<string> GetSecurityStamp(TUser user, CancellationToken cancellationToken = default(CancellationToken));
}
}

16
src/Microsoft.AspNet.Identity/IUserStore.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -14,35 +15,40 @@ namespace Microsoft.AspNet.Identity
/// Insert a new user
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Create(TUser user);
Task Create(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Update a user
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Update(TUser user);
Task Update(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Delete a user
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Delete(TUser user);
Task Delete(TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Finds a user
/// </summary>
/// <param name="userId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindById(TKey userId);
Task<TUser> FindById(TKey userId, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Find a user by name
/// </summary>
/// <param name="userName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<TUser> FindByName(string userName);
Task<TUser> FindByName(string userName, CancellationToken cancellationToken = default(CancellationToken));
}
}

13
src/Microsoft.AspNet.Identity/IUserTokenProvider.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -14,8 +15,9 @@ namespace Microsoft.AspNet.Identity
/// <param name="purpose"></param>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<string> Generate(string purpose, UserManager<TUser, TKey> manager, TUser user);
Task<string> Generate(string purpose, UserManager<TUser, TKey> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Validate and unprotect a token, returns null if invalid
@ -24,8 +26,9 @@ namespace Microsoft.AspNet.Identity
/// <param name="token"></param>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> Validate(string purpose, string token, UserManager<TUser, TKey> manager, TUser user);
Task<bool> Validate(string purpose, string token, UserManager<TUser, TKey> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Notifies the user that a token has been generated, i.e. via email or sms, or can no-op
@ -33,15 +36,17 @@ namespace Microsoft.AspNet.Identity
/// <param name="token"></param>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task Notify(string token, UserManager<TUser, TKey> manager, TUser user);
Task Notify(string token, UserManager<TUser, TKey> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns true if provider can be used for this user, i.e. could require a user to have an email
/// </summary>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> IsValidProviderForUser(UserManager<TUser, TKey> manager, TUser user);
Task<bool> IsValidProviderForUser(UserManager<TUser, TKey> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken));
}
}

9
src/Microsoft.AspNet.Identity/IUserTwoFactorStore.cs
View File

@ -1,4 +1,5 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
{
@ -14,14 +15,16 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="user"></param>
/// <param name="enabled"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task SetTwoFactorEnabled(TUser user, bool enabled);
Task SetTwoFactorEnabled(TUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Returns whether two factor is enabled for the user
/// </summary>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> GetTwoFactorEnabled(TUser user);
Task<bool> GetTwoFactorEnabled(TUser user, CancellationToken cancellationToken = default(CancellationToken));
}
}

4
src/Microsoft.AspNet.Identity/IUserValidator.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -17,7 +18,8 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<IdentityResult> Validate(UserManager<TUser, TKey> manager, TUser user);
Task<IdentityResult> Validate(UserManager<TUser, TKey> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken));
}
}

4
src/Microsoft.AspNet.Identity/PasswordValidator.cs
View File

@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -40,8 +41,9 @@ namespace Microsoft.AspNet.Identity
/// Ensures that the string is of the required length and meets the configured requirements
/// </summary>
/// <param name="item"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual Task<IdentityResult> Validate(string item)
public virtual Task<IdentityResult> Validate(string item, CancellationToken cancellationToken = default(CancellationToken))
{
if (item == null)
{

39
src/Microsoft.AspNet.Identity/RoleManager.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -92,17 +93,18 @@ namespace Microsoft.AspNet.Identity
GC.SuppressFinalize(this);
}
private async Task<IdentityResult> ValidateRoleInternal(TRole role)
private async Task<IdentityResult> ValidateRoleInternal(TRole role, CancellationToken cancellationToken)
{
return (RoleValidator == null) ? IdentityResult.Success : await RoleValidator.Validate(this, role);
return (RoleValidator == null) ? IdentityResult.Success : await RoleValidator.Validate(this, role, cancellationToken);
}
/// <summary>
/// Create a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> Create(TRole role)
public virtual async Task<IdentityResult> Create(TRole role, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
if (role == null)
@ -110,12 +112,12 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("role");
}
var result = await ValidateRoleInternal(role);
var result = await ValidateRoleInternal(role, cancellationToken);
if (!result.Succeeded)
{
return result;
}
await Store.Create(role);
await Store.Create(role, cancellationToken);
return IdentityResult.Success;
}
@ -123,8 +125,9 @@ namespace Microsoft.AspNet.Identity
/// Update an existing role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> Update(TRole role)
public virtual async Task<IdentityResult> Update(TRole role, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
if (role == null)
@ -132,12 +135,12 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("role");
}
var result = await ValidateRoleInternal(role);
var result = await ValidateRoleInternal(role, cancellationToken);
if (!result.Succeeded)
{
return result;
}
await Store.Update(role);
await Store.Update(role, cancellationToken);
return IdentityResult.Success;
}
@ -145,8 +148,9 @@ namespace Microsoft.AspNet.Identity
/// Delete a role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> Delete(TRole role)
public virtual async Task<IdentityResult> Delete(TRole role, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
if (role == null)
@ -154,7 +158,7 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("role");
}
await Store.Delete(role);
await Store.Delete(role, cancellationToken);
return IdentityResult.Success;
}
@ -162,8 +166,9 @@ namespace Microsoft.AspNet.Identity
/// Returns true if the role exists
/// </summary>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<bool> RoleExists(string roleName)
public virtual async Task<bool> RoleExists(string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
if (roleName == null)
@ -171,26 +176,28 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("roleName");
}
return await FindByName(roleName) != null;
return await FindByName(roleName, cancellationToken) != null;
}
/// <summary>
/// Find a role by id
/// </summary>
/// <param name="roleId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<TRole> FindById(TKey roleId)
public virtual async Task<TRole> FindById(TKey roleId, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
return await Store.FindById(roleId);
return await Store.FindById(roleId, cancellationToken);
}
/// <summary>
/// Find a role by name
/// </summary>
/// <param name="roleName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<TRole> FindByName(string roleName)
public virtual async Task<TRole> FindByName(string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
if (roleName == null)
@ -198,7 +205,7 @@ namespace Microsoft.AspNet.Identity
throw new ArgumentNullException("roleName");
}
return await Store.FindByName(roleName);
return await Store.FindByName(roleName, cancellationToken);
}
private void ThrowIfDisposed()

4
src/Microsoft.AspNet.Identity/RoleValidator.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity
@ -19,8 +20,9 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="manager"></param>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> Validate(RoleManager<TRole, TKey> manager, TRole role)
public virtual async Task<IdentityResult> Validate(RoleManager<TRole, TKey> manager, TRole role, CancellationToken cancellationToken = default(CancellationToken))
{
if (manager == null)
{

470
src/Microsoft.AspNet.Identity/UserManager.cs
View File

File diff suppressed because it is too large Load Diff

4
src/Microsoft.AspNet.Identity/UserValidator.cs
View File

@ -1,3 +1,4 @@
using System.Threading;
#if NET45
using System.Net.Mail;
#endif
@ -41,8 +42,9 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <param name="manager"></param>
/// <param name="user"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> Validate(UserManager<TUser, TKey> manager, TUser user)
public virtual async Task<IdentityResult> Validate(UserManager<TUser, TKey> manager, TUser user, CancellationToken cancellationToken = default(CancellationToken))
{
if (manager == null)
{

1
src/Microsoft.AspNet.Identity/project.json
View File

@ -3,6 +3,7 @@
"dependencies": {
"Microsoft.AspNet.DependencyInjection" : "0.1-alpha-*",
"System.Security.Claims" : "0.1-alpha-*",
"Microsoft.AspNet.HttpFeature" : "0.1-alpha-*",
"Microsoft.AspNet.Security.DataProtection" : "0.1-alpha-*"
},
"configurations": {

33
test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryStoreTest.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNet.Testing;
using Xunit;
@ -388,23 +389,23 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
private class StaticTokenProvider : IUserTokenProvider<InMemoryUser, string>
{
public Task<string> Generate(string purpose, UserManager<InMemoryUser, string> manager,
InMemoryUser user)
InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(MakeToken(purpose, user));
}
public Task<bool> Validate(string purpose, string token, UserManager<InMemoryUser, string> manager,
InMemoryUser user)
InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(token == MakeToken(purpose, user));
}
public Task Notify(string token, UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task Notify(string token, UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<bool> IsValidProviderForUser(UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task<bool> IsValidProviderForUser(UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(true);
}
@ -719,17 +720,17 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
{
public const string ErrorMessage = "I'm Bad.";
public Task<IdentityResult> Validate(string password)
public Task<IdentityResult> Validate(string password, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
public Task<IdentityResult> Validate(RoleManager<InMemoryRole, string> manager, InMemoryRole role)
public Task<IdentityResult> Validate(RoleManager<InMemoryRole, string> manager, InMemoryRole role, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
public Task<IdentityResult> Validate(UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task<IdentityResult> Validate(UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
@ -1092,23 +1093,23 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
private class EmailTokenProvider : IUserTokenProvider<InMemoryUser, string>
{
public Task<string> Generate(string purpose, UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task<string> Generate(string purpose, UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(MakeToken(purpose));
}
public Task<bool> Validate(string purpose, string token, UserManager<InMemoryUser, string> manager,
InMemoryUser user)
InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(token == MakeToken(purpose));
}
public Task Notify(string token, UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task Notify(string token, UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return manager.SendEmail(user.Id, token, token);
}
public async Task<bool> IsValidProviderForUser(UserManager<InMemoryUser, string> manager, InMemoryUser user)
public async Task<bool> IsValidProviderForUser(UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return !string.IsNullOrEmpty(await manager.GetEmail(user.Id));
}
@ -1121,23 +1122,23 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
private class SmsTokenProvider : IUserTokenProvider<InMemoryUser, string>
{
public Task<string> Generate(string purpose, UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task<string> Generate(string purpose, UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(MakeToken(purpose));
}
public Task<bool> Validate(string purpose, string token, UserManager<InMemoryUser, string> manager,
InMemoryUser user)
InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(token == MakeToken(purpose));
}
public Task Notify(string token, UserManager<InMemoryUser, string> manager, InMemoryUser user)
public Task Notify(string token, UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return manager.SendSms(user.Id, token);
}
public async Task<bool> IsValidProviderForUser(UserManager<InMemoryUser, string> manager, InMemoryUser user)
public async Task<bool> IsValidProviderForUser(UserManager<InMemoryUser, string> manager, InMemoryUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return !string.IsNullOrEmpty(await manager.GetPhoneNumber(user.Id));
}
@ -1419,7 +1420,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
{
public IdentityMessage Message { get; set; }
public Task Send(IdentityMessage message)
public Task Send(IdentityMessage message, CancellationToken cancellationToken = default(CancellationToken))
{
Message = message;
return Task.FromResult(0);

173
test/Microsoft.AspNet.Identity.Security.Test/SignInManagerTest.cs Normal file
View File

@ -0,0 +1,173 @@
using System.Threading;
using Microsoft.AspNet.Abstractions;
using Microsoft.AspNet.Abstractions.Security;
using Moq;
using System.Security.Claims;
using System.Threading.Tasks;
using Xunit;
namespace Microsoft.AspNet.Identity.Security.Test
{
public class SignInManagerTest
{
#if NET45
//TODO: Mock fails in K (this works fine in net45)
[Fact]
public async Task EnsureClaimsIdentityFactoryCreateIdentityCalled()
{
// Setup
var store = new Mock<IUserStore<TestUser, string>>();
var user = new TestUser { UserName = "Foo" };
var userManager = new UserManager<TestUser, string>(store.Object);
var identityFactory = new Mock<IClaimsIdentityFactory<TestUser, string>>();
const string authType = "Test";
var testIdentity = new ClaimsIdentity(authType);
identityFactory.Setup(s => s.Create(userManager, user, authType, CancellationToken.None)).ReturnsAsync(testIdentity).Verifiable();
userManager.ClaimsIdentityFactory = identityFactory.Object;
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(testIdentity, It.IsAny<AuthenticationProperties>())).Verifiable();
var helper = new SignInManager<TestUser, string> { UserManager = userManager, AuthenticationType = authType, Context = context.Object };
// Act
await helper.SignIn(user, false, false);
// Assert
identityFactory.VerifyAll();
}
[Fact]
public async Task PasswordSignInReturnsLockedOutWhenLockedOut()
{
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = new Mock<UserManager<TestUser, string>>();
manager.Setup(m => m.IsLockedOut(user.Id, CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.FindByName(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
var helper = new SignInManager<TestUser, string> { UserManager = manager.Object };
// Act
var result = await helper.PasswordSignIn(user.UserName, "bogus", false, false);
// Assert
Assert.Equal(SignInStatus.LockedOut, result);
manager.VerifyAll();
}
[Fact]
public async Task CanPasswordSignIn()
{
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = new Mock<UserManager<TestUser, string>>();
manager.Setup(m => m.IsLockedOut(user.Id, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByName(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPassword(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();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
response.Setup(r => r.SignIn(It.IsAny<ClaimsIdentity>(), It.IsAny<AuthenticationProperties>())).Verifiable();
var helper = new SignInManager<TestUser, string> { UserManager = manager.Object, Context = context.Object };
// Act
var result = await helper.PasswordSignIn(user.UserName, "password", false, false);
// Assert
Assert.Equal(SignInStatus.Success, result);
manager.VerifyAll();
}
[Fact]
public async Task PasswordSignInFailsWithWrongPassword()
{
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = new Mock<UserManager<TestUser, string>>();
manager.Setup(m => m.IsLockedOut(user.Id, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByName(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPassword(user, "bogus", CancellationToken.None)).ReturnsAsync(false).Verifiable();
var helper = new SignInManager<TestUser, string> { UserManager = manager.Object };
// Act
var result = await helper.PasswordSignIn(user.UserName, "bogus", false, false);
// Assert
Assert.Equal(SignInStatus.Failure, result);
manager.VerifyAll();
}
[Fact]
public async Task PasswordSignInFailsWithUnknownUser()
{
// Setup
var manager = new Mock<UserManager<TestUser, string>>();
manager.Setup(m => m.FindByName("bogus", CancellationToken.None)).ReturnsAsync(null).Verifiable();
var helper = new SignInManager<TestUser, string> { UserManager = manager.Object };
// Act
var result = await helper.PasswordSignIn("bogus", "bogus", false, false);
// Assert
Assert.Equal(SignInStatus.Failure, result);
manager.VerifyAll();
}
[Fact]
public async Task PasswordSignInFailsWithNoUserManager()
{
// Setup
var helper = new SignInManager<TestUser, string>();
// Act
var result = await helper.PasswordSignIn("bogus", "bogus", false, false);
// Assert
Assert.Equal(SignInStatus.Failure, result);
}
[Fact]
public async Task CreateUserIdentityReturnsNullNoUserManager()
{
// Setup
var user = new TestUser();
var helper = new SignInManager<TestUser, string>();
// Act
var result = await helper.CreateUserIdentity(user);
// Assert
Assert.Null(result);
}
[Fact]
public async Task PasswordSignInFailsWithWrongPasswordCanAccessFailedAndLockout()
{
// Setup
var user = new TestUser { UserName = "Foo" };
var manager = new Mock<UserManager<TestUser, string>>();
var lockedout = false;
manager.Setup(m => m.AccessFailed(user.Id, CancellationToken.None)).Returns(() =>
{
lockedout = true;
return Task.FromResult(IdentityResult.Success);
}).Verifiable();
manager.Setup(m => m.IsLockedOut(user.Id, CancellationToken.None)).Returns(() => Task.FromResult(lockedout));
manager.Setup(m => m.FindByName(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPassword(user, "bogus", CancellationToken.None)).ReturnsAsync(false).Verifiable();
var helper = new SignInManager<TestUser, string> { UserManager = manager.Object };
// Act
var result = await helper.PasswordSignIn(user.UserName, "bogus", false, true);
// Assert
Assert.Equal(SignInStatus.LockedOut, result);
manager.VerifyAll();
}
#endif
}
}

12
test/Microsoft.AspNet.Identity.Security.Test/TestUser.cs Normal file
View File

@ -0,0 +1,12 @@
namespace Microsoft.AspNet.Identity.Security.Test
{
public class TestUser : TestUser<string>
{
}
public class TestUser<TKey> : IUser<TKey>
{
public TKey Id { get; private set; }
public string UserName { get; set; }
}
}

48
test/Microsoft.AspNet.Identity.Security.Test/project.json Normal file
View File

@ -0,0 +1,48 @@
{
"version": "0.1-alpha-*",
"dependencies": {
"Microsoft.AspNet.Abstractions" : "0.1-alpha-*",
"Microsoft.AspNet.ConfigurationModel" : "0.1-alpha-*",
"Microsoft.AspNet.DependencyInjection" : "0.1-alpha-*",
"Microsoft.AspNet.Identity" : "0.1-alpha-*",
"Microsoft.AspNet.Identity.Security" : "0.1-alpha-*",
"Microsoft.AspNet.Testing" : "0.1-alpha-*",
"System.Security.Claims" : "0.1-alpha-*",
"Xunit.KRunner": "0.1-alpha-*",
"xunit.abstractions": "2.0.0-aspnet-*",
"xunit.assert": "2.0.0-aspnet-*",
"xunit.core": "2.0.0-aspnet-*",
"xunit.execution": "2.0.0-aspnet-*"
},
"configurations": {
"net45": {
"dependencies": {
"Moq" : "4.2.1312.1622",
"System.Runtime": "",
"System.Collections": ""
}
},
"k10": {
"dependencies": {
"System.Collections": "4.0.0.0",
"System.Collections.Concurrent": "4.0.0.0",
"System.ComponentModel": "4.0.0.0",
"System.Console": "4.0.0.0",
"System.Diagnostics.Debug": "4.0.10.0",
"System.Globalization": "4.0.10.0",
"System.Linq": "4.0.0.0",
"System.Linq.Expressions": "4.0.0.0",
"System.Reflection": "4.0.10.0",
"System.Reflection.Extensions": "4.0.0.0",
"System.Resources.ResourceManager": "4.0.0.0",
"System.Runtime": "4.0.20.0",
"System.Runtime.Extensions": "4.0.10.0",
"System.Threading": "4.0.0.0",
"System.Threading.Tasks": "4.0.10.0"
}
}
},
"commands": {
"test": "Xunit.KRunner"
}
}

58
test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs
View File

@ -1,5 +1,9 @@
using System;
using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using Moq;
using Xunit;
namespace Microsoft.AspNet.Identity.Test
@ -19,29 +23,49 @@ namespace Microsoft.AspNet.Identity.Test
async () => await factory.Create(manager, new TestUser(), null));
}
[Fact]
public void ConvertIdToStringWithDefaultStringReturnsNull()
#if NET45
//TODO: Mock fails in K (this works fine in net45)
[Theory]
[InlineData(false, false)]
[InlineData(false, true)]
[InlineData(true, false)]
[InlineData(true, true)]
public async Task EnsureClaimsIdentityHasExpectedClaims(bool supportRoles, bool supportClaims)
{
// Setup
var userManager = new Mock<UserManager<TestUser, string>>();
var user = new TestUser { UserName = "Foo" };
userManager.Setup(m => m.SupportsUserRole).Returns(supportRoles);
userManager.Setup(m => m.SupportsUserClaim).Returns(supportClaims);
var roleClaims = new[] { "Admin", "Local" };
userManager.Setup(m => m.GetRoles(user.Id, CancellationToken.None)).ReturnsAsync(roleClaims);
var userClaims = new[] { new Claim("Whatever", "Value"), new Claim("Whatever2", "Value2") };
userManager.Setup(m => m.GetClaims(user.Id, CancellationToken.None)).ReturnsAsync(userClaims);
const string authType = "Microsoft.AspNet.Identity";
var factory = new ClaimsIdentityFactory<TestUser, string>();
Assert.Null(factory.ConvertIdToString(default(string)));
}
[Fact]
public void ConvertIdToStringWithDefaultIntReturnsNull()
{
var factory = new ClaimsIdentityFactory<TestUser<int>, int>();
Assert.Null(factory.ConvertIdToString(default(int)));
}
// Act
var identity = await factory.Create(userManager.Object, user, authType);
[Fact]
public void ConvertIdToStringWithDefaultGuidReturnsNull()
{
var factory = new ClaimsIdentityFactory<TestUser<Guid>, Guid>();
Assert.Null(factory.ConvertIdToString(default(Guid)));
// Assert
Assert.NotNull(identity);
Assert.Equal(authType, identity.AuthenticationType);
var claims = identity.Claims;
Assert.NotNull(claims);
Assert.True(
claims.Any(c => c.Type == factory.UserNameClaimType && c.Value == user.UserName));
Assert.True(claims.Any(c => c.Type == factory.UserIdClaimType && c.Value == user.Id));
Assert.Equal(supportRoles, claims.Any(c => c.Type == factory.RoleClaimType && c.Value == "Admin"));
Assert.Equal(supportRoles, claims.Any(c => c.Type == factory.RoleClaimType && c.Value == "Local"));
foreach (var cl in userClaims)
{
Assert.Equal(supportClaims, claims.Any(c => c.Type == cl.Type && c.Value == cl.Value));
}
}
#endif
// TODO: Need Mock (test in InMemory for now)
//[Fact]
//[Fact]
//public async Task ClaimsIdentityTest()
//{
// var db = UnitTestHelper.CreateDefaultDb();

11
test/Microsoft.AspNet.Identity.Test/NoopRoleStore.cs
View File

@ -1,25 +1,26 @@
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity.Test
{
public class NoopRoleStore : IRoleStore<TestRole, string>
{
public Task Create(TestRole user)
public Task Create(TestRole user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task Update(TestRole user)
public Task Update(TestRole user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<TestRole> FindById(string roleId)
public Task<TestRole> FindById(string roleId, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestRole>(null);
}
public Task<TestRole> FindByName(string userName)
public Task<TestRole> FindByName(string userName, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestRole>(null);
}
@ -28,7 +29,7 @@ namespace Microsoft.AspNet.Identity.Test
{
}
public Task Delete(TestRole user)
public Task Delete(TestRole user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}

11
test/Microsoft.AspNet.Identity.Test/NoopUserStore.cs
View File

@ -1,25 +1,26 @@
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.AspNet.Identity.Test
{
public class NoopUserStore : IUserStore<TestUser, string>
{
public Task Create(TestUser user)
public Task Create(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task Update(TestUser user)
public Task Update(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<TestUser> FindById(string userId)
public Task<TestUser> FindById(string userId, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestUser>(null);
}
public Task<TestUser> FindByName(string userName)
public Task<TestUser> FindByName(string userName, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestUser>(null);
}
@ -28,7 +29,7 @@ namespace Microsoft.AspNet.Identity.Test
{
}
public Task Delete(TestUser user)
public Task Delete(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}

11
test/Microsoft.AspNet.Identity.Test/RoleManagerTest.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
@ -57,27 +58,27 @@ namespace Microsoft.AspNet.Identity.Test
private class NotImplementedStore : IRoleStore<TestRole, string>
{
public Task Create(TestRole role)
public Task Create(TestRole role, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task Update(TestRole role)
public Task Update(TestRole role, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task Delete(TestRole role)
public Task Delete(TestRole role, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<TestRole> FindById(string roleId)
public Task<TestRole> FindById(string roleId, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<TestRole> FindByName(string roleName)
public Task<TestRole> FindByName(string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}

8
test/Microsoft.AspNet.Identity.Test/TestUser.cs
View File

@ -1,12 +1,18 @@
using System;
namespace Microsoft.AspNet.Identity.Test
{
public class TestUser : TestUser<string>
{
public TestUser()
{
Id = Guid.NewGuid().ToString();
}
}
public class TestUser<TKey> : IUser<TKey>
{
public TKey Id { get; private set; }
public TKey Id { get; set; }
public string UserName { get; set; }
}
}

261
test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs
View File

@ -2,8 +2,10 @@ using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNet.Testing;
using Moq;
using Xunit;
namespace Microsoft.AspNet.Identity.Test
@ -27,23 +29,100 @@ namespace Microsoft.AspNet.Identity.Test
Assert.NotNull(manager.StorePublic);
}
#if NET45
//TODO: Mock fails in K (this works fine in net45)
//[Fact]
//public async Task CreateTest()
//{
// // Setup
// var store = new Mock<IUserStore<TestUser, string>>();
// var user = new TestUser();
// store.Setup(s => s.Create(user)).Verifiable();
// var userManager = new UserManager<TestUser, string>(store.Object);
[Fact]
public async Task CreateCallsStore()
{
// Setup
var store = new Mock<IUserStore<TestUser, string>>();
var user = new TestUser { UserName = "Foo" };
store.Setup(s => s.Create(user, CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
var validator = new Mock<UserValidator<TestUser, string>>();
var userManager = new UserManager<TestUser, string>(store.Object);
validator.Setup(v => v.Validate(userManager, user, CancellationToken.None)).Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
userManager.UserValidator = validator.Object;
// // Act
// var result = await userManager.Create(user);
// Act
var result = await userManager.Create(user);
// // Assert
// Assert.True(result.Succeeded);
// store.VerifyAll();
//}
// Assert
Assert.True(result.Succeeded);
store.VerifyAll();
}
[Fact]
public async Task DeleteCallsStore()
{
// Setup
var store = new Mock<IUserStore<TestUser, string>>();
var user = new TestUser { UserName = "Foo" };
store.Setup(s => s.Delete(user, CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
var userManager = new UserManager<TestUser, string>(store.Object);
// Act
var result = await userManager.Delete(user);
// Assert
Assert.True(result.Succeeded);
store.VerifyAll();
}
[Fact]
public async Task UpdateCallsStore()
{
// Setup
var store = new Mock<IUserStore<TestUser, string>>();
var user = new TestUser { UserName = "Foo" };
store.Setup(s => s.Update(user, CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable();
var validator = new Mock<UserValidator<TestUser, string>>();
var userManager = new UserManager<TestUser, string>(store.Object);
validator.Setup(v => v.Validate(userManager, user, CancellationToken.None)).Returns(Task.FromResult(IdentityResult.Success)).Verifiable();
userManager.UserValidator = validator.Object;
// Act
var result = await userManager.Update(user);
// Assert
Assert.True(result.Succeeded);
store.VerifyAll();
}
[Fact]
public async Task FindByIdCallsStore()
{
// Setup
var store = new Mock<IUserStore<TestUser, string>>();
var user = new TestUser { UserName = "Foo" };
store.Setup(s => s.FindById(user.Id, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
var userManager = new UserManager<TestUser, string>(store.Object);
// Act
var result = await userManager.FindById(user.Id);
// Assert
Assert.Equal(user, result);
store.VerifyAll();
}
[Fact]
public async Task FindByNameCallsStore()
{
// Setup
var store = new Mock<IUserStore<TestUser, string>>();
var user = new TestUser {UserName="Foo"};
store.Setup(s => s.FindByName(user.UserName, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable();
var userManager = new UserManager<TestUser, string>(store.Object);
// Act
var result = await userManager.FindByName(user.UserName);
// Assert
Assert.Equal(user, result);
store.VerifyAll();
}
#endif
[Fact]
public async Task CheckPasswordWithNullUserReturnsFalse()
@ -372,7 +451,7 @@ namespace Microsoft.AspNet.Identity.Test
{
public const string ErrorMessage = "I'm Bad.";
public Task<IdentityResult> Validate(string password)
public Task<IdentityResult> Validate(string password, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(IdentityResult.Failed(ErrorMessage));
}
@ -389,97 +468,97 @@ namespace Microsoft.AspNet.Identity.Test
IUserRoleStore<TestUser, string>,
IUserSecurityStampStore<TestUser, string>
{
public Task<IList<Claim>> GetClaims(TestUser user)
public Task<IList<Claim>> GetClaims(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<IList<Claim>>(new List<Claim>());
}
public Task AddClaim(TestUser user, Claim claim)
public Task AddClaim(TestUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task RemoveClaim(TestUser user, Claim claim)
public Task RemoveClaim(TestUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task SetEmail(TestUser user, string email)
public Task SetEmail(TestUser user, string email, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<string> GetEmail(TestUser user)
public Task<string> GetEmail(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult("");
}
public Task<bool> GetEmailConfirmed(TestUser user)
public Task<bool> GetEmailConfirmed(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(false);
}
public Task SetEmailConfirmed(TestUser user, bool confirmed)
public Task SetEmailConfirmed(TestUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<TestUser> FindByEmail(string email)
public Task<TestUser> FindByEmail(string email, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestUser>(null);
}
public Task<DateTimeOffset> GetLockoutEndDate(TestUser user)
public Task<DateTimeOffset> GetLockoutEndDate(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(DateTimeOffset.MinValue);
}
public Task SetLockoutEndDate(TestUser user, DateTimeOffset lockoutEnd)
public Task SetLockoutEndDate(TestUser user, DateTimeOffset lockoutEnd, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<int> IncrementAccessFailedCount(TestUser user)
public Task<int> IncrementAccessFailedCount(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task ResetAccessFailedCount(TestUser user)
public Task ResetAccessFailedCount(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<int> GetAccessFailedCount(TestUser user)
public Task<int> GetAccessFailedCount(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<bool> GetLockoutEnabled(TestUser user)
public Task<bool> GetLockoutEnabled(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(false);
}
public Task SetLockoutEnabled(TestUser user, bool enabled)
public Task SetLockoutEnabled(TestUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task AddLogin(TestUser user, UserLoginInfo login)
public Task AddLogin(TestUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task RemoveLogin(TestUser user, UserLoginInfo login)
public Task RemoveLogin(TestUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<IList<UserLoginInfo>> GetLogins(TestUser user)
public Task<IList<UserLoginInfo>> GetLogins(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<IList<UserLoginInfo>>(new List<UserLoginInfo>());
}
public Task<TestUser> Find(UserLoginInfo login)
public Task<TestUser> Find(UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestUser>(null);
}
@ -488,102 +567,102 @@ namespace Microsoft.AspNet.Identity.Test
{
}
public Task Create(TestUser user)
public Task Create(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task Update(TestUser user)
public Task Update(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task Delete(TestUser user)
public Task Delete(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<TestUser> FindById(string userId)
public Task<TestUser> FindById(string userId, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestUser>(null);
}
public Task<TestUser> FindByName(string userName)
public Task<TestUser> FindByName(string userName, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<TestUser>(null);
}
public Task SetPasswordHash(TestUser user, string passwordHash)
public Task SetPasswordHash(TestUser user, string passwordHash, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<string> GetPasswordHash(TestUser user)
public Task<string> GetPasswordHash(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<string>(null);
}
public Task<bool> HasPassword(TestUser user)
public Task<bool> HasPassword(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(false);
}
public Task SetPhoneNumber(TestUser user, string phoneNumber)
public Task SetPhoneNumber(TestUser user, string phoneNumber, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<string> GetPhoneNumber(TestUser user)
public Task<string> GetPhoneNumber(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult("");
}
public Task<bool> GetPhoneNumberConfirmed(TestUser user)
public Task<bool> GetPhoneNumberConfirmed(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(false);
}
public Task SetPhoneNumberConfirmed(TestUser user, bool confirmed)
public Task SetPhoneNumberConfirmed(TestUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task AddToRole(TestUser user, string roleName)
public Task AddToRole(TestUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task RemoveFromRole(TestUser user, string roleName)
public Task RemoveFromRole(TestUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<IList<string>> GetRoles(TestUser user)
public Task<IList<string>> GetRoles(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult<IList<string>>(new List<string>());
}
public Task<bool> IsInRole(TestUser user, string roleName)
public Task<bool> IsInRole(TestUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(false);
}
public Task SetSecurityStamp(TestUser user, string stamp)
public Task SetSecurityStamp(TestUser user, string stamp, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<string> GetSecurityStamp(TestUser user)
public Task<string> GetSecurityStamp(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult("");
}
public Task SetTwoFactorEnabled(TestUser user, bool enabled)
public Task SetTwoFactorEnabled(TestUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<bool> GetTwoFactorEnabled(TestUser user)
public Task<bool> GetTwoFactorEnabled(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(false);
}
@ -591,23 +670,23 @@ namespace Microsoft.AspNet.Identity.Test
private class NoOpTokenProvider : IUserTokenProvider<TestUser, string>
{
public Task<string> Generate(string purpose, UserManager<TestUser, string> manager, TestUser user)
public Task<string> Generate(string purpose, UserManager<TestUser, string> manager, TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult("Test");
}
public Task<bool> Validate(string purpose, string token, UserManager<TestUser, string> manager,
TestUser user)
TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(true);
}
public Task Notify(string token, UserManager<TestUser, string> manager, TestUser user)
public Task Notify(string token, UserManager<TestUser, string> manager, TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(0);
}
public Task<bool> IsValidProviderForUser(UserManager<TestUser, string> manager, TestUser user)
public Task<bool> IsValidProviderForUser(UserManager<TestUser, string> manager, TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(true);
}
@ -622,97 +701,97 @@ namespace Microsoft.AspNet.Identity.Test
IUserLockoutStore<TestUser, string>,
IUserTwoFactorStore<TestUser, string>
{
public Task<IList<Claim>> GetClaims(TestUser user)
public Task<IList<Claim>> GetClaims(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task AddClaim(TestUser user, Claim claim)
public Task AddClaim(TestUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task RemoveClaim(TestUser user, Claim claim)
public Task RemoveClaim(TestUser user, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetEmail(TestUser user, string email)
public Task SetEmail(TestUser user, string email, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<string> GetEmail(TestUser user)
public Task<string> GetEmail(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<bool> GetEmailConfirmed(TestUser user)
public Task<bool> GetEmailConfirmed(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetEmailConfirmed(TestUser user, bool confirmed)
public Task SetEmailConfirmed(TestUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<TestUser> FindByEmail(string email)
public Task<TestUser> FindByEmail(string email, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<DateTimeOffset> GetLockoutEndDate(TestUser user)
public Task<DateTimeOffset> GetLockoutEndDate(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetLockoutEndDate(TestUser user, DateTimeOffset lockoutEnd)
public Task SetLockoutEndDate(TestUser user, DateTimeOffset lockoutEnd, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<int> IncrementAccessFailedCount(TestUser user)
public Task<int> IncrementAccessFailedCount(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task ResetAccessFailedCount(TestUser user)
public Task ResetAccessFailedCount(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<int> GetAccessFailedCount(TestUser user)
public Task<int> GetAccessFailedCount(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<bool> GetLockoutEnabled(TestUser user)
public Task<bool> GetLockoutEnabled(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetLockoutEnabled(TestUser user, bool enabled)
public Task SetLockoutEnabled(TestUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task AddLogin(TestUser user, UserLoginInfo login)
public Task AddLogin(TestUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task RemoveLogin(TestUser user, UserLoginInfo login)
public Task RemoveLogin(TestUser user, UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<IList<UserLoginInfo>> GetLogins(TestUser user)
public Task<IList<UserLoginInfo>> GetLogins(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<TestUser> Find(UserLoginInfo login)
public Task<TestUser> Find(UserLoginInfo login, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
@ -722,72 +801,72 @@ namespace Microsoft.AspNet.Identity.Test
throw new NotImplementedException();
}
public Task Create(TestUser user)
public Task Create(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task Update(TestUser user)
public Task Update(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task Delete(TestUser user)
public Task Delete(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<TestUser> FindById(string userId)
public Task<TestUser> FindById(string userId, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<TestUser> FindByName(string userName)
public Task<TestUser> FindByName(string userName, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetPasswordHash(TestUser user, string passwordHash)
public Task SetPasswordHash(TestUser user, string passwordHash, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<string> GetPasswordHash(TestUser user)
public Task<string> GetPasswordHash(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<bool> HasPassword(TestUser user)
public Task<bool> HasPassword(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetPhoneNumber(TestUser user, string phoneNumber)
public Task SetPhoneNumber(TestUser user, string phoneNumber, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<string> GetPhoneNumber(TestUser user)
public Task<string> GetPhoneNumber(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<bool> GetPhoneNumberConfirmed(TestUser user)
public Task<bool> GetPhoneNumberConfirmed(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetPhoneNumberConfirmed(TestUser user, bool confirmed)
public Task SetPhoneNumberConfirmed(TestUser user, bool confirmed, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task SetTwoFactorEnabled(TestUser user, bool enabled)
public Task SetTwoFactorEnabled(TestUser user, bool enabled, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public Task<bool> GetTwoFactorEnabled(TestUser user)
public Task<bool> GetTwoFactorEnabled(TestUser user, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}

4
test/Microsoft.AspNet.Identity.Test/packages.config Normal file
View File

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="System.Security.Claims" version="0.1-alpha-067" targetFramework="net451" />
</packages>