public void TestCriarVendaComItem()
{
var vendaModel = new VendaModel
{
Cliente = new ClienteModel(int.MinValue, "Cliente"),
FormaDePagamento = DINHEIRO,
Itens = new List <VendaItemModel> {
new VendaItemModel {
Descricao = "Produto1",
QuantidadeComprada = 10,
QuantidadePromocional = 10,
ValorUnitario = 10,
ValorUnitarioPromocional = 10
},
new VendaItemModel {
Descricao = "Produto2",
QuantidadeComprada = 20,
QuantidadePromocional = 20,
ValorUnitario = 20,
ValorUnitarioPromocional = 20
}
}
};
IMapper mapper = PegarMapper();
IVendaEntityFactory vendaEntityFactory = new VendaEntityFactory(mapper);
VendaEntity venda = vendaEntityFactory.Criar(vendaModel);
Assert.Equal(2, venda.Itens.Count());
}
private void AdicionarItens(VendaEntity venda, VendaDTO vendaDTO)
{
if (vendaDTO.Itens == null)
{
return;
}
foreach (var item in vendaDTO.Itens)
{
var vendaItem = new VendaItemEntity(item, new CalculadoraPrecoVendaItem());
venda.AdicionarVendaItem(vendaItem);
}
}
public void TestConversaoFormaPagamento()
{
IVendaEntityFactory vendaEntityFactory = PegarVendaEntityFactory();
var vendaModel = new VendaModel();
vendaModel.Cliente = new ClienteModel(int.MinValue, string.Empty);
vendaModel.FormaDePagamento = DINHEIRO;
VendaEntity venda = vendaEntityFactory.Criar(vendaModel);
Assert.Equal(FormaDePagamento.Dinheiro, venda.FormaDePagamento);
}
public bool ProcessarVenda(VendaModel vendaModel)
{
VendaEntity venda = _vendaFactory.Criar(vendaModel);
var executouComSucesso = _salvarVendaService.Executar(venda);
if (!executouComSucesso)
{
CarregarErrosDe(_salvarVendaService);
}
return(executouComSucesso);
}
public void TestCriarFabrica()
{
IMapper mapper = PegarMapper();
IVendaEntityFactory vendaEntityFactory = new VendaEntityFactory(mapper);
var vendaModel = new VendaModel();
vendaModel.Cliente = new ClienteModel(int.MinValue, string.Empty);
VendaEntity venda = vendaEntityFactory.Criar(vendaModel);
Assert.NotNull(venda);
Assert.IsAssignableFrom <VendaEntity>(venda);
}
public void TestVendaNaoEhValidaSemProdutos()
{
VendaDTO vendaDTO = new VendaDTO
{
Cliente = new ClienteDTO("Cliente"),
FormaDePagamento = FormaDePagamento.Dinheiro
};
VendaEntity venda = VendaFactory(vendaDTO);
bool vendaEhValida = venda.Validar();
Assert.False(vendaEhValida);
}
private VendaEntity VendaFactory(VendaDTO vendaDTO)
{
var venda = new VendaEntity(vendaDTO.Cliente, vendaDTO.FormaDePagamento);
if (vendaDTO.Itens == null)
{
return(venda);
}
foreach (var item in vendaDTO.Itens)
{
var vendaItem = new VendaItemEntity(item, new CalculadoraPrecoVendaItem());
venda.AdicionarVendaItem(vendaItem);
}
return(venda);
}
public static bool MergeFrom(this VendaEntity vendaEntity, VendaEntity vendaNew, out string msg)
{
msg = String.Empty;
if (vendaEntity != null && TryValidStatus(vendaNew.Status, vendaEntity.Status))
{
vendaEntity.Status = vendaEntity.Status;
return(true);
}
else
{
msg = "Venda com status inválida ou nula";
return(false);
}
}
public void TestVendaNaoEhValidaComFormaDePagamentoIndefinida()
{
VendaDTO vendaDTO = new VendaDTO
{
Cliente = new ClienteDTO("Cliente"),
FormaDePagamento = FormaDePagamento.None,
Itens = new List <VendaItemDTO> {
VendaItemDTOFactory("Descricao", 1, 1)
}
};
VendaEntity venda = VendaFactory(vendaDTO);
var vendaEhValida = venda.Validar();
Assert.False(vendaEhValida);
}
public void TestVendaEhValidaComUmProdutoAoMenos()
{
var vendaDTO = new VendaDTO
{
Cliente = new ClienteDTO("Cliente"),
FormaDePagamento = FormaDePagamento.Dinheiro,
Itens = new List <VendaItemDTO> {
VendaItemDTOFactory("Produto1", 1, 1)
}
};
VendaEntity venda = VendaFactory(vendaDTO);
bool vendaEhValida = venda.Validar();
Assert.True(vendaEhValida);
}
public void TestExecutarServicoComSucesso()
{
var vendaMock = new Mock <VendaEntity>();
vendaMock.SetReturnsDefault <bool>(true);
VendaEntity venda = vendaMock.Object;
var vendaRepositoryMock = new Mock <IVendaRepository>();
vendaRepositoryMock.SetReturnsDefault <bool>(true);
IVendaRepository vendaRepository = vendaRepositoryMock.Object;
ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
bool executadoComSucesso = salvarVendaService.Executar(venda);
Assert.True(executadoComSucesso);
}
public void TestExecutaComSucessoQuandoRepositorioNaoGrava()
{
var mockVenda = new Mock <VendaEntity>();
mockVenda.SetReturnsDefault <bool>(true);
VendaEntity venda = mockVenda.Object;
var vendaRepositoryMock = new Mock <IVendaRepository>();
vendaRepositoryMock.SetReturnsDefault <bool>(false);
IVendaRepository vendaRepository = vendaRepositoryMock.Object;
ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
bool executadoComSucesso = salvarVendaService.Executar(venda);
Assert.False(executadoComSucesso);
}
public bool Executar(VendaEntity venda)
{
if (!venda.Validar())
{
RegistrarErro(new MensagemErro("A venda está invalida!"));
return(false);
}
bool salvouVenda = _vendaRepository.Salvar(venda);
if (!salvouVenda)
{
RegistrarErro(new MensagemErro("Não foi possível salvar a venda"));
}
return(salvouVenda);
}
public void TestVendaNaoEhValidaComTotalMenorIgualZero()
{
VendaDTO vendaDTO = new VendaDTO
{
Cliente = new ClienteDTO("Cliente"),
FormaDePagamento = FormaDePagamento.Dinheiro,
Itens = new List <VendaItemDTO> {
VendaItemDTOFactory("Produto", 0, 1)
}
};
VendaEntity venda = VendaFactory(vendaDTO);
bool vendaEhValida = venda.Validar();
decimal totalVendido = venda.TotalVenda();
Assert.False(vendaEhValida);
Assert.Equal(0, totalVendido);
}
public void TestServicoPossuiMensagemDeErroAoTentarSalvarVendaInvalida()
{
var mensagemDeRetornoEsperada = "A venda está invalida!";
var vendaMock = new Mock <VendaEntity>();
vendaMock.SetReturnsDefault <bool>(false);
VendaEntity venda = vendaMock.Object;
var vendaRepositoryMock = new Mock <IVendaRepository>();
vendaRepositoryMock.SetReturnsDefault <bool>(true);
IVendaRepository vendaRepository = vendaRepositoryMock.Object;
ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
salvarVendaService.Executar(venda);
var mensagemErro = salvarVendaService.PegarMensagensErro().First();
Assert.Equal(mensagemDeRetornoEsperada, mensagemErro.Mensagem);
}
public void TestCapturaErrosDeVendaItem()
{
var vendaItemErros = new List <ValidationResult> {
new ValidationResult("Erro no Item de venda")
};
var vendaItemMock = new Mock <VendaItemEntity>(MockBehavior.Strict);
vendaItemMock
.Setup(vi => vi.Validate())
.Returns(vendaItemErros);
vendaItemMock
.Setup(vi => vi.ValorTotal(It.IsAny <FormaDePagamento>()))
.Returns(10);
VendaEntity venda = new VendaEntity(new ClienteDTO("Cliente"), FormaDePagamento.Dinheiro);
venda.AdicionarVendaItem(vendaItemMock.Object);
var listaErrosEncontrados = venda.Validate();
Assert.Equal(vendaItemErros, listaErrosEncontrados);
}
public void TestServicoPossuiMensagemDeErroQuandoRepositorioNaoSalva()
{
var mensagemDeRetornoEsperada = "Não foi possível salvar a venda";
var vendaMock = new Mock <VendaEntity>();
vendaMock.SetReturnsDefault <bool>(true);
VendaEntity venda = vendaMock.Object;
var vendaRepositoryMock = new Mock <IVendaRepository>();
vendaRepositoryMock.SetReturnsDefault <bool>(false);
IVendaRepository vendaRepository = vendaRepositoryMock.Object;
ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
salvarVendaService.Executar(venda);
var mensagemErro = salvarVendaService.PegarMensagensErro().First();
Assert.Equal(mensagemDeRetornoEsperada, mensagemErro.Mensagem);
}
public void TestCriarVendaComFormaDePagamento(FormaDePagamento formaDePagamento)
{
var cliente = new ClienteDTO("Cliente");
var vendaDTO = new VendaDTO()
{
Cliente = cliente,
FormaDePagamento = formaDePagamento,
Itens = new List <VendaItemDTO>()
};
VendaEntity venda = new VendaEntity(vendaDTO.Cliente, vendaDTO.FormaDePagamento);
foreach (var item in vendaDTO.Itens)
{
var vendaItem = new VendaItemEntity(item, new CalculadoraPrecoVendaItem());
venda.AdicionarVendaItem(vendaItem);
}
ClienteDTO clienteRetornado = venda.Cliente;
Assert.Equal(formaDePagamento, venda.FormaDePagamento);
Assert.Equal(cliente, clienteRetornado);
}
public bool Salvar(VendaEntity venda)
{
return(true);
}
