public virtual async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
Guid?gamingGroupInvitation = null;
if (!string.IsNullOrWhiteSpace(model.GamingGroupInvitationId))
{
gamingGroupInvitation = new Guid(model.GamingGroupInvitationId);
}
NewUser newUser = new NewUser
{
EmailAddress = model.EmailAddress.Trim(),
UserName = model.UserName.Trim(),
Password = model.Password,
GamingGroupInvitationId = gamingGroupInvitation
};
RegisterNewUserResult registerNewUserResult = await this.userRegisterer.RegisterUser(newUser);
if (registerNewUserResult.Result.Succeeded)
{
return(RedirectToAction(MVC.GamingGroup.ActionNames.Index, MVC.GamingGroup.Name));
}
this.AddErrors(registerNewUserResult.Result);
}
// If we got this far, something failed, redisplay form
return(View(MVC.Account.Views.Register, model));
}
public async Task Post_ReturnsAnHttp400BadRequestResponseWhenThereIsAnIssueRegistering()
{
var registerNewUserResult = new RegisterNewUserResult
{
Result = IdentityResult.Failed("some error")
};
_autoMocker.Get <IUserRegisterer>().Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything)).Return(Task.FromResult(registerNewUserResult));
var newUserMessage = new NewUserMessage
{
EmailAddress = "*****@*****.**",
UserName = "******",
Password = "******"
};
var actualResponse = await _autoMocker.ClassUnderTest.RegisterNewUser(newUserMessage);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <HttpError>)));
var content = actualResponse.Content as ObjectContent <HttpError>;
var httpError = content.Value as HttpError;
Assert.That(actualResponse.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.That(httpError.Message, Is.EqualTo(registerNewUserResult.Result.Errors.First()));
}
public async Task <RegisterNewUserResult> RegisterUser(NewUser newUser)
{
ApplicationUser newApplicationUser = new ApplicationUser()
{
UserName = newUser.UserName,
Email = newUser.EmailAddress,
EmailConfirmed = true
};
IdentityResult identityResult = await applicationUserManager.CreateAsync(newApplicationUser, newUser.Password);
NewlyRegisteredUser newlyRegisteredUser = new NewlyRegisteredUser
{
UserId = newApplicationUser.Id
};
if (identityResult.Succeeded)
{
newlyRegisteredUser = await this.SignInAndAssociateGamingGroup(newUser, newApplicationUser);
}
RegisterNewUserResult result = new RegisterNewUserResult
{
Result = identityResult,
NewlyRegisteredUser = newlyRegisteredUser
};
return(result);
}
public async Task ItReturnsTheNewlyRegisteredUser()
{
RegisterNewUserResult result = await userRegisterer.RegisterUser(newUser);
Assert.That(result.NewlyRegisteredUser.UserId, Is.EqualTo(applicationUserIdAfterSaving));
Assert.That(result.NewlyRegisteredUser.PlayerId, Is.EqualTo(expectedNewlyRegisteredUser.PlayerId));
Assert.That(result.NewlyRegisteredUser.PlayerName, Is.EqualTo(expectedNewlyRegisteredUser.PlayerName));
Assert.That(result.NewlyRegisteredUser.GamingGroupId, Is.EqualTo(expectedNewlyRegisteredUser.GamingGroupId));
Assert.That(result.NewlyRegisteredUser.GamingGroupName, Is.EqualTo(expectedNewlyRegisteredUser.GamingGroupName));
}
public async Task Post_ReturnsANewlyRegisteredUserMessage()
{
var newUserMessage = new NewUserMessage
{
UniqueDeviceId = "some unique device id"
};
var expectedNewlyRegisteredUserMessage = new NewlyRegisteredUserMessage
{
UserId = "user id",
PlayerId = 2,
PlayerName = "player name",
GamingGroupId = 3,
GamingGroupName = "gaming group name"
};
var registerNewUserResult = new RegisterNewUserResult
{
Result = IdentityResult.Success,
NewlyRegisteredUser = new NewlyRegisteredUser
{
UserId = "user id",
PlayerId = 2,
PlayerName = "player name",
GamingGroupId = 3,
GamingGroupName = "gaming group name"
}
};
_autoMocker.Get <IUserRegisterer>().Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything)).Return(Task.FromResult(registerNewUserResult));
string authenticationTokenString = "some auth token string";
DateTime authTokenExpiration = new DateTime();
var expectedAuthToken = new AuthToken(authenticationTokenString, authTokenExpiration);
_autoMocker.Get <IAuthTokenGenerator>().Expect(mock => mock.GenerateAuthToken(
expectedNewlyRegisteredUserMessage.UserId,
newUserMessage.UniqueDeviceId)).Return(expectedAuthToken);
var actualResponse = await _autoMocker.ClassUnderTest.RegisterNewUser(newUserMessage);
Assert.That(actualResponse.Content, Is.TypeOf(typeof(ObjectContent <NewlyRegisteredUserMessage>)));
var content = actualResponse.Content as ObjectContent <NewlyRegisteredUserMessage>;
var actualNewlyRegisteredUserMessage = content.Value as NewlyRegisteredUserMessage;
Assert.That(actualNewlyRegisteredUserMessage.UserId, Is.EqualTo(expectedNewlyRegisteredUserMessage.UserId));
Assert.That(actualNewlyRegisteredUserMessage.PlayerId, Is.EqualTo(expectedNewlyRegisteredUserMessage.PlayerId));
Assert.That(actualNewlyRegisteredUserMessage.PlayerName, Is.EqualTo(expectedNewlyRegisteredUserMessage.PlayerName));
Assert.That(actualNewlyRegisteredUserMessage.GamingGroupId, Is.EqualTo(expectedNewlyRegisteredUserMessage.GamingGroupId));
Assert.That(actualNewlyRegisteredUserMessage.GamingGroupName, Is.EqualTo(expectedNewlyRegisteredUserMessage.GamingGroupName));
Assert.That(actualNewlyRegisteredUserMessage.AuthenticationToken, Is.EqualTo(expectedAuthToken.AuthenticationTokenString));
Assert.That(actualNewlyRegisteredUserMessage.AuthenticationTokenExpirationDateTime, Is.EqualTo(expectedAuthToken.AuthenticationTokenExpirationDateTime));
}
public async Task ItRedirectsToTheGamingGroupPageIfTheUserIsSuccessfullyRegistered()
{
RegisterNewUserResult registerNewUserResult = new RegisterNewUserResult
{
Result = IdentityResult.Success
};
userRegistererMock.Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything))
.Return(Task.FromResult(registerNewUserResult));
RedirectToRouteResult result = await accountControllerPartialMock.Register(expectedViewModel) as RedirectToRouteResult;
Assert.AreEqual(MVC.GamingGroup.ActionNames.Index, result.RouteValues["action"]);
}
public virtual async Task <HttpResponseMessage> RegisterNewUser(NewUserMessage newUserMessage)
{
NewUser newUser = Mapper.Map <NewUserMessage, NewUser>(newUserMessage);
RegisterNewUserResult registerNewUserResult = await this.userRegisterer.RegisterUser(newUser);
if (registerNewUserResult.Result.Succeeded)
{
string authToken = authTokenGenerator.GenerateAuthToken(registerNewUserResult.NewlyRegisteredUser.UserId);
NewlyRegisteredUserMessage newlyRegisteredUserMessage = Mapper.Map <NewlyRegisteredUser, NewlyRegisteredUserMessage>(registerNewUserResult.NewlyRegisteredUser);
newlyRegisteredUserMessage.AuthenticationToken = authToken;
return(Request.CreateResponse(HttpStatusCode.OK, newlyRegisteredUserMessage));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, registerNewUserResult.Result.Errors.First()));
}
public async Task ItRegistersANewUserIfThereAreNoModelErrors()
{
RegisterNewUserResult registerNewUserResult = new RegisterNewUserResult
{
Result = IdentityResult.Success
};
userRegistererMock.Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything))
.Return(Task.FromResult(registerNewUserResult));
ViewResult result = await accountControllerPartialMock.Register(expectedViewModel) as ViewResult;
userRegistererMock.AssertWasCalled(mock => mock.RegisterUser(Arg <NewUser> .Matches(
user => user.EmailAddress == expectedViewModel.EmailAddress &&
user.UserName == expectedViewModel.UserName &&
user.Password == expectedViewModel.Password &&
user.GamingGroupInvitationId == new Guid(expectedViewModel.GamingGroupInvitationId))));
}
public async Task ItAddsErrorsAndStaysOnThePageIfRegisteringFails()
{
string errorMessage = "some error message";
IdentityResult failureIdentityResult = new IdentityResult(new string[]
{
errorMessage
});
RegisterNewUserResult registerNewUserResult = new RegisterNewUserResult
{
Result = failureIdentityResult
};
userRegistererMock.Expect(mock => mock.RegisterUser(Arg <NewUser> .Is.Anything))
.Return(Task.FromResult(registerNewUserResult));
ViewResult result = await accountControllerPartialMock.Register(expectedViewModel) as ViewResult;
Assert.AreSame(expectedViewModel, result.Model);
Assert.AreEqual(MVC.Account.Views.Register, result.ViewName);
Assert.True(accountControllerPartialMock.ModelState[string.Empty].Errors.Any(error => error.ErrorMessage == errorMessage));
}
public string RegisterNewUser(string mobile, string pinCode)
{
RegisterNewUserResult newUser = new RegisterNewUserResult();
if (registrationTries <= 3)
{
newUser.isLocked = false;
newUser.DBGetStoredPin(mobile, pinCode);
if (newUser.isRegistered)
{
newUser.isRegistered = true;
}
else
{
registrationTries++;
}
}
else
{
newUser.isLocked = true;
}
return(new JavaScriptSerializer().Serialize(newUser));
}
