React to options and hosting changes

samples/IdentitySample.Mvc/Models/IdentityModels.cs

@@ -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)
         {
         }

samples/IdentitySample.Mvc/Models/SampleData.cs

@@ -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>>();

samples/IdentitySample.Mvc/Startup.cs

@@ -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()

samples/IdentitySample.Mvc/project.json

@@ -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": {
         },

src/Microsoft.AspNet.Identity.EntityFramework/IdentityEntityFrameworkBuilderExtensions.cs

@@ -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;
         }
 

src/Microsoft.AspNet.Identity/BuilderExtensions.cs

@@ -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);

src/Microsoft.AspNet.Identity/ClaimsIdentityFactory.cs

@@ -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)
             {

src/Microsoft.AspNet.Identity/IdentityBuilder.cs

@@ -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;
         }
 

src/Microsoft.AspNet.Identity/IdentityServiceCollectionExtensions.cs

@@ -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;

src/Microsoft.AspNet.Identity/SecurityStampValidator.cs

@@ -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)

src/Microsoft.AspNet.Identity/SignInManager.cs

@@ -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)
                 {

src/Microsoft.AspNet.Identity/UserManager.cs

@@ -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)

test/Microsoft.AspNet.Identity.EntityFramework.Test/CustomPocoTest.cs

@@ -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();
+            var serviceProvider = UserStoreTest.ConfigureDbServices(ConnectionString).BuildServiceProvider();
-            services.Add(OptionsServices.GetDefaultServices());
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
-            services.AddEntityFramework().AddSqlServer();
-            services.ConfigureOptions<DbContextOptions>(options => options.UseSqlServer(ConnectionString));
-            var serviceProvider = services.BuildServiceProvider();
             return new CustomDbContext<TKey>(serviceProvider);
         }
 

test/Microsoft.AspNet.Identity.EntityFramework.Test/DefaultPocoTest.cs

@@ -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();
+            var services = UserStoreTest.ConfigureDbServices(ConnectionString);
-            services.Add(OptionsServices.GetDefaultServices());
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
-            services.AddEntityFramework().AddSqlServer();
-            services.ConfigureOptions<DbContextOptions>(options => options.UseSqlServer(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);
             });

test/Microsoft.AspNet.Identity.EntityFramework.Test/SqlStoreTestBase.cs

@@ -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();
+            var serviceProvider = UserStoreTest.ConfigureDbServices(ConnectionString).BuildServiceProvider();
-            services.AddEntityFramework().AddSqlServer();
-            services.Add(OptionsServices.GetDefaultServices());
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
-            services.ConfigureOptions<DbContextOptions>(options =>
-                options.UseSqlServer(ConnectionString));
-            var serviceProvider = services.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();
+            var serviceProvider = UserStoreTest.ConfigureDbServices(ConnectionString).BuildServiceProvider();
-            services.AddEntityFramework().AddSqlServer();
-            services.Add(OptionsServices.GetDefaultServices());
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
-            services.ConfigureOptions<DbContextOptions>(options => options.UseSqlServer(ConnectionString));
-            var serviceProvider = services.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());
+                UserStoreTest.ConfigureDbServices(ConnectionString, services);
-                services.AddEntityFramework().AddSqlServer();
                 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());
+                UserStoreTest.ConfigureDbServices(ConnectionString, services);
-                services.AddEntityFramework().AddSqlServer();
                 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>>();

test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreGuidKeyTest.cs

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

test/Microsoft.AspNet.Identity.EntityFramework.Test/UserStoreTest.cs

@@ -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();
+            var serviceProvider = ConfigureDbServices(ConnectionString).BuildServiceProvider();
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
-            services.AddEntityFramework().AddSqlServer();
-            services.Add(OptionsServices.GetDefaultServices());
-            services.ConfigureOptions<DbContextOptions>(options =>
-                options.UseSqlServer(ConnectionString));
-            var serviceProvider = services.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());
+                ConfigureDbServices(ConnectionString, services);
-                services.AddEntityFramework().AddSqlServer();
+                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();
+            var serviceProvider = ConfigureDbServices(ConnectionString).BuildServiceProvider();
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
+            var db = new IdentityDbContext(serviceProvider, serviceProvider.GetService<IOptions<DbContextOptions>>().Options);
-            services.AddEntityFramework().AddSqlServer();
-            var dbOptions = new DbContextOptions();
-            dbOptions.UseSqlServer(ConnectionString);
-            var serviceProvider = services.BuildServiceProvider();
-            var db = new IdentityDbContext(serviceProvider, dbOptions);
             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();
+            var serviceProvider = ConfigureDbServices(ConnectionString).BuildServiceProvider();
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
+            var db = new ApplicationDbContext(serviceProvider, serviceProvider.GetService<IOptions<DbContextOptions>>());
-            services.AddEntityFramework().AddSqlServer();
-            services.Add(OptionsServices.GetDefaultServices());
-            var serviceProvider = services.BuildServiceProvider();
-
-            var db = new ApplicationDbContext(serviceProvider, serviceProvider.GetService<IOptionsAccessor<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();
+            var services = ConfigureDbServices(ConnectionString);
-            services.AddInstance<ILoggerFactory>(new NullLoggerFactory());
             services.AddIdentity().AddRoleStore(new RoleStore<IdentityRole>(context));
             return services.BuildServiceProvider().GetService<RoleManager<IdentityRole>>();
         }

test/Microsoft.AspNet.Identity.InMemory.Test/HttpSignInTest.cs

@@ -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();

test/Microsoft.AspNet.Identity.InMemory.Test/StartupTest.cs

@@ -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>>();

test/Microsoft.AspNet.Identity.Test/ClaimsIdentityFactoryTest.cs

@@ -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);

test/Microsoft.AspNet.Identity.Test/IdentityOptionsTest.cs

@@ -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;

test/Microsoft.AspNet.Identity.Test/SecurityStampValidatorTest.cs

@@ -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);

test/Microsoft.AspNet.Identity.Test/SignInManagerTest.cs

@@ -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();
         }
+
     }
 }

test/Microsoft.AspNet.Identity.Test/UserManagerTest.cs

@@ -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>();

test/Shared/MockHelpers.cs

@@ -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);