public void SecurityServiceManager_GetRoleByName_InvalidData_ErrorThrown(String roleName)
{
TestScenario testScenario = TestScenario.CreateRoleInvalidData;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
Should.Throw <ArgumentNullException>(async() => { await securityServiceManager.GetRoleByName(roleName, CancellationToken.None); });
}
public void SecurityServiceManager_RegisterUser_InvalidRequest_ErrorThrown(Boolean nullRequest,
String givenName,
String familyName,
String emailAddress,
Boolean nullClaims,
Boolean nullRoles,
Type exceptionType)
{
TestScenario testScenario = TestScenario.RegisterUserInvalidData;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
RegisterUserRequest request = null;
if (!nullRequest)
{
request = new RegisterUserRequest
{
Claims = nullClaims ? null : SecurityServiceManagerTestData.Claims,
GivenName = givenName,
FamilyName = familyName,
EmailAddress = emailAddress,
Password = SecurityServiceManagerTestData.Password,
PhoneNumber = SecurityServiceManagerTestData.PhoneNumber,
Roles = nullRoles ? null : SecurityServiceManagerTestData.Roles
};
}
Should.Throw(async() => { await securityServiceManager.RegisterUser(request, CancellationToken.None); }, exceptionType);
}
private SecurityServiceManager SetupSecurityServiceManager(ConfigurationDbContext configurationDbContext = null)
{
this.SetupServiceProvider();
this.SetupErrorDescriber();
IdentityOptions identityOptions = new IdentityOptions();
identityOptions.Tokens.ProviderMap.Add("Default",
new TokenProviderDescriptor(typeof(IUserTwoFactorTokenProvider <IdentityUser>)));
Mock <IOptions <IdentityOptions> > options = new Mock <IOptions <IdentityOptions> >();
options.Setup(o => o.Value).Returns(identityOptions);
UserManager <IdentityUser> userManager =
new UserManager <IdentityUser>(this.UserStore.Object, options.Object, this.PasswordHasher.Object,
this.UserValidators, this.PasswordValidators,
null, this.ErrorDescriber.Object, this.ServiceProvider.Object, new NullLogger <UserManager <IdentityUser> >());
RoleManager <IdentityRole> roleManager =
new RoleManager <IdentityRole>(this.RoleStore.Object, null, null, null, null);
if (configurationDbContext != null)
{
this.GetConfigurationDbContext(Guid.NewGuid().ToString());
}
SignInManager <IdentityUser> signInManager = new SignInManager <IdentityUser>(userManager, this.ContextAccessor.Object, this.ClaimsFactory.Object, null, null, null, null);
SecurityServiceManager securityServiceManager =
new SecurityServiceManager(this.PasswordHasher.Object, userManager, roleManager, signInManager, configurationDbContext);
return(securityServiceManager);
}
public async Task SecurityServiceManager_CreateRole_DuplicateRole_ErrorThrown()
{
TestScenario testScenario = TestScenario.CreateRoleDuplicateRoleName;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
CreateRoleRequest request = SecurityServiceManagerTestData.GetCreateRoleRequest;
Should.Throw <IdentityResultException>(async() => { await securityServiceManager.CreateRole(request, CancellationToken.None); });
}
public void SecurityServiceManager_RegisterUser_Failed_ErrorThrown(TestScenario testScenario,
Type exceptionType)
{
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
RegisterUserRequest request = SecurityServiceManagerTestData.GetRegisterUserRequest;
Should.Throw(async() => { await securityServiceManager.RegisterUser(request, CancellationToken.None); }, exceptionType);
}
public async Task SecurityServiceManager_GetRoleByName_RoleNotFound_ErrorThrown()
{
TestScenario testScenario = TestScenario.GetRoleRoleNotFound;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
Should.Throw <NotFoundException>(async() =>
{
await securityServiceManager.GetRoleByName("testrole", CancellationToken.None);
});
}
public async Task SecurityServiceManager_GetUserByUserId_InvalidData_ErrorThrown()
{
TestScenario testScenario = TestScenario.GetUserByUserIdInvalidId;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
Should.Throw <ArgumentNullException>(async() =>
{
await securityServiceManager.GetUserByUserId(Guid.Empty, CancellationToken.None);
});
}
public async Task SecurityServiceManager_GetUserByUserName_InvalidData_ErrorThrown(String userName)
{
TestScenario testScenario = TestScenario.GetUserByUserNameInvalidUserName;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
Should.Throw <ArgumentNullException>(async() =>
{
await securityServiceManager.GetUserByUserName(userName, CancellationToken.None);
});
}
public async Task SecurityServiceManager_GetUserByUserName_UserNotFound_ErrorThrown()
{
TestScenario testScenario = TestScenario.GetUserByUserNameNotFound;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
Should.Throw <NotFoundException>(async() =>
{
await securityServiceManager.GetUserByUserName(SecurityServiceManagerTestData.UserName, CancellationToken.None);
});
}
public void SecurityServiceManager_CreateRole_InvalidData_ErrorThrown(String roleName)
{
TestScenario testScenario = TestScenario.CreateRoleInvalidData;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
CreateRoleRequest request = SecurityServiceManagerTestData.GetCreateRoleRequest;
request.RoleName = roleName;
Should.Throw <ArgumentNullException>(async() => { await securityServiceManager.CreateRole(request, CancellationToken.None); });
}
private SecurityServiceManager SetupSecurityServiceManager(TestScenario testScenario)
{
this.SetupPasswordHasher(testScenario);
this.SetupUserStore(testScenario);
this.SetupQueryableUserStore(testScenario);
this.SetupUserRoleStore(testScenario);
this.SetupUserClaimStore(testScenario);
this.SetupUserPasswordStore(testScenario);
this.SetupUserSecurityStampStore(testScenario);
this.SetupUserEmailStore(testScenario);
this.SetupPasswordValidatiors(testScenario);
this.SetupUserValidators(testScenario);
this.SetupServiceProvider(testScenario);
this.SetupErrorDescriber();
this.SetupRoleStore(testScenario);
IdentityOptions identityOptions = new IdentityOptions();
identityOptions.Tokens.ProviderMap.Add("Default",
new TokenProviderDescriptor(typeof(IUserTwoFactorTokenProvider <IdentityUser>)));
Mock <IOptions <IdentityOptions> > options = new Mock <IOptions <IdentityOptions> >();
options.Setup(o => o.Value).Returns(identityOptions);
UserManager <IdentityUser> userManager =
new UserManager <IdentityUser>(this.UserStore.Object, options.Object, this.PasswordHasher.Object,
this.UserValidators, this.PasswordValidators,
null, this.ErrorDescriber.Object, this.ServiceProvider.Object, new NullLogger <UserManager <IdentityUser> >());
RoleManager <IdentityRole> roleManager =
new RoleManager <IdentityRole>(this.RoleStore.Object, null, null, null, null);
Mock <Func <IConfigurationDbContext> > configurationDbContextResolver =
new Mock <Func <IConfigurationDbContext> >();
SignInManager <IdentityUser> signInManager = new SignInManager <IdentityUser>(userManager, this.ContextAccessor.Object, this.ClaimsFactory.Object, null, null, null);
//Mock<IOptions<ServiceOptions>> serviceOptions = new Mock<IOptions<ServiceOptions>>();
//serviceOptions.Setup(so => so.Value).Returns(new ServiceOptions
//{
// PublicOrigin = "http://localhost"
//});
Mock <IMessagingService> messagingService = new Mock <IMessagingService>();
SecurityServiceManager securityServiceManager =
new SecurityServiceManager(this.PasswordHasher.Object, userManager, messagingService.Object, roleManager, signInManager);
return(securityServiceManager);
}
public async Task SecurityServiceManager_CreateRole_RoleIsCreated()
{
TestScenario testScenario = TestScenario.CreateRoleSuccess;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
CreateRoleRequest request = SecurityServiceManagerTestData.GetCreateRoleRequest;
var response = await securityServiceManager.CreateRole(request, CancellationToken.None);
response.ShouldNotBeNull();
response.RoleId.ShouldNotBe(Guid.Empty);
}
public async Task SecurityServiceManager_GetRoleByName_RoleDataReturned()
{
TestScenario testScenario = TestScenario.GetRoleSuccess;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
var response = await securityServiceManager.GetRoleByName("testrole", CancellationToken.None);
response.ShouldNotBeNull();
response.Id.ShouldNotBe(Guid.Empty);
response.Name.ShouldBe("testrole");
response.NormalizedName.ShouldBe("testrole".ToUpper());
}
public async Task SecurityServiceManager_GetUserByUserName_UserDataReturned()
{
TestScenario testScenario = TestScenario.GetUserByUserNameSuccess;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
IdentityUser response = await securityServiceManager.GetUserByUserName(SecurityServiceManagerTestData.UserName, CancellationToken.None);
response.Id.ShouldBe(SecurityServiceManagerTestData.User1Id);
response.UserName.ShouldBe(SecurityServiceManagerTestData.UserName);
response.Email.ShouldBe(SecurityServiceManagerTestData.EmailAddress);
response.PhoneNumber.ShouldBe(SecurityServiceManagerTestData.PhoneNumber);
}
//[InlineData(null)]
//[InlineData("")]
public async Task SecurityServiceManager_RegisterUser_UserIsRegistered(String password)
{
TestScenario testScenario = TestScenario.RegisterUserSuccess;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
RegisterUserRequest request = SecurityServiceManagerTestData.GetRegisterUserRequest;
request.Password = password;
RegisterUserResponse response = await securityServiceManager.RegisterUser(request, CancellationToken.None);
response.ShouldNotBeNull();
response.UserId.ShouldNotBe(Guid.Empty);
}
public async Task SecurityServiceManager_GetUserByUserId_UserDataReturned()
{
TestScenario testScenario = TestScenario.GetUserByUserIdSuccess;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
GetUserResponse response = await securityServiceManager.GetUserByUserId(Guid.Parse(SecurityServiceManagerTestData.User1Id), CancellationToken.None);
response.UserId.ShouldBe(Guid.Parse(SecurityServiceManagerTestData.User1Id));
response.UserName.ShouldBe(SecurityServiceManagerTestData.UserName);
response.Claims.ShouldNotBeEmpty();
response.Email.ShouldBe(SecurityServiceManagerTestData.EmailAddress);
response.PhoneNumber.ShouldBe(SecurityServiceManagerTestData.PhoneNumber);
response.Roles.ShouldBe(SecurityServiceManagerTestData.Roles);
}
public void SecurityServiceManager_CanBeCreated_IsCreated()
{
Mock <IPasswordHasher <IdentityUser> > passwordHasher = new Mock <IPasswordHasher <IdentityUser> >();
Mock <IUserStore <IdentityUser> > userStore = new Mock <IUserStore <IdentityUser> >();
UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(userStore.Object, null, null, null, null, null, null, null, null);
Mock <IMessagingService> messagingService = new Mock <IMessagingService>();
Mock <IRoleStore <IdentityRole> > roleStore = new Mock <IRoleStore <IdentityRole> >();
RoleManager <IdentityRole> roleManager = new RoleManager <IdentityRole>(roleStore.Object, null, null, null, null);
Mock <IHttpContextAccessor> contextAccessor = new Mock <IHttpContextAccessor>();
Mock <IUserClaimsPrincipalFactory <IdentityUser> > claimsFactory = new Mock <IUserClaimsPrincipalFactory <IdentityUser> >();
//Mock<Func<IConfigurationDbContext>> configurationDbContext = new Mock<Func<IConfigurationDbContext>>();
SignInManager <IdentityUser> signInManager = new SignInManager <IdentityUser>(userManager, contextAccessor.Object, claimsFactory.Object, null, null, null);
SecurityServiceManager securityServiceManager = new SecurityServiceManager(passwordHasher.Object, userManager, messagingService.Object, roleManager, signInManager);
securityServiceManager.ShouldNotBeNull();
}
