public async void HttpPost_Create_ModelIsValid_ShouldIncludeUserDetails()
{
var model = ValidModel();
var newUser = A.Fake <IUnauthenticatedUser>();
var token = A.Fake <TokenResponse>();
var accessToken = "token";
A.CallTo(() => oauthClientCredential.GetClientCredentialsAsync()).Returns(token);
var userCreationData = new InternalUserCreationData();
A.CallTo(() => newUser.CreateInternalUserAsync(A <InternalUserCreationData> ._, token.AccessToken))
.Invokes((InternalUserCreationData u, string t) =>
{
userCreationData = u;
accessToken = token.AccessToken;
})
.Returns(Task.FromResult(A.Dummy <string>()));
A.CallTo(() => apiClient.User).Returns(newUser);
A.CallTo(() => weeeAuthorization.SignIn(A <string> ._, A <string> ._, A <bool> ._))
.Returns(LoginResult.Success("dshadjk", A.Dummy <ActionResult>()));
await AccountController().Create(model);
Assert.Equal(model.Name, userCreationData.FirstName);
Assert.Equal(model.Surname, userCreationData.Surname);
Assert.Equal(model.Email, userCreationData.Email);
Assert.Equal(model.Password, userCreationData.Password);
}
public async Task <IHttpActionResult> CreateInternalUser(InternalUserCreationData model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
Surname = model.Surname,
};
user.Claims.Add(new IdentityUserClaim
{
ClaimType = ClaimTypes.AuthenticationMethod,
ClaimValue = Claims.CanAccessInternalArea,
UserId = user.Id
});
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
await SendActivationEmail(user.Id, user.Email, model.ActivationBaseUrl);
return(Ok(user.Id));
}
public async Task<IHttpActionResult> CreateInternalUser(InternalUserCreationData model)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
Surname = model.Surname,
};
user.Claims.Add(new IdentityUserClaim
{
ClaimType = ClaimTypes.AuthenticationMethod,
ClaimValue = Claims.CanAccessInternalArea,
UserId = user.Id
});
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return GetErrorResult(result);
}
await SendActivationEmail(user.Id, user.Email, model.ActivationBaseUrl);
return Ok(user.Id);
}
public async Task <string> CreateInternalUserAsync(InternalUserCreationData userCreationData, string accessToken)
{
httpClient.SetBearerToken(accessToken);
var response = await httpClient.PostAsJsonAsync(Controller + "CreateInternalUser", userCreationData);
return(await response.CreateResponseAsync <string>());
}
public async Task <ActionResult> Create(InternalUserCreationViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userCreationData = new InternalUserCreationData
{
Email = model.Email,
FirstName = model.Name,
Surname = model.Surname,
Password = model.Password,
ConfirmPassword = model.ConfirmPassword,
ActivationBaseUrl = externalRouteService.ActivateInternalUserAccountUrl,
};
try
{
using (var client = apiClient())
{
var response = await apiClientCredential().GetClientCredentialsAsync();
var userId = await client.User.CreateInternalUserAsync(userCreationData, response.AccessToken);
var loginResult = await weeeAuthorization.SignIn(model.Email, model.Password, false);
if (loginResult.Successful)
{
await client.SendAsync(loginResult.AccessToken, new AddCompetentAuthorityUser(userId));
return(RedirectToAction("AdminAccountActivationRequired"));
}
ModelState.AddModelError(string.Empty, loginResult.ErrorMessage);
}
}
catch (ApiBadRequestException ex)
{
this.HandleBadRequest(ex);
if (ModelState.IsValid)
{
throw;
}
AddRemoveModelStateErrors();
}
catch (SmtpException)
{
ViewBag.Errors = new[] { "The activation email was not sent, please try again later." };
}
return(View(model));
}
public async Task<ActionResult> Create(InternalUserCreationViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var userCreationData = new InternalUserCreationData
{
Email = model.Email,
FirstName = model.Name,
Surname = model.Surname,
Password = model.Password,
ConfirmPassword = model.ConfirmPassword,
ActivationBaseUrl = externalRouteService.ActivateInternalUserAccountUrl,
};
try
{
using (var client = apiClient())
{
var userId = await client.User.CreateInternalUserAsync(userCreationData);
var loginResult = await weeeAuthorization.SignIn(model.Email, model.Password, false);
if (loginResult.Successful)
{
await client.SendAsync(loginResult.AccessToken, new AddCompetentAuthorityUser(userId));
return RedirectToAction("AdminAccountActivationRequired");
}
ModelState.AddModelError(string.Empty, loginResult.ErrorMessage);
}
}
catch (ApiBadRequestException ex)
{
this.HandleBadRequest(ex);
if (ModelState.IsValid)
{
throw;
}
AddRemoveModelStateErrors();
}
catch (SmtpException)
{
ViewBag.Errors = new[] { "The activation email was not sent, please try again later." };
}
return View(model);
}
public async Task HttpPost_NewUser_IsValid()
{
var userCreationViewModel = GetValidUserCreationViewModel();
var newUser = A.Fake <IUnauthenticatedUser>();
var userCreationData = new InternalUserCreationData();
A.CallTo(() => newUser.CreateInternalUserAsync(A <InternalUserCreationData> ._, A <string> ._))
.Invokes((InternalUserCreationData u) => userCreationData = u)
.Returns(Task.FromResult(A.Dummy <string>()));
A.CallTo(() => weeeClient.User).Returns(newUser);
await NewUserController().UserCreation(userCreationViewModel);
}
public async Task CreateInternalUser_WithValidModel_IssuesCanAccessInternalAreaClaim()
{
// Arrange
ApplicationUser capturedUser = null;
ApplicationUserManager userManager = A.Fake <ApplicationUserManager>();
A.CallTo(() => userManager.CreateAsync(A <ApplicationUser> ._))
.Invokes((ApplicationUser user) => capturedUser = user)
.Returns(IdentityResult.Success);
A.CallTo(() => userManager.CreateAsync(A <ApplicationUser> ._, A <string> ._))
.Invokes((ApplicationUser user, string password) => capturedUser = user)
.Returns(IdentityResult.Success);
IUserContext userContext = A.Fake <IUserContext>();
IWeeeEmailService emailService = A.Fake <IWeeeEmailService>();
IGetAdminUserDataAccess getAdminUserDataAccess = A.Dummy <IGetAdminUserDataAccess>();
UnauthenticatedUserController controller = new UnauthenticatedUserController(
userManager,
userContext,
emailService,
getAdminUserDataAccess);
InternalUserCreationData model = new InternalUserCreationData()
{
FirstName = "John",
Surname = "Smith",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
ActivationBaseUrl = "ActivationBaseUrl"
};
// Act
await controller.CreateInternalUser(model);
// Assert
Assert.NotNull(capturedUser);
int claimCount = capturedUser.Claims.Count(
c => c.ClaimType == ClaimTypes.AuthenticationMethod &&
c.ClaimValue == Claims.CanAccessInternalArea);
Assert.True(claimCount == 1, "A single \"CanAccessInternalArea\" claim was not issued to the user.");
}
public async void HttpPost_Create_ModelIsValid_ShouldIncludeUserDetails()
{
var model = ValidModel();
var newUser = A.Fake<IUnauthenticatedUser>();
var userCreationData = new InternalUserCreationData();
A.CallTo(() => newUser.CreateInternalUserAsync(A<InternalUserCreationData>._))
.Invokes((InternalUserCreationData u) => userCreationData = u)
.Returns(Task.FromResult(A.Dummy<string>()));
A.CallTo(() => apiClient.User).Returns(newUser);
A.CallTo(() => weeeAuthorization.SignIn(A<string>._, A<string>._, A<bool>._))
.Returns(LoginResult.Success("dshadjk", A.Dummy<ActionResult>()));
await AccountController().Create(model);
Assert.Equal(model.Name, userCreationData.FirstName);
Assert.Equal(model.Surname, userCreationData.Surname);
Assert.Equal(model.Email, userCreationData.Email);
Assert.Equal(model.Password, userCreationData.Password);
}
public async Task<string> CreateInternalUserAsync(InternalUserCreationData userCreationData)
{
var response = await httpClient.PostAsJsonAsync(Controller + "CreateInternalUser", userCreationData);
return await response.CreateResponseAsync<string>();
}
