UserIdentityUserToken> GetIdentityRepository(AdminIdentityDbContext dbContext,
UserManager <UserIdentity> userManager,
RoleManager <UserIdentityRole> roleManager,
IMapper mapper)
{
return(new IdentityRepository <AdminIdentityDbContext, UserIdentity, UserIdentityRole, string,
UserIdentityUserClaim, UserIdentityUserRole, UserIdentityUserLogin, UserIdentityRoleClaim,
UserIdentityUserToken>(dbContext, userManager, roleManager, mapper));
}
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.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 AddUserRoleAsync()
{
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 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.Should().BeEquivalentTo(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();
}
}
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 RemoveRoleClaimAsync()
{
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 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.Should().BeEquivalentTo(newRoleDto);
//Generate random new role claim
var roleClaimDto = IdentityDtoMock <string> .GenerateRandomRoleClaim(0, roleDto.Id);
await identityService.CreateRoleClaimsAsync(roleClaimDto);
//Get new role claim
var roleClaim = await context.RoleClaims.Where(x => x.ClaimType == roleClaimDto.ClaimType && x.ClaimValue == roleClaimDto.ClaimValue).SingleOrDefaultAsync();
roleClaimDto.ClaimId = roleClaim.Id;
var newRoleClaimDto = await identityService.GetRoleClaimAsync(roleDto.Id.ToString(), roleClaimDto.ClaimId);
//Assert new role
roleClaimDto.Should().BeEquivalentTo(newRoleClaimDto, options => options.Excluding(o => o.RoleName));
await identityService.DeleteRoleClaimsAsync(roleClaimDto);
var roleClaimToDelete = await context.RoleClaims.Where(x => x.ClaimType == roleClaimDto.ClaimType && x.ClaimValue == roleClaimDto.ClaimValue).SingleOrDefaultAsync();
//Assert removed role claim
roleClaimToDelete.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();
}
}
RoleClaimsDto <string> > GetIdentityService(AdminIdentityDbContext context)
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
var mapper = GetMapper();
var identityRepository = GetIdentityRepository(context, testUserManager, testRoleManager, mapper);
var localizerIdentityResource = new IdentityServiceResources();
var auditLoggerMock = new Mock <IAuditEventLogger>();
var auditLogger = auditLoggerMock.Object;
var identityService = GetIdentityService(identityRepository, localizerIdentityResource, mapper, auditLogger);
return(identityService);
}
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 UpdateRoleAsync()
{
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 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.Should().BeEquivalentTo(newRoleDto);
//Detached the added item
context.Entry(role).State = EntityState.Detached;
//Generete new role with added item id
var roleDtoForUpdate = IdentityDtoMock <string> .GenerateRandomRole(role.Id);
//Update role
await identityService.UpdateRoleAsync(roleDtoForUpdate);
var updatedRole = await identityService.GetRoleAsync(roleDtoForUpdate.Id.ToString());
//Assert updated role
roleDtoForUpdate.Should().BeEquivalentTo(updatedRole);
}
}
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.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);
}
}
public async Task DeletePersistedGrantsAsync()
{
using (var context = new IdentityServerPersistedGrantDbContext(_dbContextOptions, _operationalStore))
{
using (var identityDbContext = new AdminIdentityDbContext(_identityDbContextOptions))
{
var persistedGrantRepository = GetPersistedGrantRepository(identityDbContext, context);
var localizerMock = new Mock <IPersistedGrantAspNetIdentityServiceResources>();
var localizer = localizerMock.Object;
var auditLoggerMock = new Mock <IAuditEventLogger>();
var auditLogger = auditLoggerMock.Object;
var persistedGrantService = GetPersistedGrantService(persistedGrantRepository, localizer, auditLogger);
const int subjectId = 1;
for (var i = 0; i < 4; i++)
{
//Generate persisted grant
var persistedGrantKey = Guid.NewGuid().ToString();
var persistedGrant = PersistedGrantMock.GenerateRandomPersistedGrant(persistedGrantKey, subjectId.ToString());
//Try add new persisted grant
await context.PersistedGrants.AddAsync(persistedGrant);
}
await context.SaveChangesAsync();
//Try delete persisted grant
await persistedGrantService.DeletePersistedGrantsAsync(subjectId.ToString());
var grant = await persistedGrantRepository.GetPersistedGrantsByUserAsync(subjectId.ToString());
//Assert
grant.TotalCount.Should().Be(0);
}
}
}
public async Task AddRoleAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//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);
}
}
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.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 DeleteRoleAsync()
{
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 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.Should().BeEquivalentTo(newRoleDto);
//Remove role
await identityService.DeleteRoleAsync(newRoleDto);
//Try Get Removed role
var removeRole = await context.Roles.Where(x => x.Id == role.Id)
.SingleOrDefaultAsync();
//Assert removed role
removeRole.Should().BeNull();
}
}
public async Task DeleteUserAsync()
{
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);
//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 AddRoleClaimAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//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);
//Generate random new role claim
var roleClaimDto = IdentityDtoMock <string> .GenerateRandomRoleClaim(0, roleDto.Id);
await identityService.CreateRoleClaimsAsync(roleClaimDto);
//Get new role claim
var roleClaim = await context.RoleClaims.Where(x => x.ClaimType == roleClaimDto.ClaimType && x.ClaimValue == roleClaimDto.ClaimValue).SingleOrDefaultAsync();
roleClaimDto.ClaimId = roleClaim.Id;
var newRoleClaimDto = await identityService.GetRoleClaimAsync(roleDto.Id.ToString(), roleClaimDto.ClaimId);
//Assert new role
roleClaimDto.ShouldBeEquivalentTo(newRoleClaimDto, options => options.Excluding(o => o.RoleName));
}
}
public async Task UpdateRoleAsync()
{
using (var context = new AdminIdentityDbContext(_dbContextOptions))
{
var identityService = GetIdentityService(context);
//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);
//Detached the added item
context.Entry(role).State = EntityState.Detached;
//Generete new role with added item id
var roleDtoForUpdate = IdentityDtoMock <string> .GenerateRandomRole(role.Id);
//Update role
await identityService.UpdateRoleAsync(roleDtoForUpdate);
var updatedRole = await identityService.GetRoleAsync(roleDtoForUpdate.Id.ToString());
//Assert updated role
roleDtoForUpdate.ShouldBeEquivalentTo(updatedRole);
}
}
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);
}
}
public RoleClaimRepository(AdminIdentityDbContext dbContext, IMapper mapper, ILogger <RoleRepository> logger)
: base(dbContext, mapper, logger)
{
}
private IPersistedGrantAspNetIdentityRepository GetPersistedGrantRepository(AdminIdentityDbContext identityDbContext, IdentityServerPersistedGrantDbContext context)
{
var persistedGrantRepository = new PersistedGrantAspNetIdentityRepository <AdminIdentityDbContext, IdentityServerPersistedGrantDbContext, UserIdentity, UserIdentityRole, string, UserIdentityUserClaim, UserIdentityUserRole, UserIdentityUserLogin, UserIdentityRoleClaim, UserIdentityUserToken>(identityDbContext, context);
return(persistedGrantRepository);
}
public UserTokenRepository(AdminIdentityDbContext dbContext, IMapper mapper, ILogger <UserTokenRepository> logger)
: base(dbContext, mapper, logger)
{
}
private UserManager <UserIdentity> GetTestUserManager(AdminIdentityDbContext context)
{
var testUserManager = IdentityMock.TestUserManager(new UserStore <UserIdentity, UserIdentityRole, AdminIdentityDbContext, string, UserIdentityUserClaim, UserIdentityUserRole, UserIdentityUserLogin, UserIdentityUserToken, UserIdentityRoleClaim>(context, new IdentityErrorDescriber()));
return(testUserManager);
}
private RoleManager <UserIdentityRole> GetTestRoleManager(AdminIdentityDbContext context)
{
var testRoleManager = IdentityMock.TestRoleManager(new RoleStore <UserIdentityRole, AdminIdentityDbContext, string, UserIdentityUserRole, UserIdentityRoleClaim>(context, new IdentityErrorDescriber()));
return(testRoleManager);
}
public AdminIdentityRepository(AdminIdentityDbContext context, IMapper mapper, ILogger logger
//, IAuditEventLogger auditEventLogger
) : base(context, mapper, logger)
{
}
