Remove hosting and logging dependencies

src/Microsoft.AspNet.Identity/IdentityLogger.cs

@@ -12,6 +12,11 @@ namespace Microsoft.AspNet.Identity.Logging
         private static TResult Log<TResult>(this ILogger logger, TResult result, Func<TResult, LogLevel> getLevel,
             Func<string> messageAccessor)
         {
+            if (logger == null)
+            {
+                return result;
+            }
+
             var logLevel = getLevel(result);
 
             // Check if log level is enabled before creating the message.

src/Microsoft.AspNet.Identity/IdentityServiceCollectionExtensions.cs

@@ -45,8 +45,6 @@ namespace Microsoft.Framework.DependencyInjection
             // Services used by identity
             services.AddOptions();
             services.AddDataProtection();
-            services.AddLogging();
-            services.TryAdd(ServiceDescriptor.Singleton<IHttpContextAccessor, HttpContextAccessor>());
 
             // Identity services
             services.TryAdd(ServiceDescriptor.Transient<IUserValidator<TUser>, UserValidator<TUser>>());
@@ -86,20 +84,17 @@ namespace Microsoft.Framework.DependencyInjection
             services.Configure<CookieAuthenticationOptions>(options =>
             {
                 options.AuthenticationScheme = IdentityOptions.ExternalCookieAuthenticationScheme;
-                options.AutomaticAuthentication = false;
                 options.CookieName = IdentityOptions.ExternalCookieAuthenticationScheme;
                 options.ExpireTimeSpan = TimeSpan.FromMinutes(5);
             }, IdentityOptions.ExternalCookieAuthenticationScheme);
             services.Configure<CookieAuthenticationOptions>(options =>
             {
                 options.AuthenticationScheme = IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme;
-                options.AutomaticAuthentication = false;
                 options.CookieName = IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme;
             }, IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme);
             services.Configure<CookieAuthenticationOptions>(options =>
             {
                 options.AuthenticationScheme = IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme;
-                options.AutomaticAuthentication = false;
                 options.CookieName = IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme;
                 options.ExpireTimeSpan = TimeSpan.FromMinutes(5);
             }, IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme);

src/Microsoft.AspNet.Identity/RoleManager.cs

@@ -57,7 +57,7 @@ namespace Microsoft.AspNet.Identity
                 }
             }
 
-            Logger = logger?.CreateLogger<RoleManager<TRole>>() ?? new Logger<RoleManager<TRole>>(new LoggerFactory());
+            Logger = logger?.CreateLogger<RoleManager<TRole>>();
         }
 
         /// <summary>
@@ -408,7 +408,7 @@ namespace Microsoft.AspNet.Identity
         protected virtual async Task<IDisposable> BeginLoggingScopeAsync(TRole role, [CallerMemberName] string methodName = null)
         {
             var state = Resources.FormatLoggingResultMessageForRole(methodName, await GetRoleIdAsync(role));
-            return Logger.BeginScope(state);
+            return Logger?.BeginScope(state);
         }
             
 

src/Microsoft.AspNet.Identity/SignInManager.cs

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Security.Claims;
-using System.Security.Principal;
 using System.Threading.Tasks;
 using Microsoft.AspNet.Hosting;
 using Microsoft.AspNet.Http;
@@ -26,8 +25,8 @@ namespace Microsoft.AspNet.Identity
         public SignInManager(UserManager<TUser> userManager,
             IHttpContextAccessor contextAccessor,
             IUserClaimsPrincipalFactory<TUser> claimsFactory,
-            IOptions<IdentityOptions> optionsAccessor = null,
+            IOptions<IdentityOptions> optionsAccessor,
-            ILoggerFactory logger = null)
+            ILoggerFactory logger)
         {
             if (userManager == null)
             {
@@ -48,7 +47,7 @@ namespace Microsoft.AspNet.Identity
             ClaimsFactory = claimsFactory;
             Options = optionsAccessor?.Options ?? new IdentityOptions();
 
-            Logger = logger?.CreateLogger<SignInManager<TUser>>() ?? new Logger<SignInManager<TUser>>(new LoggerFactory());
+            Logger = logger?.CreateLogger<SignInManager<TUser>>();
         }
 
         protected internal virtual ILogger Logger { get; set; }
@@ -400,7 +399,7 @@ namespace Microsoft.AspNet.Identity
         protected virtual async Task<IDisposable> BeginLoggingScopeAsync(TUser user, [CallerMemberName] string methodName = null)
         {
             var state = Resources.FormatLoggingResultMessageForUser(methodName, await UserManager.GetUserIdAsync(user));
-            return Logger.BeginScope(state);
+            return Logger?.BeginScope(state);
         }
             
 

src/Microsoft.AspNet.Identity/UserManager.cs

@@ -81,7 +81,7 @@ namespace Microsoft.AspNet.Identity
                 }
             }
 
-            Logger = logger?.CreateLogger<UserManager<TUser>>() ?? new Logger<UserManager<TUser>>(new LoggerFactory());
+            Logger = logger?.CreateLogger<UserManager<TUser>>();
 
             if (tokenProviders != null)
             {
@@ -1996,7 +1996,7 @@ namespace Microsoft.AspNet.Identity
         protected virtual async Task<IDisposable> BeginLoggingScopeAsync(TUser user, [CallerMemberName] string methodName = null)
         {
             var state = Resources.FormatLoggingResultMessageForUser(methodName, await GetUserIdAsync(user));
-            return Logger.BeginScope(state);
+            return Logger?.BeginScope(state);
         }
             
 

src/Microsoft.AspNet.Identity/project.json

@@ -5,7 +5,6 @@
     "Microsoft.AspNet.Authentication.Cookies": "1.0.0-*",
     "Microsoft.AspNet.Cryptography.KeyDerivation": "1.0.0-*",
     "Microsoft.AspNet.Http" : "1.0.0-*",
-    "Microsoft.AspNet.Hosting" : "1.0.0-*",
     "Microsoft.AspNet.Hosting.Interfaces" : "1.0.0-*",
     "Microsoft.Framework.ConfigurationModel.Interfaces": "1.0.0-*",
     "Microsoft.Framework.DependencyInjection.Interfaces" : "1.0.0-*",

test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/RoleStoreTest.cs

@@ -14,24 +14,18 @@ namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test
         [Fact]
         public async Task CanCreateUsingAddRoleManager()
         {
-            var services = new ServiceCollection();
+            var manager = TestIdentityFactory.CreateRoleManager();
-            services.AddEntityFramework().AddInMemoryStore();
-            var store = new RoleStore<IdentityRole>(new InMemoryContext());
-            services.AddInstance<IRoleStore<IdentityRole>>(store);
-            services.AddIdentity<IdentityUser,IdentityRole>();
-            var provider = services.BuildServiceProvider();
-            var manager = provider.GetRequiredService<RoleManager<IdentityRole>>();
             Assert.NotNull(manager);
             IdentityResultAssert.IsSuccess(await manager.CreateAsync(new IdentityRole("arole")));
         }
+
         [Fact]
         public async Task CanCreateRoleWithSingletonManager()
         {
-            var services = new ServiceCollection();
+            var services = TestIdentityFactory.CreateTestServices();
             services.AddEntityFramework().AddInMemoryStore();
             services.AddTransient<InMemoryContext>();
             services.AddTransient<IRoleStore<IdentityRole>, RoleStore<IdentityRole, InMemoryContext>>();
-            services.AddIdentity<IdentityUser, IdentityRole>();
             services.AddSingleton<RoleManager<IdentityRole>>();
             var provider = services.BuildServiceProvider();
             var manager = provider.GetRequiredService<RoleManager<IdentityRole>>();

test/Microsoft.AspNet.Identity.EntityFramework.InMemory.Test/TestIdentityFactory.cs

@@ -1,7 +1,9 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using Microsoft.AspNet.Hosting;
 using Microsoft.Framework.DependencyInjection;
+using Microsoft.Framework.Logging;
 
 namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test
 {
@@ -19,10 +21,18 @@ namespace Microsoft.AspNet.Identity.EntityFramework.InMemory.Test
             return db;
         }
 
-        public static RoleManager<IdentityRole> CreateRoleManager(InMemoryContext context)
+        public static IServiceCollection CreateTestServices()
         {
             var services = new ServiceCollection();
+            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+            services.AddLogging();
             services.AddIdentity<IdentityUser, IdentityRole>();
+            return services;
+        }
+
+        public static RoleManager<IdentityRole> CreateRoleManager(InMemoryContext context)
+        {
+            var services = CreateTestServices();
             services.AddInstance<IRoleStore<IdentityRole>>(new RoleStore<IdentityRole>(context));
             return services.BuildServiceProvider().GetRequiredService<RoleManager<IdentityRole>>();
         }

test/Microsoft.AspNet.Identity.EntityFramework.Test/Microsoft.AspNet.Identity.EntityFramework.Test.xproj

@@ -13,5 +13,8 @@
   <PropertyGroup>
     <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
   <Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
 </Project>

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

@@ -34,6 +34,7 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
             var contextAccessor = new Mock<IHttpContextAccessor>();
             contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
             var services = new ServiceCollection();
+            services.AddLogging();
             services.AddInstance(contextAccessor.Object);
             services.AddIdentity<TestUser, TestRole>();
                 services.AddSingleton<IUserStore<TestUser>, InMemoryUserStore<TestUser>>();

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

@@ -70,12 +70,12 @@ namespace Microsoft.AspNet.Identity.Test
         {
             Assert.Throws<ArgumentNullException>("userManager", () => new SignInManager<TestUser>(null, null, null, null, null));
             var userManager = MockHelpers.MockUserManager<TestUser>().Object;
-            Assert.Throws<ArgumentNullException>("contextAccessor", () => new SignInManager<TestUser>(userManager, null, null, null));
+            Assert.Throws<ArgumentNullException>("contextAccessor", () => new SignInManager<TestUser>(userManager, null, null, null, null));
             var contextAccessor = new Mock<IHttpContextAccessor>();
-            Assert.Throws<ArgumentNullException>("contextAccessor", () => new SignInManager<TestUser>(userManager, contextAccessor.Object, null, null));
+            Assert.Throws<ArgumentNullException>("contextAccessor", () => new SignInManager<TestUser>(userManager, contextAccessor.Object, null, null, null));
             var context = new Mock<HttpContext>();
             contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            Assert.Throws<ArgumentNullException>("claimsFactory", () => new SignInManager<TestUser>(userManager, contextAccessor.Object, null, null));
+            Assert.Throws<ArgumentNullException>("claimsFactory", () => new SignInManager<TestUser>(userManager, contextAccessor.Object, null, null, null));
         }
 
         //TODO: Mock fails in K (this works fine in net45)
@@ -129,8 +129,8 @@ namespace Microsoft.AspNet.Identity.Test
             var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
             var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object, null);
             helper.Logger = logger.Object;
-            string expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
+            var expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "Lockedout");
+            var expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "Lockedout");
 
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "bogus", false, false);
@@ -153,6 +153,23 @@ namespace Microsoft.AspNet.Identity.Test
             return manager;
         }
 
+        private static SignInManager<TestUser> SetupSignInManager(UserManager<TestUser> manager, HttpContext context, StringBuilder logStore = null, IdentityOptions identityOptions = null)
+        {
+            var contextAccessor = new Mock<IHttpContextAccessor>();
+            contextAccessor.Setup(a => a.HttpContext).Returns(context);
+            var roleManager = MockHelpers.MockRoleManager<TestRole>();
+            identityOptions = identityOptions ?? new IdentityOptions();
+            var options = new Mock<IOptions<IdentityOptions>>();
+            options.Setup(a => a.Options).Returns(identityOptions);
+            var claimsFactory = new UserClaimsPrincipalFactory<TestUser, TestRole>(manager, roleManager.Object, options.Object);
+            var sm = new SignInManager<TestUser>(manager, contextAccessor.Object, claimsFactory, options.Object, null);
+            if (logStore != null)
+            {
+                sm.Logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore).Object;
+            }
+            return sm;
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
@@ -169,19 +186,10 @@ namespace Microsoft.AspNet.Identity.Test
             var response = new Mock<HttpResponse>();
             context.Setup(c => c.Response).Returns(response.Object).Verifiable();
             SetupSignIn(response, user.Id, isPersistent);
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new UserClaimsPrincipalFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object, null);
+            var expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            helper.Logger = logger.Object;
+            var expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "Succeeded");
-            string expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "Succeeded");
 
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "password", isPersistent, false);
@@ -193,9 +201,35 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
 
+        [Fact]
+        public async Task CanPasswordSignInWithNoLogger()
+        {
+            // Setup
+            var user = new TestUser { UserName = "Foo" };
+            var manager = SetupUserManager(user);
+            manager.Setup(m => m.SupportsUserLockout).Returns(true).Verifiable();
+            manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
+            manager.Setup(m => m.CheckPasswordAsync(user, "password")).ReturnsAsync(true).Verifiable();
+
+            var context = new Mock<HttpContext>();
+            var response = new Mock<HttpResponse>();
+            context.Setup(c => c.Response).Returns(response.Object).Verifiable();
+            SetupSignIn(response, user.Id, false);
+            var helper = SetupSignInManager(manager.Object, context.Object);
+
+            // Act
+            var result = await helper.PasswordSignInAsync(user.UserName, "password", false, false);
+
+            // Assert
+            Assert.True(result.Succeeded);
+            manager.Verify();
+            context.Verify();
+            response.Verify();
+        }
+
+
         [Fact]
         public async Task PasswordSignInWorksWithNonTwoFactorStore()
         {
@@ -211,14 +245,7 @@ namespace Microsoft.AspNet.Identity.Test
             var response = new Mock<HttpResponse>();
             SetupSignIn(response);
             context.Setup(c => c.Response).Returns(response.Object).Verifiable();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
+            var helper = SetupSignInManager(manager.Object, context.Object);
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new UserClaimsPrincipalFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object);
 
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "password", false, false);
@@ -228,7 +255,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
 
         [Theory]
@@ -260,22 +286,10 @@ namespace Microsoft.AspNet.Identity.Test
                 It.Is<ClaimsPrincipal>(id => id.FindFirstValue(ClaimTypes.Name) == user.Id),
                 It.IsAny<AuthenticationProperties>())).Verifiable();
             context.Setup(c => c.Response).Returns(response.Object).Verifiable();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore);
-            var helper = new SignInManager<TestUser>(manager.Object,
+            var expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-                contextAccessor.Object,
+            var expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "RequiresTwoFactor");
-                new UserClaimsPrincipalFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object),
-                options.Object,
-                null);
-            helper.Logger = logger.Object;
-            string expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "RequiresTwoFactor");
 
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "password", false, false);
@@ -288,7 +302,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
 
         [Theory]
@@ -314,20 +327,10 @@ namespace Microsoft.AspNet.Identity.Test
             var response = new Mock<HttpResponse>();
             context.Setup(c => c.Response).Returns(response.Object).Verifiable();
             SetupSignIn(response, user.Id, isPersistent, loginProvider);
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            response.Setup(r => r.SignOut(IdentityOptions.ExternalCookieAuthenticationScheme)).Verifiable();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new UserClaimsPrincipalFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object, null);
+            var expectedScope = string.Format("{0} for {1}: {2}", "ExternalLoginSignInAsync", "user", user.Id);
-            helper.Logger = logger.Object;
+            var expectedLog = string.Format("{0} : {1}", "ExternalLoginSignInAsync", "Succeeded");
-            string expectedScope = string.Format("{0} for {1}: {2}", "ExternalLoginSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "ExternalLoginSignInAsync", "Succeeded");
 
             // Act
             var result = await helper.ExternalLoginSignInAsync(loginProvider, providerKey, isPersistent);
@@ -339,7 +342,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
 
         [Theory]
@@ -375,16 +377,10 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Setup(m => m.VerifyTwoFactorTokenAsync(user, provider, code)).ReturnsAsync(true).Verifiable();
             var context = new Mock<HttpContext>();
             var response = new Mock<HttpResponse>();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
             var twoFactorInfo = new SignInManager<TestUser>.TwoFactorAuthenticationInfo { UserId = user.Id };
             var loginProvider = "loginprovider";
             var id = SignInManager<TestUser>.StoreTwoFactorInfo(user.Id, externalLogin ? loginProvider : null);
             var authResult = new AuthenticationResult(id, new AuthenticationProperties(), new AuthenticationDescription());
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new UserClaimsPrincipalFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
             if (externalLogin)
             {
                 response.Setup(r => r.SignIn(
@@ -408,13 +404,10 @@ namespace Microsoft.AspNet.Identity.Test
             }
             context.Setup(c => c.Response).Returns(response.Object).Verifiable();
             context.Setup(c => c.AuthenticateAsync(IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme)).ReturnsAsync(authResult).Verifiable();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object, null);
+            var expectedScope = string.Format("{0} for {1}: {2}", "TwoFactorSignInAsync", "user", user.Id);
-            helper.Logger = logger.Object;
+            var expectedLog = string.Format("{0} : {1}", "TwoFactorSignInAsync", "Succeeded");
-            string expectedScope = string.Format("{0} for {1}: {2}", "TwoFactorSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "TwoFactorSignInAsync", "Succeeded");
 
             // Act
             var result = await helper.TwoFactorSignInAsync(provider, code, isPersistent, rememberClient);
@@ -426,7 +419,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
 
         [Fact]
@@ -437,23 +429,14 @@ namespace Microsoft.AspNet.Identity.Test
             var manager = SetupUserManager(user);
             var context = new Mock<HttpContext>();
             var response = new Mock<HttpResponse>();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new UserClaimsPrincipalFactory<TestUser, TestRole>(manager.Object, roleManager.Object, options.Object);
-
             context.Setup(c => c.Response).Returns(response.Object).Verifiable();
             response.Setup(r => r.SignIn(
                 IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme,
                 It.Is<ClaimsPrincipal>(i => i.FindFirstValue(ClaimTypes.Name) == user.Id
                     && i.Identities.First().AuthenticationType == IdentityOptions.TwoFactorRememberMeCookieAuthenticationType),
                 It.Is<AuthenticationProperties>(v => v.IsPersistent == true))).Verifiable();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object).Verifiable();
-            options.Setup(a => a.Options).Returns(identityOptions).Verifiable();
 
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory, options.Object);
+            var helper = SetupSignInManager(manager.Object, context.Object);
 
             // Act
             await helper.RememberTwoFactorClientAsync(user);
@@ -462,8 +445,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
-            options.Verify();
         }
 
         [Theory]
@@ -490,15 +471,7 @@ namespace Microsoft.AspNet.Identity.Test
             id.AddClaim(new Claim(ClaimTypes.Name, user.Id));
             var authResult = new AuthenticationResult(new ClaimsPrincipal(id), new AuthenticationProperties(), new AuthenticationDescription());
             context.Setup(c => c.AuthenticateAsync(IdentityOptions.TwoFactorRememberMeCookieAuthenticationScheme)).ReturnsAsync(authResult).Verifiable();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
+            var helper = SetupSignInManager(manager.Object, context.Object);
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
-            claimsFactory.Setup(m => m.CreateAsync(user)).ReturnsAsync(new ClaimsPrincipal(new ClaimsIdentity(IdentityOptions.ApplicationCookieAuthenticationType))).Verifiable();
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
 
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "password", isPersistent, false);
@@ -508,8 +481,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
-            claimsFactory.Verify();
         }
 
         [Theory]
@@ -525,18 +496,9 @@ namespace Microsoft.AspNet.Identity.Test
             response.Setup(r => r.SignOut(authenticationScheme)).Verifiable();
             response.Setup(r => r.SignOut(IdentityOptions.TwoFactorUserIdCookieAuthenticationScheme)).Verifiable();
             response.Setup(r => r.SignOut(IdentityOptions.ExternalCookieAuthenticationScheme)).Verifiable();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
             IdentityOptions.ApplicationCookieAuthenticationScheme = authenticationScheme;
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object, null);
-            helper.Logger = logger.Object;
 
             // Act
             helper.SignOut();
@@ -544,8 +506,6 @@ namespace Microsoft.AspNet.Identity.Test
             // Assert
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
-            claimsFactory.Verify();
         }
 
         [Fact]
@@ -558,19 +518,10 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Setup(m => m.IsLockedOutAsync(user)).ReturnsAsync(false).Verifiable();
             manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable();
             var context = new Mock<HttpContext>();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
+            var expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            helper.Logger = logger.Object;
+            var expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "Failed");
-            string expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "PasswordSignInAsync", "Failed");
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "bogus", false, false);
 
@@ -580,7 +531,6 @@ namespace Microsoft.AspNet.Identity.Test
             Assert.NotEqual(-1, logStore.ToString().IndexOf(expectedScope));
             manager.Verify();
             context.Verify();
-            contextAccessor.Verify();
         }
 
         [Fact]
@@ -590,14 +540,7 @@ namespace Microsoft.AspNet.Identity.Test
             var manager = MockHelpers.MockUserManager<TestUser>();
             manager.Setup(m => m.FindByNameAsync("bogus")).ReturnsAsync(null).Verifiable();
             var context = new Mock<HttpContext>();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
+            var helper = SetupSignInManager(manager.Object, context.Object);
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
 
             // Act
             var result = await helper.PasswordSignInAsync("bogus", "bogus", false, false);
@@ -606,7 +549,6 @@ namespace Microsoft.AspNet.Identity.Test
             Assert.False(result.Succeeded);
             manager.Verify();
             context.Verify();
-            contextAccessor.Verify();
         }
 
         [Fact]
@@ -625,14 +567,7 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Setup(m => m.IsLockedOutAsync(user)).Returns(() => Task.FromResult(lockedout));
             manager.Setup(m => m.CheckPasswordAsync(user, "bogus")).ReturnsAsync(false).Verifiable();
             var context = new Mock<HttpContext>();
-            var contextAccessor = new Mock<IHttpContextAccessor>();
+            var helper = SetupSignInManager(manager.Object, context.Object);
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
-            var identityOptions = new IdentityOptions();
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
 
             // Act
             var result = await helper.PasswordSignInAsync(user.UserName, "bogus", false, true);
@@ -664,20 +599,12 @@ namespace Microsoft.AspNet.Identity.Test
                 context.Setup(c => c.Response).Returns(response.Object).Verifiable();
                 SetupSignIn(response);
             }
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
             var identityOptions = new IdentityOptions();
             identityOptions.SignIn.RequireConfirmedEmail = true;
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore, identityOptions);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object);
+            var expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            helper.Logger = logger.Object;
+            var expectedLog = string.Format("{0} : {1}", "CanSignInAsync", confirmed.ToString());
-            string expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "CanSignInAsync", confirmed.ToString());
 
             // Act
             var result = await helper.PasswordSignInAsync(user, "password", false, false);
@@ -692,7 +619,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
 
         private static void SetupSignIn(Mock<HttpResponse> response, string userId = null, bool? isPersistent = null, string loginProvider = null)
@@ -722,20 +648,12 @@ namespace Microsoft.AspNet.Identity.Test
                 SetupSignIn(response);
             }
 
-            var contextAccessor = new Mock<IHttpContextAccessor>();
-            contextAccessor.Setup(a => a.HttpContext).Returns(context.Object);
-            var roleManager = MockHelpers.MockRoleManager<TestRole>();
             var identityOptions = new IdentityOptions();
             identityOptions.SignIn.RequireConfirmedPhoneNumber = true;
-            var options = new Mock<IOptions<IdentityOptions>>();
-            options.Setup(a => a.Options).Returns(identityOptions);
-            var claimsFactory = new Mock<UserClaimsPrincipalFactory<TestUser, TestRole>>(manager.Object, roleManager.Object, options.Object);
             var logStore = new StringBuilder();
-            var logger = MockHelpers.MockILogger<SignInManager<TestUser>>(logStore);
+            var helper = SetupSignInManager(manager.Object, context.Object, logStore, identityOptions);
-            var helper = new SignInManager<TestUser>(manager.Object, contextAccessor.Object, claimsFactory.Object, options.Object, null);
+            var expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            helper.Logger = logger.Object;
+            var expectedLog = string.Format("{0} : {1}", "CanSignInAsync", confirmed.ToString());
-            string expectedScope = string.Format("{0} for {1}: {2}", "PasswordSignInAsync", "user", user.Id);
-            string expectedLog = string.Format("{0} : {1}", "CanSignInAsync", confirmed.ToString());
 
             // Act
             var result = await helper.PasswordSignInAsync(user, "password", false, false);
@@ -748,7 +666,6 @@ namespace Microsoft.AspNet.Identity.Test
             manager.Verify();
             context.Verify();
             response.Verify();
-            contextAccessor.Verify();
         }
     }
 }

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

@@ -7,7 +7,7 @@ using System.Linq;
 using System.Security.Claims;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.AspNet.Identity.Test;
+using Microsoft.AspNet.Hosting;
 using Microsoft.Framework.DependencyInjection;
 using Moq;
 using Xunit;
@@ -22,6 +22,8 @@ namespace Microsoft.AspNet.Identity.Test
             var services = new ServiceCollection()
                     .AddTransient<IUserStore<TestUser>, NoopUserStore>();
             services.AddIdentity<TestUser, TestRole>();
+            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+            services.AddLogging();
             var manager = services.BuildServiceProvider().GetRequiredService<UserManager<TestUser>>();
             Assert.NotNull(manager.PasswordHasher);
             Assert.NotNull(manager.Store);
@@ -1374,6 +1376,8 @@ namespace Microsoft.AspNet.Identity.Test
             services.AddInstance<IdentityErrorDescriber>(describer)
                 .AddInstance<IUserStore<TestUser>>(store.Object)
                 .AddIdentity<TestUser, TestRole>();
+            services.AddLogging();
+            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
 
             var manager = services.BuildServiceProvider().GetRequiredService<UserManager<TestUser>>();