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