public GenericCommandResult Create(
[FromBody] CreateUserCommand command,
[FromServices] CreateUserHandler handler
)
{
return((GenericCommandResult)handler.Handler(command));
}
public void SetUp()
{
_userService = new Mock <IUserService>();
_eventPublisher = new Mock <IEventPublisher>();
_handler = new CreateUserHandler(_userService.Object, _eventPublisher.Object);
}
public HttpResponseMessage Create(User user, string inviteCode) //done
{
var handler = new CreateUserHandler(_connectionString);
var response = handler.Handle(new CreateUserRequest
{
Email = user.Email,
Password = user.Password,
Username = user.Name,
InvitationCode = inviteCode
});
var createDashRequest = new CreateDashboardRequest
{
DashName = "Hello_DashBoardify",
UserId = response.UserId
};
var createDashHandler = new CreateDashboardHandler(_connectionString);
var createResponse = createDashHandler.Handle(createDashRequest);
if (createResponse.HasErrors || response.HasErrors)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, response));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public void ShouldReturnSuccessWhenSendAInvalidCommand()
{
var handler = new CreateUserHandler(new FakeUserRepository());
var result = (CommandResult)handler.handle(FakeCommandCreateUser.invalidCommand());
Assert.AreEqual(false, result.Success);
}
public async Task CreateUser_Success()
{
//arrange
var command = new CreateUser
{
FirstName = "FirstName",
LastName = "LastName",
InitiatorId = GlobalAdmin.Id
};
var handler = new CreateUserHandler(EntityRepository, EventTransmitter);
//act
await handler.HandleAsync(command);
//assert
var entities = GetRecordedEntities <User>(EntityRepository, nameof(EntityRepository.AddAsync));
Assert.That(entities.Count, Is.EqualTo(1));
Assert.That(entities[0].Name, Is.EqualTo(command.Name));
Assert.That(entities[0].IsShopManager, Is.False);
Assert.That(entities[0].Shop, Is.Null);
var events = GetRecordedEvents <DomainEvent <User> >();
Assert.That(events.Count, Is.EqualTo(1));
Assert.That(events[0].Trigger, Is.EqualTo(Trigger.Added));
Assert.That(events[0].Entity, Is.EqualTo(entities[0]));
Assert.That(events[0].RaisedBy, Is.EqualTo(command.InitiatorId));
}
static void Main_Example(string[] args)
{
var logger = new ConsoleLogger();
var sqlConnectionFactory = new SqlConnectionFactory("SQL Connection", logger);
var createUserHandler = new CreateUserHandler(new UserService(new QueryExecutor(sqlConnectionFactory),
new CommandExecutor(sqlConnectionFactory), new CacheService(logger, new RestClient("API KEY"))), logger);
createUserHandler.Handle();
}
public void TestInitialize()
{
_userWriteRepositoryMock = new Mock <IUserWriteRepository>();
_userReadRepositoryMock = new Mock <IUserReadRepository>();
_mapper = MappingProfile.InitializeAutoMapper().CreateMapper();
createuserCommand = GetCreateUserCommand();
_createUserHandlerSut = new CreateUserHandler(_userReadRepositoryMock.Object,
_userWriteRepositoryMock.Object, _mapper);
}
public CreateUserHandlerTests()
{
_userRepositoryMock = new Mock <IUserRepository>();
_schoolingRepositoryMock = new Mock <ISchoolingRepository>();
_createUserHandler = new CreateUserHandler(
_userRepositoryMock.Object,
_schoolingRepositoryMock.Object);
}
public void CreateQuizHandler_ResultNotNull()
{
var command = new CreateUserCommand(new User());
var handler = new CreateUserHandler(_mock.Object);
var result = handler.Handle(command, CancellationToken.None);
Assert.NotNull(result);
}
public void DadoUmUsuarioJaCadastrado_IsInvalid()
{
var command = new CreateUserCommand("user", "1234", "1234");
var handler = new CreateUserHandler(new FakeRepositoryUsuario());
var result = handler.Handle(command).Result;
Assert.AreNotEqual(0, result.Notifications.Count);
Assert.AreEqual(true, result.Invalid);
}
public void Initialize()
{
var repositoryMock = new Mock <IUserRepository>();
repositoryMock.Setup(r => r.Save(It.IsAny <IMono <User> >())).Returns(Mono.Just(new User()));
var userRepository = repositoryMock.Object;
var command = new CreateUserHandler(userRepository);
this.context.Command = command;
}
public void Setup()
{
Init();
var mockMapper = new MapperConfiguration(cfg => { cfg.AddProfile(new AutoMapping()); });
var mapper = mockMapper.CreateMapper();
var producer = new Mock <IProducer>();
_createUserHandler = new CreateUserHandler(Context, mapper, producer.Object);
}
public UsersController(GetUserHandler getUserHandler, CreateUserHandler createUserHandler, ChangePasswordHandler changePasswordHandler, ResetPasswordStepOneHandler resetPasswordStepOneHandler, ValidateResetPasswordTokenHandler validateResetPasswordTokenHandler, ResetPasswordStepTwoHandler resetPasswordStepTwoHandler,
ChangeProfileSettingsHandler changeProfileSettingsHandler)
{
_getUserHandler = getUserHandler;
_createUserHandler = createUserHandler;
_changePasswordHandler = changePasswordHandler;
_resetPasswordStepOneHandler = resetPasswordStepOneHandler;
_validateResetPasswordTokenHandler = validateResetPasswordTokenHandler;
_resetPasswordStepTwoHandler = resetPasswordStepTwoHandler;
_changeProfileSettingsHandler = changeProfileSettingsHandler;
}
public async Task CreateQuizHandler_ResultFalse()
{
var command = new CreateUserCommand(new User {
_id = "1"
});
var handler = new CreateUserHandler(_mock.Object);
var result = await handler.Handle(command, CancellationToken.None);
Assert.AreEqual(result, false);
}
public async Task CreateQuizHandler_ResultTrue(string value)
{
var command = new CreateUserCommand(new User {
_id = value
});
var handler = new CreateUserHandler(_mock.Object);
var result = await handler.Handle(command, CancellationToken.None);
Assert.AreEqual(result, true);
}
public async Task <ActionResult> Post([FromBody] CommandCreateUser command,
[FromServices] CreateUserHandler handler)
{
var result = (CommandResult)handler.handle(command);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task commandhandler_create_user()
{
var uniqueChecker = new Mock <IUserUniqueLoginChecker>();
var companyUniqueChecker = new Mock <ICompanyUniqueNameChecker>();
var repository = new Mock <IUserRepository>();
var handler = new CreateUserHandler(uniqueChecker.Object, repository.Object, new FakeHashService(), companyUniqueChecker.Object);
var request = new CreateUserCommand("*****@*****.**", "veryhard4break!", "INC");
uniqueChecker.Setup(mock => mock.IsUnique(It.IsAny <string>())).ReturnsAsync(true);
companyUniqueChecker.Setup(mock => mock.IsUnique(It.IsAny <string>())).ReturnsAsync(true);
await handler.Handle(request, CancellationToken.None);
repository.Verify(mock => mock.Save(It.Is <User>(user => user.Login == request.Login && user.Password == request.Password)));
repository.Verify(mock => mock.Save(It.Is <Company>(company => company.Name == request.CompanyName)));
}
public async Task ShouldReturnErrorWhenCommandIsInvalid(CreateUserCommand command)
{
var fakeRepository = new Mock <IUserRepository>();
fakeRepository
.Setup(repository => repository.Exists(It.IsAny <string>()))
.ReturnsAsync(false);
var handler = new CreateUserHandler(fakeRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeFalse();
result.Errors.Should().HaveCountGreaterThan(0);
handler.Invalid.Should().BeTrue();
}
public void SetUp()
{
BodyFitTrackerContext bodyFitTrackerContext = DatabaseConnectionFactory.GetInMemoryDatabase(true);
AppUser appUser = new AppUser("*****@*****.**", "", "", 60, GenderType.Male, MeasurementSystem.Imperial);
bodyFitTrackerContext.Add(appUser);
bodyFitTrackerContext.SaveChanges();
var jwtGeneratorMock = new Mock <IJwtGenerator>();
var passwordHasherMock = new Mock <IPasswordHasher>();
jwtGeneratorMock.Setup(x => x.CreateToken(It.IsAny <AppUser>())).Returns("");
passwordHasherMock.Setup(x => x.GeneratePassword(It.IsAny <string>())).Returns(("", ""));
_createUserHandler = new CreateUserHandler(bodyFitTrackerContext, passwordHasherMock.Object, jwtGeneratorMock.Object);
}
public async Task register_user_handler_should_not_be_null()
{
var userRepositoryMock = new Mock <IUserRepository>();
var passwordService = new Mock <IPasswordService>();
passwordService.Setup(x => x.HashPassword(It.IsAny <string>())).Returns("asdasd");
var createUserHandler = new CreateUserHandler(userRepositoryMock.Object, passwordService.Object);
var result = await createUserHandler.Handle(new CreateUserCommand()
{
Email = "asdasdasd",
Password = "******",
Username = "******"
}, new CancellationToken());
result.Should().NotBeNull();
}
public void DataMustBeSavedToDatabaseOnceSuccessfulPassValidation()
{
var fakeUserRepo = A.Fake <IUserRepository>();
var fakeValidator = new CreateUserValidator(fakeUserRepo);
var testMessage = new CreateUserMessage
{
Username = "******",
Password = "******",
Role = UserRole.Admin
};
var handler = new CreateUserHandler(fakeUserRepo, fakeValidator);
handler.Handle(testMessage);
A.CallTo(() => fakeUserRepo.Create(testMessage)).MustHaveHappened();
}
public async Task ShouldReturnSuccessWhenCommandIsValid(CreateUserCommand command)
{
var fakeRepository = new Mock <IUserRepository>();
fakeRepository
.Setup(repository => repository.Exists(It.IsAny <string>()))
.ReturnsAsync(false);
var handler = new CreateUserHandler(fakeRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Data.Should().NotBeNull();
result.Success.Should().BeTrue();
result.Errors.Should().BeNullOrEmpty();
handler.Valid.Should().BeTrue();
}
public void AddsUserToRepository_RaisesIntegrationEvent()
{
var repository = new Mock <IUserRepository>(MockBehavior.Strict);
repository.Setup(r => r.AddAsync(It.Is <Domain.User>(p => ValidateEquality(p)))).Returns(Task.CompletedTask).Verifiable();
repository.Setup(r => r.SaveChanges()).Returns(Task.CompletedTask).Verifiable();
var busPublisher = new Mock <IBusPublisher>(MockBehavior.Strict);
busPublisher.Setup(p => p.Publish <IUserCreated>(It.Is <IUserCreated>(e => ValidateEquality(e)))).Returns(Task.CompletedTask).Verifiable();
var handler = new CreateUserHandler(repository.Object, busPublisher.Object);
var result = handler.HandleAsync(Cmd, new Mock <ICorrelationContext>().Object).GetAwaiter().GetResult();
Assert.IsTrue(result.Successful);
repository.Verify();
busPublisher.Verify();
}
public void Should_throw_validation_exception_when_validation_fails()
{
var command = new CreateUser
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
UserName = "******"
};
var userRepositoryMock = new Mock <IUserRepository>();
var validatorMock = new Mock <IValidator <CreateUser> >();
validatorMock.Setup(x => x.Validate(command)).Returns(new ValidationResult(new List <ValidationFailure> {
new ValidationFailure("Id", "Id Error")
}));
var createUserHandler = new CreateUserHandler(userRepositoryMock.Object, validatorMock.Object);
Assert.Throws <ValidationException>(() => createUserHandler.Handle(command));
}
public async Task Should_validate_command_and_save_new_user()
{
var command = new CreateUser
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
UserName = "******"
};
var userRepositoryMock = new Mock <IUserRepository>();
userRepositoryMock.Setup(x => x.CreateAsync(It.IsAny <User>())).Returns(Task.FromResult(false));
var validatorMock = new Mock <IValidator <CreateUser> >();
validatorMock.Setup(x => x.Validate(command)).Returns(new ValidationResult());
var createUserHandler = new CreateUserHandler(userRepositoryMock.Object, validatorMock.Object);
await createUserHandler.HandleAsync(command);
validatorMock.Verify(x => x.Validate(command));
userRepositoryMock.Verify(x => x.CreateAsync(It.IsAny <User>()));
}
public CreateUserHandlerTest()
{
_authRepository = Substitute.For <IAuthRepository>();
_handler = new CreateUserHandler(_authRepository);
}
public UsuarioController(CreateUserHandler createUserHandler, IUserRepository userRepository, IConfiguration configuration)
{
_createUserHandler = createUserHandler;
_userRepository = userRepository;
_configuration = configuration;
}
public void Setup()
{
_userRepository = new Mock <IUserRepository>();
_sut = new CreateUserHandler(_userRepository.Object);
}
public UsersController(CreateUserHandler createUserHandler,
IUserRepository userRepository)
{
_createUserHandler = createUserHandler;
_userRepository = userRepository;
}
public void Setup()
{
_sut = new Fixture().Create <CreateUserHandler>();
}
