public async Task AddUserHandler_Should_Add_User()
{
// Arrange...
Domain.Models.User addedUser = _fixture.Create <Domain.Models.User>();
var mockUnitOfWork = Substitute.For <IUnitOfWork>();
mockUnitOfWork.UserRepository.When(x => x.Create(Arg.Any <User>()))
.Do(x => x.Arg <User>().Id = addedUser.Id);
mockUnitOfWork.CompleteAsync().Returns(1);
var mockMapper = Substitute.For <IMapper>();
mockMapper.Map <Domain.Models.User>(Arg.Any <Application.Commands.AddUserCommand>()).Returns(addedUser);
var sut = new AddUserCommandHandler(mockUnitOfWork, mockMapper);
var addUserCommand = _fixture.Create <AddUserCommand>();
var ct = new CancellationToken();
// Act...
var actualUserId = await sut.Handle(addUserCommand, ct);
// Assert...
actualUserId.Should().Be(addedUser.Id);
mockUnitOfWork.UserRepository.Received(1).Create(Arg.Any <User>());
await mockUnitOfWork.Received(1).CompleteAsync();
}
public void user_add_command_failed()
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization {
ConfigureMembers = true
});
var finalUser = fixture.Create <User>();
var command = fixture.Build <AddUserCommand>()
.With(user => user.CommercialEmail, finalUser.CommercialEmail.Value)
.With(user => user.Cnpj, finalUser.Cnpj.Value)
.With(user => user.Name, finalUser.Name.Value)
.Create();
var mediator = fixture.Create <IMediator>();
var logger = fixture.Create <ILogger <AddUserCommandHandler> >();
var db = fixture.Create <IDbSession <IUserRepository> >();
var handler = new AddUserCommandHandler(logger, mediator, db);
var result = handler.Execute(command);
db.DidNotReceive().Repository.Add(finalUser);
db.DidNotReceive().SaveChanges();
Assert.True(!result.IsSucceed && result.Violations.Count == 3);
}
public void Setup()
{
repositoryMock = Substitute.For <IUserRepository>();
mediatorHandlerMock = Substitute.For <IMediatorHandler>();
var unitOfWorkMock = Substitute.For <IUnitOfWork>();
unitOfWorkMock.CommitAsync().Returns(true);
handler = new AddUserCommandHandler(repositoryMock, unitOfWorkMock, new NotificationContext(), mediatorHandlerMock);
}
private AddUserCommandHandler GetCommandHandler()
{
AddUserCommandHandler sut = new AddUserCommandHandler();
IReadRepository <User> read = Substitute.For <IReadRepository <User> >();
sut.ReadRepository = read;
IWriteRepository <User> write = Substitute.For <IWriteRepository <User> >();
sut.WriteRepository = write;
return(sut);
}
public void Execute_Should_Not_Add_Invalid_User()
{
AddUserCommandHandler sut = GetCommandHandler();
AddUserCommand command = UserCommandHandlerTestHelper.GetAddCommand("a".PadLeft(101, 'a'));
string expectedInvalid = string.Format(MessagesModel.MaxLength, "100");
UserCommandResult result = sut.Execute(command);
var calls = sut.WriteRepository.ReceivedCalls().Count();
Assert.AreEqual(0, calls);
}
public async Task AddUserHandler_Should_Add_User()
{
// Arrange...
var unitOfWork = GetUnitOfWork(out var inMemoryContext);
var mapper = GetMapper();
var sut = new AddUserCommandHandler(unitOfWork, mapper);
var addUserCommand = _fixture.Create <AddUserCommand>();
var ct = new CancellationToken();
// Act...
var addedUserId = await sut.Handle(addUserCommand, ct);
// Assert...
inMemoryContext.Users.Count().Should().Be(1);
}
public async void ShouldAddUser()
{
var fixture = new Fixture();
using (DatabaseContext dbContext = DbContextHelpers.CreateDatabaseContext())
{
var command = fixture.Create <AddUserCommand>();
var handler = new AddUserCommandHandler(dbContext);
await handler.Handle(command, CancellationToken.None);
var created = await dbContext.Users.FindAsync(command.UserId);
created.Id.Should().Be(command.UserId);
}
}
public void AddUserHandler_Should_Throw_When_Command_Is_Null()
{
// Arrange...
var mockUnitOfWork = Substitute.For <IUnitOfWork>();
var mockMapper = Substitute.For <IMapper>();
var sut = new AddUserCommandHandler(mockUnitOfWork, mockMapper);
const AddUserCommand addUserCommand = null;
var ct = new CancellationToken();
// Act...
Func <Task> action = async() => await sut.Handle(addUserCommand, ct);
// Assert...
action.Should().Throw <ArgumentNullException>();
}
public async Task AddUserCommandHandlerShouldReturnUserObject()
{
var user = new User()
{
Password = "******",
Username = "******"
};
var userCommand = new AddUserCommand(user)
{
User = user
};
var handler = new AddUserCommandHandler(_userRepositoryMock.Object);
_userRepositoryMock.Setup(a => a.Add(userCommand.User)).ReturnsAsync(user);
var result = await handler.Handle(userCommand, new CancellationToken());
result.Should().BeOfType <User>();
}
public void CreateUser_Successfully(User user)
{
var handler = new AddUserCommandHandler(base.UnitOfWorkMock.Object);
var result = handler.Handle(new AddUserCommand()
{
User = new BasicUserVm()
{
Name = user.Name,
Email = user.Email,
Lastname = user.Lastname,
TelephoneNumber = user.TelephoneNumber,
Age = user.Age,
Address = user.Address.Select(u => new AddressVm {
Description = u.Description
}).ToList()
}
}, default);
Assert.IsNotNull(result);
Assert.IsInstanceOf <Task <Response <UserVm> > >(result);
Assert.AreEqual(StatusCodes.Status200OK, result.Result.StatusCode);
}
public AddUserCommandHandlerShould()
{
_userRepositoryMock = new Mock <IUserRepository>();
_sut = new AddUserCommandHandler(_userRepositoryMock.Object, new EntityFactory());
}
public void user_add_command_succed()
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization {
ConfigureMembers = true
});
fixture.Register <EntityId>(() => EntityId.From(fixture.Create <Guid>()));
fixture.Register <Name>(() => Name.From(fixture.Create <string>()));
fixture.Register <Version>(() => Version.From(fixture.Create <int>()));
fixture.Register <SocialSecurityId>(() => SocialSecurityId.From(fixture.Create <string>()));
fixture.Register <Email>(() => Email.From(string.Format($"{fixture.Create<string>()}@teste.com")));
fixture.Register <User>(() => User.From(fixture.Create <EntityId>(),
fixture.Create <Name>(), fixture.Create <SocialSecurityId>(),
fixture.Create <Email>(), fixture.Create <Version>()));
var finalUser = fixture.Create <User>();
var command = fixture.Build <AddUserCommand>()
.With(user => user.CommercialEmail, finalUser.CommercialEmail.Value)
.With(user => user.Cnpj, finalUser.Cnpj.Value)
.With(user => user.Name, finalUser.Name.Value)
.Create();
var mediator = fixture.Create <IMediator>();
var logger = fixture.Create <ILogger <AddUserCommandHandler> >();
var db = fixture.Create <IDbSession <IUserRepository> >();
var handler = new AddUserCommandHandler(logger, mediator, db);
var result = handler.Execute(command);
db.Received().Repository.Add(finalUser);
db.Received().SaveChanges();
mediator.Received(1).Publish(Arg.Any <UserAddedEvent>());
Assert.True(result.IsSucceed);
}
