public async Task <bool> Post([FromBody] PedidoModel model)
{
try
{
AdicionarPedidoCommand adicionarPedidoCommand = new AdicionarPedidoCommand();
adicionarPedidoCommand.ClienteId = model.Cliente.Id;
await _mediatorHandler.EnviarComando(adicionarPedidoCommand);
foreach (var item in model.Itens)
{
AdicionarItemPedidoCommand adicionarItemPedidoCommand = new AdicionarItemPedidoCommand(item.Produto.Id, item.Quantidade, model.Cliente.Id);
await _mediatorHandler.EnviarComando(adicionarItemPedidoCommand);
}
return(true);
}
catch (DominioException ex)
{
return(false);
}
catch (Exception ex)
{
return(false);
}
}
public async Task AdicionarItem_NovoItemPedidoRascunho_DeveExecutarComSucesso()
{
//Arrange
var clienteId = Guid.NewGuid();
var pedido = Pedido.PedidoFactory.NovoPedidoRascunho(clienteId);
var pedidoItemExistente = new PedidoItem(Guid.NewGuid(), "Produto Teste", 2, 100);
pedido.AdicionarItem(pedidoItemExistente);
var pedidoCommand = new AdicionarItemPedidoCommand(clienteId, Guid.NewGuid(), "Outro produto", 1, 50);
var mocker = new AutoMocker();
var pedidoHandler = mocker.CreateInstance <PedidoCommandHandler>();
mocker.GetMock <IPedidoRepositorio>()
.Setup(r => r.ObterPedidoRascunhoPorClienteId(clienteId)).Returns(Task.FromResult(pedido));
mocker.GetMock <IPedidoRepositorio>().Setup(r => r.UnitOfWork.Commit()).Returns(Task.FromResult(true));
//Act
var result = await pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
//Assert
Assert.True(result);
mocker.GetMock <IPedidoRepositorio>().Verify(r => r.AdicionarItem(It.IsAny <PedidoItem>()), Times.Once);
mocker.GetMock <IPedidoRepositorio>().Verify(r => r.Atualizar(It.IsAny <Pedido>()), Times.Once);
mocker.GetMock <IPedidoRepositorio>().Verify(r => r.UnitOfWork.Commit(), Times.Once);
}
public async Task AdicionarItem_NovoItemAoPedidoRascunho_DeveExecutarComSucesso()
{
// Arrange
var clienteId = Guid.NewGuid();
var pedido = Pedido.PedidoFactory.NovoPedidoRascunho(clienteId);
var pedidoItemExistente = new PedidoItem(Guid.NewGuid(), "Produto 01", 2, 100);
pedido.AdicionarItem(pedidoItemExistente);
var pedidoCommand = new AdicionarItemPedidoCommand(clienteId: clienteId,
produtoId: Guid.NewGuid(),
nome: "Produto Teste",
quantidade: 2,
valorUnitario: 100);
// Act
var pedidoRepository = Substitute.For <IPedidoRepository>();
var mediator = Substitute.For <IMediator>();
var pedidoHandler = Substitute.For <PedidoCommandHandler>(pedidoRepository, mediator);
pedidoRepository.ObterPedidoRascunhoPorClienteId(clienteId).Returns(pedido);
pedidoRepository.UnitOfWork.Commit().Returns(true);
var result = await pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
// Assert
result.Should().BeTrue();
pedidoRepository.Received(1).AdicionarItem(Arg.Any <PedidoItem>());
pedidoRepository.Received(1).Atualizar(Arg.Any <Pedido>());
await pedidoRepository.UnitOfWork.Received(1).Commit();
}
public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
TempData["Erro"] = "Produto com estoque insuficiente";
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
// ClienteId é o cliente logado;
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
await _mediatorHandler.EnviarComando(command);
if (OperacaoValida())
{
return(RedirectToAction("Index"));
}
// Esse TempData está sendo utilizado porque está dando um Redirect - toda vez que da um Redirect, perde o estado do request anterior, então precisa persistir a mensagem no TempData;
TempData["Erros"] = ObterMensagensErro();
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
public async Task DeveAdicionarUmNovoItemParaUmPedidoNovoComSucesso()
{
// Arrange
var command = new AdicionarItemPedidoCommand(Guid.NewGuid(), Guid.NewGuid(),
"produto teste", 2, 100);
var mocker = new AutoMocker();
var pedidoHandler = mocker.CreateInstance <PedidoCommandHandler>();
mocker.GetMock <IPedidoRepository>()
.Setup(x => x.UnitOfWork.Commit())
.Returns(Task.FromResult(true));
// Act
var resultado = await pedidoHandler.Handle(command, CancellationToken.None);
// Assert
resultado.Should().BeTrue();
mocker.GetMock <IPedidoRepository>()
.Verify(x => x.Adicionar(It.IsAny <Pedido>()), Times.Once);
mocker.GetMock <IPedidoRepository>()
.Verify(x => x.UnitOfWork.Commit(), Times.Once);
// mocker.GetMock<IMediator>()
// .Verify(x =>
// x.Publish(It.IsAny<INotification>(), CancellationToken.None), Times.Once);
}
public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
TempData["Erro"] = "Produto com estoque insuficiente";
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
await _mediatorHandler.EnviarComando(command);
if (OperacaoValida())
{
return(RedirectToAction("Index"));
}
TempData["Erros"] = ObterMensagensErro();
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
public async Task AdicionarItem_ItemExistenteAoPedidoRascunho_DeveExecutarComSucesso()
{
//Arrange
var pedidoItemExistente = new PedidoItem(_produtoId, "ProdutoTeste", 1, 100);
_pedido.AdicionarItem(pedidoItemExistente);
var pedidoCommand = new AdicionarItemPedidoCommand(_clienteId, _produtoId, "ProdutoTeste", 1, 100);
_mocker.GetMock <IPedidoRepository>()
.Setup(r => r.ObterPedidoRascunhoPorClienteId(_clienteId)).Returns(Task.FromResult(_pedido));
_mocker.GetMock <IPedidoRepository>().Setup(r => r.UnitOfWork.Commit()).Returns(Task.FromResult(true));
//Act
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
//Assert
Assert.True(result);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.AtualizarItem(It.IsAny <PedidoItem>()), Times.Once);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.Atualizar(It.IsAny <Pedido>()), Times.Once);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.UnitOfWork.Commit(), Times.Once);
}
public void DeveNotificarErrosParaCommandInvalido()
{
// Arrange
var command = new AdicionarItemPedidoCommand(
Guid.Empty,
Guid.Empty,
"",
0,
0
);
// Act
var estaValido = command.EstaValido();
var erros = command.Validacoes
.Errors
.Select(x => x.ErrorMessage)
.ToList();
// Assert
estaValido.Should().BeFalse();
erros.Should()
.Contain(ValidacaoParaAdicionarItemPedido.IdClienteErroMsg)
.And.Contain(ValidacaoParaAdicionarItemPedido.IdProdutoErroMsg)
.And.Contain(ValidacaoParaAdicionarItemPedido.NomeErroMsg)
.And.Contain(ValidacaoParaAdicionarItemPedido.QtdMinErroMsg)
.And.Contain(ValidacaoParaAdicionarItemPedido.ValorErroMsg);
}
public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
TempData["Erro"] = "Produto com estoque insuficiente";
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
await _IMediateHandler.EnviarComando(command);
if (OperacaoValida())
{
return(RedirectToAction("Index"));
}
// Esta sendo usado o TempData porque estou usando o redirectToAction toda ves que uso esse redirection eu perco o
//estado do meu request anterior,então eu preciso persistir minha msg de erro no meu temp data
TempData["Erro"] = "Produto Indisponível";
// Esse redirect é um novo request
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
public void AdicionarItemPedidoCommand_ComandoEstaValido_DevePassarNaValidacao()
{
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.NewGuid(),
Guid.NewGuid(), "Produto Teste", 2, 100);
var result = pedidoCommand.EhValido();
Assert.True(result);
}
public void AdicionarItemPedidoCommand_QuantidadeUnidadesSuperiorAoPermitido_NaoDevePassarNaValidacao()
{
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.NewGuid(),
Guid.NewGuid(), "Produto Teste", Pedido.MAX_UNIDADES_ITEM + 1, 100);
var result = pedidoCommand.EhValido();
Assert.False(result);
Assert.Contains(AdicionarItemPedidoValidation.QtdMaxErroMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
}
public void AdicionarItemPedidoCommand_ComandoEstaValido_DevePassarNaValidacao()
{
// Arrange
var command = new AdicionarItemPedidoCommand(Guid.NewGuid(), Guid.NewGuid(), "Produto Teste", 2, 100);
// Act
var result = command.EhValido();
// Assert
Assert.True(result);
}
public async Task AdicionarItem_CommandInvalido_DeveRetornarFalsoELancarEventosDeNotificacao()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.Empty, Guid.Empty, "", 0, 0);
// Act
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
// Assert
Assert.False(result);
_mocker.GetMock <IMediator>().Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Exactly(5));
}
public async Task DeveAtualizarItemPreviamenteAdicionado()
{
// Arrange
var clienteId = Guid.NewGuid();
var produtoId = Guid.NewGuid();
var pedido = new Pedido(clienteId);
var item = new PedidoItem(produtoId, "Produto teste", 2, 100);
pedido.AdicionarItem(item);
var command = new AdicionarItemPedidoCommand(
clienteId,
produtoId,
"Produto teste",
2,
100);
var mocker = new AutoMocker();
var pedidoHandler = mocker.CreateInstance <PedidoCommandHandler>();
var repository = mocker.GetMock <IPedidoRepository>();
repository
.Setup(x => x.ObterPedidoRascunho(clienteId))
.Returns(Task.FromResult(pedido));
repository
.Setup(x => x.UnitOfWork.Commit())
.Returns(Task.FromResult(true));
// Act
var resultado = await pedidoHandler.Handle(command, CancellationToken.None);
// Assert
resultado.Should().BeTrue();
repository
.Verify(x =>
x.AtualizarItem(It.IsAny <PedidoItem>()), Times.Once);
repository
.Verify(x =>
x.Atualizar(It.IsAny <Pedido>()), Times.Once);
repository
.Verify(x =>
x.UnitOfWork.Commit(), Times.Once);
}
public void AdicionarItemPedidoCommand_QuantidadeUnidadesAcimaPermitido_NaoDevePassarNaValidacao()
{
//Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.NewGuid(), Guid.NewGuid(),
"Teste", Pedido.MAX_UNIDADES_ITEM + 1, 0);
//Act
var result = pedidoCommand.EhValido();
//Assert
Assert.False(result);
Assert.Contains(AdicionarItemPedidoValidation.QtdMaxErrorMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
}
public async Task AdicionarItem_NovoPedido_DeveExecutarComSucesso()
{
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.NewGuid(),
Guid.NewGuid(), "Novo Produto", 2, 150);
_mocker.GetMock <IPedidoRepository>().Setup(r => r.UnitOfWork.Commit()).Returns(Task.FromResult(true));
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
Assert.True(result);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.Adicionar(It.IsAny <Pedido>()), Times.Once);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.UnitOfWork.Commit(), Times.Once);
// mocker.GetMock<IMediator>().Verify(r => r.Publish(It.IsAny<INotification>(), CancellationToken.None), Times.Once);
}
public void AdicionarItemPedidoCommand_ComandoEstaInvalido_NaoDevePassarNaValidacao()
{
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.Empty,
Guid.Empty, "", 0, 0);
var result = pedidoCommand.EhValido();
Assert.False(result);
Assert.Contains(AdicionarItemPedidoValidation.IdClienteErroMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.IdProdutoErroMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.NomeErroMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.QtdMinErroMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.ValorErroMsg, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
}
public void AdicionarItemPedidoCommand_CommandoEstaValido_DevePassarNaValidacao()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(clienteId: Guid.NewGuid(),
produtoId: Guid.NewGuid(),
nome: "Produto Teste",
quantidade: 2,
valorUnitario: 100);
// Act
var result = pedidoCommand.EhValido();
// Assert
result.Should().BeTrue();
}
public async Task AdicionarItem_NovoPedido_DeveExecutarComSucesso()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.NewGuid(), Guid.NewGuid(), "Produto Teste", 2, 100);
_mocker.GetMock <IPedidoRepository>().Setup(p => p.UnitOfWork.Commit()).Returns(Task.FromResult(true));
// Act
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
// Assert
Assert.True(result);
_mocker.GetMock <IPedidoRepository>().Verify(p => p.Adicionar(It.IsAny <Pedido>()), Times.Once);
_mocker.GetMock <IPedidoRepository>().Verify(p => p.UnitOfWork.Commit(), Times.Once);
}
public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
}
var comando = new AdicionarItemPedidoCommand(clienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
}
public void AdicionarItemPedidoCommand_ComandoEstaInvalido_NaoDevePassarNasValidacoes()
{
//Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(Guid.Empty, Guid.Empty, "", 0, 0);
//Act
var result = pedidoCommand.EhValido();
//Assert
Assert.False(result);
Assert.Contains(AdicionarItemPedidoValidation.IdClienteMsgErro, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.IdProdutoMsgErro, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.NomeMsgErro, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.QtdMinMsgErro, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
Assert.Contains(AdicionarItemPedidoValidation.ValorUnitarioMsgErro, pedidoCommand.ValidationResult.Errors.Select(c => c.ErrorMessage));
}
public void AdicionarItemPedidoCommand_QuantidadeUnidadesSuperiorAoPermitido_NaoDevePassarNaValidacao()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(clienteId: Guid.NewGuid(),
produtoId: Guid.NewGuid(),
nome: "Produto Teste",
quantidade: Pedido.MAX_UNIDADES_ITEM + 1,
valorUnitario: 100);
// Act
var result = pedidoCommand.EhValido();
// Assert
result.Should().BeFalse();
pedidoCommand.ValidationResult.Errors.Should().HaveCount(1);
pedidoCommand.ValidationResult.Errors.Should().Contain(x => x.ErrorMessage == AdicionarItemPedidoValidation.QtdMaxErroMsg);
}
public async Task AdicionarItem_NovoPedido_DeveExecutarComSucesso()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(_clienteId, _produtoId,
"Produto Teste", 2, 100);
_mocker.GetMock <IPedidoRepository>().Setup(r => r.UnitOfWork.Commit()).Returns(Task.FromResult(true));
// Act
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
// Assert
Assert.True(result);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.Adicionar(It.IsAny <Pedido>()), Times.Once);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.UnitOfWork.Commit(), Times.Once);
//_mocker.GetMock<IMediator>().Verify(result => result.Publish(It.IsAny<INotification>(), CancellationToken.None), Times.Once);
}
public async Task AdicionarItem_ItemExistenteAoPedidoRascunhoTotalizandoQuantidadeAcimaDoPermitido_DeveRetornarFalsoELancarEventosDeNotificacao()
{
// Arrange
var pedidoItemExistente = new PedidoItem(_produtoId, "Produto 1", 2, 100);
_pedido.AdicionarItem(pedidoItemExistente);
var pedidoCommand = new AdicionarItemPedidoCommand(_clienteId, _produtoId, "Produto 1", Pedido.MAX_UNIDADES_ITEM, 100);
_mocker.GetMock <IPedidoRepository>()
.Setup(r => r.ObterPedidoRascunhoPorClienteId(_clienteId)).Returns(Task.FromResult(_pedido));
// Act
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
// Assert
Assert.False(result);
_mocker.GetMock <IMediator>().Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Exactly(1));
}
public async Task <IActionResult> Post([FromBody] ItemViewModel item)
{
var produto = await _produtoAppService.ObterPorId(item.Id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < item.Quantidade)
{
NotificarErro("ErroValidacao", "Produto com estoque insuficiente");
}
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, item.Quantidade, produto.Valor);
await _mediatorHandler.Send(command);
return(Response());
}
public async Task AdicionarItem_CommandoInvalido_DeveRetornarFalsoELancarEventosDeNotificacao()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(clienteId: Guid.Empty,
produtoId: Guid.NewGuid(),
nome: "",
quantidade: 0,
valorUnitario: 0);
// Act
var pedidoRepository = Substitute.For <IPedidoRepository>();
var mediator = Substitute.For <IMediator>();
var pedidoHandler = Substitute.For <PedidoCommandHandler>(pedidoRepository, mediator);
var result = await pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
// Assert
result.Should().BeFalse();
await mediator.Received(4).Publish(Arg.Any <INotification>());
}
public async Task AdicionarItem_NovoPedido_DeveExecutarComSucesso()
{
//Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(_clienteId,
_produtoId, "Produto Teste", 2, 100);
//implementação de CQRS via commandHandler -> recebe injeções de dependencia (repositorio e mediator-entrega do comando para o comand handler)
//var mocker = new AutoMocker();
//var pedidoHandler = mocker.CreateInstance<PedidoCommandHandler>();
_mocker.GetMock <IPedidoRepository>().Setup(r => r.UnitOfWork.Commit()).Returns(Task.FromResult(true));
//Act
var result = await _pedidoHandler.Handle(pedidoCommand, CancellationToken.None);
//Assert
Assert.True(result);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.Adicionar(It.IsAny <Pedido>()), Times.Once);
_mocker.GetMock <IPedidoRepository>().Verify(r => r.UnitOfWork.Commit(), Times.Once);
//mocker.GetMock<IMediator>().Verify(r => r.Publish(It.IsAny<INotification>(),CancellationToken.None), Times.Once);
}
public void AdicionarItemPedidoCommand_CommandoEstaInvalido_NaoDevePassarNaValidacao()
{
// Arrange
var pedidoCommand = new AdicionarItemPedidoCommand(clienteId: Guid.Empty,
produtoId: Guid.Empty,
nome: "",
quantidade: 0,
valorUnitario: 0);
// Act
var result = pedidoCommand.EhValido();
// Assert
result.Should().BeFalse();
pedidoCommand.ValidationResult.Errors.Should().HaveCount(5);
pedidoCommand.ValidationResult.Errors.Should().Contain(x => x.ErrorMessage == AdicionarItemPedidoValidation.IdProdutoErroMsg);
pedidoCommand.ValidationResult.Errors.Should().Contain(x => x.ErrorMessage == AdicionarItemPedidoValidation.IdClienteErroMsg);
pedidoCommand.ValidationResult.Errors.Should().Contain(x => x.ErrorMessage == AdicionarItemPedidoValidation.NomeErroMsg);
pedidoCommand.ValidationResult.Errors.Should().Contain(x => x.ErrorMessage == AdicionarItemPedidoValidation.QtdMinErroMsg);
pedidoCommand.ValidationResult.Errors.Should().Contain(x => x.ErrorMessage == AdicionarItemPedidoValidation.ValorErroMsg);
}
public void CommandParaAdicionarItemDeveSerValido()
{
// Arrange
var command = new AdicionarItemPedidoCommand(
Guid.NewGuid(),
Guid.NewGuid(),
"Produto teste",
2,
100
);
// Act
var estaValido = command.EstaValido();
// Assert
estaValido
.Should()
.BeTrue();
}
public async Task DeveNotificarErrosParaUmCommandInvalido()
{
// Arrange
var command = new AdicionarItemPedidoCommand(
Guid.Empty, Guid.Empty, "", 0, 0);
var mocker = new AutoMocker();
var pedidoHandler = mocker.CreateInstance <PedidoCommandHandler>();
// Act
var resultado = await pedidoHandler.Handle(command, CancellationToken.None);
// Assert
resultado.Should().BeFalse();
mocker.GetMock <IMediator>()
.Verify(x =>
x.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Exactly(5));
}
