public async Task UpdateUser()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminIdentityDbContext>();
var identityService = GetIdentityService(serviceProvider);
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get inserted userid
var userId = await dbContext.Users.Where(x => x.UserName == userDto.UserName).Select(x => x.Id).SingleOrDefaultAsync();
var updatedUserDto = IdentityDtoMock <string> .GenerateRandomUser(userId);
var result = await controller.UserProfile(updatedUserDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserProfile");
var updatedUser = await identityService.GetUserAsync(updatedUserDto.Id.ToString());
updatedUserDto.ShouldBeEquivalentTo(updatedUser, opts => opts.Excluding(x => x.Id));
}
public async Task UserChangePassword()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminDbContext>();
var identityService = serviceProvider.GetRequiredService <IIdentityService>();
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock.GenerateRandomUser(0);
await identityService.CreateUserAsync(userDto);
var userId = await dbContext.Users.Where(x => x.UserName == userDto.UserName).Select(x => x.Id).SingleOrDefaultAsync();
var changePassword = IdentityDtoMock.GenerateRandomUserChangePassword(userId, "IdentityServer4!");
var result = await controller.UserChangePassword(changePassword);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserProfile");
var user = await dbContext.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
user.PasswordHash.Should().NotBeNull();
}
public async Task AddUser()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminDbContext>();
var identityService = serviceProvider.GetRequiredService <IIdentityService>();
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock.GenerateRandomUser(0);
var result = await controller.UserProfile(userDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("Users");
var user = await dbContext.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var addedUser = await identityService.GetUserAsync(userDto);
userDto.ShouldBeEquivalentTo(addedUser, opts => opts.Excluding(x => x.Id));
}
public async Task AddUserClaim()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminIdentityDbContext>();
var identityService = GetIdentityService(serviceProvider);
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
var user = await dbContext.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var userClaimsDto = IdentityDtoMock <string> .GenerateRandomUserClaim(0, user.Id);
var result = await controller.UserClaims(userClaimsDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserClaims");
var userClaim = await dbContext.UserClaims.Where(x => x.ClaimValue == userClaimsDto.ClaimValue).SingleOrDefaultAsync();
var addedUserClaim = await identityService.GetUserClaimAsync(user.Id.ToString(), userClaim.Id);
userClaimsDto.ShouldBeEquivalentTo(addedUserClaim, opts => opts.Excluding(x => x.ClaimId));
}
public async Task AddUserAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);
var localizerIdentityResource = new IdentityServiceResources();
IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);
//Generate random new user
var userDto = IdentityDtoMock.GenerateRandomUser(Guid.NewGuid());
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto);
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
}
}
public async Task UserProvidersDelete()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminDbContext>();
var identityService = serviceProvider.GetRequiredService <IIdentityService>();
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock.GenerateRandomUser(Guid.Empty);
await identityService.CreateUserAsync(userDto);
var userId = await dbContext.Users.Where(x => x.UserName == userDto.UserName).Select(x => x.Id).SingleOrDefaultAsync();
var randomProviderKey = Guid.NewGuid().ToString();
var randomProviderLogin = Guid.NewGuid().ToString();
var provider = IdentityMock.GenerateRandomUserProviders(randomProviderKey, randomProviderLogin, userId);
await dbContext.UserLogins.AddAsync(provider);
await dbContext.SaveChangesAsync();
var providersDto = IdentityDtoMock.GenerateRandomUserProviders(randomProviderKey, randomProviderLogin, userId);
var result = await controller.UserProvidersDelete(providersDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserProviders");
var userProvider = await dbContext.UserLogins.Where(x => x.ProviderKey == randomProviderKey).SingleOrDefaultAsync();
userProvider.Should().BeNull();
}
public async Task AddUser()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <CustomDbContext>();
var identityService = GetIdentityService(serviceProvider);
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock <string> .GenerateRandomUser("1");
var personDto = CustomIdentityDtoMock <long, UserDto <string>, string> .GenerateRandomPerson(1);
personDto.UserId = userDto.Id;
personDto.User = userDto;
var result = await controller.Post(personDto);
// Assert
//var viewResult = Assert.IsType<RedirectToActionResult>(result);
//result.sta.Should().Be("OK");
var user = await dbContext.Pepole.Where(x => x.LastName == personDto.LastName).SingleOrDefaultAsync();
personDto.Id = user.Id;
var addedUser = await identityService.GetPersonAsync(personDto.Id);
userDto.ShouldBeEquivalentTo(addedUser, opts => opts.Excluding(x => x.Id));
}
public async Task DeleteUserRoleAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);
var localizerIdentityResource = new IdentityServiceResources();
IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);
//Generate random new user
var userDto = IdentityDtoMock.GenerateRandomUser(Guid.NewGuid());
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto);
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Generate random new role
var roleDto = IdentityDtoMock.GenerateRandomRole(Guid.NewGuid());
await identityService.CreateRoleAsync(roleDto);
//Get new role
var role = await context.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();
roleDto.Id = role.Id;
var newRoleDto = await identityService.GetRoleAsync(roleDto);
//Assert new role
roleDto.ShouldBeEquivalentTo(newRoleDto);
var userRoleDto = IdentityDtoMock.GenerateRandomUserRole(roleDto.Id.Value, userDto.Id.Value);
await identityService.CreateUserRoleAsync(userRoleDto);
//Get new role
var userRole = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRole.Should().NotBeNull();
await identityService.DeleteUserRoleAsync(userRoleDto);
//Get deleted role
var userRoleDeleted = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRoleDeleted.Should().BeNull();
}
}
public async Task DeleteUserClaim()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminDbContext>();
var identityService = serviceProvider.GetRequiredService <IIdentityService>();
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock.GenerateRandomUser(0);
await identityService.CreateUserAsync(userDto);
var user = await dbContext.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var userClaimsDto = IdentityDtoMock.GenerateRandomUserClaim(0, user.Id);
await identityService.CreateUserClaimsAsync(userClaimsDto);
var newUserClaim = await dbContext.UserClaims.Where(x => x.ClaimValue == userClaimsDto.ClaimValue).SingleOrDefaultAsync();
userClaimsDto.ClaimId = newUserClaim.Id;
var result = await controller.UserClaimsDelete(userClaimsDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserClaims");
var userClaim = await dbContext.UserClaims.Where(x => x.ClaimValue == userClaimsDto.ClaimValue).SingleOrDefaultAsync();
userClaim.Should().BeNull();
}
public async Task AddUserAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
}
}
public async Task DeleteUserAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Remove user
await identityService.DeleteUserAsync(newUserDto.Id.ToString(), newUserDto);
//Try Get Removed user
var removeUser = await context.Users.Where(x => x.Id == user.Id)
.SingleOrDefaultAsync();
//Assert removed user
removeUser.Should().BeNull();
}
}
public async Task DeleteUser()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminIdentityDbContext>();
var identityService = GetIdentityService(serviceProvider);
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
var userId = await dbContext.Users.Where(x => x.UserName == userDto.UserName).Select(x => x.Id).SingleOrDefaultAsync();
userDto.Id = userId;
var result = await controller.UserDelete(userDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("Users");
var user = await dbContext.Users.Where(x => x.Id == userDto.Id).SingleOrDefaultAsync();
user.Should().BeNull();
}
public async Task GetUser()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminDbContext>();
var identityService = serviceProvider.GetRequiredService <IIdentityService>();
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock.GenerateRandomUser(0);
//Add user
await identityService.CreateUserAsync(userDto);
//Get inserted userid
var userId = await dbContext.Users.Where(x => x.UserName == userDto.UserName).Select(x => x.Id).SingleOrDefaultAsync();
//Try call controller action
var result = await controller.UserProfile(userId);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
viewResult.ViewName.Should().Be("UserProfile");
viewResult.ViewData.Should().NotBeNull();
var viewModel = Assert.IsType <UserDto>(viewResult.ViewData.Model);
userDto.Id = userId;
var addedUser = await identityService.GetUserAsync(userDto);
viewModel.ShouldBeEquivalentTo(addedUser);
}
public async Task DeleteUserRoleAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Generate random new role
var roleDto = IdentityDtoMock <string> .GenerateRandomRole();
await identityService.CreateRoleAsync(roleDto);
//Get new role
var role = await context.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();
roleDto.Id = role.Id;
var newRoleDto = await identityService.GetRoleAsync(roleDto.Id.ToString());
//Assert new role
roleDto.ShouldBeEquivalentTo(newRoleDto);
var userRoleDto = IdentityDtoMock <string> .GenerateRandomUserRole <RoleDto <string> >(roleDto.Id, userDto.Id);
await identityService.CreateUserRoleAsync(userRoleDto);
//Get new role
var userRole = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRole.Should().NotBeNull();
await identityService.DeleteUserRoleAsync(userRoleDto);
//Get deleted role
var userRoleDeleted = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRoleDeleted.Should().BeNull();
}
}
public async Task AddUserRole()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminDbContext>();
var identityService = serviceProvider.GetRequiredService <IIdentityService>();
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock.GenerateRandomUser(Guid.NewGuid());
await identityService.CreateUserAsync(userDto);
var roleDto = IdentityDtoMock.GenerateRandomRole(Guid.NewGuid());
await identityService.CreateRoleAsync(roleDto);
var user = await dbContext.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var role = await dbContext.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();
roleDto.Id = role.Id;
var userRoleDto = IdentityDtoMock.GenerateRandomUserRole(roleDto.Id, user.Id);
var result = await controller.UserRoles(userRoleDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserRoles");
var userRole = await dbContext.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRoleDto.Should().BeEquivalentTo(userRole);
}
public async Task DeleteUserRoleAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.Email == userDto.Email).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Generate random new role
var roleDto = IdentityDtoMock <string> .GenerateRandomRole();
await identityService.CreateRoleAsync(roleDto);
//Get new role
var role = await context.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();
roleDto.Id = role.Id;
var newRoleDto = await identityService.GetRoleAsync(roleDto.Id.ToString());
//Assert new role
roleDto.ShouldBeEquivalentTo(newRoleDto);
var userRoleDto = IdentityDtoMock <string> .GenerateRandomUserRole <RoleDto <string> >(roleDto.Id, userDto.Id);
await identityService.CreateUserRoleAsync(userRoleDto);
//Get new role
var userRole = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRole.Should().NotBeNull();
await identityService.DeleteUserRoleAsync(userRoleDto);
//Get deleted role
var userRoleDeleted = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRoleDeleted.Should().BeNull();
}
}
public async Task DeleteUserProviderAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.Should().BeEquivalentTo(newUserDto);
var userProvider = IdentityMock.GenerateRandomUserProviders(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
newUserDto.Id);
//Add new user login
await context.UserLogins.AddAsync(userProvider);
await context.SaveChangesAsync();
//Get added user provider
var addedUserProvider = await context.UserLogins.Where(x => x.ProviderKey == userProvider.ProviderKey && x.LoginProvider == userProvider.LoginProvider).SingleOrDefaultAsync();
addedUserProvider.Should().NotBeNull();
var userProviderDto = IdentityDtoMock <string> .GenerateRandomUserProviders(userProvider.ProviderKey, userProvider.LoginProvider,
userProvider.UserId);
await identityService.DeleteUserProvidersAsync(userProviderDto);
//Get deleted user provider
var deletedUserProvider = await context.UserLogins.Where(x => x.ProviderKey == userProvider.ProviderKey && x.LoginProvider == userProvider.LoginProvider).SingleOrDefaultAsync();
deletedUserProvider.Should().BeNull();
}
}
public async Task DeleteUserClaimAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.Should().BeEquivalentTo(newUserDto);
//Generate random new user claim
var userClaimDto = IdentityDtoMock <string> .GenerateRandomUserClaim(0, userDto.Id);
await identityService.CreateUserClaimsAsync(userClaimDto);
//Get new user claim
var claim = await context.UserClaims.Where(x => x.ClaimType == userClaimDto.ClaimType && x.ClaimValue == userClaimDto.ClaimValue).SingleOrDefaultAsync();
userClaimDto.ClaimId = claim.Id;
var newUserClaim = await identityService.GetUserClaimAsync(userDto.Id.ToString(), claim.Id);
//Assert new user claim
userClaimDto.Should().BeEquivalentTo(newUserClaim);
await identityService.DeleteUserClaimsAsync(userClaimDto);
//Get deleted user claim
var deletedClaim = await context.UserClaims.Where(x => x.ClaimType == userClaimDto.ClaimType && x.ClaimValue == userClaimDto.ClaimValue).SingleOrDefaultAsync();
deletedClaim.Should().BeNull();
}
}
public async Task DeleteUser()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminIdentityDbContext>();
var identityService = GetIdentityService(serviceProvider);
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
var userId = await dbContext.Users.Where(x => x.UserName == userDto.UserName).Select(x => x.Id).SingleOrDefaultAsync();
userDto.Id = userId;
// A user cannot delete own account
var subjectClaim = new Claim(IdentityModel.JwtClaimTypes.Subject, userDto.Id);
ProvideControllerContextWithClaimsPrincipal(controller, subjectClaim);
var result = await controller.UserDelete(userDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserDelete", "Users cannot delete their own account");
var user = await dbContext.Users.Where(x => x.Id == userDto.Id).SingleOrDefaultAsync();
user.Should().NotBeNull();
subjectClaim = new Claim(IdentityModel.JwtClaimTypes.Subject, "1");
ProvideControllerContextWithClaimsPrincipal(controller, subjectClaim);
result = await controller.UserDelete(userDto);
// Assert
viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("Users");
user = await dbContext.Users.Where(x => x.Id == userDto.Id).SingleOrDefaultAsync();
user.Should().BeNull();
}
public async Task DeleteUserProviderAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.Email == userDto.Email).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
var userProvider = IdentityMock.GenerateRandomUserProviders(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
newUserDto.Id);
//Add new user login
await context.UserLogins.AddAsync(userProvider);
await context.SaveChangesAsync();
//Get added user provider
var addedUserProvider = await context.UserLogins.Where(x => x.ProviderKey == userProvider.ProviderKey && x.LoginProvider == userProvider.LoginProvider).SingleOrDefaultAsync();
addedUserProvider.Should().NotBeNull();
var userProviderDto = IdentityDtoMock <string> .GenerateRandomUserProviders(userProvider.ProviderKey, userProvider.LoginProvider,
userProvider.UserId);
await identityService.DeleteUserProvidersAsync(userProviderDto);
//Get deleted user provider
var deletedUserProvider = await context.UserLogins.Where(x => x.ProviderKey == userProvider.ProviderKey && x.LoginProvider == userProvider.LoginProvider).SingleOrDefaultAsync();
deletedUserProvider.Should().BeNull();
}
}
public async Task DeleteUserClaimAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.Email == userDto.Email).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Generate random new user claim
var userClaimDto = IdentityDtoMock <string> .GenerateRandomUserClaim(0, userDto.Id);
await identityService.CreateUserClaimsAsync(userClaimDto);
//Get new user claim
var claim = await context.UserClaims.Where(x => x.ClaimType == userClaimDto.ClaimType && x.ClaimValue == userClaimDto.ClaimValue).SingleOrDefaultAsync();
userClaimDto.ClaimId = claim.Id;
var newUserClaim = await identityService.GetUserClaimAsync(userDto.Id.ToString(), claim.Id);
//Assert new user claim
userClaimDto.ShouldBeEquivalentTo(newUserClaim);
await identityService.DeleteUserClaimsAsync(userClaimDto);
//Get deleted user claim
var deletedClaim = await context.UserClaims.Where(x => x.ClaimType == userClaimDto.ClaimType && x.ClaimValue == userClaimDto.ClaimValue).SingleOrDefaultAsync();
deletedClaim.Should().BeNull();
}
}
public async Task AddUserClaimAsync()
{
using (var context = new AdminDbContext(_dbContextOptions))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);
var localizerIdentityResource = new IdentityServiceResources();
IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);
//Generate random new user
var userDto = IdentityDtoMock.GenerateRandomUser(0);
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto);
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Generate random new user claim
var userClaimDto = IdentityDtoMock.GenerateRandomUserClaim(0, userDto.Id);
await identityService.CreateUserClaimsAsync(userClaimDto);
//Get new user claim
var claim = await context.UserClaims.Where(x => x.ClaimType == userClaimDto.ClaimType && x.ClaimValue == userClaimDto.ClaimValue).SingleOrDefaultAsync();
userClaimDto.ClaimId = claim.Id;
var newUserClaim = await identityService.GetUserClaimAsync(userDto.Id, claim.Id);
//Assert new user claim
userClaimDto.ShouldBeEquivalentTo(newUserClaim);
}
}
public async Task UpdateUserAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.Should().BeEquivalentTo(newUserDto);
//Detached the added item
context.Entry(user).State = EntityState.Detached;
//Generete new user with added item id
var userDtoForUpdate = IdentityDtoMock <string> .GenerateRandomUser(user.Id);
//Update user
await identityService.UpdateUserAsync(userDtoForUpdate);
var updatedUser = await identityService.GetUserAsync(userDtoForUpdate.Id.ToString());
//Assert updated user
userDtoForUpdate.Should().BeEquivalentTo(updatedUser);
}
}
public async Task AddUserRole()
{
//Get Services
var serviceProvider = GetServices();
var dbContext = serviceProvider.GetRequiredService <AdminIdentityDbContext>();
var identityService = GetIdentityService(serviceProvider);
// Get controller
var controller = PrepareIdentityController(serviceProvider);
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
var roleDto = IdentityDtoMock <string> .GenerateRandomRole();
await identityService.CreateRoleAsync(roleDto);
var user = await dbContext.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var role = await dbContext.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();
roleDto.Id = role.Id;
var userRoleDto = IdentityDtoMock <string> .GenerateRandomUserRole <RoleDto <string> >(roleDto.Id, user.Id);
var result = await controller.UserRoles(userRoleDto);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
viewResult.ActionName.Should().Be("UserRoles");
var userRole = await dbContext.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();
userRoleDto.ShouldBeEquivalentTo(userRole, opts => opts.Excluding(x => x.Roles)
.Excluding(x => x.RolesList)
.Excluding(x => x.PageSize)
.Excluding(x => x.TotalCount)
.Excluding(x => x.UserName));
}
public async Task AddUserAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.Email == userDto.Email).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
}
}
public async Task DeleteUserAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper);
//Generate random new user
var userDto = IdentityDtoMock <int> .GenerateRandomUser(0);
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Remove user
await identityService.DeleteUserAsync(newUserDto.Id.ToString(), newUserDto);
//Try Get Removed user
var removeUser = await context.Users.Where(x => x.Id == user.Id)
.SingleOrDefaultAsync();
//Assert removed user
removeUser.Should().BeNull();
}
}
public async Task UpdateUserAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//Generate random new user
var userDto = IdentityDtoMock <string> .GenerateRandomUser();
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.Email == userDto.Email).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto.Id.ToString());
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Detached the added item
context.Entry(user).State = EntityState.Detached;
//Generete new user with added item id
var userDtoForUpdate = IdentityDtoMock <string> .GenerateRandomUser(user.Id);
//Update user
await identityService.UpdateUserAsync(userDtoForUpdate);
var updatedUser = await identityService.GetUserAsync(userDtoForUpdate.Id.ToString());
//Assert updated user
userDtoForUpdate.ShouldBeEquivalentTo(updatedUser);
}
}
