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

Add logging for functional tests

This commit is contained in:
John Luo 2018-03-14 18:24:00 -07:00
parent 56666e349c
commit e233e60e6f
8 changed files with 505 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Identity.sln
View File

@ -965,4 +965,4 @@ Global
GlobalSection(ExtensibilityGlobals) = postSolution GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {B3F2A592-CCE0-40C2-8CA4-7B1293DED874} SolutionGuid = {B3F2A592-CCE0-40C2-8CA4-7B1293DED874}
EndGlobalSection EndGlobalSection
EndGlobal EndGlobal

75
test/Identity.FunctionalTests/AuthorizationTests.cs
View File

@ -1,14 +1,17 @@
// Copyright (c) .NET Foundation. All rights reserved. // 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. // 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 System.Threading.Tasks;
using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
using Xunit.Abstractions;
namespace Microsoft.AspNetCore.Identity.FunctionalTests 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; ServerFactory = serverFactory;
} }
@ -37,15 +40,18 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[MemberData(nameof(AuthorizedPages))] [MemberData(nameof(AuthorizedPages))]
public async Task AnonymousUserCantAccessAuthorizedPages(string url) public async Task AnonymousUserCantAccessAuthorizedPages(string url)
{ {
// Arrange using (StartLog(out var loggerFactory, $"{nameof(AnonymousUserCantAccessAuthorizedPages)}_{WebUtility.UrlEncode(url)}"))
var client = ServerFactory.CreateDefaultClient(); {
// Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
// Act // Act
var response = await client.GetAsync(url); var response = await client.GetAsync(url);
// Assert // Assert
var location = ResponseAssert.IsRedirect(response); var location = ResponseAssert.IsRedirect(response);
Assert.StartsWith("/Identity/Account/Login?", location.PathAndQuery); Assert.StartsWith("/Identity/Account/Login?", location.PathAndQuery);
}
} }
// The routes commented below are not directly accessible by // The routes commented below are not directly accessible by
@ -74,15 +80,18 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[MemberData(nameof(RouteableAuthorizedPages))] [MemberData(nameof(RouteableAuthorizedPages))]
public async Task AuthenticatedUserCanAccessAuthorizedPages(string url) public async Task AuthenticatedUserCanAccessAuthorizedPages(string url)
{ {
// Arrange using (StartLog(out var loggerFactory, $"{nameof(AuthenticatedUserCanAccessAuthorizedPages)}_{WebUtility.UrlEncode(url)}"))
var client = ServerFactory.CreateDefaultClient(); {
await UserStories.RegisterNewUserAsync(client); // Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
await UserStories.RegisterNewUserAsync(client);
// Act // Act
var response = await client.GetAsync(url); var response = await client.GetAsync(url);
// Assert // Assert
await ResponseAssert.IsHtmlDocumentAsync(response); await ResponseAssert.IsHtmlDocumentAsync(response);
}
} }
// The routes commented below are not directly accessible by // The routes commented below are not directly accessible by
@ -107,14 +116,17 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[MemberData(nameof(UnauthorizedPages))] [MemberData(nameof(UnauthorizedPages))]
public async Task AnonymousUserCanAccessNotAuthorizedPages(string url) public async Task AnonymousUserCanAccessNotAuthorizedPages(string url)
{ {
// Arrange using (StartLog(out var loggerFactory, $"{nameof(AnonymousUserCanAccessNotAuthorizedPages)}_{WebUtility.UrlEncode(url)}"))
var client = ServerFactory.CreateDefaultClient(); {
// Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
// Act // Act
var response = await client.GetAsync(url); var response = await client.GetAsync(url);
// Assert // Assert
await ResponseAssert.IsHtmlDocumentAsync(response); await ResponseAssert.IsHtmlDocumentAsync(response);
}
} }
public static TheoryData<string> UnauthorizedPagesAllowAnonymous => public static TheoryData<string> UnauthorizedPagesAllowAnonymous =>
@ -131,16 +143,19 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[MemberData(nameof(UnauthorizedPagesAllowAnonymous))] [MemberData(nameof(UnauthorizedPagesAllowAnonymous))]
public async Task AnonymousUserAllowedAccessToPages_WithGlobalAuthorizationFilter(string url) public async Task AnonymousUserAllowedAccessToPages_WithGlobalAuthorizationFilter(string url)
{ {
// Arrange using (StartLog(out var loggerFactory, $"{nameof(AnonymousUserAllowedAccessToPages_WithGlobalAuthorizationFilter)}_{WebUtility.UrlEncode(url)}"))
var server = ServerFactory.CreateServer(builder => {
builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter())); // Arrange
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter()));
var client = ServerFactory.CreateDefaultClient(server);
// Act // Act
var response = await client.GetAsync(url); var response = await client.GetAsync(url);
// Assert // Assert
await ResponseAssert.IsHtmlDocumentAsync(response); await ResponseAssert.IsHtmlDocumentAsync(response);
}
} }
} }
} }

13
test/Identity.FunctionalTests/Infrastructure/ServerFactory.cs
View File

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

277
test/Identity.FunctionalTests/LoginTests.cs
View File

@ -5,14 +5,16 @@ using System;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Identity.DefaultUI.WebSite; using Identity.DefaultUI.WebSite;
using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
using Xunit.Abstractions;
using Xunit.Sdk; using Xunit.Sdk;
namespace Microsoft.AspNetCore.Identity.FunctionalTests 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; ServerFactory = serverFactory;
} }
@ -22,203 +24,230 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[Fact] [Fact]
public async Task CanLogInWithAPreviouslyRegisteredUser() public async Task CanLogInWithAPreviouslyRegisteredUser()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateDefaultServer(); {
var client = ServerFactory.CreateDefaultClient(server); // Arrange
var newClient = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateDefaultServer(loggerFactory);
var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
// Act & Assert // Act & Assert
await UserStories.RegisterNewUserAsync(client, userName, password); await UserStories.RegisterNewUserAsync(client, userName, password);
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
await UserStories.LoginExistingUserAsync(newClient, userName, password); await UserStories.LoginExistingUserAsync(newClient, userName, password);
}
} }
[Fact] [Fact]
public async Task CanLogInWithTwoFactorAuthentication() public async Task CanLogInWithTwoFactorAuthentication()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateDefaultServer(); {
var client = ServerFactory.CreateDefaultClient(server); // Arrange
var newClient = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateDefaultServer(loggerFactory);
var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn); var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn);
var twoFactorKey = showRecoveryCodes.Context.AuthenticatorKey; var twoFactorKey = showRecoveryCodes.Context.AuthenticatorKey;
// Act & Assert // Act & Assert
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey); await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey);
}
} }
[Fact] [Fact]
public async Task CanLogInWithTwoFactorAuthentication_WithGlobalAuthorizeFilter() public async Task CanLogInWithTwoFactorAuthentication_WithGlobalAuthorizeFilter()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateServer(builder => {
builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter())); // Arrange
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, builder =>
var newClient = ServerFactory.CreateDefaultClient(server); builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter()));
var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn); var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn);
var twoFactorKey = showRecoveryCodes.Context.AuthenticatorKey; var twoFactorKey = showRecoveryCodes.Context.AuthenticatorKey;
// Act & Assert // Act & Assert
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey); await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey);
}
} }
[Fact] [Fact]
public async Task CanLogInWithRecoveryCode() public async Task CanLogInWithRecoveryCode()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateDefaultServer(); {
var client = ServerFactory.CreateDefaultClient(server); // Arrange
var newClient = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateDefaultServer(loggerFactory);
var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn); var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn);
var recoveryCode = showRecoveryCodes.Context.RecoveryCodes.First(); var recoveryCode = showRecoveryCodes.Context.RecoveryCodes.First();
// Act & Assert // Act & Assert
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
await UserStories.LoginExistingUserRecoveryCodeAsync(newClient, userName, password, recoveryCode); await UserStories.LoginExistingUserRecoveryCodeAsync(newClient, userName, password, recoveryCode);
}
} }
[Fact] [Fact]
public async Task CanLogInWithRecoveryCode_WithGlobalAuthorizeFilter() public async Task CanLogInWithRecoveryCode_WithGlobalAuthorizeFilter()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateServer(builder => {
builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter())); // Arrange
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, builder =>
var newClient = ServerFactory.CreateDefaultClient(server); builder.ConfigureServices(services => services.SetupGlobalAuthorizeFilter()));
var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn); var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn);
var recoveryCode = showRecoveryCodes.Context.RecoveryCodes.First(); var recoveryCode = showRecoveryCodes.Context.RecoveryCodes.First();
// Act & Assert // Act & Assert
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
await UserStories.LoginExistingUserRecoveryCodeAsync(newClient, userName, password, recoveryCode); await UserStories.LoginExistingUserRecoveryCodeAsync(newClient, userName, password, recoveryCode);
}
} }
[Fact] [Fact]
public async Task CannotLogInWithoutRequiredEmailConfirmation() public async Task CannotLogInWithoutRequiredEmailConfirmation()
{ {
// Arrange using (StartLog(out var loggerFactory))
var emailSender = new ContosoEmailSender();
var server = ServerFactory.CreateServer(builder =>
{ {
builder.ConfigureServices(services => services // Arrange
.SetupTestEmailSender(emailSender) var emailSender = new ContosoEmailSender();
.SetupEmailRequired()); var server = ServerFactory.CreateServer(loggerFactory, builder =>
}); {
builder.ConfigureServices(services => services
.SetupTestEmailSender(emailSender)
.SetupEmailRequired());
});
var client = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server); var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
// Act & Assert // Act & Assert
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
await Assert.ThrowsAnyAsync<XunitException>(() => UserStories.LoginExistingUserAsync(newClient, userName, password)); await Assert.ThrowsAnyAsync<XunitException>(() => UserStories.LoginExistingUserAsync(newClient, userName, password));
}
} }
[Fact] [Fact]
public async Task CanLogInAfterConfirmingEmail() public async Task CanLogInAfterConfirmingEmail()
{ {
// Arrange using (StartLog(out var loggerFactory))
var emailSender = new ContosoEmailSender();
var server = ServerFactory.CreateServer(builder =>
{ {
builder.ConfigureServices(services => services // Arrange
.SetupTestEmailSender(emailSender) var emailSender = new ContosoEmailSender();
.SetupEmailRequired()); var server = ServerFactory.CreateServer(loggerFactory, builder =>
}); {
builder.ConfigureServices(services => services
.SetupTestEmailSender(emailSender)
.SetupEmailRequired());
});
var client = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server); var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
// Act & Assert // Act & Assert
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
var email = Assert.Single(emailSender.SentEmails); var email = Assert.Single(emailSender.SentEmails);
await UserStories.ConfirmEmailAsync(email, newClient); await UserStories.ConfirmEmailAsync(email, newClient);
await UserStories.LoginExistingUserAsync(newClient, userName, password); await UserStories.LoginExistingUserAsync(newClient, userName, password);
}
} }
[Fact] [Fact]
public async Task CanLoginWithASocialLoginProvider() public async Task CanLoginWithASocialLoginProvider()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateServer(builder => {
builder.ConfigureServices(services => services.SetupTestThirdPartyLogin())); // Arrange
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, builder =>
var newClient = ServerFactory.CreateDefaultClient(server); builder.ConfigureServices(services => services.SetupTestThirdPartyLogin()));
var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var guid = Guid.NewGuid(); var guid = Guid.NewGuid();
var userName = $"{guid}"; var userName = $"{guid}";
var email = $"{guid}@example.com"; var email = $"{guid}@example.com";
// Act & Assert // Act & Assert
await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email); await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email);
await UserStories.LoginWithSocialLoginAsync(newClient, userName); await UserStories.LoginWithSocialLoginAsync(newClient, userName);
}
} }
[Fact] [Fact]
public async Task CanLogInAfterResettingThePassword() public async Task CanLogInAfterResettingThePassword()
{ {
// Arrange using (StartLog(out var loggerFactory))
var emailSender = new ContosoEmailSender(); {
var server = ServerFactory.CreateServer(b => b.ConfigureServices(s => // Arrange
s.SetupTestEmailSender(emailSender))); var emailSender = new ContosoEmailSender();
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, b => b.ConfigureServices(s =>
var resetPasswordClient = ServerFactory.CreateDefaultClient(server); s.SetupTestEmailSender(emailSender)));
var newClient = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var resetPasswordClient = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var newPassword = $"!New.Password1$"; var newPassword = $"!New.Password1$";
await UserStories.RegisterNewUserAsync(client, userName, password); await UserStories.RegisterNewUserAsync(client, userName, password);
var registrationEmail = Assert.Single(emailSender.SentEmails); var registrationEmail = Assert.Single(emailSender.SentEmails);
await UserStories.ConfirmEmailAsync(registrationEmail, client); await UserStories.ConfirmEmailAsync(registrationEmail, client);
// Act & Assert // Act & Assert
await UserStories.ForgotPasswordAsync(resetPasswordClient, userName); await UserStories.ForgotPasswordAsync(resetPasswordClient, userName);
Assert.Equal(2, emailSender.SentEmails.Count); Assert.Equal(2, emailSender.SentEmails.Count);
var email = emailSender.SentEmails[1]; var email = emailSender.SentEmails[1];
await UserStories.ResetPasswordAsync(resetPasswordClient, email, userName, newPassword); await UserStories.ResetPasswordAsync(resetPasswordClient, email, userName, newPassword);
await UserStories.LoginExistingUserAsync(newClient, userName, newPassword); await UserStories.LoginExistingUserAsync(newClient, userName, newPassword);
}
} }
} }
} }

262
test/Identity.FunctionalTests/ManagementTests.cs
View File

@ -8,13 +8,15 @@ using System.Security.Claims;
using System.Threading.Tasks; using System.Threading.Tasks;
using Identity.DefaultUI.WebSite; using Identity.DefaultUI.WebSite;
using Microsoft.AspNetCore.TestHost; using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
using Xunit.Abstractions;
namespace Microsoft.AspNetCore.Identity.FunctionalTests 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; ServerFactory = serverFactory;
} }
@ -24,192 +26,216 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[Fact] [Fact]
public async Task CanEnableTwoFactorAuthentication() public async Task CanEnableTwoFactorAuthentication()
{ {
// Arrange using (StartLog(out var loggerFactory))
var client = ServerFactory.CreateDefaultClient(); {
// Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var index = await UserStories.RegisterNewUserAsync(client, userName, password); var index = await UserStories.RegisterNewUserAsync(client, userName, password);
// Act & Assert // Act & Assert
await UserStories.EnableTwoFactorAuthentication(index); await UserStories.EnableTwoFactorAuthentication(index);
}
} }
[Fact] [Fact]
public async Task CanConfirmEmail() public async Task CanConfirmEmail()
{ {
// Arrange using (StartLog(out var loggerFactory))
var emails = new ContosoEmailSender(); {
var server = ServerFactory.CreateServer(builder => // Arrange
builder.ConfigureServices(s => s.SetupTestEmailSender(emails))); var emails = new ContosoEmailSender();
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureServices(s => s.SetupTestEmailSender(emails)));
var client = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var index = await UserStories.RegisterNewUserAsync(client, userName, password); var index = await UserStories.RegisterNewUserAsync(client, userName, password);
var manageIndex = await UserStories.SendEmailConfirmationLinkAsync(index); var manageIndex = await UserStories.SendEmailConfirmationLinkAsync(index);
// Act & Assert // Act & Assert
Assert.Equal(2, emails.SentEmails.Count); Assert.Equal(2, emails.SentEmails.Count);
var email = emails.SentEmails[1]; var email = emails.SentEmails[1];
await UserStories.ConfirmEmailAsync(email, client); await UserStories.ConfirmEmailAsync(email, client);
}
} }
[Fact] [Fact]
public async Task CanChangePassword() public async Task CanChangePassword()
{ {
// Arrange using (StartLog(out var loggerFactory))
var principals = new List<ClaimsPrincipal>(); {
var server = ServerFactory.CreateServer(builder => // Arrange
builder.ConfigureTestServices(s => s.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme))); var principals = new List<ClaimsPrincipal>();
var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureTestServices(s => s.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
var client = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server); var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = "!Test.Password1"; var password = "!Test.Password1";
var index = await UserStories.RegisterNewUserAsync(client, userName, password); var index = await UserStories.RegisterNewUserAsync(client, userName, password);
// Act 1 // Act 1
var changedPassword = await UserStories.ChangePasswordAsync(index, "!Test.Password1", "!Test.Password2"); var changedPassword = await UserStories.ChangePasswordAsync(index, "!Test.Password1", "!Test.Password2");
// Assert 1 // Assert 1
// RefreshSignIn generates a new security stamp claim // RefreshSignIn generates a new security stamp claim
AssertClaimsNotEqual(principals[0], principals[1], "AspNet.Identity.SecurityStamp"); AssertClaimsNotEqual(principals[0], principals[1], "AspNet.Identity.SecurityStamp");
// Act 2 // Act 2
await UserStories.LoginExistingUserAsync(newClient, userName, "!Test.Password2"); await UserStories.LoginExistingUserAsync(newClient, userName, "!Test.Password2");
// Assert 2 // Assert 2
// Signing in again with a different client uses the same security stamp claim // Signing in again with a different client uses the same security stamp claim
AssertClaimsEqual(principals[1], principals[2], "AspNet.Identity.SecurityStamp"); AssertClaimsEqual(principals[1], principals[2], "AspNet.Identity.SecurityStamp");
}
} }
[Fact] [Fact]
public async Task CanSetPasswordWithExternalLogin() public async Task CanSetPasswordWithExternalLogin()
{ {
// Arrange using (StartLog(out var loggerFactory))
var principals = new List<ClaimsPrincipal>(); {
var server = ServerFactory.CreateServer(builder => // Arrange
builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin() var principals = new List<ClaimsPrincipal>();
.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme))); var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin()
.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
var client = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server); var newClient = ServerFactory.CreateDefaultClient(server);
var guid = Guid.NewGuid(); var guid = Guid.NewGuid();
var userName = $"{guid}"; var userName = $"{guid}";
var email = $"{guid}@example.com"; var email = $"{guid}@example.com";
// Act 1 // Act 1
var index = await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email); var index = await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email);
index = await UserStories.LoginWithSocialLoginAsync(newClient, userName); index = await UserStories.LoginWithSocialLoginAsync(newClient, userName);
// Assert 1 // Assert 1
Assert.NotNull(principals[1].Identities.Single().Claims.Single(c => c.Type == ClaimTypes.AuthenticationMethod).Value); Assert.NotNull(principals[1].Identities.Single().Claims.Single(c => c.Type == ClaimTypes.AuthenticationMethod).Value);
// Act 2 // Act 2
await UserStories.SetPasswordAsync(index, "!Test.Password2"); await UserStories.SetPasswordAsync(index, "!Test.Password2");
// Assert 2 // Assert 2
// RefreshSignIn uses the same AuthenticationMethod claim value // RefreshSignIn uses the same AuthenticationMethod claim value
AssertClaimsEqual(principals[1], principals[2], ClaimTypes.AuthenticationMethod); AssertClaimsEqual(principals[1], principals[2], ClaimTypes.AuthenticationMethod);
// Act & Assert 3 // Act & Assert 3
// Can log in with the password set above // Can log in with the password set above
await UserStories.LoginExistingUserAsync(ServerFactory.CreateDefaultClient(server), email, "!Test.Password2"); await UserStories.LoginExistingUserAsync(ServerFactory.CreateDefaultClient(server), email, "!Test.Password2");
}
} }
[Fact] [Fact]
public async Task CanRemoveExternalLogin() public async Task CanRemoveExternalLogin()
{ {
// Arrange using (StartLog(out var loggerFactory))
var principals = new List<ClaimsPrincipal>(); {
var server = ServerFactory.CreateServer(builder => // Arrange
builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin() var principals = new List<ClaimsPrincipal>();
.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme))); var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin()
.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
var client = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var guid = Guid.NewGuid(); var guid = Guid.NewGuid();
var userName = $"{guid}"; var userName = $"{guid}";
var email = $"{guid}@example.com"; var email = $"{guid}@example.com";
// Act // Act
var index = await UserStories.RegisterNewUserAsync(client, email, "!TestPassword1"); var index = await UserStories.RegisterNewUserAsync(client, email, "!TestPassword1");
var linkLogin = await UserStories.LinkExternalLoginAsync(index, email); var linkLogin = await UserStories.LinkExternalLoginAsync(index, email);
await UserStories.RemoveExternalLoginAsync(linkLogin, email); await UserStories.RemoveExternalLoginAsync(linkLogin, email);
// RefreshSignIn generates a new security stamp claim // RefreshSignIn generates a new security stamp claim
AssertClaimsNotEqual(principals[0], principals[1], "AspNet.Identity.SecurityStamp"); AssertClaimsNotEqual(principals[0], principals[1], "AspNet.Identity.SecurityStamp");
}
} }
[Fact] [Fact]
public async Task CanResetAuthenticator() public async Task CanResetAuthenticator()
{ {
// Arrange using (StartLog(out var loggerFactory))
var principals = new List<ClaimsPrincipal>(); {
var server = ServerFactory.CreateServer(builder => // Arrange
builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin() var principals = new List<ClaimsPrincipal>();
.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme))); var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureTestServices(s => s.SetupTestThirdPartyLogin()
.SetupGetUserClaimsPrincipal(user => principals.Add(user), IdentityConstants.ApplicationScheme)));
var client = ServerFactory.CreateDefaultClient(server); var client = ServerFactory.CreateDefaultClient(server);
var newClient = ServerFactory.CreateDefaultClient(server); var newClient = ServerFactory.CreateDefaultClient(server);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
// Act // Act
var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password); var loggedIn = await UserStories.RegisterNewUserAsync(client, userName, password);
var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn); var showRecoveryCodes = await UserStories.EnableTwoFactorAuthentication(loggedIn);
var twoFactorKey = showRecoveryCodes.Context.AuthenticatorKey; var twoFactorKey = showRecoveryCodes.Context.AuthenticatorKey;
// Use a new client to simulate a new browser session. // Use a new client to simulate a new browser session.
var index = await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey); var index = await UserStories.LoginExistingUser2FaAsync(newClient, userName, password, twoFactorKey);
await UserStories.ResetAuthenticator(index); await UserStories.ResetAuthenticator(index);
// RefreshSignIn generates a new security stamp claim // RefreshSignIn generates a new security stamp claim
AssertClaimsNotEqual(principals[1], principals[2], "AspNet.Identity.SecurityStamp"); AssertClaimsNotEqual(principals[1], principals[2], "AspNet.Identity.SecurityStamp");
}
} }
[Fact] [Fact]
public async Task CanDownloadPersonalData() public async Task CanDownloadPersonalData()
{ {
// Arrange using (StartLog(out var loggerFactory))
var client = ServerFactory.CreateDefaultClient(); {
// Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var index = await UserStories.RegisterNewUserAsync(client, userName, password); var index = await UserStories.RegisterNewUserAsync(client, userName, password);
// Act & Assert // Act & Assert
var jsonData = await UserStories.DownloadPersonalData(index, userName); var jsonData = await UserStories.DownloadPersonalData(index, userName);
Assert.Contains($"\"Id\":\"", jsonData); Assert.Contains($"\"Id\":\"", jsonData);
Assert.Contains($"\"UserName\":\"{userName}\"", jsonData); Assert.Contains($"\"UserName\":\"{userName}\"", jsonData);
Assert.Contains($"\"Email\":\"{userName}\"", jsonData); Assert.Contains($"\"Email\":\"{userName}\"", jsonData);
Assert.Contains($"\"EmailConfirmed\":\"False\"", jsonData); Assert.Contains($"\"EmailConfirmed\":\"False\"", jsonData);
Assert.Contains($"\"PhoneNumber\":\"null\"", jsonData); Assert.Contains($"\"PhoneNumber\":\"null\"", jsonData);
Assert.Contains($"\"PhoneNumberConfirmed\":\"False\"", jsonData); Assert.Contains($"\"PhoneNumberConfirmed\":\"False\"", jsonData);
Assert.Contains($"\"TwoFactorEnabled\":\"False\"", jsonData); Assert.Contains($"\"TwoFactorEnabled\":\"False\"", jsonData);
}
} }
[Fact] [Fact]
public async Task CanDeleteUser() public async Task CanDeleteUser()
{ {
// Arrange using (StartLog(out var loggerFactory))
var client = ServerFactory.CreateDefaultClient(); {
// Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
var index = await UserStories.RegisterNewUserAsync(client, userName, password); var index = await UserStories.RegisterNewUserAsync(client, userName, password);
// Act & Assert // Act & Assert
await UserStories.DeleteUser(index, password); await UserStories.DeleteUser(index, password);
}
} }
private void AssertClaimsEqual(ClaimsPrincipal expectedPrincipal, ClaimsPrincipal actualPrincipal, string claimType) private void AssertClaimsEqual(ClaimsPrincipal expectedPrincipal, ClaimsPrincipal actualPrincipal, string claimType)

42
test/Identity.FunctionalTests/RegistrationTests.cs
View File

@ -3,13 +3,15 @@
using System; using System;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.Extensions.Logging.Testing;
using Xunit; using Xunit;
using Xunit.Abstractions;
namespace Microsoft.AspNetCore.Identity.FunctionalTests 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; ServerFactory = serverFactory;
} }
@ -19,30 +21,36 @@ namespace Microsoft.AspNetCore.Identity.FunctionalTests
[Fact] [Fact]
public async Task CanRegisterAUser() public async Task CanRegisterAUser()
{ {
// Arrange using (StartLog(out var loggerFactory))
var client = ServerFactory.CreateDefaultClient(); {
// Arrange
var client = ServerFactory.CreateDefaultClient(loggerFactory);
var userName = $"{Guid.NewGuid()}@example.com"; var userName = $"{Guid.NewGuid()}@example.com";
var password = $"!Test.Password1$"; var password = $"!Test.Password1$";
// Act & Assert // Act & Assert
await UserStories.RegisterNewUserAsync(client, userName, password); await UserStories.RegisterNewUserAsync(client, userName, password);
}
} }
[Fact] [Fact]
public async Task CanRegisterWithASocialLoginProvider() public async Task CanRegisterWithASocialLoginProvider()
{ {
// Arrange using (StartLog(out var loggerFactory))
var server = ServerFactory.CreateServer(builder => {
builder.ConfigureServices(services => services.SetupTestThirdPartyLogin())); // Arrange
var client = ServerFactory.CreateDefaultClient(server); var server = ServerFactory.CreateServer(loggerFactory, builder =>
builder.ConfigureServices(services => services.SetupTestThirdPartyLogin()));
var client = ServerFactory.CreateDefaultClient(server);
var guid = Guid.NewGuid(); var guid = Guid.NewGuid();
var userName = $"{guid}"; var userName = $"{guid}";
var email = $"{guid}@example.com"; var email = $"{guid}@example.com";
// Act & Assert // Act & Assert
await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email); await UserStories.RegisterNewUserWithSocialLoginAsync(client, userName, email);
}
} }
} }
} }

5
test/Service.FunctionalTests/Infrastructure/CredentialsServerBuilder.cs
View File

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

241
test/Service.FunctionalTests/TraditionalWebApplicationTests.cs
View File

@ -2,97 +2,105 @@
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System; using System;
using System.Linq;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Net; using System.Net;
using System.Net.Http;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Testing; using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.AspNetCore.Testing.xunit; using Microsoft.AspNetCore.Testing.xunit;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Testing;
using Microsoft.Extensions.Primitives; using Microsoft.Extensions.Primitives;
using Microsoft.IdentityModel.Protocols.OpenIdConnect; using Microsoft.IdentityModel.Protocols.OpenIdConnect;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
using Xunit; using Xunit;
using System.Net.Http; using Xunit.Abstractions;
namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests 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")] [ConditionalFact(Skip = "https://github.com/aspnet/Identity/issues/1630")]
[FrameworkSkipCondition(RuntimeFrameworks.CLR, SkipReason = "https://github.com/aspnet/Identity/issues/1346")] [FrameworkSkipCondition(RuntimeFrameworks.CLR, SkipReason = "https://github.com/aspnet/Identity/issues/1346")]
public async Task CanPerform_AuthorizationCode_Flow() public async Task CanPerform_AuthorizationCode_Flow()
{ {
// Arrange using (StartLog(out var loggerFactory, minLogLevel: LogLevel.Debug))
var clientId = Guid.NewGuid().ToString(); {
var resourceId = Guid.NewGuid().ToString(); // Arrange
var clientId = Guid.NewGuid().ToString();
var resourceId = Guid.NewGuid().ToString();
var appBuilder = new CredentialsServerBuilder() var appBuilder = new CredentialsServerBuilder(loggerFactory)
.EnsureDeveloperCertificate() .EnsureDeveloperCertificate()
.ConfigureReferenceData(data => data .ConfigureReferenceData(data => data
.CreateIntegratedWebClientApplication(clientId) .CreateIntegratedWebClientApplication(clientId)
.CreateResourceApplication(resourceId, "ResourceApplication", "read") .CreateResourceApplication(resourceId, "ResourceApplication", "read")
.CreateUser("testUser", "Pa$$w0rd")) .CreateUser("testUser", "Pa$$w0rd"))
.ConfigureInMemoryEntityFrameworkStorage() .ConfigureInMemoryEntityFrameworkStorage()
.ConfigureMvcAutomaticSignIn() .ConfigureMvcAutomaticSignIn()
.ConfigureOpenIdConnectClient(options => .ConfigureOpenIdConnectClient(options =>
{ {
options.ClientId = clientId; options.ClientId = clientId;
options.ResponseType = OpenIdConnectResponseType.Code; options.ResponseType = OpenIdConnectResponseType.Code;
options.ResponseMode = OpenIdConnectResponseMode.Query; options.ResponseMode = OpenIdConnectResponseMode.Query;
options.Scope.Add("https://localhost/DFC7191F-FF74-42B9-A292-08FEA80F5B20/v2.0/ResourceApplication/read"); options.Scope.Add("https://localhost/DFC7191F-FF74-42B9-A292-08FEA80F5B20/v2.0/ResourceApplication/read");
}) })
.ConfigureIntegratedClient(clientId); .ConfigureIntegratedClient(clientId);
var client = appBuilder.Build(); var client = appBuilder.Build();
// Act & Assert // Act & Assert
// Navigate to protected resource. // Navigate to protected resource.
var goToAuthorizeResponse = await client.GetAsync("https://localhost/Home/About"); var goToAuthorizeResponse = await client.GetAsync("https://localhost/Home/About");
// Redirected to authorize // Redirected to authorize
var location = ResponseAssert.IsRedirect(goToAuthorizeResponse); var location = ResponseAssert.IsRedirect(goToAuthorizeResponse);
var oidcCookiesComparisonCriteria = CookieComparison.Strict & ~CookieComparison.NameEquals | CookieComparison.NameStartsWith; var oidcCookiesComparisonCriteria = CookieComparison.Strict & ~CookieComparison.NameEquals | CookieComparison.NameStartsWith;
ResponseAssert.HasCookie(CreateExpectedSetNonceCookie(), goToAuthorizeResponse, oidcCookiesComparisonCriteria); ResponseAssert.HasCookie(CreateExpectedSetNonceCookie(), goToAuthorizeResponse, oidcCookiesComparisonCriteria);
ResponseAssert.HasCookie(CreateExpectedSetCorrelationIdCookie(), goToAuthorizeResponse, oidcCookiesComparisonCriteria); ResponseAssert.HasCookie(CreateExpectedSetCorrelationIdCookie(), goToAuthorizeResponse, oidcCookiesComparisonCriteria);
var authorizeParameters = ResponseAssert.LocationHasQueryParameters<OpenIdConnectMessage>( var authorizeParameters = ResponseAssert.LocationHasQueryParameters<OpenIdConnectMessage>(
goToAuthorizeResponse, goToAuthorizeResponse,
"state"); "state");
// Navigate to authorize // Navigate to authorize
var goToLoginResponse = await client.GetAsync(location); var goToLoginResponse = await client.GetAsync(location);
// Redirected to login // Redirected to login
location = ResponseAssert.IsRedirect(goToLoginResponse); location = ResponseAssert.IsRedirect(goToLoginResponse);
// Navigate to login // Navigate to login
var goToAuthorizeWithCookie = await client.GetAsync(location); var goToAuthorizeWithCookie = await client.GetAsync(location);
// Stamp a login cookie and redirect back to authorize. // Stamp a login cookie and redirect back to authorize.
location = ResponseAssert.IsRedirect(goToAuthorizeWithCookie); location = ResponseAssert.IsRedirect(goToAuthorizeWithCookie);
ResponseAssert.HasCookie(".AspNetCore.Identity.Application", goToAuthorizeWithCookie, CookieComparison.NameEquals); ResponseAssert.HasCookie(".AspNetCore.Identity.Application", goToAuthorizeWithCookie, CookieComparison.NameEquals);
// Navigate to authorize with a login cookie. // Navigate to authorize with a login cookie.
var goToSignInOidcCallback = await client.GetAsync(location); var goToSignInOidcCallback = await client.GetAsync(location);
// Stamp an application session cookie and redirect to relying party callback with an authorization code on the query string. // Stamp an application session cookie and redirect to relying party callback with an authorization code on the query string.
location = ResponseAssert.IsRedirect(goToSignInOidcCallback); location = ResponseAssert.IsRedirect(goToSignInOidcCallback);
ResponseAssert.HasCookie("Microsoft.AspNetCore.Identity.Service", goToSignInOidcCallback, CookieComparison.NameEquals); ResponseAssert.HasCookie("Microsoft.AspNetCore.Identity.Service", goToSignInOidcCallback, CookieComparison.NameEquals);
var callBackQueryParameters = ResponseAssert.LocationHasQueryParameters<OpenIdConnectMessage>(goToSignInOidcCallback, "code", ("state", authorizeParameters.State)); var callBackQueryParameters = ResponseAssert.LocationHasQueryParameters<OpenIdConnectMessage>(goToSignInOidcCallback, "code", ("state", authorizeParameters.State));
// Navigate to relying party callback. // Navigate to relying party callback.
var goToProtectedResource = await client.GetAsync(location); var goToProtectedResource = await client.GetAsync(location);
// Stamp a session cookie and redirect to the protected resource. // Stamp a session cookie and redirect to the protected resource.
location = ResponseAssert.IsRedirect(goToProtectedResource); location = ResponseAssert.IsRedirect(goToProtectedResource);
ResponseAssert.HasCookie(".AspNetCore.Cookies", goToProtectedResource, CookieComparison.NameEquals); ResponseAssert.HasCookie(".AspNetCore.Cookies", goToProtectedResource, CookieComparison.NameEquals);
ResponseAssert.HasCookie(CreateExpectedSetCorrelationIdCookie(DateTime.Parse("1/1/1970 12:00:00 AM +00:00")), goToProtectedResource, CookieComparison.Delete); ResponseAssert.HasCookie(CreateExpectedSetCorrelationIdCookie(DateTime.Parse("1/1/1970 12:00:00 AM +00:00")), goToProtectedResource, CookieComparison.Delete);
ResponseAssert.HasCookie(CreateExpectedSetNonceCookie(DateTime.Parse("1/1/1970 12:00:00 AM +00:00")), goToProtectedResource, CookieComparison.Delete); ResponseAssert.HasCookie(CreateExpectedSetNonceCookie(DateTime.Parse("1/1/1970 12:00:00 AM +00:00")), goToProtectedResource, CookieComparison.Delete);
var protectedResourceResponse = await client.GetAsync(location); var protectedResourceResponse = await client.GetAsync(location);
ResponseAssert.IsOK(protectedResourceResponse); ResponseAssert.IsOK(protectedResourceResponse);
ResponseAssert.IsHtmlDocument(protectedResourceResponse); ResponseAssert.IsHtmlDocument(protectedResourceResponse);
}
} }
private SetCookieHeaderValue CreateExpectedSetCorrelationIdCookie(DateTime expires = default(DateTime)) private SetCookieHeaderValue CreateExpectedSetCorrelationIdCookie(DateTime expires = default(DateTime))
@ -121,67 +129,70 @@ namespace Microsoft.AspnetCore.Identity.Service.FunctionalTests
[FrameworkSkipCondition(RuntimeFrameworks.CLR, SkipReason = "https://github.com/aspnet/Identity/issues/1346")] [FrameworkSkipCondition(RuntimeFrameworks.CLR, SkipReason = "https://github.com/aspnet/Identity/issues/1346")]
public async Task CanPerform_IdToken_Flow() public async Task CanPerform_IdToken_Flow()
{ {
// Arrange using (StartLog(out var loggerFactory, minLogLevel: LogLevel.Debug))
var clientId = Guid.NewGuid().ToString();
var resourceId = Guid.NewGuid().ToString();
var appBuilder = new CredentialsServerBuilder()
.EnsureDeveloperCertificate()
.ConfigureReferenceData(data => data
.CreateIntegratedWebClientApplication(clientId)
.CreateUser("testUser", "Pa$$w0rd"))
.ConfigureInMemoryEntityFrameworkStorage()
.ConfigureMvcAutomaticSignIn()
.ConfigureOpenIdConnectClient(options =>
{
options.ClientId = clientId;
})
.ConfigureIntegratedClient(clientId);
var client = appBuilder.Build();
// Act
var goToAuthorizeResponse = await client.GetAsync("https://localhost/Home/About");
// Assert
Assert.Equal(HttpStatusCode.Redirect, goToAuthorizeResponse.StatusCode);
// Act
var goToLoginResponse = await client.GetAsync(goToAuthorizeResponse.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.Redirect, goToLoginResponse.StatusCode);
// Act
var goToAuthorizeWithCookie = await client.GetAsync(goToLoginResponse.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.Redirect, goToAuthorizeWithCookie.StatusCode);
// Act
var goToSignInOidcCallback = await client.GetAsync(goToAuthorizeWithCookie.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.OK, goToSignInOidcCallback.StatusCode);
ResponseAssert.IsHtmlDocument(goToSignInOidcCallback);
var form = GetForm(await goToSignInOidcCallback.Content.ReadAsStringAsync());
var formRequest = new HttpRequestMessage(new HttpMethod(form.Method), form.Action)
{ {
Content = new FormUrlEncodedContent(form.Values) // Arrange
}; var clientId = Guid.NewGuid().ToString();
var resourceId = Guid.NewGuid().ToString();
// Act var appBuilder = new CredentialsServerBuilder(loggerFactory)
var goToProtectedResource = await client.SendAsync(formRequest); .EnsureDeveloperCertificate()
.ConfigureReferenceData(data => data
.CreateIntegratedWebClientApplication(clientId)
.CreateUser("testUser", "Pa$$w0rd"))
.ConfigureInMemoryEntityFrameworkStorage()
.ConfigureMvcAutomaticSignIn()
.ConfigureOpenIdConnectClient(options =>
{
options.ClientId = clientId;
})
.ConfigureIntegratedClient(clientId);
// Assert var client = appBuilder.Build();
Assert.Equal(HttpStatusCode.Redirect, goToProtectedResource.StatusCode);
// Act // Act
var protectedResourceResponse = await client.GetAsync(goToProtectedResource.Headers.Location); var goToAuthorizeResponse = await client.GetAsync("https://localhost/Home/About");
// Assert // Assert
Assert.Equal(HttpStatusCode.OK, protectedResourceResponse.StatusCode); Assert.Equal(HttpStatusCode.Redirect, goToAuthorizeResponse.StatusCode);
ResponseAssert.IsHtmlDocument(protectedResourceResponse);
// Act
var goToLoginResponse = await client.GetAsync(goToAuthorizeResponse.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.Redirect, goToLoginResponse.StatusCode);
// Act
var goToAuthorizeWithCookie = await client.GetAsync(goToLoginResponse.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.Redirect, goToAuthorizeWithCookie.StatusCode);
// Act
var goToSignInOidcCallback = await client.GetAsync(goToAuthorizeWithCookie.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.OK, goToSignInOidcCallback.StatusCode);
ResponseAssert.IsHtmlDocument(goToSignInOidcCallback);
var form = GetForm(await goToSignInOidcCallback.Content.ReadAsStringAsync());
var formRequest = new HttpRequestMessage(new HttpMethod(form.Method), form.Action)
{
Content = new FormUrlEncodedContent(form.Values)
};
// Act
var goToProtectedResource = await client.SendAsync(formRequest);
// Assert
Assert.Equal(HttpStatusCode.Redirect, goToProtectedResource.StatusCode);
// Act
var protectedResourceResponse = await client.GetAsync(goToProtectedResource.Headers.Location);
// Assert
Assert.Equal(HttpStatusCode.OK, protectedResourceResponse.StatusCode);
ResponseAssert.IsHtmlDocument(protectedResourceResponse);
}
} }