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

React to options and hosting changes

This commit is contained in:
Hao Kung 2014-10-14 19:19:44 -07:00
parent 9255f200b0
commit 3abe532761
25 changed files with 114 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
samples/IdentitySample.Mvc/Models/IdentityModels.cs
View File

@ -10,7 +10,7 @@ namespace IdentitySample.Models
public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
public ApplicationDbContext(IServiceProvider serviceProvider, IOptionsAccessor<IdentityDbContextOptions> optionsAccessor)
public ApplicationDbContext(IServiceProvider serviceProvider, IOptions<IdentityDbContextOptions> optionsAccessor)
: base(serviceProvider, optionsAccessor.Options)
{
}

2
samples/IdentitySample.Mvc/Models/SampleData.cs
View File

@ -36,7 +36,7 @@ namespace IdentitySample.Models
/// <returns></returns>
private static async Task CreateAdminUser(IServiceProvider serviceProvider)
{
var options = serviceProvider.GetService<IOptionsAccessor<IdentityDbContextOptions>>().Options;
var options = serviceProvider.GetService<IOptions<IdentityDbContextOptions>>().Options;
const string adminRole = "Administrator";
var userManager = serviceProvider.GetService<UserManager<ApplicationUser>>();

3
samples/IdentitySample.Mvc/Startup.cs
View File

@ -29,7 +29,7 @@ namespace IdentitySamples
{
services.AddEntityFramework().AddSqlServer();
services.AddScoped<ApplicationDbContext>();
services.ConfigureOptions<IdentityDbContextOptions>(options =>
services.Configure<IdentityDbContextOptions>(options =>
{
options.DefaultAdminUserName = Configuration.Get("DefaultAdminUsername");
options.DefaultAdminPassword = Configuration.Get("DefaultAdminPassword");
@ -66,7 +66,6 @@ namespace IdentitySamples
public void Configure(IApplicationBuilder app)
{
app.UseErrorPage(ErrorPageOptions.ShowAll)
.UsePerRequestServices()
.UseStaticFiles()
.UseIdentity()
.UseFacebookAuthentication()

1
samples/IdentitySample.Mvc/project.json
View File

@ -24,6 +24,7 @@
"web": "Microsoft.AspNet.Hosting --server Microsoft.AspNet.Server.WebListener --server.urls http://localhost:41532",
"run": "run server.urls=http://localhost:41532"
},
"webroot": ".",
"frameworks": {
"aspnet50": {
},

1
src/Microsoft.AspNet.Identity.EntityFramework/IdentityEntityFrameworkBuilderExtensions.cs
View File

@ -35,7 +35,6 @@ namespace Microsoft.Framework.DependencyInjection
{
builder.Services.AddScoped<IUserStore<TUser>, UserStore<TUser, TRole, TContext>>();
builder.Services.AddScoped<IRoleStore<TRole>, RoleStore<TRole, TContext>>();
builder.Services.AddScoped<TContext>();
return builder;
}

1
src/Microsoft.AspNet.Identity/BuilderExtensions.cs
View File

@ -22,7 +22,6 @@ namespace Microsoft.AspNet.Builder
throw new ArgumentNullException("app");
}
app.UseCookieAuthentication(null, IdentityOptions.ExternalCookieAuthenticationType);
app.UseCookieAuthentication(null, IdentityOptions.ApplicationCookieAuthenticationType);
app.UseCookieAuthentication(null, IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
app.UseCookieAuthentication(null, IdentityOptions.TwoFactorUserIdCookieAuthenticationType);
app.UseCookieAuthentication(null, IdentityOptions.ApplicationCookieAuthenticationType);

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

@ -18,7 +18,7 @@ namespace Microsoft.AspNet.Identity
where TRole : class
{
public ClaimsIdentityFactory(UserManager<TUser> userManager, RoleManager<TRole> roleManager,
IOptionsAccessor<IdentityOptions> optionsAccessor)
IOptions<IdentityOptions> optionsAccessor)
{
if (userManager == null)
{

2
src/Microsoft.AspNet.Identity/IdentityBuilder.cs
View File

@ -49,7 +49,7 @@ namespace Microsoft.AspNet.Identity
public IdentityBuilder<TUser, TRole> ConfigureIdentity(Action<IdentityOptions> action, int order = 0)
{
Services.AddOptionsAction(new OptionsAction<IdentityOptions>(action) { Order = order });
Services.Configure(action, order);
return this;
}

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

@ -15,7 +15,7 @@ namespace Microsoft.Framework.DependencyInjection
{
public static IServiceCollection ConfigureIdentity(this IServiceCollection services, Action<IdentityOptions> configure)
{
return services.ConfigureOptions(configure);
return services.Configure(configure);
}
public static IdentityBuilder<IdentityUser, IdentityRole> AddIdentity(this IServiceCollection services,
@ -36,7 +36,7 @@ namespace Microsoft.Framework.DependencyInjection
{
if (identityConfig != null)
{
services.ConfigureOptions<IdentityOptions>(identityConfig);
services.Configure<IdentityOptions>(identityConfig);
}
if (configureOptions != null)
{
@ -50,12 +50,12 @@ namespace Microsoft.Framework.DependencyInjection
services.AddScoped<RoleManager<TRole>>();
services.AddScoped<IClaimsIdentityFactory<TUser>, ClaimsIdentityFactory<TUser, TRole>>();
services.ConfigureOptions<ExternalAuthenticationOptions>(options =>
services.Configure<ExternalAuthenticationOptions>(options =>
{
options.SignInAsAuthenticationType = IdentityOptions.ExternalCookieAuthenticationType;
});
services.ConfigureOptions<CookieAuthenticationOptions>(options =>
services.Configure<CookieAuthenticationOptions>(options =>
{
options.AuthenticationType = IdentityOptions.ApplicationCookieAuthenticationType;
//CookieName = ".AspNet.Identity." + ClaimsIdentityOptions.DefaultAuthenticationType,
@ -66,7 +66,7 @@ namespace Microsoft.Framework.DependencyInjection
};
}, IdentityOptions.ApplicationCookieAuthenticationType);
services.ConfigureOptions<CookieAuthenticationOptions>(options =>
services.Configure<CookieAuthenticationOptions>(options =>
{
options.AuthenticationType = IdentityOptions.ExternalCookieAuthenticationType;
options.AuthenticationMode = AuthenticationMode.Passive;
@ -74,14 +74,14 @@ namespace Microsoft.Framework.DependencyInjection
options.ExpireTimeSpan = TimeSpan.FromMinutes(5);
}, IdentityOptions.ExternalCookieAuthenticationType);
services.ConfigureOptions<CookieAuthenticationOptions>(options =>
services.Configure<CookieAuthenticationOptions>(options =>
{
options.AuthenticationType = IdentityOptions.TwoFactorRememberMeCookieAuthenticationType;
options.AuthenticationMode = AuthenticationMode.Passive;
options.CookieName = IdentityOptions.TwoFactorRememberMeCookieAuthenticationType;
}, IdentityOptions.TwoFactorRememberMeCookieAuthenticationType);
services.ConfigureOptions<CookieAuthenticationOptions>(options =>
services.Configure<CookieAuthenticationOptions>(options =>
{
options.AuthenticationType = IdentityOptions.TwoFactorUserIdCookieAuthenticationType;
options.AuthenticationMode = AuthenticationMode.Passive;

2
src/Microsoft.AspNet.Identity/SecurityStampValidator.cs
View File

@ -60,7 +60,7 @@ namespace Microsoft.AspNet.Identity
if (issuedUtc != null)
{
var timeElapsed = currentUtc.Subtract(issuedUtc.Value);
var identityOptions = context.HttpContext.RequestServices.GetService<IOptionsAccessor<IdentityOptions>>().Options;
var identityOptions = context.HttpContext.RequestServices.GetService<IOptions<IdentityOptions>>().Options;
validate = timeElapsed > identityOptions.SecurityStampValidationInterval;
}
if (validate)

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

@ -22,7 +22,7 @@ namespace Microsoft.AspNet.Identity
public class SignInManager<TUser> where TUser : class
{
public SignInManager(UserManager<TUser> userManager, IContextAccessor<HttpContext> contextAccessor,
IClaimsIdentityFactory<TUser> claimsFactory, IOptionsAccessor<IdentityOptions> optionsAccessor)
IClaimsIdentityFactory<TUser> claimsFactory, IOptions<IdentityOptions> optionsAccessor)
{
if (userManager == null)
{
@ -94,6 +94,15 @@ namespace Microsoft.AspNet.Identity
return UserManager.SupportsUserLockout && await UserManager.IsLockedOutAsync(user, token);
}
private Task ResetLockout(TUser user, CancellationToken token)
{
if (UserManager.SupportsUserLockout)
{
return UserManager.ResetAccessFailedCountAsync(user, token);
}
return Task.FromResult(0);
}
/// <summary>
/// Validates that the claims identity has a security stamp matching the users
/// Returns the user if it matches, null otherwise
@ -131,6 +140,7 @@ namespace Microsoft.AspNet.Identity
}
if (await UserManager.CheckPasswordAsync(user, password, cancellationToken))
{
await ResetLockout(user, cancellationToken);
return await SignInOrTwoFactorAsync(user, isPersistent, cancellationToken);
}
if (UserManager.SupportsUserLockout && shouldLockout)
@ -224,7 +234,7 @@ namespace Microsoft.AspNet.Identity
if (await UserManager.VerifyTwoFactorTokenAsync(user, provider, code, cancellationToken))
{
// When token is verified correctly, clear the access failed count used for lockout
await UserManager.ResetAccessFailedCountAsync(user, cancellationToken);
await ResetLockout(user, cancellationToken);
// Cleanup external cookie
if (twoFactorInfo.LoginProvider != null)
{

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

@ -37,7 +37,7 @@ namespace Microsoft.AspNet.Identity
/// <param name="userValidator"></param>
/// <param name="passwordValidator"></param>
/// <param name="claimsIdentityFactory"></param>
public UserManager(IUserStore<TUser> store, IOptionsAccessor<IdentityOptions> optionsAccessor,
public UserManager(IUserStore<TUser> store, IOptions<IdentityOptions> optionsAccessor,
IPasswordHasher<TUser> passwordHasher, IUserValidator<TUser> userValidator,
IPasswordValidator<TUser> passwordValidator, IUserNameNormalizer userNameNormalizer,
IEnumerable<IUserTokenProvider<TUser>> tokenProviders)

9
test/Microsoft.AspNet.Identity.EntityFramework.Test/CustomPocoTest.cs
View File

@ -33,7 +33,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public DbSet<User<TKey>> Users { get; set; }
public CustomDbContext(IServiceProvider services) :
base(services, services.GetService<IOptionsAccessor<DbContextOptions>>().Options)
base(services, services.GetService<IOptions<DbContextOptions>>().Options)
{ }
protected override void OnModelCreating(ModelBuilder modelBuilder)
@ -48,12 +48,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public CustomDbContext<TKey> GetContext<TKey>() where TKey : IEquatable<TKey>
{
var services = new ServiceCollection();
services.Add(OptionsServices.GetDefaultServices());
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
services.ConfigureOptions<DbContextOptions>(options => options.UseSqlServer(ConnectionString));
var serviceProvider = services.BuildServiceProvider();
var serviceProvider = UserStoreTest.ConfigureDbServices(ConnectionString).BuildServiceProvider();
return new CustomDbContext<TKey>(serviceProvider);
}

14
test/Microsoft.AspNet.Identity.EntityFramework.Test/DefaultPocoTest.cs
View File

@ -21,14 +21,10 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
private readonly string ConnectionString = @"Server=(localdb)\v11.0;Database=DefaultSchemaTest" + DateTime.Now.Month + "-" + DateTime.Now.Day + "-" + DateTime.Now.Year + ";Trusted_Connection=True;";
public IdentityDbContext CreateContext(bool ensureCreated = false)
{
var services = new ServiceCollection();
services.Add(OptionsServices.GetDefaultServices());
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
services.ConfigureOptions<DbContextOptions>(options => options.UseSqlServer(ConnectionString));
var services = UserStoreTest.ConfigureDbServices(ConnectionString);
var serviceProvider = services.BuildServiceProvider();
var db = new IdentityDbContext(serviceProvider,
serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>().Options);
serviceProvider.GetService<IOptions<DbContextOptions>>().Options);
if (ensureCreated)
{
db.Database.EnsureCreated();
@ -55,12 +51,10 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
var context = CreateContext(true);
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services =>
builder.UseServices(services =>
{
services.AddEntityFramework().AddSqlServer();
UserStoreTest.ConfigureDbServices(ConnectionString, services);
services.AddIdentitySqlServer();
services.ConfigureOptions<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
// todo: constructor resolution doesn't work well with IdentityDbContext since it has 4 constructors
services.AddInstance(context);
});

37
test/Microsoft.AspNet.Identity.EntityFramework.Test/SqlStoreTestBase.cs
View File

@ -27,7 +27,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public class ApplicationDbContext : IdentityDbContext<TUser, TRole, TKey>
{
public ApplicationDbContext(IServiceProvider services, IOptionsAccessor<DbContextOptions> options) : base(services, options.Options) { }
public ApplicationDbContext(IServiceProvider services, IOptions<DbContextOptions> options) : base(services, options.Options) { }
}
[TestPriority(-1000)]
@ -46,28 +46,17 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public void DropDb()
{
var services = new ServiceCollection();
services.AddEntityFramework().AddSqlServer();
services.Add(OptionsServices.GetDefaultServices());
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.ConfigureOptions<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
var serviceProvider = services.BuildServiceProvider();
var serviceProvider = UserStoreTest.ConfigureDbServices(ConnectionString).BuildServiceProvider();
var db = new ApplicationDbContext(serviceProvider,
serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>());
serviceProvider.GetService<IOptions<DbContextOptions>>());
db.Database.EnsureDeleted();
}
public ApplicationDbContext CreateContext(bool delete = false)
{
var services = new ServiceCollection();
services.AddEntityFramework().AddSqlServer();
services.Add(OptionsServices.GetDefaultServices());
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.ConfigureOptions<DbContextOptions>(options => options.UseSqlServer(ConnectionString));
var serviceProvider = services.BuildServiceProvider();
var serviceProvider = UserStoreTest.ConfigureDbServices(ConnectionString).BuildServiceProvider();
var db = new ApplicationDbContext(serviceProvider,
serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>());
serviceProvider.GetService<IOptions<DbContextOptions>>());
if (delete)
{
db.Database.EnsureDeleted();
@ -96,7 +85,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
{
context = CreateTestContext();
}
var services = new ServiceCollection();
var services = UserStoreTest.ConfigureDbServices(ConnectionString);
services.AddIdentity<TUser, TRole>().AddRoleStore(new RoleStore<TRole, ApplicationDbContext, TKey>((ApplicationDbContext)context));
return services.BuildServiceProvider().GetService<RoleManager<TRole>>();
}
@ -112,13 +101,10 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
EnsureDatabase();
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services =>
builder.UseServices(services =>
{
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
UserStoreTest.ConfigureDbServices(ConnectionString, services);
services.AddIdentitySqlServer<ApplicationDbContext, TUser, TRole, TKey>();
services.ConfigureOptions<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
});
var userStore = builder.ApplicationServices.GetService<IUserStore<TUser>>();
@ -140,10 +126,9 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
EnsureDatabase();
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services =>
builder.UseServices(services =>
{
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
UserStoreTest.ConfigureDbServices(ConnectionString, services);
services.AddIdentitySqlServer<ApplicationDbContext, TUser, TRole, TKey>();
services.ConfigureIdentity(options =>
{
@ -154,8 +139,6 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
options.Password.RequireDigit = false;
options.User.UserNameValidationRegex = null;
});
services.ConfigureOptions<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
});
var userStore = builder.ApplicationServices.GetService<IUserStore<TUser>>();

3
test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreGuidKeyTest.cs
View File

@ -77,8 +77,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
{
context = CreateTestContext();
}
var services = new ServiceCollection();
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
var services = UserStoreTest.ConfigureDbServices(ConnectionString);
services.AddIdentity<GuidUser, GuidRole>().AddRoleStore(new ApplicationRoleStore((ApplicationDbContext)context));
return services.BuildServiceProvider().GetService<RoleManager<GuidRole>>();
}

61
test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreTest.cs
View File

@ -26,7 +26,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
public ApplicationDbContext(IServiceProvider services, IOptionsAccessor<DbContextOptions> options) : base(services, options.Options) { }
public ApplicationDbContext(IServiceProvider services, IOptions<DbContextOptions> options) : base(services, options.Options) { }
}
[TestPriority(-1000)]
@ -45,15 +45,9 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public void DropDb()
{
var services = new ServiceCollection();
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
services.Add(OptionsServices.GetDefaultServices());
services.ConfigureOptions<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
var serviceProvider = services.BuildServiceProvider();
var serviceProvider = ConfigureDbServices(ConnectionString).BuildServiceProvider();
var db = new ApplicationDbContext(serviceProvider,
serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>());
serviceProvider.GetService<IOptions<DbContextOptions>>());
db.Database.EnsureDeleted();
}
@ -63,13 +57,11 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
EnsureDatabase();
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services =>
builder.UseServices(services =>
{
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
ConfigureDbServices(ConnectionString, services);
services.AddScoped<ApplicationDbContext>();
services.AddDefaultIdentity<ApplicationDbContext, ApplicationUser, IdentityRole>();
services.ConfigureOptions<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
});
var userStore = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
@ -91,7 +83,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
EnsureDatabase();
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services =>
builder.UseServices(services =>
{
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
@ -103,7 +95,7 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
options.Password.RequireUppercase = false;
options.Password.RequireDigit = false;
});
services.ConfigureOptions<DbContextOptions>(options =>
services.Configure<DbContextOptions>(options =>
options.UseSqlServer(ConnectionString));
});
@ -135,13 +127,8 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
public IdentityDbContext CreateContext(bool delete = false)
{
var services = new ServiceCollection();
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
var dbOptions = new DbContextOptions();
dbOptions.UseSqlServer(ConnectionString);
var serviceProvider = services.BuildServiceProvider();
var db = new IdentityDbContext(serviceProvider, dbOptions);
var serviceProvider = ConfigureDbServices(ConnectionString).BuildServiceProvider();
var db = new IdentityDbContext(serviceProvider, serviceProvider.GetService<IOptions<DbContextOptions>>().Options);
if (delete)
{
db.Database.EnsureDeleted();
@ -160,16 +147,25 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
CreateContext();
}
public static IServiceCollection ConfigureDbServices(string connectionString, IServiceCollection services = null)
{
if (services == null)
{
services = new ServiceCollection();
}
services.AddEntityFramework().AddSqlServer();
services.Add(OptionsServices.GetDefaultServices());
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.Configure<DbContextOptions>(options =>
options.UseSqlServer(connectionString));
return services;
}
public ApplicationDbContext CreateAppContext()
{
CreateContext();
var services = new ServiceCollection();
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
services.AddEntityFramework().AddSqlServer();
services.Add(OptionsServices.GetDefaultServices());
var serviceProvider = services.BuildServiceProvider();
var db = new ApplicationDbContext(serviceProvider, serviceProvider.GetService<IOptionsAccessor<DbContextOptions>>());
var serviceProvider = ConfigureDbServices(ConnectionString).BuildServiceProvider();
var db = new ApplicationDbContext(serviceProvider, serviceProvider.GetService<IOptions<DbContextOptions>>());
db.Database.EnsureCreated();
return db;
}
@ -188,10 +184,9 @@ namespace Microsoft.AspNet.Identity.EntityFramework.Test
return CreateManager((DbContext)context);
}
public static RoleManager<IdentityRole> CreateRoleManager(IdentityDbContext context)
public RoleManager<IdentityRole> CreateRoleManager(IdentityDbContext context)
{
var services = new ServiceCollection();
services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
var services = ConfigureDbServices(ConnectionString);
services.AddIdentity().AddRoleStore(new RoleStore<IdentityRole>(context));
return services.BuildServiceProvider().GetService<RoleManager<IdentityRole>>();
}

9
test/Microsoft.AspNet.Identity.InMemory.Test/HttpSignInTest.cs
View File

@ -25,13 +25,6 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
public async Task VerifyAccountControllerSignIn(bool isPersistent)
{
var app = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
//app.UseServices(services =>
//{
// services.SetupOptions<CookieAuthenticationOptions>(options =>
// {
// options.AuthenticationType = IdentityOptions.ApplicationCookieAuthenticationType;
// });
//});
app.UseCookieAuthentication();
var context = new Mock<HttpContext>();
@ -40,7 +33,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
response.Setup(r => r.SignIn(It.Is<AuthenticationProperties>(v => v.IsPersistent == isPersistent), It.IsAny<ClaimsIdentity>())).Verifiable();
var contextAccessor = new Mock<IContextAccessor<HttpContext>>();
contextAccessor.Setup(a => a.Value).Returns(context.Object);
app.UsePerRequestServices(services =>
app.UseServices(services =>
{
services.AddInstance(contextAccessor.Object);
services.AddIdentity<ApplicationUser, IdentityRole>().AddInMemory();

4
test/Microsoft.AspNet.Identity.InMemory.Test/StartupTest.cs
View File

@ -21,7 +21,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
{
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services => services.AddIdentity<ApplicationUser>().AddInMemory());
builder.UseServices(services => services.AddIdentity<ApplicationUser>().AddInMemory());
var userStore = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
var roleStore = builder.ApplicationServices.GetService<IRoleStore<IdentityRole>>();
@ -40,7 +40,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
public void VerifyUseInMemoryLifetimes()
{
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services => services.AddIdentity<ApplicationUser>().AddInMemory());
builder.UseServices(services => services.AddIdentity<ApplicationUser>().AddInMemory());
var userStore = builder.ApplicationServices.GetService<IUserStore<ApplicationUser>>();
var roleStore = builder.ApplicationServices.GetService<IRoleStore<IdentityRole>>();

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

@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity.Test
{
var userManager = MockHelpers.MockUserManager<TestUser>().Object;
var roleManager = MockHelpers.MockRoleManager<TestRole>().Object;
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
Assert.Throws<ArgumentNullException>("optionsAccessor",
() => new ClaimsIdentityFactory<TestUser, TestRole>(userManager, roleManager, options.Object));
var identityOptions = new IdentityOptions();
@ -71,7 +71,7 @@ namespace Microsoft.AspNet.Identity.Test
roleManager.Setup(m => m.GetClaimsAsync(local, CancellationToken.None)).ReturnsAsync(localClaims);
}
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
var identityOptions = new IdentityOptions();
options.Setup(a => a.Options).Returns(identityOptions);
var factory = new ClaimsIdentityFactory<TestUser, TestRole>(userManager.Object, roleManager.Object, options.Object);

18
test/Microsoft.AspNet.Identity.Test/IdentityOptionsTest.cs
View File

@ -66,7 +66,7 @@ namespace Microsoft.AspNet.Identity.Test
var services = new ServiceCollection {OptionsServices.GetDefaultServices()};
services.AddIdentity(config.GetSubKey("identity"));
var accessor = services.BuildServiceProvider().GetService<IOptionsAccessor<IdentityOptions>>();
var accessor = services.BuildServiceProvider().GetService<IOptions<IdentityOptions>>();
Assert.NotNull(accessor);
var options = accessor.Options;
Assert.Equal(roleClaimType, options.ClaimsIdentity.RoleClaimType);
@ -96,14 +96,14 @@ namespace Microsoft.AspNet.Identity.Test
var services = new ServiceCollection { OptionsServices.GetDefaultServices() };
services.AddIdentity(config.GetSubKey("identity"),
o => { o.User.RequireUniqueEmail = false; o.Lockout.MaxFailedAccessAttempts++; });
var accessor = services.BuildServiceProvider().GetService<IOptionsAccessor<IdentityOptions>>();
var accessor = services.BuildServiceProvider().GetService<IOptions<IdentityOptions>>();
Assert.NotNull(accessor);
var options = accessor.Options;
Assert.False(options.User.RequireUniqueEmail);
Assert.Equal(1001, options.Lockout.MaxFailedAccessAttempts);
}
public class PasswordsNegativeLengthSetup : OptionsAction<IdentityOptions>
public class PasswordsNegativeLengthSetup : ConfigureOptions<IdentityOptions>
{
public PasswordsNegativeLengthSetup()
: base(options => options.Password.RequiredLength = -1)
@ -114,15 +114,15 @@ namespace Microsoft.AspNet.Identity.Test
public void CanCustomizeIdentityOptions()
{
var builder = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
builder.UsePerRequestServices(services =>
builder.UseServices(services =>
{
services.AddIdentity<IdentityUser>();
services.AddOptionsAction<PasswordsNegativeLengthSetup>();
services.ConfigureOptions<PasswordsNegativeLengthSetup>();
});
var setup = builder.ApplicationServices.GetService<IOptionsAction<IdentityOptions>>();
var setup = builder.ApplicationServices.GetService<IConfigureOptions<IdentityOptions>>();
Assert.IsType(typeof(PasswordsNegativeLengthSetup), setup);
var optionsGetter = builder.ApplicationServices.GetService<IOptionsAccessor<IdentityOptions>>();
var optionsGetter = builder.ApplicationServices.GetService<IOptions<IdentityOptions>>();
Assert.NotNull(optionsGetter);
var myOptions = optionsGetter.Options;
Assert.True(myOptions.Password.RequireLowercase);
@ -136,12 +136,12 @@ namespace Microsoft.AspNet.Identity.Test
public void CanSetupIdentityOptions()
{
var app = new ApplicationBuilder(new ServiceCollection().BuildServiceProvider());
app.UsePerRequestServices(services =>
app.UseServices(services =>
{
services.AddIdentity<IdentityUser>().ConfigureIdentity(options => options.User.RequireUniqueEmail = true);
});
var optionsGetter = app.ApplicationServices.GetService<IOptionsAccessor<IdentityOptions>>();
var optionsGetter = app.ApplicationServices.GetService<IOptions<IdentityOptions>>();
Assert.NotNull(optionsGetter);
var myOptions = optionsGetter.Options;

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

@ -39,7 +39,7 @@ namespace Microsoft.AspNet.Identity.Test
var userManager = MockHelpers.MockUserManager<IdentityUser>();
var claimsManager = new Mock<IClaimsIdentityFactory<IdentityUser>>();
var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero };
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var httpContext = new Mock<HttpContext>();
var contextAccessor = new Mock<IContextAccessor<HttpContext>>();
@ -74,7 +74,7 @@ namespace Microsoft.AspNet.Identity.Test
var userManager = MockHelpers.MockUserManager<IdentityUser>();
var claimsManager = new Mock<IClaimsIdentityFactory<IdentityUser>>();
var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero };
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var httpContext = new Mock<HttpContext>();
var contextAccessor = new Mock<IContextAccessor<HttpContext>>();
@ -109,7 +109,7 @@ namespace Microsoft.AspNet.Identity.Test
var userManager = MockHelpers.MockUserManager<IdentityUser>();
var claimsManager = new Mock<IClaimsIdentityFactory<IdentityUser>>();
var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.Zero };
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var contextAccessor = new Mock<IContextAccessor<HttpContext>>();
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);
@ -143,7 +143,7 @@ namespace Microsoft.AspNet.Identity.Test
var userManager = MockHelpers.MockUserManager<IdentityUser>();
var claimsManager = new Mock<IClaimsIdentityFactory<IdentityUser>>();
var identityOptions = new IdentityOptions { SecurityStampValidationInterval = TimeSpan.FromDays(1) };
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var contextAccessor = new Mock<IContextAccessor<HttpContext>>();
contextAccessor.Setup(a => a.Value).Returns(httpContext.Object);

32
test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs
View File

@ -123,7 +123,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
@ -148,6 +148,7 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
context.Setup(c => c.Response).Returns(response.Object).Verifiable();
@ -156,7 +157,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
claimsFactory.Setup(m => m.CreateAsync(user, CancellationToken.None)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable();
@ -184,6 +185,7 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
response.Setup(r => r.SignIn(It.IsAny<AuthenticationProperties>(), It.IsAny<ClaimsIdentity>())).Verifiable();
@ -192,7 +194,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
@ -229,6 +231,10 @@ namespace Microsoft.AspNet.Identity.Test
manager.Setup(m => m.FindByNameAsync(user.UserName, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.GetUserIdAsync(user, CancellationToken.None)).ReturnsAsync(user.Id).Verifiable();
manager.Setup(m => m.CheckPasswordAsync(user, "password", CancellationToken.None)).ReturnsAsync(true).Verifiable();
if (supportsLockout)
{
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
}
var context = new Mock<HttpContext>();
var response = new Mock<HttpResponse>();
response.Setup(r => r.SignIn(It.Is<ClaimsIdentity>(id => id.Name == user.Id))).Verifiable();
@ -237,7 +243,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, new ClaimsIdentityFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object), options.Object);
@ -281,7 +287,7 @@ namespace Microsoft.AspNet.Identity.Test
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
response.Setup(r => r.SignOut(IdentityOptions.ExternalCookieAuthenticationType)).Verifiable();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
claimsFactory.Setup(m => m.CreateAsync(user, CancellationToken.None)).ReturnsAsync(new ClaimsIdentity("Microsoft.AspNet.Identity")).Verifiable();
@ -328,6 +334,7 @@ namespace Microsoft.AspNet.Identity.Test
if (supportsLockout)
{
manager.Setup(m => m.IsLockedOutAsync(user, CancellationToken.None)).ReturnsAsync(false).Verifiable();
manager.Setup(m => m.ResetAccessFailedCountAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable();
}
manager.Setup(m => m.FindByIdAsync(user.Id, CancellationToken.None)).ReturnsAsync(user).Verifiable();
manager.Setup(m => m.VerifyTwoFactorTokenAsync(user, provider, code, CancellationToken.None)).ReturnsAsync(true).Verifiable();
@ -342,7 +349,7 @@ namespace Microsoft.AspNet.Identity.Test
var authResult = new AuthenticationResult(id, new AuthenticationProperties(), new AuthenticationDescription());
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new ClaimsIdentityFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
if (externalLogin)
@ -393,7 +400,7 @@ namespace Microsoft.AspNet.Identity.Test
var contextAccessor = new Mock<IContextAccessor<HttpContext>>();
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new ClaimsIdentityFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
@ -449,7 +456,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
claimsFactory.Setup(m => m.CreateAsync(user, CancellationToken.None)).ReturnsAsync(new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType)).Verifiable();
@ -482,7 +489,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
IdentityOptions.ApplicationCookieAuthenticationType = authenticationType;
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
@ -511,7 +518,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
@ -534,7 +541,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
@ -568,7 +575,7 @@ namespace Microsoft.AspNet.Identity.Test
contextAccessor.Setup(a => a.Value).Returns(context.Object);
var roleManager = MockHelpers.MockRoleManager<TestRole>();
var identityOptions = new IdentityOptions();
var options = new Mock<IOptionsAccessor<IdentityOptions>>();
var options = new Mock<IOptions<IdentityOptions>>();
options.Setup(a => a.Options).Returns(identityOptions);
var claimsFactory = new Mock<ClaimsIdentityFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
@ -580,5 +587,6 @@ namespace Microsoft.AspNet.Identity.Test
Assert.Equal(SignInStatus.LockedOut, result);
manager.VerifyAll();
}
}
}

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

@ -21,7 +21,7 @@ namespace Microsoft.AspNet.Identity.Test
{
public IUserStore<TestUser> StorePublic { get { return Store; } }
public TestManager(IUserStore<TestUser> store, IOptionsAccessor<IdentityOptions> optionsAccessor,
public TestManager(IUserStore<TestUser> store, IOptions<IdentityOptions> optionsAccessor,
IPasswordHasher<TestUser> passwordHasher, IUserValidator<TestUser> userValidator,
IPasswordValidator<TestUser> passwordValidator)
: base(store, optionsAccessor, passwordHasher, userValidator, passwordValidator, null, null) { }
@ -517,7 +517,7 @@ namespace Microsoft.AspNet.Identity.Test
public async Task ManagerPublicNullChecks()
{
var store = new NotImplementedStore();
var optionsAccessor = new OptionsAccessor<IdentityOptions>(null);
var optionsAccessor = new OptionsManager<IdentityOptions>(null);
var passwordHasher = new PasswordHasher<TestUser>();
var userValidator = new UserValidator<TestUser>();
var passwordValidator = new PasswordValidator<TestUser>();

4
test/Shared/MockHelpers.cs
View File

@ -33,7 +33,7 @@ namespace Microsoft.AspNet.Identity.Test
public static Mock<UserManager<TUser>> MockUserManager<TUser>() where TUser : class
{
var store = new Mock<IUserStore<TUser>>();
var options = new OptionsAccessor<IdentityOptions>(null);
var options = new OptionsManager<IdentityOptions>(null);
return new Mock<UserManager<TUser>>(
store.Object,
options,
@ -57,7 +57,7 @@ namespace Microsoft.AspNet.Identity.Test
public static UserManager<TUser> TestUserManager<TUser>(IUserStore<TUser> store) where TUser : class
{
var options = new OptionsAccessor<IdentityOptions>(null);
var options = new OptionsManager<IdentityOptions>(null);
var validator = new Mock<UserValidator<TUser>>();
var userManager = new UserManager<TUser>(store, options, new PasswordHasher<TUser>(),
validator.Object, new PasswordValidator<TUser>(), new UpperInvariantUserNameNormalizer(), null);