public void Adicionar_ClienteValido_RetornaVerdadeiro()
{
// Arrange
_clienteRepository.Setup(x => x.Adicionar(_clienteValido)).Returns(true);
// Act && Assert
_clienteService.Adicionar(_clienteValido).Should().BeTrue();
_clienteRepository.Verify(x => x.Adicionar(_clienteValido), Times.Once);
}
public void ClienteService_Adicionar_DeveExecutarComSucesso()
{
var cliente = _clienteTestsAutoMockerFixture.GerarClienteValido();
_clienteService.Adicionar(cliente);
_clienteTestsAutoMockerFixture.AutoMocker.GetMock <IClienteRepository>().Verify(r => r.Adicionar(cliente), Times.Once);
_clienteTestsAutoMockerFixture.AutoMocker.GetMock <IMediator>().Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Once);
}
public void ClienteService_Adicionar_DeveExecutarComSucesso()
{
//Arrange
var cliente = _clienteTestsAutoMockerFixture.GerarClienteValido();
//Act
_clienteService.Adicionar(cliente);
//Assert
Assert.True(cliente.EhValido()); //não é obrigatorio
_clienteTestsAutoMockerFixture.Mocker.GetMock <IClienteRepository>().Verify(r => r.Adicionar(cliente), Times.Once);
_clienteTestsAutoMockerFixture.Mocker.GetMock <IMediator>().Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Once);
}
public void ClienteService_Adicionar_DeveExecutarComSucesso1()
{
//arrange
var cliente = _clienteTestsBogus.GerarClienteValido();
//act
clienteService.Adicionar(cliente);
//assert
Assert.True(cliente.EhValido());
_clienteTestsBogus.mocker.GetMock <IClienteRepository>().Verify(l => l.Adicionar(cliente), Times.Once);
_clienteTestsBogus.mocker.GetMock <IMediator>().Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Once);
}
public void testInserts()
{
Seguro Dados = new Seguro()
{
Cliente = new Cliente {
Nome = "Thiago", CPF = "11111111111", Idade = 27
},
Veiculo = new Veiculo {
Marca = "Honda", Modelo = "Fit", Valor = 70000
}
};
IClienteService _clienteService = new ClienteService(new ClienteRepository());
IVeiculoService _veiculoService = new VeiculoService(new VeiculoRepository());
ISeguroService _seguroService = new SeguroService(new SeguroRepository());
Dados.Cliente = _clienteService.Adicionar(Dados.Cliente);
Dados.Veiculo.Id_Cliente = Dados.Cliente.Id;
Dados.Veiculo = _veiculoService.Adicionar(Dados.Veiculo);
var seguro = _seguroService.Adicionar(Dados);
Assert.AreEqual(true, seguro != null);
}
public void ClienteService_Adicionar_DeveExecutarComSucesso()
{
// Arrange
var cliente = _clienteTestsBogus.GerarClienteValido();
//Utilizando a biblioteca Mock para gerar instâncias de classes, resolvendo automaticamente
// as suas dependências
var clienteRepo = new Mock <IClienteRepository>();
var mediatr = new Mock <IMediator>();
//A instâcia estará disponínel através da propriedade Object
var clienteService = new ClienteService(clienteRepo.Object, mediatr.Object);
// Act
clienteService.Adicionar(cliente);
// Assert
Assert.True(cliente.EhValido());
//Verificando se um determinado método dentro de Cliente repositório foi chamado uma vez
clienteRepo.Verify(r => r.Adicionar(cliente), Times.Once);
//It.IsAny -> Valida se o método publish recebeu algum objeto que implementa a interface INotification
// e que o método Publish tenha sido chamado 1 vez
mediatr.Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Once);
}
public RedirectToActionResult Adicionar(AdicionarRequestModel requestModel)
{
// Validações e filtros de Dados
var listaDeErros = requestModel.ValidarEFiltrar();
if (listaDeErros.Count > 0)
{
TempData["formMensagensErro"] = listaDeErros;
return(RedirectToAction("Adicionar"));
}
// Execuções de Operações
try {
_clienteService.Adicionar(requestModel);
TempData["formMensagemSucesso"] = "Cliente adicionado com sucesso!";
return(RedirectToAction("Index"));
} catch (Exception exception)
{
TempData["formMensagensErro"] = new List <string> {
exception.Message
};
return(RedirectToAction("Adicionar"));
}
}
public void DadoClienteComInformacaoValidaDeveIncluirNoBanco()
{
//Arrange
var clienteId = Guid.NewGuid();
var cliente = new Cliente()
{
Id = clienteId,
Nome = "Carlos",
Endereco = "Rua Teste",
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("DbHungryPizzaContext")
.Options;
var contexto = new ApplicationDbContext(options);
var clienteRepository = new ClienteRepository(contexto);
var notificador = new Notificador();
var clienteService = new ClienteService(clienteRepository, notificador);
//Act
var retorno = clienteService.Adicionar(cliente);
//Assert
var cadastroCliente = clienteRepository.ObterCliente(clienteId);
Assert.NotNull(cadastroCliente.Result);
}
public RedirectToActionResult Cliente(AdicionarClienteRequestModel requestModel)
{
var Nome = requestModel.Nome;
var Tipo = requestModel.Tipo;
var Email = requestModel.Email;
var Data = requestModel.Data;
var Endereco = requestModel.Endereco;
var Observacao = requestModel.Observacao;
var CpfCnpj = requestModel.CpfCnpj;
try
{
_clienteService.Adicionar(requestModel);
TempData["msg_sucesso"] = "Cliente adicionado com sucesso!";
return(RedirectToAction("Cliente"));
}
catch (Exception exception)
{
TempData["msg"] = new List <string> {
exception.Message
};
return(RedirectToAction("Cliente"));
}
}
public RedirectToActionResult Adicionar(AdicionarRequestViewModel requestModel)
{
/* VALIDAÇÔES E FILTROS */
var listaDeErros = requestModel.ValidarEFiltrar();
if (listaDeErros.Count > 0)
{
TempData["formMensagensErro"] = listaDeErros;
return(RedirectToAction("Adicionar"));
}
/* OPERAÇÔES */
try {
_clienteService.Adicionar(requestModel);
TempData["formMensagemSucesso"] = "Cliente adicionado com sucesso!";
return(RedirectToAction("Index"));
} catch (Exception exception) {
TempData["formMensagensErro"] = new List <string> {
exception.Message
};
return(RedirectToAction("Adicionar"));
}
}
public async void ClienteService_Adicionar_DeveExecutarComSucesso()
{
// Arrange
var cliente = _clienteTestsAutoMockerFixture.GerarClienteValido();
_clienteTestsAutoMockerFixture.Mocker.GetMock <IClienteRepository>().Setup(c => c.JaExisteCliente(cliente.Id, cliente.CnpjCpfDi))
.Returns(false);
// Act
var retorno = await _clienteService.Adicionar(cliente);
// Assert
Assert.True(retorno);
Assert.True(cliente.EhValido());
_clienteTestsAutoMockerFixture.Mocker.GetMock <IClienteRepository>().Verify(r => r.JaExisteCliente(cliente.Id, cliente.CnpjCpfDi), Times.Once);
_clienteTestsAutoMockerFixture.Mocker.GetMock <IClienteRepository>().Verify(r => r.Adicionar(cliente), Times.Once);
}
public void ClienteService_Adicionar_DeveExecutarComSucesso()
{
// Arrange
var cliente = ClienteTestsAutoMockerFixture.GerarClienteValido();
// Act
ClienteService.Adicionar(cliente);
// Assert
//Assert.True(cliente.EhValido());
cliente.EhValido().Should().BeTrue();
ClienteTestsAutoMockerFixture.AutoMocker.GetMock <IClienteRepository>()
.Verify(r => r.Adicionar(cliente), Times.Once);
ClienteTestsAutoMockerFixture.AutoMocker.GetMock <IMediator>()
.Verify(m => m.Publish(It.IsAny <INotification>(), default), Times.Once);
}
public void ClienteService_Adicionar_DeveFalharDevidoClienteInvalido()
{
var cliente = _clienteTestsBogusFixture.GerarClienteInvalido();
var clienteRepo = new Mock <IClienteRepository>();
var mediatr = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepo.Object, mediatr.Object);
clienteService.Adicionar(cliente);
clienteRepo.Verify(r => r.Adicionar(cliente), Times.Never);
mediatr.Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Never);
}
public void DadoPedidoComInformacaoValidaDeveIncluirNoBanco()
{
//Arrange
var pedidoId = Guid.NewGuid();
var clienteId = Guid.NewGuid();
var cliente = new Cliente()
{
Id = clienteId,
Nome = "Carlos",
Endereco = "Rua Teste",
};
var pedidoPizza = new PedidoPizza();
var listaPedidoPizzas = new List <PedidoPizza>();
var pizza = new Pizza();
pizza.Valor = 50;
for (int i = 0; i < 2; i++)
{
pedidoPizza.TipoPizza = TipoPizza.Meia;
pedidoPizza.Pizza = pizza;
listaPedidoPizzas.Add(pedidoPizza);
}
var pedido = new Pedido()
{
Id = pedidoId,
ClienteId = clienteId,
PedidoPizzas = listaPedidoPizzas
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("DbHungryPizzaContext")
.Options;
var contexto = new ApplicationDbContext(options);
var clienteRepository = new ClienteRepository(contexto);
var pedidoRepository = new PedidoRepository(contexto);
var notificador = new Notificador();
var clienteService = new ClienteService(clienteRepository, notificador);
var pedidoService = new PedidoService(pedidoRepository, clienteRepository, notificador);
//Act
var retornoCliente = clienteService.Adicionar(cliente);
var retornoPedido = pedidoService.Adicionar(pedido);
//Assert
var cadastroPedido = pedidoRepository.ObterPorId(pedidoId);
Assert.NotNull(cadastroPedido.Result);
}
public IActionResult OnPost()
{
var cliente = new Cliente
{
nom_cliente = this.cliente.nom_cliente,
des_observacao = this.cliente.des_observacao,
fl_ativo = true,
dt_cadastramento = DateTime.Now
};
_clienteService.Adicionar(cliente);
return(Redirect("./Index"));
}
public void ClienteService_Adicionar_DeveFalharDevidoClienteInvalido()
{
//Arrange
var cliente = _clienteTestsFixture.GerarClienteInvalido();
var clienteRepository = new Mock <IClienteRepository>();
var clienteMediator = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepository.Object, clienteMediator.Object);
//Act
clienteService.Adicionar(cliente);
// Assert
clienteRepository.Verify(r => r.Adicionar(cliente), Times.Never);
clienteMediator.Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Never);
}
public void ClienteService_Adicionar_DeveFalharDevidoClienteInvalido()
{
// Arrange
var cliente = ClienteTestsBogus.GerarClienteInvalido();
var clienteRepo = new Mock <IClienteRepository>();
var mediator = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepo.Object, mediator.Object);
// Act
clienteService.Adicionar(cliente);
// Assert
Assert.False(cliente.EhValido());
clienteRepo.Verify(r => r.Adicionar(cliente), Times.Never);
mediator.Verify(m => m.Publish(It.IsAny <INotification>(), default), Times.Never);
}
public void ClienteService_Adicionar_DeveFalharDevidoClienteInvalido()
{
//Arrange
var cliente = _clienteTestsFixture.GerarClienteInvalido();
var clienteRepo = new Mock <IClienteRepository>();
var mediatr = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepo.Object, mediatr.Object);
//Act
clienteService.Adicionar(cliente);
//Assert
Assert.False(cliente.EhValido());
clienteRepo.Verify(rep => rep.Adicionar(cliente), Times.Never);
mediatr.Verify(med => med.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Never);
}
public void ClienteService_Adicionar_DeveExecutarComSucesso()
{
// Arrange
var cliente = _clienteTestsBogusFixture.GerarClienteValido();
var clienteRepo = new Mock <IClienteRepository>();
var mediator = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepo.Object, mediator.Object);
// Act
clienteService.Adicionar(cliente);
// Assert
clienteRepo.Verify(r => r.Adicionar(cliente), Times.Once);
mediator.Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None));
}
public void ClienteService_Adicionar_DeveExecutarComSucesso()
{
// Arrange
var cliente = _clienteTestsBogus.GerarClienteValido();
var clienteRepo = new Mock <IClienteRepository>();
var mediatr = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepo.Object, mediatr.Object);
// Act
clienteService.Adicionar(cliente);
// Assert
Assert.True(cliente.EhValido());
//Verifica se o método Adicionar do objeto clienteRepo foi chamado ao menos uma vez, conforme o esperado.
clienteRepo.Verify(r => r.Adicionar(cliente), Times.Once);
//Verifica se o método publish foi chamado para qualquer classe que implementa a interface Inotification ao menos uma vez, conforme o esperado.
mediatr.Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Once);
}
public JsonResult Incluir(ClienteModelView cliente)
{
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <ClienteModelView, ClienteDTO>());
var mapper = new Mapper(config);
_clienteService.Adicionar(mapper.Map <ClienteDTO>(cliente));
return(Json("Cadastro efetuado com sucesso"));
}
}
public void ClienteService_Adicionar_DeveFalharDevidoClienteInvalido()
{
//Arrange
var cliente = _clienteTestsBogus.GerarClienteInvalido();
var clienteRepo = new Mock <IClienteRepository>();
var mediatr = new Mock <IMediator>();
var clienteService = new ClienteService(clienteRepo.Object, mediatr.Object);
//Act
clienteService.Adicionar(cliente);
//Assert
Assert.False(cliente.EhValido()); //não é obrigatorio
//assert interno do moq que validar se um determinado método foi chamado para o objeto em questão, quantas vezes?
clienteRepo.Verify(r => r.Adicionar(cliente), Times.Never);
//se foi passado no publish qualquer classe que implemente a interface INotification
mediatr.Verify(m => m.Publish(It.IsAny <INotification>(), CancellationToken.None), Times.Never);
}
public void ClienteService_AdicionarCliente_RetornarComSucesso()
{
// Arrange
var cliente = new Cliente
{
Nome = "Alberto",
Email = "*****@*****.**",
CPF = "25666158880",
DataNascimento = new DateTime(1980, 01, 01)
};
var repo = MockRepository.GenerateStub <IClienteRepository>();
var clienteService = new ClienteService(repo);
// Act
var result = clienteService.Adicionar(cliente);
// Assert
Assert.IsTrue(result.ValidationResult.IsValid);
}
public void ClienteService_AdicionarCliente_RetornarComFalha()
{
// Arrange
var cliente = new Cliente
{
Nome = "A",
Email = "",
CPF = "25666158881",
DataNascimento = new DateTime(2019, 01, 01)
};
var repo = MockRepository.GenerateStub <IClienteRepository>();
var clienteService = new ClienteService(repo);
// Act
var result = clienteService.Adicionar(cliente);
// Assert
Assert.IsFalse(result.ValidationResult.IsValid);
}
public void Cliente_NaoDeveIncluir_CpfJaExiste_RetornoInvalido()
{
//Arrange
var mockRepository = new Mock <IClienteRepository>(MockBehavior.Strict);
Notificacoes notificacoes = new Notificacoes();
IClienteService clienteService = new ClienteService(mockRepository.Object, notificacoes);
mockRepository.Setup(s => s.ObterPorCpfCnpj(clienteNovo.CpfCnpj)).Returns(clienteValido);
mockRepository.Setup(s => s.Adicionar(clienteNovo)).Returns(clienteNovo);
mockRepository.Setup(s => s.SaveChanges()).Returns(1);
//Act
clienteValido = clienteService.Adicionar(clienteNovo);
//Assert
Assert.True(clienteValido.IsValid);
Assert.True(notificacoes.TemNotificacao());
mockRepository.Verify(mock => mock.ObterPorCpfCnpj(clienteNovo.CpfCnpj), Times.Once);
mockRepository.Verify(mock => mock.Adicionar(clienteNovo), Times.Never);
mockRepository.Verify(mock => mock.SaveChanges(), Times.Never);
}
public void Cliente_IncluidoComSucesso_RetornoValido()
{
//Arrange
var mockRepository = new Mock <IClienteRepository>(MockBehavior.Strict);
Notificacoes notificacoes = new Notificacoes();
IClienteService clienteService = new ClienteService(mockRepository.Object, notificacoes);
mockRepository.Setup(s => s.ObterPorCpfCnpj(clienteValido.CpfCnpj)).Returns(clienteNull);
mockRepository.Setup(s => s.Adicionar(clienteValido)).Returns(clienteValido);
mockRepository.Setup(s => s.SaveChanges()).Returns(1);
//Act
clienteValido = clienteService.Adicionar(clienteValido);
//Assert
Assert.True(clienteValido.IsValid);
mockRepository.Verify(mock => mock.ObterPorCpfCnpj(clienteValido.CpfCnpj), Times.Once);
mockRepository.Verify(mock => mock.Adicionar(clienteValido), Times.Once);
mockRepository.Verify(mock => mock.SaveChanges(), Times.Once);
}
public void ClienteService_AdicionarCliente_RetornarComSucesso()
{
//Arrang
var cliente = new Cliente
{
Nome = "Marcela",
CPF = "15633485602",
Email = "*****@*****.**",
DataNascimento = new DateTime(1980, 01, 01)
};
var repo = MockRepository.GenerateMock <IClienteRepository>();
repo.Stub(s => s.Adicionar(cliente));
var clienteService = new ClienteService(repo);
//Act
var result = clienteService.Adicionar(cliente);
//Assert
Assert.IsTrue(result.ValidationResult.IsValid);
}
public RedirectToActionResult CadCliente(CadClienteRequestModel requestModel)
{
var listaDeErros = requestModel.ValidarEFiltrar();
if (listaDeErros.Count > 0)
{
TempData["FormMensagensErro"] = listaDeErros;
return(RedirectToAction("CadCliente"));
}
try
{
_clienteService.Adicionar(requestModel);
TempData["FormMensagemSucesso"] = "Cliente adicionado com sucesso!";
return(RedirectToAction("Cliente"));
}
catch (Exception exception)
{
TempData["FormMensagemErro"] = new List <string> {
exception.Message
};
return(RedirectToAction("CadCliente"));
}
}