Merge branch 'release/2.1' into dev

test/Identity.FunctionalTests/AuthorizationTests.cs

@@ -1,14 +1,17 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Net;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging.Testing;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace Microsoft.AspNetCore.Identity.FunctionalTests
 {
-    public class AuthorizationTests : IClassFixture<ServerFactory>
+    public class AuthorizationTests : LoggedTest, IClassFixture<ServerFactory>
     {
-        public AuthorizationTests(ServerFactory serverFactory)
+        public AuthorizationTests(ServerFactory serverFactory, ITestOutputHelper output) : base(output)
         {
             ServerFactory = serverFactory;
         }
@@ -36,9 +39,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
         [Theory]
         [MemberData(nameof(AuthorizedPages))]
         public async Task AnonymousUserCantAccessAuthorizedPages(string url)
+        {
+            using (StartLog(out var loggerFactory, $"{nameof(AnonymousUserCantAccessAuthorizedPages)}_{WebUtility.UrlEncode(url)}"))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
 
                 // Act
                 var response = await client.GetAsync(url);
@@ -47,6 +52,7 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 var location = ResponseAssert.IsRedirect(response);
                 Assert.StartsWith("/Identity/Account/Login?", location.PathAndQuery);
             }
+        }
 
         // The routes commented below are not directly accessible by
         // typing the URL in the browser. They have to be accessed as
@@ -73,9 +79,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
         [Theory]
         [MemberData(nameof(RouteableAuthorizedPages))]
         public async Task AuthenticatedUserCanAccessAuthorizedPages(string url)
+        {
+            using (StartLog(out var loggerFactory, $"{nameof(AuthenticatedUserCanAccessAuthorizedPages)}_{WebUtility.UrlEncode(url)}"))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
                 await UserStories.RegisterNewUserAsync(client);
 
                 // Act
@@ -84,6 +92,7 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Assert
                 await ResponseAssert.IsHtmlDocumentAsync(response);
             }
+        }
 
         // The routes commented below are not directly accessible by
         // typing the URL in the browser. They have to be accessed as
@@ -106,9 +115,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
         [Theory]
         [MemberData(nameof(UnauthorizedPages))]
         public async Task AnonymousUserCanAccessNotAuthorizedPages(string url)
+        {
+            using (StartLog(out var loggerFactory, $"{nameof(AnonymousUserCanAccessNotAuthorizedPages)}_{WebUtility.UrlEncode(url)}"))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
 
                 // Act
                 var response = await client.GetAsync(url);
@@ -116,6 +127,7 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Assert
                 await ResponseAssert.IsHtmlDocumentAsync(response);
             }
+        }
 
         public static TheoryData<string> UnauthorizedPagesAllowAnonymous =>
         new TheoryData<string>
@@ -130,9 +142,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
         [Theory]
         [MemberData(nameof(UnauthorizedPagesAllowAnonymous))]
         public async Task AnonymousUserAllowedAccessToPages_WithGlobalAuthorizationFilter(string url)
+        {
+            using (StartLog(out var loggerFactory, $"{nameof(AnonymousUserAllowedAccessToPages_WithGlobalAuthorizationFilter)}_{WebUtility.UrlEncode(url)}"))
             {
                 // Arrange
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                    builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter()));
                 var client = ServerFactory.CreateDefaultClient(server);
 
@@ -144,3 +158,4 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
             }
         }
     }
+}

test/Identity.FunctionalTests/Infrastructure/ServerFactory.cs

@@ -10,6 +10,7 @@ using Identity.DefaultUI.WebSite;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Identity.FunctionalTests
 {
@@ -19,12 +20,14 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
         private IList<IDisposable> _disposableServers = new List<IDisposable>();
 
         public TestServer CreateServer(
+            ILoggerFactory loggerFactory,
             Action<IWebHostBuilder> configureBuilder,
             [CallerMemberName] string isolationKey = "")
         {
             var builder = WebHostBuilderFactory
                 .CreateFromTypesAssemblyEntryPoint<Startup>(new string[] { })
                 .UseSolutionRelativeContentRoot(Path.Combine("test", "WebSites", "Identity.DefaultUI.WebSite"))
+                .ConfigureServices(collection => collection.AddSingleton(loggerFactory))
                 .ConfigureServices(sc => sc.SetupTestDatabase(isolationKey)
                     .AddMvc()
                     // Mark the cookie as essential for right now, as Identity uses it on
@@ -38,8 +41,8 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
             return server;
         }
 
-        public TestServer CreateDefaultServer([CallerMemberName] string isolationKey = "") =>
+        public TestServer CreateDefaultServer(ILoggerFactory loggerFactory, [CallerMemberName] string isolationKey = "") =>
-            CreateServer(b => { }, isolationKey);
+            CreateServer(loggerFactory, b => { }, isolationKey);
 
         public HttpClient CreateDefaultClient(TestServer server)
         {
@@ -51,8 +54,8 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
             return client;
         }
 
-        public HttpClient CreateDefaultClient() =>
+        public HttpClient CreateDefaultClient(ILoggerFactory loggerFactory) =>
-            CreateDefaultClient(CreateDefaultServer());
+            CreateDefaultClient(CreateDefaultServer(loggerFactory));
 
         protected virtual void Dispose(bool disposing)
         {

test/Identity.FunctionalTests/LoginTests.cs

@@ -5,14 +5,16 @@ using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Identity.DefaultUI.WebSite;
+using Microsoft.Extensions.Logging.Testing;
 using Xunit;
+using Xunit.Abstractions;
 using Xunit.Sdk;
 
 namespace Microsoft.AspNetCore.Identity.FunctionalTests
 {
-    public class LoginTests : IClassFixture<ServerFactory>
+    public class LoginTests : LoggedTest, IClassFixture<ServerFactory>
     {
-        public LoginTests(ServerFactory serverFactory)
+        public LoginTests(ServerFactory serverFactory, ITestOutputHelper output) : base(output)
         {
             ServerFactory = serverFactory;
         }
@@ -21,9 +23,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
 
         [Fact]
         public async Task CanLogInWithAPreviouslyRegisteredUser()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateDefaultServer();
+                var server = ServerFactory.CreateDefaultServer(loggerFactory);
                 var client = ServerFactory.CreateDefaultClient(server);
                 var newClient = ServerFactory.CreateDefaultClient(server);
 
@@ -36,12 +40,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Use a new client to simulate a new browser session.
                 await UserStories.LoginExistingUserAsync(newClient, userName, password);
             }
+        }
 
         [Fact]
         public async Task CanLogInWithTwoFactorAuthentication()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateDefaultServer();
+                var server = ServerFactory.CreateDefaultServer(loggerFactory);
                 var client = ServerFactory.CreateDefaultClient(server);
                 var newClient = ServerFactory.CreateDefaultClient(server);
 
@@ -57,12 +64,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Use a new client to simulate a new browser session.
                 await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey);
             }
+        }
 
         [Fact]
         public async Task CanLogInWithTwoFactorAuthentication_WithGlobalAuthorizeFilter()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                    builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter()));
                 var client = ServerFactory.CreateDefaultClient(server);
                 var newClient = ServerFactory.CreateDefaultClient(server);
@@ -79,12 +89,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Use a new client to simulate a new browser session.
                 await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey);
             }
+        }
 
         [Fact]
         public async Task CanLogInWithRecoveryCode()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateDefaultServer();
+                var server = ServerFactory.CreateDefaultServer(loggerFactory);
                 var client = ServerFactory.CreateDefaultClient(server);
                 var newClient = ServerFactory.CreateDefaultClient(server);
 
@@ -100,12 +113,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Use a new client to simulate a new browser session.
                 await UserStories.LoginExistingUserRecoveryCodeAsync(newClient, userName, password, recoveryCode);
             }
+        }
 
         [Fact]
         public async Task CanLogInWithRecoveryCode_WithGlobalAuthorizeFilter()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter()));
                 var client = ServerFactory.CreateDefaultClient(server);
                 var newClient = ServerFactory.CreateDefaultClient(server);
@@ -122,13 +138,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Use a new client to simulate a new browser session.
                 await UserStories.LoginExistingUserRecoveryCodeAsync(newClient, userName, password, recoveryCode);
             }
+        }
 
         [Fact]
         public async Task CannotLogInWithoutRequiredEmailConfirmation()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var emailSender = new ContosoEmailSender();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                 {
                     builder.ConfigureServices(services => services
                         .SetupTestEmailSender(emailSender)
@@ -147,13 +166,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Use a new client to simulate a new browser session.
                 await Assert.ThrowsAnyAsync<XunitException>(() => UserStories.LoginExistingUserAsync(newClient, userName, password));
             }
+        }
 
         [Fact]
         public async Task CanLogInAfterConfirmingEmail()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var emailSender = new ContosoEmailSender();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                 {
                     builder.ConfigureServices(services => services
                         .SetupTestEmailSender(emailSender)
@@ -175,12 +197,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
 
                 await UserStories.LoginExistingUserAsync(newClient, userName, password);
             }
+        }
 
         [Fact]
         public async Task CanLoginWithASocialLoginProvider()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureServices(services => services.SetupTestThirdPartyLogin()));
                 var client = ServerFactory.CreateDefaultClient(server);
                 var newClient = ServerFactory.CreateDefaultClient(server);
@@ -193,13 +218,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email);
                 await UserStories.LoginWithSocialLoginAsync(newClient, userName);
             }
+        }
 
         [Fact]
         public async Task CanLogInAfterResettingThePassword()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var emailSender = new ContosoEmailSender();
-            var server = ServerFactory.CreateServer(b => b.ConfigureServices(s =>
+                var server = ServerFactory.CreateServer(loggerFactory, b => b.ConfigureServices(s =>
                     s.SetupTestEmailSender(emailSender)));
                 var client = ServerFactory.CreateDefaultClient(server);
                 var resetPasswordClient = ServerFactory.CreateDefaultClient(server);
@@ -222,3 +250,4 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
             }
         }
     }
+}

test/Identity.FunctionalTests/ManagementTests.cs

@@ -8,13 +8,15 @@ using System.Security.Claims;
 using System.Threading.Tasks;
 using Identity.DefaultUI.WebSite;
 using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.Logging.Testing;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace Microsoft.AspNetCore.Identity.FunctionalTests
 {
-    public class ManagementTests : IClassFixture<ServerFactory>
+    public class ManagementTests : LoggedTest, IClassFixture<ServerFactory>
     {
-        public ManagementTests(ServerFactory serverFactory)
+        public ManagementTests(ServerFactory serverFactory, ITestOutputHelper output) : base(output)
         {
             ServerFactory = serverFactory;
         }
@@ -23,9 +25,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
 
         [Fact]
         public async Task CanEnableTwoFactorAuthentication()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
 
                 var userName = $"{Guid.NewGuid()}@example.com";
                 var password = $"!Test.Password1$";
@@ -35,13 +39,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Act & Assert
                 await UserStories.EnableTwoFactorAuthentication(index);
             }
+        }
 
         [Fact]
         public async Task CanConfirmEmail()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var emails = new ContosoEmailSender();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureServices(s => s.SetupTestEmailSender(emails)));
                 var client = ServerFactory.CreateDefaultClient(server);
 
@@ -56,13 +63,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 var email = emails.SentEmails[1];
                 await UserStories.ConfirmEmailAsync(email, client);
             }
+        }
 
         [Fact]
         public async Task CanChangePassword()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var principals = new List<ClaimsPrincipal>();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureTestServices(s => s.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
 
                 var client = ServerFactory.CreateDefaultClient(server);
@@ -87,13 +97,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Signing in again with a different client uses the same security stamp claim
                 AssertClaimsEqual(principals[1], principals[2], "AspNet.Identity.SecurityStamp");
             }
+        }
 
         [Fact]
         public async Task CanSetPasswordWithExternalLogin()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var principals = new List<ClaimsPrincipal>();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin()
                     .SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
 
@@ -122,13 +135,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Can log in with the password set above
                 await UserStories.LoginExistingUserAsync(ServerFactory.CreateDefaultClient(server), email, "!Test.Password2");
             }
+        }
 
         [Fact]
         public async Task CanRemoveExternalLogin()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var principals = new List<ClaimsPrincipal>();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin()
                     .SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
 
@@ -146,13 +162,16 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // RefreshSignIn generates a new security stamp claim
                 AssertClaimsNotEqual(principals[0], principals[1], "AspNet.Identity.SecurityStamp");
             }
+        }
 
         [Fact]
         public async Task CanResetAuthenticator()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
                 var principals = new List<ClaimsPrincipal>();
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin()
                     .SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
 
@@ -174,12 +193,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // RefreshSignIn generates a new security stamp claim
                 AssertClaimsNotEqual(principals[1], principals[2], "AspNet.Identity.SecurityStamp");
             }
+        }
 
         [Fact]
         public async Task CanDownloadPersonalData()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
 
                 var userName = $"{Guid.NewGuid()}@example.com";
                 var password = $"!Test.Password1$";
@@ -196,12 +218,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 Assert.Contains($"\"PhoneNumberConfirmed\":\"False\"", jsonData);
                 Assert.Contains($"\"TwoFactorEnabled\":\"False\"", jsonData);
             }
+        }
 
         [Fact]
         public async Task CanDeleteUser()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
 
                 var userName = $"{Guid.NewGuid()}@example.com";
                 var password = $"!Test.Password1$";
@@ -211,6 +236,7 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Act & Assert
                 await UserStories.DeleteUser(index, password);
             }
+        }
 
         private void AssertClaimsEqual(ClaimsPrincipal expectedPrincipal, ClaimsPrincipal actualPrincipal, string claimType)
         {

test/Identity.FunctionalTests/RegistrationTests.cs

@@ -3,13 +3,15 @@
 
 using System;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging.Testing;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace Microsoft.AspNetCore.Identity.FunctionalTests
 {
-    public class RegistrationTests : IClassFixture<ServerFactory>
+    public class RegistrationTests : LoggedTest, IClassFixture<ServerFactory>
     {
-        public RegistrationTests(ServerFactory serverFactory)
+        public RegistrationTests(ServerFactory serverFactory, ITestOutputHelper output) : base(output)
         {
             ServerFactory = serverFactory;
         }
@@ -18,9 +20,11 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
 
         [Fact]
         public async Task CanRegisterAUser()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var client = ServerFactory.CreateDefaultClient();
+                var client = ServerFactory.CreateDefaultClient(loggerFactory);
 
                 var userName = $"{Guid.NewGuid()}@example.com";
                 var password = $"!Test.Password1$";
@@ -28,12 +32,15 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
                 // Act & Assert
                 await UserStories.RegisterNewUserAsync(client, userName, password);
             }
+        }
 
         [Fact]
         public async Task CanRegisterWithASocialLoginProvider()
+        {
+            using (StartLog(out var loggerFactory))
             {
                 // Arrange
-            var server = ServerFactory.CreateServer(builder =>
+                var server = ServerFactory.CreateServer(loggerFactory, builder =>
                     builder.ConfigureServices(services => services.SetupTestThirdPartyLogin()));
                 var client = ServerFactory.CreateDefaultClient(server);
 
@@ -46,3 +53,4 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
             }
         }
     }
+}

test/Service.FunctionalTests/Infrastructure/CredentialsServerBuilder.cs

@@ -11,11 +11,11 @@ using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Identity.Service;
 using Microsoft.AspNetCore.Identity.Service.IntegratedWebClient;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
 using Microsoft.IdentityModel.Tokens;
 
 namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
@@ -24,9 +24,10 @@ namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
     {
         private readonly DelegatingHandler _loopBackHandler = new LoopBackHandler();
 
-        public CredentialsServerBuilder(string[] args = null)
+        public CredentialsServerBuilder(ILoggerFactory loggerFactory, string[] args = null)
         {
             Server = Program.CreateWebHostBuilder(args ?? Array.Empty<string>())
+                .ConfigureServices(collection => collection.AddSingleton(loggerFactory))
                 .UseSolutionRelativeContentRoot(@"./test/WebSites/Identity.OpenIdConnect.WebSite");
         }
 

test/Service.FunctionalTests/TraditionalWebApplicationTests.cs

@@ -2,32 +2,39 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Linq;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
+using System.Net.Http;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.AspNetCore.Testing.xunit;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Testing;
 using Microsoft.Extensions.Primitives;
 using Microsoft.IdentityModel.Protocols.OpenIdConnect;
 using Microsoft.Net.Http.Headers;
 using Xunit;
-using System.Net.Http;
+using Xunit.Abstractions;
 
 namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
 {
-    public class TraditionalWebApplicationTests
+    public class TraditionalWebApplicationTests : LoggedTest
     {
+        public TraditionalWebApplicationTests(ITestOutputHelper output) : base(output) { }
+
         [ConditionalFact(Skip = "https://github.com/aspnet/Identity/issues/1630")]
         [FrameworkSkipCondition(RuntimeFrameworks.CLR, SkipReason = "https://github.com/aspnet/Identity/issues/1346")]
         public async Task CanPerform_AuthorizationCode_Flow()
+        {
+            using (StartLog(out var loggerFactory, minLogLevel: LogLevel.Debug))
             {
                 // Arrange
                 var clientId = Guid.NewGuid().ToString();
                 var resourceId = Guid.NewGuid().ToString();
 
-            var appBuilder = new CredentialsServerBuilder()
+                var appBuilder = new CredentialsServerBuilder(loggerFactory)
                     .EnsureDeveloperCertificate()
                     .ConfigureReferenceData(data => data
                         .CreateIntegratedWebClientApplication(clientId)
@@ -94,6 +101,7 @@ namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
                 ResponseAssert.IsOK(protectedResourceResponse);
                 ResponseAssert.IsHtmlDocument(protectedResourceResponse);
             }
+        }
 
         private SetCookieHeaderValue CreateExpectedSetCorrelationIdCookie(DateTime expires = default(DateTime))
         {
@@ -120,12 +128,14 @@ namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
         [ConditionalFact(Skip = "https://github.com/aspnet/Identity/issues/1630")]
         [FrameworkSkipCondition(RuntimeFrameworks.CLR, SkipReason = "https://github.com/aspnet/Identity/issues/1346")]
         public async Task CanPerform_IdToken_Flow()
+        {
+            using (StartLog(out var loggerFactory, minLogLevel: LogLevel.Debug))
             {
                 // Arrange
                 var clientId = Guid.NewGuid().ToString();
                 var resourceId = Guid.NewGuid().ToString();
 
-            var appBuilder = new CredentialsServerBuilder()
+                var appBuilder = new CredentialsServerBuilder(loggerFactory)
                     .EnsureDeveloperCertificate()
                     .ConfigureReferenceData(data => data
                         .CreateIntegratedWebClientApplication(clientId)
@@ -183,6 +193,7 @@ namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
                 Assert.Equal(HttpStatusCode.OK, protectedResourceResponse.StatusCode);
                 ResponseAssert.IsHtmlDocument(protectedResourceResponse);
             }
+        }
 
 
         public class Form