public async Task CreateUserWithExistingLogin()
{
// Initialize the database
await _userManager.CreateAsync(_user);
var databaseSizeBeforeCreate = _userManager.Users.Count();
var managedUserDto = new ManagedUserDto
{
Login = DefaultLogin, // this login should already be used
Password = DefaultPassword,
FirstName = DefaultFirstname,
LastName = DefaultLastname,
Email = "anothermail@localhost",
Activated = true,
ImageUrl = DefaultImageurl,
LangKey = DefaultLangkey,
Roles = new HashSet <string> {
RolesConstants.USER
}
};
// Create the User
var response = await _client.PostAsync("/api/users", TestUtil.ToJsonContent(managedUserDto));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
// Validate the User in the database
var userList = _userManager.Users.ToList();
userList.Count().Should().Be(databaseSizeBeforeCreate);
}
public async Task TestRegisterValid()
{
var client = _factory.CreateClient();
var userManager = _factory.GetRequiredService <UserManager <User> >();
var validUser = new ManagedUserDto
{
Login = "******",
Password = "******",
FirstName = "Alice",
LastName = "Test",
Email = "*****@*****.**",
ImageUrl = "http://placehold.it/50x50",
LangKey = Constants.DefaultLangKey,
Roles = new HashSet <string>
{
RolesConstants.USER
}
};
var user = await userManager.FindByNameAsync(validUser.Login);
user.Should().BeNull();
var response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(validUser));
response.StatusCode.Should().Be(HttpStatusCode.Created);
user = await userManager.FindByNameAsync(validUser.Login);
user.Should().NotBeNull();
}
public async Task CreateUserWithExistingId()
{
var databaseSizeBeforeCreate = _userManager.Users.Count();
var managedUserDto = new ManagedUserDto
{
Id = "id",
Login = DefaultLogin,
Password = DefaultPassword,
FirstName = DefaultFirstname,
LastName = DefaultLastname,
Email = DefaultEmail,
Activated = true,
ImageUrl = DefaultImageurl,
LangKey = DefaultLangkey,
Roles = new HashSet <string> {
RolesConstants.USER
}
};
// An entity with an existing ID cannot be created, so this API call must fail
var response = await _client.PostAsync("/api/users", TestUtil.ToJsonContent(managedUserDto));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
// Validate the User in the database
var userList = _userManager.Users.ToList();
userList.Count().Should().Be(databaseSizeBeforeCreate);
}
public async Task TestRegisterNullPassword()
{
var client = _factory.CreateClient();
var userManager = _factory.GetRequiredService <UserManager <User> >();
var invalidUser = new ManagedUserDto
{
Login = "******",
Password = null, // invalid null password
FirstName = "Bob",
LastName = "Green",
Email = "*****@*****.**",
Activated = true,
ImageUrl = "http://placehold.it/50x50",
LangKey = Constants.DefaultLangKey,
Roles = new HashSet <string>
{
RolesConstants.USER
}
};
var response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(invalidUser));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
var user = await userManager.FindByNameAsync(invalidUser.Login);
user.Should().BeNull();
}
public async Task TestRegisterAdminIsIgnored()
{
var client = _factory.CreateClient();
var userManager = _factory.GetRequiredService <UserManager <User> >();
var validUser = new ManagedUserDto
{
Login = "******",
Password = "******",
FirstName = "Bad",
LastName = "Guy",
Email = "*****@*****.**",
Activated = true,
ImageUrl = "http://placehold.it/50x50",
LangKey = Constants.DefaultLangKey,
Roles = new HashSet <string>
{
RolesConstants.ADMIN
}
};
var response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(validUser));
response.StatusCode.Should().Be(HttpStatusCode.Created);
var user = await userManager.FindByNameAsync(validUser.Login);
user.Should().NotBeNull();
// user.Roles.Count.Should().Be(1);
// user.Roles.Should().Contain(role => role.Name == RolesConstants.USER);
}
public async Task TestRegisterDuplicateLogin()
{
var client = _factory.CreateClient();
var userManager = _factory.GetRequiredService <UserManager <User> >();
// First registration
var firstUser = new ManagedUserDto
{
Login = "******",
Password = "******",
FirstName = "Alice",
LastName = "Something",
Email = "*****@*****.**",
ImageUrl = "http://placehold.it/50x50",
LangKey = Constants.DefaultLangKey,
Roles = new HashSet <string>
{
RolesConstants.ADMIN
}
};
// Duplicate login, different email
var secondUser = new ManagedUserDto
{
Login = firstUser.Login,
Password = firstUser.Password,
FirstName = firstUser.FirstName,
LastName = firstUser.LastName,
Email = "*****@*****.**",
ImageUrl = firstUser.ImageUrl,
LangKey = firstUser.LangKey,
Roles = new HashSet <string>(firstUser.Roles)
//TODO add createdBy etc.
};
// First user
var response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(firstUser));
response.StatusCode.Should().Be(HttpStatusCode.Created);
// Second (non activated) user
response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(secondUser));
response.StatusCode.Should().Be(HttpStatusCode.Created);
var testUser = await userManager.FindByEmailAsync(secondUser.Email);
testUser.Should().NotBeNull();
testUser.Activated = true;
await userManager.UpdateAsync(testUser);
// Second (already activated) user
response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(secondUser));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task <IActionResult> RegisterAccount([FromBody] ManagedUserDto managedUserDto)
{
if (!CheckPasswordLength(managedUserDto.Password))
{
throw new InvalidPasswordException();
}
var user = await _userService.RegisterUser(_userMapper.Map <User>(managedUserDto), managedUserDto.Password);
await _mailService.SendActivationEmail(user);
return(CreatedAtAction(nameof(GetAccount), user));
}
public async Task UpdateUserLogin()
{
// Initialize the database
await _userManager.CreateAsync(_user);
var databaseSizeBeforeUpdate = _userManager.Users.Count();
//Update the user
var updatedUser = await _userManager.FindByIdAsync(_user.Id);
//TODO Add CreatedBy, CreatedDate, ModifiedBy, ModidfieDate
var managedUserDto = new ManagedUserDto
{
Id = updatedUser.Id,
Login = UpdatedLogin,
Password = UpdatedPassword,
FirstName = UpdatedFirstname,
LastName = UpdatedLastname,
Email = UpdatedEmail,
Activated = updatedUser.Activated,
ImageUrl = UpdatedImageurl,
LangKey = UpdatedLangkey,
Roles = new HashSet <string>
{
RolesConstants.USER
}
};
var response = await _client.PutAsync("/api/users", TestUtil.ToJsonContent(managedUserDto));
response.StatusCode.Should().Be(HttpStatusCode.OK);
// Validate the User in the database
var userList = _userManager.Users.ToList();
userList.Count().Should().Be(databaseSizeBeforeUpdate);
// var testUser = userList[userList.Count - 1];
// TODO FIX database refresh to prevent the usage of context/Reload
var testUser = Fixme.ReloadUser(_factory, updatedUser);
testUser.Login.Should().Be(UpdatedLogin);
testUser.FirstName.Should().Be(UpdatedFirstname);
testUser.LastName.Should().Be(UpdatedLastname);
testUser.Email.Should().Be(UpdatedEmail);
testUser.ImageUrl.Should().Be(UpdatedImageurl);
testUser.LangKey.Should().Be(UpdatedLangkey);
}
public async Task UpdateUserExistingLogin()
{
// Initialize the database
await _userManager.CreateAsync(_user);
var anotherUser = new User
{
Login = "******",
PasswordHash = _passwordHasher.HashPassword(null, TestUtil.RandomAlphabetic(60)),
Activated = true,
Email = "jhipster@localhost",
FirstName = "java",
LastName = "hipster",
ImageUrl = "",
LangKey = "en"
};
await _userManager.CreateAsync(anotherUser);
//Update the user
var updatedUser = await _userManager.FindByIdAsync(_user.Id);
//TODO Add CreatedBy, CreatedDate, ModifiedBy, ModidfieDate
var managedUserDto = new ManagedUserDto
{
Id = updatedUser.Id,
Login = "******", //this login should be already used by anotherUser
Password = updatedUser.PasswordHash,
FirstName = updatedUser.FirstName,
LastName = updatedUser.LastName,
Email = updatedUser.Email,
Activated = updatedUser.Activated,
ImageUrl = updatedUser.ImageUrl,
LangKey = updatedUser.LangKey,
Roles = new HashSet <string>
{
RolesConstants.USER
}
};
var response = await _client.PutAsync("/api/users", TestUtil.ToJsonContent(managedUserDto));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task CreateUser()
{
var databaseSizeBeforeCreate = _userManager.Users.Count();
// Create the User
var managedUserDto = new ManagedUserDto
{
Login = DefaultLogin,
Password = DefaultPassword,
FirstName = DefaultFirstname,
LastName = DefaultLastname,
Email = DefaultEmail,
Activated = true,
ImageUrl = DefaultImageurl,
LangKey = DefaultLangkey,
Roles = new HashSet <string>
{
RolesConstants.USER
}
};
var response = await _client.PostAsync("/api/users", TestUtil.ToJsonContent(managedUserDto));
response.StatusCode.Should().Be(HttpStatusCode.Created);
// Validate the User in the database
var userList = _userManager.Users.ToList();
userList.Count().Should().Be(databaseSizeBeforeCreate + 1);
var testUser = userList[userList.Count - 1];
testUser.Login.Should().Be(DefaultLogin);
testUser.FirstName.Should().Be(DefaultFirstname);
testUser.LastName.Should().Be(DefaultLastname);
testUser.Email.Should().Be(DefaultEmail);
testUser.ImageUrl.Should().Be(DefaultImageurl);
testUser.LangKey.Should().Be(DefaultLangkey);
}
public async Task TestRegisterDuplicateEmail()
{
var client = _factory.CreateClient();
var userManager = _factory.GetRequiredService <UserManager <User> >();
// First user
var firstUser = new ManagedUserDto
{
Login = "******",
Password = "******",
FirstName = "Alice",
LastName = "Test",
Email = "*****@*****.**",
ImageUrl = "http://placehold.it/50x50",
LangKey = Constants.DefaultLangKey,
Roles = new HashSet <string>
{
RolesConstants.ADMIN
}
};
// Register first user
var response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(firstUser));
response.StatusCode.Should().Be(HttpStatusCode.Created);
var testUser1 = userManager.FindByNameAsync(firstUser.Login);
testUser1.Should().NotBeNull();
// Duplicate email, different login
var secondUser = new ManagedUserDto
{
Login = "******",
Password = firstUser.Password,
FirstName = firstUser.FirstName,
LastName = firstUser.LastName,
Email = firstUser.Email,
ImageUrl = firstUser.ImageUrl,
LangKey = firstUser.LangKey,
Roles = new HashSet <string>(firstUser.Roles)
};
// Register second (non activated) user
response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(secondUser));
response.StatusCode.Should().Be(HttpStatusCode.Created);
var testUser2 = await userManager.FindByNameAsync(firstUser.Login);
testUser2.Should().BeNull();
var testUser3 = await userManager.FindByNameAsync(secondUser.Login);
testUser3.Should().NotBeNull();
// Duplicate email - with uppercase email address
var userWithUpperCaseEmail = new ManagedUserDto
{
Id = firstUser.Id,
Login = "******",
Password = firstUser.Password,
FirstName = firstUser.FirstName,
LastName = firstUser.LastName,
Email = "*****@*****.**",
ImageUrl = firstUser.ImageUrl,
LangKey = firstUser.LangKey,
Roles = new HashSet <string>(firstUser.Roles)
};
// Register third (not activated) user
response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(userWithUpperCaseEmail));
response.StatusCode.Should().Be(HttpStatusCode.Created);
var testUser4 = await userManager.FindByNameAsync(userWithUpperCaseEmail.Login);
testUser4.Should().NotBeNull();
testUser4.Email.Should().Be(firstUser.Email);
testUser4.Activated = true;
await userManager.UpdateAsync(testUser4);
// Register 4th (already activated) user
response = await client.PostAsync("/api/register", TestUtil.ToJsonContent(secondUser));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
