public bool Validate(RegisterRepresentation representation)
{
if (representation == null)
{
return(false);
}
return(Regex.IsMatch(representation.Password, @"(?!.*\s)[0-9a-zA-Z!@#\\$%*()_+^&}{:;?.]*$"));
}
public bool ShouldConfirmSubscription(RegisterRepresentation newRegistration)
{
if (newRegistration.Provider == "OAuth")
{
return(false);
}
return(true);
}
public void RegisterShouldReturnConflictIfCannotRegister()
{
var registerRepresentation = new RegisterRepresentation();
_representationValidatorMock.Setup(m => m.Validate(registerRepresentation)).Returns(true);
_registrationServiceMock.Setup(m => m.UserExists(registerRepresentation.Email, It.IsAny <Func <string, Account> >())).Returns(true);
var result = _controller.Register(registerRepresentation) as ConflictResult;
var response = result.ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.Conflict, response.StatusCode);
}
public void RegisterShouldReturnBadRequestWhenNotMatchingPassword()
{
var registerRepresentation = new RegisterRepresentation();
_representationValidatorMock.Setup(m => m.Validate(registerRepresentation)).Returns(false);
var result = _controller.Register(registerRepresentation) as InvalidModelStateResult;
var response = result.ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
Assert.AreEqual("The password format does not match the policy", result.ModelState["password"].Errors[0].ErrorMessage);
}
public Account Register(RegisterRepresentation newRegistration)
{
newRegistration.Password = _cryptographer.GetPasswordHash(
newRegistration.Password,
_cryptographer.CreateSalt());
var newAccount = _registrationMapper.Map(newRegistration);
if (newAccount.Provider == "OAuth")
{
newAccount.ConfirmEmail(DateTime.Now);
}
return(newAccount);
}
public void RegisterShouldReturnOkIfAccountCreated()
{
var registerRepresentation = new RegisterRepresentation();
var account = new Account("*****@*****.**", "pass", "");
_representationValidatorMock.Setup(m => m.Validate(registerRepresentation)).Returns(true);
_registrationServiceMock.Setup(m => m.UserExists(registerRepresentation.Email, It.IsAny <Func <string, Account> >())).Returns(false);
_registrationServiceMock.Setup(m => m.Register(registerRepresentation)).Returns(account);
var result = _controller.Register(registerRepresentation) as OkResult;
var response = result.ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
_accountRepositoryMock.Verify(m => m.Save(account), Times.Once());
}
public IHttpActionResult Register(RegisterRepresentation registerRepresentation)
{
var confirmationUrl = new Uri(Request.RequestUri, "/confirmation");
if (registerRepresentation == null)
{
ModelState.AddModelError(string.Empty, "The posted body is not valid.");
}
if (!_validator.Validate(registerRepresentation))
{
ModelState.AddModelError("password", "The password format does not match the policy");
}
if (ModelState.IsValid)
{
if (_registrationService.UserExists(registerRepresentation.Email,
email => _accountRepository.FindByEmail(email)))
{
return(Conflict());
}
IHttpActionResult response = Ok(); // Here we shoud have set up a Created but would need and URL for created ressource.
var account = _registrationService.Register(registerRepresentation);
if (_registrationService.ShouldConfirmSubscription(registerRepresentation))
{
var expirationEndDate = DateTime.Now.AddDays(5);
account.SetActivationCode(Guid.NewGuid(), expirationEndDate);
_notifier.SendActivationNotification(account.Email);
response = Created(confirmationUrl, new ConfirmationRepresentation
{
Email = account.Email,
Code = account.ActivationCode,
ExpirationTime = account.ActivationCodeExpirationTime.GetValueOrDefault(expirationEndDate)
});
}
_accountRepository.Save(account);
return(response);
}
return(BadRequest(ModelState));
}
public void RegisterShouldSendActivationNotificationIfSubscribtionMustBeConfirmed()
{
var registerRepresentation = new RegisterRepresentation();
var account = new Account("*****@*****.**", "pass", "");
_representationValidatorMock.Setup(m => m.Validate(registerRepresentation)).Returns(true);
_registrationServiceMock.Setup(m => m.UserExists(registerRepresentation.Email, It.IsAny <Func <string, Account> >())).Returns(false);
_registrationServiceMock.Setup(m => m.Register(registerRepresentation)).Returns(account);
_registrationServiceMock.Setup(m => m.ShouldConfirmSubscription(registerRepresentation)).Returns(true);
var result = _controller.Register(registerRepresentation) as CreatedNegotiatedContentResult <ConfirmationRepresentation>;
var response = result.ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.AreEqual(account.Email, result.Content.Email);
_notifierMock.Verify(m => m.SendActivationNotification(account.Email), Times.Once());
}
public IHttpActionResult Register(RegisterRepresentation registerRepresentation)
{
var confirmationUrl = new Uri(Request.RequestUri, "/confirmation");
if (ModelState.IsValid)
{
if (!Regex.IsMatch(registerRepresentation.Password,
@"(?!.*\s)[0-9a-zA-Z!@#\\$%*()_+^&}{:;?.]*$"))
{
ModelState.AddModelError("password", "The password does not match the policy");
return(BadRequest(ModelState));
}
IHttpActionResult response = Ok(); // Here we shoud have set up a Created but would need and URL for created ressource.
using (var ctx = new RegistrationContext())
{
if (ctx.Accounts.Any(a => a.Email == registerRepresentation.Email))
{
return(Conflict());
}
var cryptographer = new Cryptographer();
string cryptedPassword = cryptographer.GetPasswordHash(
registerRepresentation.Password,
cryptographer.CreateSalt());
var account = new Account
{
Email = registerRepresentation.Email,
Password = cryptedPassword,
Provider = registerRepresentation.Provider
};
account.ConfirmEmail(DateTime.Now);
if (!account.IsEmailConfirmed)
{
var expirationEndDate = DateTime.Now.AddDays(5);
account.SetActivationCode(Guid.NewGuid(), expirationEndDate);
var notifier = new Notifier();
notifier.SendActivationNotification(account.Email);
response = Created(confirmationUrl, new ConfirmationRepresentation
{
Email = account.Email,
Code = account.ActivationCode,
ExpirationTime = account.ActivationCodeExpirationTime.GetValueOrDefault(expirationEndDate)
});
}
ctx.Accounts.Add(account);
ctx.SaveChanges();
return(response);
}
}
return(BadRequest(ModelState));
}
public Account Map(RegisterRepresentation representation)
{
return(new Account(representation.Email, representation.Password, representation.Provider));
}
