protected override async Task When()
{
_request = new ForgotPasswordRequest {
Email = "*****@*****.**"
};
var userManager = _serviceProvider.GetRequiredService <UserManager <SIOUser> >();
var user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = _request.Email,
FirstName = "firstname",
LastName = "lastname",
UserName = _request.Email,
};
await userManager.CreateAsync(user);
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
await userManager.ConfirmEmailAsync(user, token);
user.IsArchived = true;
await userManager.UpdateAsync(user);
_controller.ValidateRequest(_request);
}
protected override async Task When()
{
_request = new LoginRequest {
Email = "*****@*****.**", Password = "******"
};
_controller.ValidateRequest(_request);
var userManager = _serviceProvider.GetRequiredService <UserManager <SIOUser> >();
_user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = _request.Email,
FirstName = "firstname",
LastName = "lastname",
UserName = _request.Email,
};
await userManager.CreateAsync(_user);
var token = await userManager.GenerateEmailConfirmationTokenAsync(_user);
await userManager.ConfirmEmailAsync(_user, token);
await userManager.AddPasswordAsync(_user, "correct_password");
}
public async Task Register_POST_Should_Error_When_User_Is_Not_Verified()
{
var controller = BuildController(out var serviceProvider);
var request = new RegisterRequest
{
Email = "*****@*****.**",
FirstName = "FirstName",
LastName = "LastName"
};
var userManager = serviceProvider.GetRequiredService <UserManager <SIOUser> >();
var user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = request.Email,
FirstName = "firstname",
LastName = "lastname",
UserName = request.Email,
};
await userManager.CreateAsync(user);
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
controller.ValidateRequest(request);
var result = await controller.Register(request);
result.Should().NotBeNull();
result.Should().BeOfType <ViewResult>();
controller.ModelState.IsValid.Should().BeFalse();
}
public async Task Logout_POST_Should_Redirect_To_LoggedOut_When_Authenticated_And_Idp_Is_Not_Null_And_Logout_Id_Is_Null()
{
var controller = BuildController(out var serviceProvider);
var user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = "*****@*****.**",
FirstName = "firstname",
LastName = "lastname",
UserName = "******",
};
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "example name"),
new Claim(ClaimTypes.NameIdentifier, "1"),
new Claim(JwtClaimTypes.IdentityProvider, "asdf"),
new Claim(JwtClaimTypes.Subject, user.Id),
new Claim("custom-claim", "example claim value"),
}, "mock"))
}
};
var userManager = serviceProvider.GetRequiredService <UserManager <SIOUser> >();
await userManager.CreateAsync(user);
var result = await controller.Logout(new LogoutRequest());
result.Should().BeOfType <ViewResult>();
}
public async Task Verify_POST_Should_Error_When_Unable_To_Confirm_User_Email()
{
var controller = BuildController(out var serviceProvider);
var mockUser = new Mock <ClaimsPrincipal>();
mockUser.SetupGet(mu => mu.Identity.IsAuthenticated).Returns(false);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = mockUser.Object
}
};
var request = new VerifyRequest
{
Email = "*****@*****.**",
Password = "******",
RePassword = "******",
Token = Convert.ToBase64String(Encoding.UTF8.GetBytes("invalid_token"))
};
var userManager = serviceProvider.GetRequiredService <UserManager <SIOUser> >();
var user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = request.Email,
FirstName = "firstname",
LastName = "lastname",
UserName = request.Email,
};
await userManager.CreateAsync(user);
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
controller.ValidateRequest(request);
var result = await controller.Verify(request);
result.Should().NotBeNull();
result.Should().BeOfType <ViewResult>();
controller.ModelState.IsValid.Should().BeFalse();
}
public async Task Verify_POST_Should_Redirect_To_Default_App_Url_When_Verify_Succeeds()
{
var controller = BuildController(out var serviceProvider);
var mockUser = new Mock <ClaimsPrincipal>();
mockUser.SetupGet(mu => mu.Identity.IsAuthenticated).Returns(false);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = mockUser.Object
}
};
var request = new VerifyRequest
{
Email = "*****@*****.**",
Password = "******",
RePassword = "******"
};
var userManager = serviceProvider.GetRequiredService <UserManager <SIOUser> >();
var user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = request.Email,
FirstName = "firstname",
LastName = "lastname",
UserName = request.Email,
};
await userManager.CreateAsync(user);
request.Token = Convert.ToBase64String(Encoding.UTF8.GetBytes(await userManager.GenerateEmailConfirmationTokenAsync(user)));
controller.ValidateRequest(request);
var result = await controller.Verify(request);
result.Should().BeOfType <RedirectResult>();
((RedirectResult)result).Url.Should().Be("DefaultAppUrl");
controller.ModelState.IsValid.Should().BeTrue();
}
protected override async Task When()
{
_request = new LoginRequest {
Email = "*****@*****.**", Password = "******", ReturnUrl = "https://localhost/mock"
};
var section = new Mock <IConfigurationSection>();
section.SetupGet(s => s.Value).Returns(_defaultAppUrl);
_configuration.Setup(c => c.GetSection(It.Is <string>((s) => s == "DefaultAppUrl"))).Returns(section.Object);
var mockUrlHelper = new Mock <IUrlHelper>();
mockUrlHelper.Setup(uh => uh.IsLocalUrl(It.IsAny <string>())).Returns(false);
_controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
};
_controller.Url = mockUrlHelper.Object;
var userManager = _serviceProvider.GetRequiredService <UserManager <SIOUser> >();
_user = new SIOUser
{
Id = Guid.NewGuid().ToString(),
Email = _request.Email,
FirstName = "firstname",
LastName = "lastname",
UserName = _request.Email,
};
await userManager.CreateAsync(_user);
var token = await userManager.GenerateEmailConfirmationTokenAsync(_user);
await userManager.ConfirmEmailAsync(_user, token);
await userManager.AddPasswordAsync(_user, _request.Password);
}
public async Task ExecuteAsync(RegisterUserCommand command, CancellationToken cancellationToken = default)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
if (cancellationToken.IsCancellationRequested)
{
_logger.LogInformation($"{nameof(RegisterUserCommandHandler)}.{nameof(ExecuteAsync)} was cancelled before execution");
cancellationToken.ThrowIfCancellationRequested();
}
var user = await _userManager.FindByEmailAsync(command.Email);
if (user != null)
{
if (user.EmailConfirmed)
{
throw new EmailInUseException();
}
else
{
await _userManager.GenerateEmailConfirmationTokenAsync(user);
throw new UserNotVerifiedException();
}
}
user = new SIOUser
{
Id = command.Subject,
Email = command.Email,
FirstName = command.FirstName,
LastName = command.LastName,
UserName = command.Email,
};
var userResult = await _userManager.CreateAsync(user);
if (!userResult.Succeeded)
{
throw new UserCreationException();
}
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
await _userManager.UpdateAsync(user);
var aggregate = _aggregateFactory.FromHistory <User, UserState>(Enumerable.Empty <IEvent>());
if (aggregate == null)
{
throw new ArgumentNullException(nameof(aggregate));
}
aggregate.Register(
subject: user.Id,
email: user.Email,
firstName: user.FirstName,
lastName: user.LastName,
activationToken: token
);
await _aggregateRepository.SaveAsync(aggregate, command, cancellationToken : cancellationToken);
}
