public void UserCountTest()
{
MockUserRepository repo = Initialize();
var expectedCount = 8;
Assert.AreEqual(repo.Users.Count, expectedCount);
}
private void VerifyUserRepository_ReadSingleWasCalled(Int32 timesCalled)
{
MockUserRepository
.Verify(x => x.ReadSingle(
It.IsAny <Int32>())
, Times.Exactly(timesCalled));
}
private void MockWithTestData(TestData testData)
{
MockUserRepository.Expect(m => m.Items).Return(testData.Users.AsQueryable());
MockProviderRepository.Expect(m => m.Items).Return(testData.Providers.AsQueryable());
MockProgramRepository.Expect(m => m.Items).Return(testData.Programs.AsQueryable());
MockSchoolRepository.Expect(m => m.Items).Return(testData.Schools.AsQueryable());
MockRoleRepository.Expect(m => m.Items).Return(testData.Roles.AsQueryable());
MockUserRoleRepository.Expect(m => m.Items).Return(testData.UserRoles.AsQueryable());
MockCustomDataOriginRepository.Expect(m => m.Items).Return(testData.CustomDataOrigins.AsQueryable());
MockCustomFieldCategoryRepository.Expect(m => m.Items).Return(testData.CustomFieldCategories.AsQueryable());
MockCustomFieldValueRepository.Expect(m => m.Items).Return(testData.CustomFieldValues.AsQueryable());
MockCustomFieldRepository.Expect(m => m.Items).Return(testData.CustomFields.AsQueryable());
MockCustomFieldTypeRepository.Expect(m => m.Items).Return(testData.CustomFieldTypes.AsQueryable());
MockStudentRepository.Expect(m => m.Items).Return(testData.Students.AsQueryable());
MockPropertyRepository.Expect(m => m.Items).Return(testData.Properties.AsQueryable());
MockPriorityRepository.Expect(m => m.Items).Return(testData.Priorities.AsQueryable());
MockFulfillmentStatusRepository.Expect(m => m.Items).Return(testData.FulfillmentStatuses.AsQueryable());
MockSubjectRepository.Expect(m => m.Items).Return(testData.Subjects.AsQueryable());
MockServiceTypeRepository.Expect(m => m.Items).Return(testData.ServiceTypes.AsQueryable());
MockServiceOfferingRepository.Expect(m => m.Items).Return(testData.ServiceOfferings.AsQueryable());
MockServiceAttendanceRepository.Expect(m => m.Items).Return(testData.ServiceAttendances.AsQueryable());
MockStudentAssignedOfferingRepository.Expect(m => m.Items).Return(testData.StudentAssignedOfferings.AsQueryable());
MockCategoryRepository.Expect(m => m.Items).Return(testData.Categories.AsQueryable());
MockServiceRequestRepository.Expect(m => m.Items).Return(testData.ServiceRequests.AsQueryable());
MockServiceRequestFulfillmentRepository.Expect(m => m.Items).Return(testData.ServiceRequestFulfillments.AsQueryable());
MockUserAccessChangeEventRepository.Expect(m => m.Items).Return(testData.UserAccessChangeEvents.AsQueryable());
MockEulaAgreementRepository.Expect(m => m.Items).Return(testData.Eulas.AsQueryable());
MockEulaAcceptanceRepository.Expect(m => m.Items).Return(testData.EulaAcceptances.AsQueryable());
MockPrivateHealthDataViewEventRepository.Expect(m => m.Items).Return(testData.PrivateHealthDataViewEvents.AsQueryable());
MockLoginEventRepository.Expect(m => m.Items).Return(testData.LoginEvents.AsQueryable());
}
private static AuthService GetService()
{
var mockRepo = new MockUserRepository();
var authService = new AuthService(mockRepo);
return(authService);
}
public void UserSearchTest()
{
MockUserRepository repo = Initialize();
var result = repo.GetUsersBySubstring("Kári", repo);
Assert.AreEqual(result.Count, 1);
}
public void CreateNewUserPaymentThenFindThenDelete()
{
var command = new SavePaymentInfoCommand();
command.UserId = Guid.Parse("c9276b76-c56a-43ba-96b5-83b48a5fcce3");
command.Id = Guid.NewGuid();
command.PaymentInfo = new UserPaymentInfo();
command.PaymentInfo.Token = "thisisnotalegittoken";
command.PaymentInfo.UserPaymentInfoId = Guid.NewGuid();
var userRepo = new MockUserRepository();
var paymentRepo = new MockUserPaymentRepository();
var encryptor = new RijndaelManagedEncryptor();
var handler = new PaymentCommandHandler(userRepo, paymentRepo, encryptor);
handler.Handle(command);
var paymentInfo = paymentRepo.Get(command.PaymentInfo);
try
{
Assert.IsNotNull(paymentInfo);
Assert.AreNotEqual(command.PaymentInfo.Token, "thisisnotalegittoken");
}
finally
{
paymentRepo.Remove(paymentInfo);
}
}
private void VerifyUserRepositoryQueryWasCalled(Int32 timesCalled)
{
MockUserRepository
.Verify(x => x.Query(
It.IsAny <Query <User> >(),
It.IsAny <Int32>())
, Times.Exactly(timesCalled));
}
public void UserByIdTest()
{
MockUserRepository repo = Initialize();
var result = repo.GetUserById("13", repo);
var expected = "13";
Assert.AreEqual(result.Id, expected);
}
public HomeControllerTests()
{
WebSecurity = new Mock <IWebSecurity>(MockBehavior.Strict);
SetUpContext();
//Setup the fake security, repos, and db.
UserRepository = new MockUserRepository(SocialContext, WebSecurity.Object, new PostRepository(SocialContext)
, new GroupRepository(SocialContext));
Controller = new HomeController(UserRepository);
}
public void ConfigureIocContainer()
{
Container.Register(Component.For <CryptoHelper>());
#region Factory
Container.Register(Component.For <IntegrationClientFactory>());
Container.Register(Component.For <IntegrationFactory>());
Container.Register(Component.For <JournalFactory>());
Container.Register(Component.For <LabelFactory>());
Container.Register(Component.For <LabelTranslationFactory>());
Container.Register(Component.For <LanguageFactory>());
Container.Register(Component.For <OrganizationFactory>());
Container.Register(Component.For <ProjectFactory>());
Container.Register(Component.For <SendEmailLogFactory>());
Container.Register(Component.For <TokenFactory>());
Container.Register(Component.For <TokenRequestLogFactory>());
Container.Register(Component.For <UserFactory>());
Container.Register(Component.For <UserLoginLogFactory>());
#endregion
#region Repository
Container.Register(Component.For <IIntegrationClientRepository>().Instance(MockIntegrationClientRepository.Object));
Container.Register(Component.For <IIntegrationRepository>().Instance(MockIntegrationRepository.Object));
Container.Register(Component.For <IJournalRepository>().Instance(MockJournalRepository.Object));
Container.Register(Component.For <ILabelRepository>().Instance(MockLabelRepository.Object));
Container.Register(Component.For <ILabelTranslationRepository>().Instance(MockLabelTranslationRepository.Object));
Container.Register(Component.For <ILanguageRepository>().Instance(MockLanguageRepository.Object));
Container.Register(Component.For <IOrganizationRepository>().Instance(MockOrganizationRepository.Object));
Container.Register(Component.For <IProjectRepository>().Instance(MockProjectRepository.Object));
Container.Register(Component.For <ISendEmailLogRepository>().Instance(MockSendEmailLogRepository.Object));
Container.Register(Component.For <ITokenRepository>().Instance(MockTokenRepository.Object));
Container.Register(Component.For <ITokenRequestLogRepository>().Instance(MockTokenRequestLogRepository.Object));
Container.Register(Component.For <IUserLoginLogRepository>().Instance(MockUserLoginLogRepository.Object));
Container.Register(Component.For <IUserRepository>().Instance(MockUserRepository.Object));
#endregion
#region UnitOfWork
Container.Register(Component.For <ILabelUnitOfWork>().Instance(MockLabelUnitOfWork.Object));
Container.Register(Component.For <ILogOnUnitOfWork>().Instance(MockLogOnUnitOfWork.Object));
Container.Register(Component.For <IProjectUnitOfWork>().Instance(MockProjectUnitOfWork.Object));
Container.Register(Component.For <ISignUpUnitOfWork>().Instance(MockSignUpUnitOfWork.Object));
#endregion
#region Setup For Cache
MockUserRepository.Setup_SelectById_Returns_OrganizationOneUserOne();
MockUserRepository.Setup_Select_Returns_OrganizationOneUserOne();
MockOrganizationRepository.Setup_SelectById_Returns_OrganizationOne();
MockOrganizationRepository.Setup_Select_Returns_OrganizationOne();
#endregion
}
public void WhenCalling_UsersExists_WithValidUserId_RepositoryMethodCalled(int userId)
{
//arrange
MockUserRepository.Setup(s => s.UserExistsAsync(userId)).Returns(Task.FromResult(true));
//act
var result = GetService().UserExistsAsync(userId);
//assert
MockUserRepository.Verify(s => s.UserExistsAsync(userId), Times.Once);
}
public void Initialize()
{
_mockPostRepo = new MockPostRepository();
_postLogic = new PostLogic(_mockPostRepo);
_mockAuraRepo = new MockAuraRepository();
_auraLogic = new AuraLogic(_mockAuraRepo);
_mockUserRepo = new MockUserRepository();
_userLogic = new UserLogic(_mockUserRepo);
_mockCategoryRepo = new MockCategoryRepository();
_categoryLogic = new CategoryLogic(_mockCategoryRepo);
}
public void DeleteOnUserService()
{
//arrange
UserService userService = new UserService(MockUnitOfWork.Object);
//act
userService.Delete(testContext.SingleUser.Id);
//assert - expected exception
MockUserRepository.Verify(y => y.Delete(It.IsAny <Guid>()));
userService.Dispose();
}
public UnitOfWork(ESFContext context)
{
this._context = context;
#if Debug_Mock
User = new MockUserRepository(this._context);
Reports = new MockReportRepository(this._context);
Debris = new MockDebrisRepository(this._context);
#else
User = new UserRepository(this._context);
Reports = new ReportRepository(this._context);
Debris = new DebrisRepository(this._context);
#endif
}
public async Task JournalService_GetJournalsOfUser_Invalid_UserNotFound()
{
// arrange
var request = GetUserJournalReadListRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneUserOne();
// act
var result = await SystemUnderTest.GetJournalsOfUser(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Success);
AssertReturnType <JournalReadListResponse>(result);
MockUserRepository.Verify_SelectById();
}
public async Task AdminService_AllUserLoginLogs_Invalid_CurrentUserNotSuperAdmin()
{
// arrange
var request = GetAllLoginLogReadListRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneUserOne();
// act
var result = await SystemUnderTest.GetAllUserLoginLogs(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid);
AssertReturnType <AllLoginLogReadListResponse>(result);
MockUserRepository.Verify_SelectById();
}
public async Task AdminService_AcceptSuperAdminUserInvite_Invalid_UserNotFound()
{
// arrange
var request = GetAdminAcceptInviteRequest();
MockUserRepository.Setup_Select_Returns_OrganizationOneUserOneNotExist();
// act
var result = await SystemUnderTest.AcceptSuperAdminUserInvite(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid, UserNotFound);
AssertReturnType <AdminAcceptInviteResponse>(result);
MockUserRepository.Verify_Select();
}
public async Task ProjectService_GetProjects_Success()
{
// arrange
var request = GetProjectReadListRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneAdminUserOne();
// act
var result = await SystemUnderTest.GetProjects(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Success);
AssertReturnType <ProjectReadListResponse>(result);
MockUserRepository.Verify_SelectById();
}
public async Task AdminService_OrganizationChangeActivation_Invalid_CurrentUserNotSuperAdmin()
{
// arrange
var request = GetOrganizationChangeActivationRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneUserOne();
// act
var result = await SystemUnderTest.OrganizationChangeActivation(request);
// assert
result.Status.ShouldBe(ResponseStatus.Invalid);
result.ErrorMessages.ShouldNotBeNull();
AssertReturnType <OrganizationChangeActivationResponse>(result);
MockUserRepository.Verify_SelectById();
}
public void InitializeTest()
{
Users = new List <User> {
new User {
Id = 20, UserKey = "3u2e2"
}, new User {
Id = 30, UserKey = "29e8r2fj"
}, new User {
Id = 40, UserKey = "w8iw2j2"
}
};
MockUserRepository = MockRepository.GenerateMock <IUserRepository>();
MockUserRepository.Expect(r => r.Items).Return(Users.AsQueryable());
BaseIdentity = new ClaimsIdentity("Federated");
Target = new EducationSecurityIdentity(BaseIdentity, Users[0]);
}
public void UpdateOnUserService()
{
//arrange
UserService userService = new UserService(MockUnitOfWork.Object);
//set username to that of another user
testContext.SingleUser.Username = testContext.SingleUser.Username + "WITHUPDATE";
//act
userService.Update(testContext.SingleUser);
//assert - expected exception
MockUserRepository.Verify(y => y.Update(It.IsAny <User>()));
userService.Dispose();
}
public async Task ProjectService_GetProjects_InvalidOrganizationEntity()
{
// arrange
var request = GetProjectReadListRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationTwoUserOne();
// act
var result = await SystemUnderTest.GetProjects(request);
// assert
result.ErrorMessages.ShouldNotBeNull();
result.Status.ShouldBe(ResponseStatus.Invalid);
AssertReturnType <ProjectReadListResponse>(result);
MockUserRepository.Verify_SelectById();
}
public async Task ProjectService_EditProject_Invalid_OrganizationNotActive()
{
// arrange
var request = GetProjectEditRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneAdminUserOne();
MockOrganizationRepository.Setup_Any_Returns_True();
// act
var result = await SystemUnderTest.EditProject(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid, OrganizationNotActive);
AssertReturnType <ProjectEditResponse>(result);
MockUserRepository.Verify_SelectById();
MockOrganizationRepository.Verify_Any();
}
public async Task AdminService_ChangeActivation_Invalid_UserNotFound()
{
// arrange
var request = GetUserChangeActivationRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneSuperAdminUserOne();
MockUserRepository.Setup_Select_Returns_OrganizationOneUserOneNotExist();
// act
var result = await SystemUnderTest.ChangeActivation(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid, UserNotFound);
AssertReturnType <UserChangeActivationResponse>(result);
MockUserRepository.Verify_SelectById();
MockUserRepository.Verify_Select();
}
public async Task AdminService_AcceptSuperAdminUserInvite_Failed()
{
// arrange
var request = GetAdminAcceptInviteRequest();
MockUserRepository.Setup_Select_Returns_OrganizationOneSuperAdminUserInvitedAtOneWeekBefore();
MockOrganizationRepository.Setup_Any_Returns_False();
// act
var result = await SystemUnderTest.AcceptSuperAdminUserInvite(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Failed);
AssertReturnType <AdminAcceptInviteResponse>(result);
MockUserRepository.Verify_Select();
MockOrganizationRepository.Verify_Any();
}
public async Task AdminService_ValidateSuperAdminUserInvitation_Invalid_OrganizationNotFound()
{
// arrange
var request = GetAdminInviteValidateRequest();
MockUserRepository.Setup_Select_Returns_OrganizationOneUserOne();
MockOrganizationRepository.Setup_Any_Returns_True();
// act
var result = await SystemUnderTest.ValidateSuperAdminUserInvitation(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid, OrganizationNotFound);
AssertReturnType <AdminInviteValidateResponse>(result);
MockUserRepository.Verify_Select();
MockOrganizationRepository.Verify_Any();
}
public async Task AdminService_ValidateSuperAdminUserInvitation_Success()
{
// arrange
var request = GetAdminInviteValidateRequest();
MockUserRepository.Setup_Select_Returns_OrganizationOneSuperAdminUserInvitedAtOneDayBefore();
MockOrganizationRepository.Setup_Any_Returns_False();
// act
var result = await SystemUnderTest.ValidateSuperAdminUserInvitation(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Success);
AssertReturnType <AdminInviteValidateResponse>(result);
MockUserRepository.Verify_Select();
MockOrganizationRepository.Verify_Any();
}
public async Task AdminService_InviteSuperAdminUser_Invalid_UserAlreadyInvited()
{
// arrange
var request = GetAdminInviteRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneSuperAdminUserOne();
MockUserRepository.Setup_Select_Returns_OrganizationOneUserOne();
// act
var result = await SystemUnderTest.InviteSuperAdminUser(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid, "user_already_invited");
AssertReturnType <AdminInviteResponse>(result);
MockUserRepository.Verify_SelectById();
MockUserRepository.Verify_Select();
}
public void CreateNewOrganizationWithUserThenDelete()
{
var command = new CreateOrganizationCommand();
command.Name = "Test Org";
command.PrimaryEmailAddress = "*****@*****.**";
command.WebsiteUrl = "www.n-dexed.com";
IHashProvider hashProvider = new PublicPrivateKeyHasher();
string publicKey = ConfigurationManager.AppSettings["PublicKey"];
string privateKey = ConfigurationManager.AppSettings["PrivateKey"];
hashProvider.RegisterKeyPair(publicKey, privateKey);
IRepository <UserInfo, UserInfo> userRepository = new MockUserRepository();
ISearchableRepository <UserInfo, UserInfo> searchRepository = new MockUserRepository();
var messager = new MockMailMessager();
IEncryptor encryptor = new RijndaelManagedEncryptor();
IAuthorizationTokenProvider tokenProvider = new HashAuthorizationTokenProvider(hashProvider, encryptor);
ICommandHandler <CreateUserCommand> commandHandler = new UserCommandHandler(hashProvider, userRepository, messager, tokenProvider, searchRepository);
var handler = new OrganizationCommandHandler(new MockOrganizationRepository(), searchRepository,
commandHandler);
try
{
handler.Handle(command);
}
finally
{
try
{
var searchCriteria = new UserInfo()
{
EmailAddress = command.PrimaryEmailAddress
};
var user = searchRepository.Search(searchCriteria).First();
userRepository.Remove(user);
}
catch
{
}
}
}
public async Task ProjectService_RestoreProject_Invalid_ProjectNotFound()
{
// arrange
var request = GetProjectRestoreRequest();
MockUserRepository.Setup_SelectById_Returns_OrganizationOneUserOne();
MockProjectRepository.Setup_Select_Returns_InvalidProject();
// act
var result = await SystemUnderTest.RestoreProject(request);
// assert
AssertResponseStatusAndErrorMessages(result, ResponseStatus.Invalid, ProjectNotFound);
AssertReturnType <ProjectRestoreResponse>(result);
MockUserRepository.Verify_SelectById();
MockProjectRepository.Verify_Select();
}
