/// <summary>
/// Registers a user.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// The response object.
/// </returns>
public async Task <RegisterUserResponse> RegisterUser(RegisterUserRequest request)
{
return(await Orchestrate(async delegate {
var dataModel = assembler.NewUserDataModel(request);
var registerResult = await repository.RegisterUser(dataModel);
return assembler.NewRegisterUserResponse(registerResult, request.RequestReference);
}, request));
}
public void NewRegisterUserResponse_ValidParams_ReturnsResponse()
{
var guid = Guid.NewGuid();
var test = assembler.NewRegisterUserResponse(validDataModel, guid);
Assert.IsNotNull(test);
Assert.IsInstanceOf <RegisterUserResponse>(test);
Assert.IsTrue(test.Success);
Assert.AreEqual(test.RequestReference, guid);
}
public void SetUp()
{
validRegisterUserRequest =
new RegisterUserRequest
{
DateOfBirth = DateTime.Today,
EmailAddress = "TEST",
FirstName = "TEST",
LastName = "TEST",
Password = "******",
Username = "******"
};
validDataModel = new UserDataModel
{
Id = Guid.NewGuid(),
CreationTime = DateTime.Now,
DateOfBirth = DateTime.Today,
EmailAddress = "TEST",
FirstName = "TEST",
Hash = new byte[] { },
Iterations = 1,
LastName = "TEST",
Salt = new byte[] { }
};
validRegisterUserResponse =
new RegisterUserResponse
{
RegisterSuccess = true,
RequestReference = validRegisterUserRequest.RequestReference
};
invalidDataModel = new UserDataModel();
invalidRegisterUserRequest = new RegisterUserRequest();
invalidRegisterUserResponse = new RegisterUserResponse {
Errors = { new ResponseErrorWrapper() }
};
exceptionRegisterUserRequest = new RegisterUserRequest {
DateOfBirth = DateTime.MinValue
};
validValidateUserRequest =
new ValidateUserRequest {
EmailAddress = "TEST", Password = "******", Username = "******"
};
invalidValidateUserRequest = new ValidateUserRequest();
exceptionValidateUserRequest = new ValidateUserRequest {
EmailAddress = "EXC", Password = "******", Username = "******"
};
invalidValidateUserResponse = new ValidateUserResponse {
Errors = { new ResponseErrorWrapper() }
};
validValidateUserResponse = new ValidateUserResponse {
LoginSuccess = true
};
assembler = Substitute.For <IUserAssembler>();
repository = Substitute.For <IUserRepository>();
assembler.NewUserDataModel(validRegisterUserRequest).Returns(validDataModel);
assembler.NewUserDataModel(invalidRegisterUserRequest).Returns(invalidDataModel);
assembler.NewRegisterUserResponse(validDataModel, validRegisterUserRequest.RequestReference)
.Returns(validRegisterUserResponse);
assembler.NewUserDataModel(exceptionRegisterUserRequest).Throws(new Exception("TEST"));
assembler.NewRegisterUserResponse(invalidDataModel, invalidRegisterUserRequest.RequestReference)
.Returns(invalidRegisterUserResponse);
assembler.NewValidateUserResponse(validDataModel, validValidateUserRequest.RequestReference)
.Returns(validValidateUserResponse);
assembler.NewValidateUserResponse(invalidDataModel, invalidValidateUserRequest.RequestReference)
.Returns(invalidValidateUserResponse);
repository.RegisterUser(validDataModel).Returns(validDataModel);
repository.RegisterUser(invalidDataModel).Returns(invalidDataModel);
repository.GetUser(validValidateUserRequest.EmailAddress, validValidateUserRequest.Password)
.Returns(validDataModel);
repository.GetUser(invalidValidateUserRequest.EmailAddress, invalidRegisterUserRequest.Password)
.Returns(invalidDataModel);
repository.GetUser(exceptionValidateUserRequest.EmailAddress, exceptionValidateUserRequest.Password)
.Throws(new Exception("TEST"));
errorHelper = Substitute.For <IErrorHelper>();
errorHelper.Create(Arg.Any <Exception>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
.Returns(new ResponseErrorWrapper());
errorHelper.Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
.Returns(new ResponseErrorWrapper());
orchestrator = new UserOrchestrator(assembler, repository, errorHelper);
}
