public async Task OnPostAsync_Incorrect_Registration()
{
//// Arrange
var authenticationServiceMock = new Mock <IAuthenticationService>();
authenticationServiceMock.Setup(x => x.Register(It.IsAny <Patient>())).ReturnsAsync(false);
var localizerMock = new Mock <ICultureLocalizer>();
localizerMock.Setup(x => x.Text(It.IsAny <string>())).Returns(new LocalizedString("name", "test"));
var registerModel = new RegisterModel(localizerMock.Object, authenticationServiceMock.Object)
{
RegistrationForm = new RegistrationForm()
{
Birthday = DateTime.MinValue
}
};
//// Act
await registerModel.OnPostAsync();
//// Assert
Assert.NotNull(registerModel.Msg);
}
public void RegisterUser_FirstUser_LocalRedirect()
{
// Arrange
FakeUserManager fakeUserManager = new FakeUserManager();
fakeUserManager.SetUsers(new List <ApplicationUser>(new ApplicationUser[] {}).AsQueryable());
FakeSignInManager fakeSignInManager = new FakeSignInManager();
RegisterModel registerModel = new RegisterModel(fakeUserManager, fakeSignInManager, new FakeLogger <LoginModel>(), null);
registerModel.PageContext = new PageContext();
registerModel.Input = new RegisterModel.InputModel
{
Email = "*****@*****.**",
Password = "******",
};
// Act
IActionResult result = registerModel.OnPostAsync().Result;
// Assert
Assert.IsType(typeof(LocalRedirectResult), result);
}
public async Task Test_Register_BreachedPassword(string password)
{
// Arrange
// Set up user manager
var mockUserManager = TestHelpers.CreateMockUserManager();
// Set up registration token validator
var mockRegistrationTokenValidator = new Mock <IRegistrationTokenValidator>(MockBehavior.Strict);
mockRegistrationTokenValidator.Setup(v => v.TokenIsValid(It.IsAny <string>())).Returns(true);
// Set up password breach checker
var passwordBreachChecker = TestHelpers.CreatePasswordBreachChecker(password, isBreached: true);
// Set up model
var model = new RegisterModel(
Mock.Of <IHttpContextAccessor>(),
mockUserManager.Object,
Mock.Of <IRegistrationTokenRepository>(),
mockRegistrationTokenValidator.Object,
passwordBreachChecker,
Mock.Of <ILogger <RegisterModel> >(),
Mock.Of <IEmailRepository>())
{
Input = CreateInputModel("token", password),
};
// Act
var result = await model.OnPostAsync();
// Assert
Assert.IsType <PageResult>(result);
}
public async Task OnPostAsync_Correct_Registration()
{
//// Arrange
var authenticationServiceMock = new Mock <IAuthenticationService>();
authenticationServiceMock.Setup(x => x.Register(It.IsAny <Patient>())).ReturnsAsync(true);
var localizerMock = new Mock <ICultureLocalizer>();
localizerMock.Setup(x => x.Text(It.IsAny <string>())).Returns(new LocalizedString("name", "test"));
var registerModel = new RegisterModel(localizerMock.Object, authenticationServiceMock.Object)
{
RegistrationForm = new RegistrationForm()
{
Birthday = DateTime.MinValue
}
};
var httpContext = new DefaultHttpContext();
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var pageContext = new PageContext(actionContext);
registerModel.PageContext = pageContext;
//// Act
await registerModel.OnPostAsync();
//// Assert
Assert.Null(registerModel.Msg);
}
public async Task OnPostWithValidModelAndUserCreatedAndVerificationStartFailsThenInvalidateModel()
{
// Arrange
_userStore.As <IUserPasswordStore <ApplicationUser> >().Setup(x => x.CreateAsync(
It.IsAny <ApplicationUser>(), It.IsAny <CancellationToken>()
)).ReturnsAsync(IdentityResult.Success);
_verificationService.Setup(
x => x.StartVerificationAsync(It.IsAny <string>(), It.IsAny <string>())
).ReturnsAsync(new VerificationResult(new List <string> {
"Error"
}));
var registerModel = new RegisterModel(GetUserManager(), _signInManage.Object, _verificationService.Object, _logger.Object);
registerModel.Input = new RegisterModel.InputModel
{
UserName = "******", Password = "******", FullPhoneNumber = "+1234567890", Channel = "sms"
};
// Act
var result = await registerModel.OnPostAsync("");
// Assert
Assert.False(registerModel.ModelState.IsValid);
Assert.IsType <PageResult>(result);
_verificationService.Verify(x => x.StartVerificationAsync("+1234567890", "sms"), Times.Once);
}
public async Task Test_Register_InvalidToken(string registrationToken)
{
// Arrange
// Set up user manager
var mockUserManager = TestHelpers.CreateMockUserManager();
// Set up registration token validator
var mockRegistrationTokenValidator = new Mock <IRegistrationTokenValidator>(MockBehavior.Strict);
mockRegistrationTokenValidator.Setup(v => v.TokenIsValid(registrationToken)).Returns(false);
// Set up model
var model = new RegisterModel(
Mock.Of <IHttpContextAccessor>(),
mockUserManager.Object,
Mock.Of <IRegistrationTokenRepository>(),
mockRegistrationTokenValidator.Object,
Mock.Of <IPasswordBreachChecker>(),
Mock.Of <ILogger <RegisterModel> >(),
Mock.Of <IEmailRepository>())
{
Input = CreateInputModel(registrationToken, "password")
};
// Act
var result = await model.OnPostAsync();
// Assert
Assert.IsType <PageResult>(result);
}
public async Task OnPostWithValidModelStateAndUserCreationFailsThenReturnsPage()
{
// Arrange
_userStore.As <IUserPasswordStore <ApplicationUser> >().Setup(x => x.CreateAsync(
It.IsAny <ApplicationUser>(), It.IsAny <CancellationToken>()
)).ReturnsAsync(
IdentityResult.Failed(new IdentityError {
Code = "1", Description = "Error"
})
);
var registerModel = new RegisterModel(GetUserManager(), _signInManage.Object, _verificationService.Object, _logger.Object);
registerModel.Input = new RegisterModel.InputModel
{
UserName = "******", Password = "******", FullPhoneNumber = "+1234567890"
};
// Act
var result = await registerModel.OnPostAsync("");
// Assert
Assert.False(registerModel.ModelState.IsValid);
Assert.IsType <PageResult>(result);
}
public async Task OnPostWithInvalidModelStateThenReturnsPage()
{
var registerModel = new RegisterModel(GetUserManager(), _signInManage.Object, _verificationService.Object, _logger.Object);
// Arrange
registerModel.ModelState.AddModelError("key", "Another error");
// Act
var result = await registerModel.OnPostAsync("");
// Assert
Assert.IsType <PageResult>(result);
}
public async Task OnRegister_WhenPassInvalidUser_ModelStateThrowsanError()
{
var user = new PortFreightUser()
{
UserName = "******", Email = "*****@*****.**", PasswordHash = "TestTest1!"
};
var inputModel = new RegisterModel.InputModel
{
Email = user.Email,
Password = user.PasswordHash
};
registerModel.Input = inputModel;
registerModel.ModelState.AddModelError("Sender Id", "Sender Id is required.");
var result = await registerModel.OnPostAsync();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(PageResult));
}
public void RegisterUser_CreateSecondUser_RedirectToUserAlreadyExistsPage()
{
// Arrange
FakeUserManager fakeUserManager = new FakeUserManager();
fakeUserManager.SetUsers(new List <ApplicationUser>(new ApplicationUser[] {
new ApplicationUser
{
UserName = "******",
}
}).AsQueryable());
RegisterModel registerModel = new RegisterModel(fakeUserManager, null, null, null);
registerModel.PageContext = new PageContext();
// Act
IActionResult result = registerModel.OnPostAsync().Result;
// Assert
Assert.IsType(typeof(RedirectToPageResult), result);
}
public async Task User_is_registered_with_valid_form()
{
//Arrange
var userManager = new Mock <FakeUserManager>();
var signInManager = new Mock <FakeSignInManager>();
var logger = new Mock <ILogger <RegisterModel> >();
var emailSender = new Mock <IEmailSender>();
var url = new Mock <IUrlHelper>();
userManager
.Setup(x => x.CreateAsync(It.IsAny <IdentityUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(IdentityResult.Success));
userManager
.Setup(x => x.GenerateEmailConfirmationTokenAsync(It.IsAny <IdentityUser>()))
.Returns(Task.FromResult("THE_CODE"));
var registerPage = new RegisterModel(userManager.Object, signInManager.Object, logger.Object, emailSender.Object)
{
Input = new RegisterModel.InputModel
{
ConfirmPassword = "******",
Email = "*****@*****.**",
Password = "******"
},
Url = url.Object,
PageContext = new Microsoft.AspNetCore.Mvc.RazorPages.PageContext {
}
};
//Act
await registerPage.OnPostAsync("theUrl");
//Assert
userManager.Verify(x => x.CreateAsync(It.IsAny <IdentityUser>(), It.IsAny <string>()));
userManager.Verify(x => x.GenerateEmailConfirmationTokenAsync(It.IsAny <IdentityUser>()));
emailSender.Verify(x => x.SendEmailAsync(It.IsAny <string>(), It.IsAny <string>(), It.Is <string>(y => y == "THE_CODE")));
}
public async Task OnPostWithValidModelAndUserCreatedAndVerificationStartedThenRedirectToVerify()
{
// Arrange
_userStore.As <IUserPasswordStore <ApplicationUser> >().Setup(x => x.CreateAsync(
It.IsAny <ApplicationUser>(), It.IsAny <CancellationToken>()
)).ReturnsAsync(IdentityResult.Success);
_verificationService.Setup(
x => x.StartVerificationAsync(It.IsAny <string>(), It.IsAny <string>())
).ReturnsAsync(new VerificationResult("SID"));
var registerModel = new RegisterModel(GetUserManager(), _signInManage.Object, _verificationService.Object, _logger.Object);
registerModel.Input = new RegisterModel.InputModel
{
UserName = "******", Password = "******", FullPhoneNumber = "+1234567890", Channel = "sms"
};
var context = new Mock <HttpContext>();
context.Setup(x => x.Session).Returns(new Mock <ISession>().Object);
registerModel.PageContext.HttpContext = context.Object;
var urlHelper = new Mock <IUrlHelper>();
urlHelper.Setup(x => x.Content(It.IsAny <string>())).Returns("redirect");
registerModel.Url = urlHelper.Object;
// Act
var result = await registerModel.OnPostAsync("return");
// Assert
Assert.True(registerModel.ModelState.IsValid);
Assert.IsType <LocalRedirectResult>(result);
Assert.Equal("redirect", (result as LocalRedirectResult)?.Url);
urlHelper.Verify(x => x.Content("~/Identity/Account/Verify/?returnUrl=return"), Times.Once);
_verificationService.Verify(x => x.StartVerificationAsync("+1234567890", "sms"), Times.Once);
}
public async Task OnPostAsync_Incorrect_Registration_InvalidDate()
{
//// Arrange
var authenticationServiceMock = new Mock <IAuthenticationService>();
var localizerMock = new Mock <ICultureLocalizer>();
localizerMock.Setup(x => x.Text(It.IsAny <string>())).Returns(new LocalizedString("name", "test"));
var registerModel = new RegisterModel(localizerMock.Object, authenticationServiceMock.Object)
{
RegistrationForm = new RegistrationForm()
{
Birthday = DateTime.UtcNow.AddDays(2)
}
};
//// Act
await registerModel.OnPostAsync();
//// Assert
Assert.False(registerModel.ModelState.IsValid);
}
public async Task <IActionResult> post([FromBody] RegisterModel registerModel)
{
var post = await registerModel.OnPostAsync();
return(post);
}
public async Task Test_Register_Succeeds(string registrationToken, string password)
{
const int IpAddressInt = 0x2414188f;
const string IpAddressString = "143.24.20.36";
const string ConfirmEmailUrl = "[Confirm email URL]";
const string RegistersuccessPageName = "/RegisterSuccess";
// Arrange
// Set up HTTP context accessor
var httpContextAccessor = TestHelpers.CreateHttpContextAccessor(IpAddressInt);
// Set up user manager
var mockUserManager = TestHelpers.CreateMockUserManager();
mockUserManager
.Setup(f => f.CreateAsync(It.IsAny <ApplicationUser>(), password))
.Returns(Task.FromResult(IdentityResult.Success))
.Callback <ApplicationUser, string>((user, p) => user.Id = "[New user Id]");
mockUserManager
.Setup(u => u.GenerateEmailConfirmationTokenAsync(It.IsAny <ApplicationUser>()))
.Returns(Task.FromResult("[Confirm email token]"));
// Set up registration token repository
var mockRegistrationTokenRepository = new Mock <IRegistrationTokenRepository>(MockBehavior.Strict);
mockRegistrationTokenRepository.Setup(r => r.DeleteRegistrationToken(registrationToken));
// Set up registration token validator
var mockRegistrationTokenValidator = new Mock <IRegistrationTokenValidator>(MockBehavior.Strict);
mockRegistrationTokenValidator.Setup(v => v.TokenIsValid(registrationToken)).Returns(true);
// Set up password breach checker
var passwordBreachChecker = TestHelpers.CreatePasswordBreachChecker(password, isBreached: false);
// Set up email repository
var mockEmailRepository = new Mock <IEmailRepository>(MockBehavior.Strict);
mockEmailRepository.Setup(e => e.AddToQueue(It.IsAny <ConfirmEmailAddress>()));
// Set up model
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(
httpContext, new RouteData(), new PageActionDescriptor(), new ModelStateDictionary());
var mockUrlHelper = new Mock <UrlHelper>(actionContext);
mockUrlHelper
.Setup(u => u.RouteUrl(It.IsAny <UrlRouteContext>()))
.Returns(ConfirmEmailUrl);
var model = new RegisterModel(
httpContextAccessor,
mockUserManager.Object,
mockRegistrationTokenRepository.Object,
mockRegistrationTokenValidator.Object,
passwordBreachChecker,
Mock.Of <ILogger <RegisterModel> >(),
mockEmailRepository.Object)
{
PageContext = { HttpContext = httpContext },
Input = CreateInputModel(registrationToken, password),
Url = mockUrlHelper.Object
};
// Act
var result = await model.OnPostAsync();
// Assert
Assert.IsType <RedirectToPageResult>(result);
Assert.Equal(RegistersuccessPageName, ((RedirectToPageResult)result).PageName);
mockRegistrationTokenRepository.Verify(
r => r.DeleteRegistrationToken(registrationToken),
Times.Once);
mockEmailRepository.Verify(
p => p.AddToQueue(
It.Is <ConfirmEmailAddress>(e =>
e.To == EmailAddress &&
e.HtmlBody.Contains(ConfirmEmailUrl, StringComparison.Ordinal) &&
e.HtmlBody.Contains(IpAddressString, StringComparison.OrdinalIgnoreCase))),
Times.Once);
}
