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(); }