public async Task ShouldEmailAlreadyExistTest() { _mockRepository.Setup(x => x.CheckAlreadyExist(It.IsAny <string>())).Returns(Task.FromResult(true)); var createUserRequest = new CreateUserRequest() { Email = "*****@*****.**", FirstName = "mock", LastName = "mock", Password = "******", Phones = new List <CreatePhoneRequest>() { new CreatePhoneRequest() { AreaCode = 11, CountryCode = "+55", Number = 123456789 } } }; var command = new UserCommandHandler(_mockRepository.Object, _mockMapper, _mockNotificationContext); var result = await command.Handler(createUserRequest); Assert.IsFalse(result.Success); Assert.IsTrue(result.Error); Assert.AreEqual(400, result.StatusCode); Assert.AreEqual(Messages.INVALID_FIELDS, result.Message); Assert.IsTrue(_mockNotificationContext.HasNotifications); }
public async Task LoadMethod_HookResultError() { var eventStore = new Mock <IEventStore>(); var errors = new List <string> { "error" }; eventStore.Setup(store => store.AppendAll(It.IsAny <List <DomainEventBase> >())) .ReturnsAsync(HookResult.ErrorResult(errors)); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var updateId = Guid.NewGuid(); var updateId2 = Guid.NewGuid(); var post = Post.Create(new PostCreateCommand("Peters Post")).CreatedEntity; var post2 = Post.Create(new PostCreateCommand("Peters Post")).CreatedEntity; var user = User.Create(new UserCreateCommand("Peter", 13)).CreatedEntity; postRepo.Setup(repo => repo.GetPost(updateId)).ReturnsAsync(post); postRepo.Setup(repo => repo.GetPost(updateId2)).ReturnsAsync(post2); userRepo.Setup(repo => repo.GetUser(updateId)).ReturnsAsync(user); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.AddPostUser(updateId, new UserAddPostApiCommand(updateId, updateId2)); Assert.AreEqual(400, ((BadRequestObjectResult)result).StatusCode); Assert.AreEqual(errors, (List <string>)((BadRequestObjectResult)result).Value); }
public UserCommandHandlerShould() : base() { _userRepository = new UserRepository(ExampleContext); _roleRepository = new RoleRepository(ExampleContext); _userCommandHandler = new UserCommandHandler(_userRepository, _roleRepository, new RfaRepository(ExampleContext)); }
public void ErrorAuthenticateUserPassword(string password, int errorCode) { var command = new AuthenticateUserCommand(null, password, _appSettings); var commandResult = new UserCommandHandler(_mapper, _userRepo.Object) .Handle(command, new CancellationToken()).Result; Assert.True(commandResult.HasError(errorCode)); }
public LTMSeed(IServiceCollection services) { IServiceProvider provider = services.BuildServiceProvider(); _context = provider.GetService <LTMDataContext>(); _userHandler = provider.GetService <UserCommandHandler>(); _productHandler = provider.GetService <ProductCommandHandler>(); }
public UserController( UserCommandHandler commandHandler, UserQueryHandler queryHandler, IMapper mapper) { _commandHandler = commandHandler; _queryHandler = queryHandler; _mapper = mapper; }
private IUserService GetUserService() { IUnitOfWork _uow = new UnitOfWork(); LTMDataContext _context = new LTMDataContext(_uow); IUserRepository _userRepository = new UserRepository(_uow, _context); var _handler = new UserCommandHandler(_userRepository); IUserService userApp = new UserService(_uow, _userRepository, _handler); return(userApp); }
public void ProcessInputAsyncCommand_UnknownCommand_UnknownHandlerCalled() { const string command = "kalvionesljfie"; var handler = new UserCommandHandler(); RunProcessInputAsyncCommandTest(command, handler, () => { handler.OnUnknownCommand += _eventFunc; }).Wait(); Assert.AreEqual(command, _commands[0].Command); Assert.IsTrue(_commands[0].Parameters.Count == 0); }
public UserCommandHandlerTests() { _faker = new Faker(); _tokenSource = new CancellationTokenSource(); _uow = new Mock <IUnitOfWork>(); _mediator = new Mock <IMediatorHandler>(); _notifications = new Mock <DomainNotificationHandler>(); _userService = new Mock <IUserService>(); _commandHandler = new UserCommandHandler(_uow.Object, _mediator.Object, _notifications.Object, _userService.Object); }
public void ParseUserCommand_CommandOnly_ParsedSuccessfully() { const string command = "part"; var rawCommand = string.Format("/{0}", command); var handler = new UserCommandHandler(); var userCommand = handler.ParseUserCommand(rawCommand); Assert.AreEqual(command, userCommand.Command); }
public void ErrorAuthenticateUserEmailOrPasswordInvalid() { Domain.Entities.Customer customer = null; _userRepo.Setup((s) => s.Authenticate(It.IsAny <Domain.Entities.User>())).Returns(Task.FromResult(customer)); var command = new AuthenticateUserCommand("[email protected]", "abc123", _appSettings); var commandResult = new UserCommandHandler(_mapper, _userRepo.Object) .Handle(command, new CancellationToken()).Result; Assert.True(commandResult.HasError(2004)); }
private Configuration() { _bus = new CommandBus(); var eventStore = new SqlStore(_bus); var repository = new DomainRepository(eventStore); //Registering my Commands to corresponding CommandHandlers var commandService = new UserCommandHandler(repository); _bus.RegisterHandler <CreateUserCommand>(commandService.Handle); _bus.RegisterHandler <UpdateUserCommand>(commandService.Handle); }
public void ProcessInputAsyncCommand_NickCommand_NickHandlerCalled() { const string command = "nick"; const string parameter = "newnickname"; var handler = new UserCommandHandler(); RunProcessInputAsyncCommandTest(command, handler, () => { handler.OnNickCommand += _eventFunc; }, parameter).Wait(); Assert.AreEqual(command, _commands[0].Command); Assert.IsTrue(_commands[0].Parameters.Count > 0); Assert.AreEqual(parameter, _commands[0].Parameters[0]); }
public void Handle_Should_Call_Create_On_Repository_When_Command_Passed() { //Arrange var repository = new Mock <IUserRepository>(); var command = CommandFactory.BuildACommandOfType().CreateUser; var userCommaneHandler = new UserCommandHandler(repository.Object); //Act userCommaneHandler.Handle(command); //Assert repository.Verify(x => x.Create(It.IsAny <User>())); }
public async Task UpdateNameUser_UserNotFound() { var eventStore = new Mock <IEventStore>(); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); userRepo.Setup(repo => repo.GetUser(Guid.NewGuid())).ReturnsAsync((User)null); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.UpdateNameUser(Guid.NewGuid(), new UserUpdateNameCommand("NeuerPeter")); Assert.AreEqual(404, ((NotFoundObjectResult)result).StatusCode); }
public async Task CreateUser_CreateFails() { var eventStore = new Mock <IEventStore>(); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.CreateUser(new UserCreateCommand("Pe", 18)); Assert.AreEqual(400, ((BadRequestObjectResult)result).StatusCode); Assert.AreEqual(1, ((List <string>)((BadRequestObjectResult)result).Value).Count); Assert.AreEqual("Name too short", ((List <string>)((BadRequestObjectResult)result).Value)[0]); }
public void ParseUserCommand_CommandAndParams_ParsedSuccessfully() { const string command = "test"; const string firstParameter = "param1"; const string secondParameter = "param2"; var rawCommand = string.Format("/{0} {1} {2}", command, firstParameter, secondParameter); var handler = new UserCommandHandler(); var userCommand = handler.ParseUserCommand(rawCommand); Assert.AreEqual(command, userCommand.Command); Assert.IsTrue(userCommand.Parameters.Count == 2); Assert.IsTrue(userCommand.Parameters.Contains(firstParameter)); Assert.IsTrue(userCommand.Parameters.Contains(secondParameter)); }
public async Task UpdateNameUser_UserUpdateNameError() { var eventStore = new Mock <IEventStore>(); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var updateId = Guid.NewGuid(); var user = User.Create(new UserCreateCommand("Peter", 13)).CreatedEntity; userRepo.Setup(repo => repo.GetUser(updateId)).ReturnsAsync(user); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.UpdateNameUser(updateId, new UserUpdateNameCommand("Np")); Assert.AreEqual(400, ((BadRequestObjectResult)result).StatusCode); Assert.AreEqual("Name too short to update", ((List <string>)((BadRequestObjectResult)result).Value)[0]); }
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 CreateUser_HookFails() { var eventStore = new Mock <IEventStore>(); var errors = new List <string> { "Some Error" }; eventStore.Setup(store => store.AppendAll(It.IsAny <List <DomainEventBase> >())) .ReturnsAsync(HookResult.ErrorResult(errors)); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.CreateUser(new UserCreateCommand("Peter", 18)); Assert.AreEqual(400, ((BadRequestObjectResult)result).StatusCode); Assert.AreEqual(errors, (List <string>)((BadRequestObjectResult)result).Value); }
public async Task UpdateNameUser_HappyPath() { var eventStore = new Mock <IEventStore>(); eventStore.Setup(store => store.AppendAll(It.IsAny <List <DomainEventBase> >())) .ReturnsAsync(HookResult.OkResult()); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var updateId = Guid.NewGuid(); var user = User.Create(new UserCreateCommand("Peter", 13)).CreatedEntity; userRepo.Setup(repo => repo.GetUser(updateId)).ReturnsAsync(user); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.UpdateNameUser(updateId, new UserUpdateNameCommand("NeuerPeter")); Assert.AreEqual(200, ((OkResult)result).StatusCode); }
public void CreateUserThenResetPasswordThenDelete() { IHashProvider hashProvider = new PublicPrivateKeyHasher(); string publicKey = ConfigurationManager.AppSettings["PublicKey"]; string privateKey = ConfigurationManager.AppSettings["PrivateKey"]; hashProvider.RegisterKeyPair(publicKey, privateKey); var userRepository = new MockUserRepository(); CreateUserCommand command = new CreateUserCommand(); command.UserName = "******"; command.Password = "******"; command.Id = Guid.NewGuid(); command.EmailAddress = "*****@*****.**"; try { var messager = new MockMailMessager(); IEncryptor encryptor = new RijndaelManagedEncryptor(); IAuthorizationTokenProvider tokenProvider = new HashAuthorizationTokenProvider(hashProvider, encryptor); ICommandHandler <CreateUserCommand> commandHandler = new UserCommandHandler(hashProvider, userRepository, messager, tokenProvider, userRepository); commandHandler.Handle(command); ICommandHandler <ResetPasswordCommand> passwordhandler = (ICommandHandler <ResetPasswordCommand>)commandHandler; ResetPasswordCommand passwordCommand = new ResetPasswordCommand(); passwordCommand.EmailAddress = command.EmailAddress; passwordhandler.Handle(passwordCommand); } finally { UserInfo searchCriteria = new UserInfo(); searchCriteria.EmailAddress = command.EmailAddress; UserInfo userData = userRepository.Search(searchCriteria).FirstOrDefault(); Assert.IsNotNull(userData); userRepository.Remove(userData); } }
public async Task ShouldInvalidUserFieldsTest() { _mockRepository.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(Task.FromResult <User>(null)); var singInUserRequest = new SingInUserRequest() { Email = "*****@*****.**", Password = "******" }; var command = new UserCommandHandler(_mockRepository.Object, _mockMapper, _mockNotificationContext); var result = await command.Handler(singInUserRequest); Assert.IsFalse(result.Success); Assert.IsTrue(result.Error); Assert.AreEqual(404, result.StatusCode); Assert.AreEqual(Messages.INVALID_EMAIL_OR_PASSWORD, result.Message); }
public async Task ShouldRequireFieldsTest() { _mockRepository.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(Task.FromResult <User>(null)); var singInUserRequest = new SingInUserRequest() { Email = "", Password = "******" }; var command = new UserCommandHandler(_mockRepository.Object, _mockMapper, _mockNotificationContext); var result = await command.Handler(singInUserRequest); Assert.IsFalse(result.Success); Assert.IsTrue(result.Error); Assert.AreEqual(400, result.StatusCode); Assert.AreEqual(Messages.MISSING_FIELDS, result.Message); }
public async Task GetByAllMethod_EmptyList() { var eventStore = new Mock <IEventStore>(); eventStore.Setup(store => store.AppendAll(It.IsAny <List <DomainEventBase> >())) .ReturnsAsync(HookResult.OkResult()); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); List <User> userList = new List <User>(); userRepo.Setup(repo => repo.GetUsers()).ReturnsAsync(userList); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.GetUsers(); Assert.AreEqual(userList, (List <User>)((OkObjectResult)result).Value); }
public async Task GetByIdMethod_NotFound() { var eventStore = new Mock <IEventStore>(); eventStore.Setup(store => store.AppendAll(It.IsAny <List <DomainEventBase> >())) .ReturnsAsync(HookResult.OkResult()); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var searchGuid = Guid.NewGuid(); userRepo.Setup(repo => repo.GetUser(searchGuid)).ReturnsAsync((User)null); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.GetUser(searchGuid); Assert.AreEqual(404, ((NotFoundObjectResult)result).StatusCode); }
public async Task ShouldCreateNew() { // Arrange Guid expectedId = Guid.NewGuid(); var repository = new Mock <IUserRepository>(); CreateUserCommand cmd = new CreateUserCommand(expectedId, "Name"); UserCommandHandler actual = new UserCommandHandler(repository.Object); // Act await actual.HandleAsync(cmd); // Assert repository.Verify(e => e.Add(It.Is <User>(a => a.Id == expectedId) ), Times.Once ); }
public async Task LoadMethod_RootNotFound() { var eventStore = new Mock <IEventStore>(); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); userRepo.Setup(repo => repo.GetUser(It.IsAny <Guid>())).ReturnsAsync((User)null); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var userGuid = Guid.NewGuid(); var result = await userCommandHandler.AddPostUser(userGuid, new UserAddPostApiCommand(Guid.NewGuid(), Guid.NewGuid())); Assert.AreEqual(404, ((NotFoundObjectResult)result).StatusCode); var errors = $"Could not find Root User with ID: {userGuid}"; Assert.AreEqual(1, ((List <string>)((NotFoundObjectResult)result).Value).Count); Assert.AreEqual(errors, ((List <string>)((NotFoundObjectResult)result).Value)[0]); }
public void CreateNewUserByCommandThenFindThenDelete() { IHashProvider hashProvider = new PublicPrivateKeyHasher(); string publicKey = ConfigurationManager.AppSettings["PublicKey"]; string privateKey = ConfigurationManager.AppSettings["PrivateKey"]; hashProvider.RegisterKeyPair(publicKey, privateKey); var userRepository = new MockUserRepository(); CreateUserCommand command = new CreateUserCommand(); command.UserName = "******"; command.Password = "******"; command.Id = Guid.NewGuid(); command.EmailAddress = "*****@*****.**"; var messager = new MockMailMessager(); IEncryptor encryptor = new RijndaelManagedEncryptor(); IAuthorizationTokenProvider tokenProvider = new HashAuthorizationTokenProvider(hashProvider, encryptor); ICommandHandler <CreateUserCommand> commandHandler = new UserCommandHandler(hashProvider, userRepository, messager, tokenProvider, userRepository); commandHandler.Handle(command); UserInfo searchCriteria = new UserInfo(); searchCriteria.EmailAddress = command.EmailAddress; UserInfo userData = userRepository.Search(searchCriteria).FirstOrDefault(); Assert.IsNotNull(userData); string pashWordHash = hashProvider.GenerateHash(command.Password, userData.Id.ToString(), publicKey); Assert.AreEqual(userData.PasswordHash, pashWordHash); Assert.AreEqual(command.EmailAddress, userData.EmailAddress); Assert.AreEqual(command.Id, userData.Id); userRepository.Remove(userData); }
public void Install(IWindsorContainer container, IConfigurationStore store) { var bus = container.Resolve<ICommandBus>(); /* container.Register(AllTypes.FromAssemblyNamed(_assemblyName) .Where(x => x.GetInterface(typeof(ICommandHandler<>).Name) != null).WithService.AllInterfaces()); var handlers = container.ResolveAll(typeof (ICommandHandler<>)); */ var userCommandHandler = new UserCommandHandler(container.Resolve<IRepository>()); var meetingCommandHandler = new MeetingCommandHandler(container.Resolve<IRepository>()); var mediaContentCommandHandler = new MediaContentCommandHandler(container.Resolve<IRepository>()); bus.RegisterCommandHandler<CreateUser>(userCommandHandler); bus.RegisterCommandHandler<UpdateUserState>(userCommandHandler); bus.RegisterCommandHandler<CreateMeeting>(meetingCommandHandler); bus.RegisterCommandHandler<AttachCameraStream>(mediaContentCommandHandler); }
public async Task LoadMethod_DomainError() { var eventStore = new Mock <IEventStore>(); var postRepo = new Mock <IPostRepository>(); var userRepo = new Mock <IUserRepository>(); var updateId = Guid.NewGuid(); var post = Post.Create(new PostCreateCommand("Peters Post")).CreatedEntity; var user = User.Create(new UserCreateCommand("Peter", 13)).CreatedEntity; postRepo.Setup(repo => repo.GetPost(updateId)).ReturnsAsync(post); userRepo.Setup(repo => repo.GetUser(updateId)).ReturnsAsync(user); var userCommandHandler = new UserCommandHandler(eventStore.Object, userRepo.Object, postRepo.Object); var result = await userCommandHandler.AddPostUser(updateId, new UserAddPostApiCommand(updateId, updateId)); Assert.AreEqual(400, ((BadRequestObjectResult)result).StatusCode); Assert.AreEqual(1, ((List <string>)((BadRequestObjectResult)result).Value).Count); Assert.AreEqual("Can not delete post that should be added", ((List <string>)((BadRequestObjectResult)result).Value)[0]); }