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

Port more tests (InMemory @ 92%, Core @ 60%)

This commit is contained in:
Hao Kung 2014-03-12 12:13:29 -07:00
parent bf649a00e1
commit 33715664e2
7 changed files with 1507 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/Microsoft.AspNet.Identity/UserValidator.cs
View File

@ -14,7 +14,6 @@ namespace Microsoft.AspNet.Identity
/// </summary>
/// <typeparam name="TUser"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TManager"></typeparam>
public class UserValidator<TUser, TKey> : IUserValidator<TUser, TKey>
where TUser : class, IUser<TKey>
where TKey : IEquatable<TKey>
@ -59,12 +58,10 @@ namespace Microsoft.AspNet.Identity
{
await ValidateEmail(manager, user, errors);
}
if (errors.Count > 0)
{
return IdentityResult.Failed(errors.ToArray());
}
return IdentityResult.Success;
return errors.Count > 0 ? IdentityResult.Failed(errors.ToArray()) : IdentityResult.Success;
}
// TODO: Revisit extensibility for Validators
/// <summary>
/// Returns true if the character is a digit between '0' and '9'

47
test/Microsoft.AspNet.Identity.InMemory.Test/ExceptionHelper.cs Normal file
View File

@ -0,0 +1,47 @@
using System;
using System.Threading.Tasks;
using Xunit;
namespace Microsoft.AspNet.Identity.InMemory.Test
{
public static class ExceptionHelper
{
public static async Task<TException> ThrowsWithError<TException>(Func<Task> act, string error)
where TException : Exception
{
var e = await Assert.ThrowsAsync<TException>(act);
if (e != null)
{
Assert.Equal(error, e.Message);
}
return e;
}
public static async Task<ArgumentException> ThrowsArgumentException(Func<Task> del, string exceptionMessage,
string paramName)
{
var e = await Assert.ThrowsAsync<ArgumentException>(del);
// Only check exception message on English build and OS, since some exception messages come from the OS
// and will be in the native language.
// TODO: needed? if (UnitTestHelper.EnglishBuildAndOS)
//{
Assert.Equal(exceptionMessage, e.Message);
Assert.Equal(paramName, e.ParamName);;
//}
return e;
}
public static Task<ArgumentException> ThrowsArgumentNullOrEmpty(Func<Task> del, string paramName)
{
return ThrowsArgumentException(del, "Value cannot be null or empty.\r\nParameter name: " + paramName,
paramName);
}
public static async Task<ArgumentNullException> ThrowsArgumentNull(Func<Task> del, string paramName)
{
var e = await Assert.ThrowsAsync<ArgumentNullException>(del);
Assert.Equal(paramName, e.ParamName);
return e;
}
}
}

342
test/Microsoft.AspNet.Identity.InMemory.Test/InMemoryUserStoreTest.cs
View File

@ -18,6 +18,18 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
Assert.Null(await manager.FindById(user.Id));
}
[Fact]
public async Task FindByEmailTest()
{
var manager = CreateManager();
const string userName = "EmailTest";
const string email = "email@test.com";
var user = new InMemoryUser(userName) { Email = email };
UnitTestHelper.IsSuccess(await manager.Create(user));
var fetch = await manager.FindByEmail(email);
Assert.Equal(user, fetch);
}
[Fact]
public async Task CreateUserNoPasswordTest()
{
@ -662,6 +674,325 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
Assert.Equal(role.Name, (await roleMgr.FindById(role.Id)).Name);
}
[Fact]
public async Task SetPhoneNumberTest()
{
var manager = CreateManager();
var userName = "PhoneTest";
var user = new InMemoryUser(userName);
user.PhoneNumber = "123-456-7890";
UnitTestHelper.IsSuccess(await manager.Create(user));
var stamp = await manager.GetSecurityStamp(user.Id);
Assert.Equal(await manager.GetPhoneNumber(user.Id), "123-456-7890");
UnitTestHelper.IsSuccess(await manager.SetPhoneNumber(user.Id, "111-111-1111"));
Assert.Equal(await manager.GetPhoneNumber(user.Id), "111-111-1111");
Assert.NotEqual(stamp, user.SecurityStamp);
}
[Fact]
public async Task ChangePhoneNumberTest()
{
var manager = CreateManager();
var userName = "PhoneTest";
var user = new InMemoryUser(userName);
user.PhoneNumber = "123-456-7890";
UnitTestHelper.IsSuccess(await manager.Create(user));
Assert.False(await manager.IsPhoneNumberConfirmed(user.Id));
var stamp = await manager.GetSecurityStamp(user.Id);
var token1 = await manager.GenerateChangePhoneNumberToken(user.Id, "111-111-1111");
UnitTestHelper.IsSuccess(await manager.ChangePhoneNumber(user.Id, "111-111-1111", token1));
Assert.True(await manager.IsPhoneNumberConfirmed(user.Id));
Assert.Equal(await manager.GetPhoneNumber(user.Id), "111-111-1111");
Assert.NotEqual(stamp, user.SecurityStamp);
}
[Fact]
public async Task ChangePhoneNumberFailsWithWrongTokenTest()
{
var manager = CreateManager();
var userName = "PhoneTest";
var user = new InMemoryUser(userName);
user.PhoneNumber = "123-456-7890";
UnitTestHelper.IsSuccess(await manager.Create(user));
Assert.False(await manager.IsPhoneNumberConfirmed(user.Id));
var stamp = await manager.GetSecurityStamp(user.Id);
UnitTestHelper.IsFailure(await manager.ChangePhoneNumber(user.Id, "111-111-1111", "bogus"),
"Invalid token.");
Assert.False(await manager.IsPhoneNumberConfirmed(user.Id));
Assert.Equal(await manager.GetPhoneNumber(user.Id), "123-456-7890");
Assert.Equal(stamp, user.SecurityStamp);
}
[Fact]
public async Task VerifyPhoneNumberTest()
{
var manager = CreateManager();
const string userName = "VerifyPhoneTest";
var user = new InMemoryUser(userName);
UnitTestHelper.IsSuccess(await manager.Create(user));
const string num1 = "111-123-4567";
const string num2 = "111-111-1111";
var token1 = await manager.GenerateChangePhoneNumberToken(user.Id, num1);
var token2 = await manager.GenerateChangePhoneNumberToken(user.Id, num2);
Assert.NotEqual(token1, token2);
Assert.True(await manager.VerifyChangePhoneNumberToken(user.Id, token1, num1));
Assert.True(await manager.VerifyChangePhoneNumberToken(user.Id, token2, num2));
Assert.False(await manager.VerifyChangePhoneNumberToken(user.Id, token2, num1));
Assert.False(await manager.VerifyChangePhoneNumberToken(user.Id, token1, num2));
}
//[Fact]
//public async Task EmailTokenFactorTest()
//{
// var manager = CreateManager();
// var messageService = new TestMessageService();
// manager.EmailService = messageService;
// const string factorId = "EmailCode";
// manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("EmailCodeTest") { Email = "foo@foo.com" };
// const string password = "password";
// UnitTestHelper.IsSuccess(await manager.Create(user, password));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// Assert.Null(messageService.Message);
// UnitTestHelper.IsSuccess(await manager.NotifyTwoFactorToken(user.Id, factorId, token));
// Assert.NotNull(messageService.Message);
// Assert.Equal(String.Empty, messageService.Message.Subject);
// Assert.Equal(token, messageService.Message.Body);
// Assert.True(await manager.VerifyTwoFactorToken(user.Id, factorId, token));
//}
//[Fact]
//public async Task EmailTokenFactorWithFormatTest()
//{
// var manager = CreateManager();
// var messageService = new TestMessageService();
// manager.EmailService = messageService;
// const string factorId = "EmailCode";
// manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider<InMemoryUser>
// {
// Subject = "Security Code",
// BodyFormat = "Your code is: {0}"
// });
// var user = new InMemoryUser("EmailCodeTest") { Email = "foo@foo.com" };
// const string password = "password";
// UnitTestHelper.IsSuccess(await manager.Create(user, password));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// Assert.Null(messageService.Message);
// UnitTestHelper.IsSuccess(await manager.NotifyTwoFactorToken(user.Id, factorId, token));
// Assert.NotNull(messageService.Message);
// Assert.Equal("Security Code", messageService.Message.Subject);
// Assert.Equal("Your code is: " + token, messageService.Message.Body);
// Assert.True(await manager.VerifyTwoFactorToken(user.Id, factorId, token));
//}
//[Fact]
//public async Task EmailFactorFailsAfterSecurityStampChangeTest()
//{
// var manager = CreateManager();
// const string factorId = "EmailCode";
// manager.RegisterTwoFactorProvider(factorId, new EmailTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("EmailCodeTest") { Email = "foo@foo.com" };
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// UnitTestHelper.IsSuccess(await manager.UpdateSecurityStamp(user.Id));
// Assert.False(await manager.VerifyTwoFactorToken(user.Id, factorId, token));
//}
//[Fact]
//public async Task UserTwoFactorProviderTest()
//{
// var manager = CreateManager();
// const string factorId = "PhoneCode";
// manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("PhoneCodeTest");
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// UnitTestHelper.IsSuccess(await manager.SetTwoFactorEnabled(user.Id, true));
// Assert.NotEqual(stamp, await manager.GetSecurityStamp(user.Id));
// Assert.True(await manager.GetTwoFactorEnabled(user.Id));
//}
[Fact]
public async Task SendSms()
{
var manager = CreateManager();
var messageService = new TestMessageService();
manager.SmsService = messageService;
var user = new InMemoryUser("SmsTest") { PhoneNumber = "4251234567" };
UnitTestHelper.IsSuccess(await manager.Create(user));
await manager.SendSms(user.Id, "Hi");
Assert.NotNull(messageService.Message);
Assert.Equal("Hi", messageService.Message.Body);
}
[Fact]
public async Task SendEmail()
{
var manager = CreateManager();
var messageService = new TestMessageService();
manager.EmailService = messageService;
var user = new InMemoryUser("EmailTest") { Email = "foo@foo.com" };
UnitTestHelper.IsSuccess(await manager.Create(user));
await manager.SendEmail(user.Id, "Hi", "Body");
Assert.NotNull(messageService.Message);
Assert.Equal("Hi", messageService.Message.Subject);
Assert.Equal("Body", messageService.Message.Body);
}
//[Fact]
//public async Task PhoneTokenFactorTest()
//{
// var manager = CreateManager();
// var messageService = new TestMessageService();
// manager.SmsService = messageService;
// const string factorId = "PhoneCode";
// manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("PhoneCodeTest") { PhoneNumber = "4251234567" };
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// Assert.Null(messageService.Message);
// UnitTestHelper.IsSuccess(await manager.NotifyTwoFactorToken(user.Id, factorId, token));
// Assert.NotNull(messageService.Message);
// Assert.Equal(token, messageService.Message.Body);
// Assert.True(await manager.VerifyTwoFactorToken(user.Id, factorId, token));
//}
//[Fact]
//public async Task PhoneTokenFactorFormatTest()
//{
// var manager = CreateManager();
// var messageService = new TestMessageService();
// manager.SmsService = messageService;
// const string factorId = "PhoneCode";
// manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider<InMemoryUser>
// {
// MessageFormat = "Your code is: {0}"
// });
// var user = new InMemoryUser("PhoneCodeTest") { PhoneNumber = "4251234567" };
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// Assert.Null(messageService.Message);
// UnitTestHelper.IsSuccess(await manager.NotifyTwoFactorToken(user.Id, factorId, token));
// Assert.NotNull(messageService.Message);
// Assert.Equal("Your code is: " + token, messageService.Message.Body);
// Assert.True(await manager.VerifyTwoFactorToken(user.Id, factorId, token));
//}
[Fact]
public async Task NoFactorProviderTest()
{
var manager = CreateManager();
var user = new InMemoryUser("PhoneCodeTest");
UnitTestHelper.IsSuccess(await manager.Create(user));
const string error = "No IUserTwoFactorProvider for 'bogus' is registered.";
await ExceptionHelper.ThrowsWithError<NotSupportedException>(() => manager.GenerateTwoFactorToken(user.Id, "bogus"), error);
await ExceptionHelper.ThrowsWithError<NotSupportedException>(
() => manager.VerifyTwoFactorToken(user.Id, "bogus", "bogus"), error);
}
[Fact]
public async Task GetValidTwoFactorTestEmptyWithNoProviders()
{
var manager = CreateManager();
var user = new InMemoryUser("test");
UnitTestHelper.IsSuccess(await manager.Create(user));
var factors = await manager.GetValidTwoFactorProviders(user.Id);
Assert.NotNull(factors);
Assert.True(!factors.Any());
}
//[Fact]
//public async Task GetValidTwoFactorTest()
//{
// var manager = CreateManager();
// manager.RegisterTwoFactorProvider("phone", new PhoneNumberTokenProvider<InMemoryUser>());
// manager.RegisterTwoFactorProvider("email", new EmailTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("test");
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var factors = await manager.GetValidTwoFactorProviders(user.Id);
// Assert.NotNull(factors);
// Assert.True(factors.Count() == 0);
// UnitTestHelper.IsSuccess(await manager.SetPhoneNumber(user.Id, "111-111-1111"));
// factors = await manager.GetValidTwoFactorProviders(user.Id);
// Assert.NotNull(factors);
// Assert.True(factors.Count() == 1);
// Assert.Equal("phone", factors[0]);
// UnitTestHelper.IsSuccess(await manager.SetEmail(user.Id, "test@test.com"));
// factors = await manager.GetValidTwoFactorProviders(user.Id);
// Assert.NotNull(factors);
// Assert.True(factors.Count() == 2);
// UnitTestHelper.IsSuccess(await manager.SetEmail(user.Id, null));
// factors = await manager.GetValidTwoFactorProviders(user.Id);
// Assert.NotNull(factors);
// Assert.True(factors.Count() == 1);
// Assert.Equal("phone", factors[0]);
//}
//[Fact]
//public async Task PhoneFactorFailsAfterSecurityStampChangeTest()
//{
// var manager = CreateManager();
// var factorId = "PhoneCode";
// manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("PhoneCodeTest");
// user.PhoneNumber = "4251234567";
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// UnitTestHelper.IsSuccess(await manager.UpdateSecurityStamp(user.Id));
// Assert.False(await manager.VerifyTwoFactorToken(user.Id, factorId, token));
//}
//[Fact]
//public async Task WrongTokenProviderFailsTest()
//{
// var manager = CreateManager();
// var factorId = "PhoneCode";
// manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider<InMemoryUser>());
// manager.RegisterTwoFactorProvider("EmailCode", new EmailTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("PhoneCodeTest");
// user.PhoneNumber = "4251234567";
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// Assert.False(await manager.VerifyTwoFactorToken(user.Id, "EmailCode", token));
//}
//[Fact]
//public async Task WrongTokenFailsTest()
//{
// var manager = CreateManager();
// var factorId = "PhoneCode";
// manager.RegisterTwoFactorProvider(factorId, new PhoneNumberTokenProvider<InMemoryUser>());
// var user = new InMemoryUser("PhoneCodeTest");
// user.PhoneNumber = "4251234567";
// UnitTestHelper.IsSuccess(await manager.Create(user));
// var stamp = user.SecurityStamp;
// Assert.NotNull(stamp);
// var token = await manager.GenerateTwoFactorToken(user.Id, factorId);
// Assert.NotNull(token);
// Assert.False(await manager.VerifyTwoFactorToken(user.Id, factorId, "abc"));
//}
private static UserManager<InMemoryUser, string> CreateManager()
{
@ -672,5 +1003,16 @@ namespace Microsoft.AspNet.Identity.InMemory.Test
{
return new RoleManager<InMemoryRole>(new InMemoryRoleStore());
}
public class TestMessageService : IIdentityMessageService
{
public IdentityMessage Message { get; set; }
public Task Send(IdentityMessage message)
{
Message = message;
return Task.FromResult(0);
}
}
}
}

1008
test/Microsoft.AspNet.Identity.InMemory.Test/j3c2kdpa.0a5 Normal file
View File

File diff suppressed because it is too large Load Diff

79
test/Microsoft.AspNet.Identity.Test/PasswordValidatorTest.cs Normal file
View File

@ -0,0 +1,79 @@
using System.Collections.Generic;
using System.Security.Claims;
using Moq;
using System;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
namespace Microsoft.AspNet.Identity.Test
{
public class PasswordValidatorTest
{
[Fact]
public async Task ValidateThrowsWithNullTest()
{
// Setup
var validator = new PasswordValidator();
// Act
// Assert
await Assert.ThrowsAsync<ArgumentNullException>(() => validator.Validate(null));
}
[Theory, InlineData(""), InlineData("abc"), InlineData("abcde")]
public async Task FailsIfTooShortTests(string input)
{
const string error = "Passwords must be at least 6 characters.";
var valid = new PasswordValidator {RequiredLength = 6};
UnitTestHelper.IsFailure(await valid.Validate(input), error);
}
[Theory, InlineData("abcdef"), InlineData("aaaaaaaaaaa")]
public async Task SuccessIfLongEnoughTests(string input) {
var valid = new PasswordValidator {RequiredLength = 6};
UnitTestHelper.IsSuccess(await valid.Validate("abcdef"));
UnitTestHelper.IsSuccess(await valid.Validate("abcdeldkajfd"));
}
[Theory, InlineData("a"), InlineData("aaaaaaaaaaa")]
public async Task FailsWithoutRequiredNonAlphanumericTests(string input)
{
var valid = new PasswordValidator { RequireNonLetterOrDigit = true };
UnitTestHelper.IsFailure(await valid.Validate(input), "Passwords must have at least one non letter or digit character.");
}
[Theory, InlineData("@"), InlineData("abcd@e!ld!kajfd"), InlineData("!!!!!!")]
public async Task SucceedsWithRequiredNonAlphanumericTests(string input)
{
var valid = new PasswordValidator { RequireNonLetterOrDigit = true };
UnitTestHelper.IsSuccess(await valid.Validate(input));
}
[Fact]
public async Task UberMixedRequiredTests()
{
const string alphaError = "Passwords must have at least one non letter or digit character.";
const string upperError = "Passwords must have at least one uppercase ('A'-'Z').";
const string lowerError = "Passwords must have at least one lowercase ('a'-'z').";
const string digitError = "Passwords must have at least one digit ('0'-'9').";
const string lengthError = "Passwords must be at least 6 characters.";
var valid = new PasswordValidator
{
RequireNonLetterOrDigit = true,
RequireDigit = true,
RequireLowercase = true,
RequireUppercase = true,
RequiredLength = 6
};
UnitTestHelper.IsFailure(await valid.Validate("abcde"),
string.Join(" ", lengthError, alphaError, digitError, upperError));
UnitTestHelper.IsFailure(await valid.Validate("a@B@cd"), digitError);
UnitTestHelper.IsFailure(await valid.Validate("___"),
string.Join(" ", lengthError, digitError, lowerError, upperError));
UnitTestHelper.IsFailure(await valid.Validate("a_b9de"), upperError);
UnitTestHelper.IsSuccess(await valid.Validate("abcd@e!ld!kaj9Fd"));
}
}
}

27
test/Microsoft.AspNet.Identity.Test/UnitTestHelper.cs Normal file
View File

@ -0,0 +1,27 @@
using System.Linq;
using Xunit;
namespace Microsoft.AspNet.Identity.Test
{
public static class UnitTestHelper
{
public static void IsSuccess(IdentityResult result)
{
Assert.NotNull(result);
Assert.True(result.Succeeded);
}
public static void IsFailure(IdentityResult result)
{
Assert.NotNull(result);
Assert.False(result.Succeeded);
}
public static void IsFailure(IdentityResult result, string error)
{
Assert.NotNull(result);
Assert.False(result.Succeeded);
Assert.Equal(error, result.Errors.First());
}
}
}

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

@ -19,7 +19,7 @@ namespace Microsoft.AspNet.Identity.Test
Assert.NotNull(manager.UserValidator);
}
// TODO: Mock fails in K (this works fine in net45)
//TODO: Mock fails in K (this works fine in net45)
//[Fact]
//public async Task CreateTest()
//{
@ -333,8 +333,6 @@ namespace Microsoft.AspNet.Identity.Test
{
return Task.FromResult(0);
}
}