public void AtualizarProduto_ProdutoInconsistente_Sucesso_False()
{
var produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
};
var stubRepository = MockRepository.GenerateMock<IProdutoRepository>();
stubRepository.Stub(p => p.Inserir(produto)).Return(produto);
stubRepository.Stub(p => p.Atualizar(produto)).Return(produto);
this.produtoService = new ProdutoService(stubRepository);
var produtoResult = this.produtoService.Inserir(produto);
Assert.IsTrue(produtoResult.ResultadoValidacao.IsValid);
string nomeAntesAtualizar = produtoResult.Nome;
decimal precoAntesAtualizar = produtoResult.Preco;
produto.Nome = string.Empty;
produto.Preco = 0;
produtoResult = this.produtoService.Atualizar(produto);
Assert.IsFalse(produtoResult.ResultadoValidacao.IsValid);
Assert.AreEqual(produtoResult.ResultadoValidacao.Erros.Count(), 2);
Assert.IsTrue(produtoResult.ResultadoValidacao.Erros.Contains(ProdutoErrors.messageProdutoNaoPossuiNome));
Assert.IsTrue(produtoResult.ResultadoValidacao.Erros.Contains(ProdutoErrors.messageProdutoNaoPossuiPreco));
}
public void AtualizarProduto_ProdutoConsistente_Sucesso_True()
{
var produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
};
var stubRepository = MockRepository.GenerateMock<IProdutoRepository>();
stubRepository.Stub(p => p.Inserir(produto)).Return(produto);
stubRepository.Stub(p => p.Atualizar(produto)).Return(produto);
this.produtoService = new ProdutoService(stubRepository);
var produtoResult = this.produtoService.Inserir(produto);
string nomeAntesAtualizar = produtoResult.Nome;
produto.Nome = "Café";
produtoResult = this.produtoService.Atualizar(produto);
Assert.IsTrue(produtoResult.ResultadoValidacao.IsValid);
Assert.AreNotEqual(produtoResult.Nome, nomeAntesAtualizar);
}
public CreateModel(INotificador notificador,
IProdutoService produtoService,
IFornecedorRepository fornecedorRepository,
IMapper mapper)
{
_notificador = notificador;
_produtoService = produtoService;
_fornecedorRepository = fornecedorRepository;
_mapper = mapper;
}
public ProdutosController(INotificador notificador,
IProdutoRepository produtoRepository,
IProdutoService produtoService,
IMapper mapper,
IUser user) : base(notificador, user)
{
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
}
public ProdutosController(IProdutoRepository produtoRepository,
IFornecedorRepository fornecedorRepository,
IMapper mapper, IProdutoService produtoService,
INotificador notificador) : base(notificador)
{
_produtoRepository = produtoRepository;
_fornecedorRepository = fornecedorRepository;
_mapper = mapper;
_produtoService = produtoService;
}
public NFCeViewModel(DestinatarioViewModel destinatarioViewModel, IDialogService dialogService, IEnviarNota enviarNotaController, INaturezaOperacaoService naturezaOperacaoService, IConfiguracaoService configuracaoService, IProdutoService produtoService, IDestinatarioService destinatarioService)
{
Pagamento = new PagamentoVO();
Produto = new ProdutoVO();
DestinatarioParaSalvar = new DestinatarioModel();
TransportadoraParaSalvar = new TransportadoraModel();
Destinatarios = new ObservableCollection <DestinatarioModel>();
Transportadoras = new ObservableCollection <TransportadoraModel>();
ProdutosCombo = new ObservableCollection <ProdutoEntity>();
AdicionarProdutoCmd = new RelayCommand <object>(AdicionarProdutoCmd_Execute, null);
GerarPagtoCmd = new RelayCommand <object>(GerarPagtoCmd_Execute, null);
EnviarNotaCmd = new RelayCommand <IClosable>(EnviarNotaCmd_Execute);
LoadedCmd = new RelayCommand <string>(LoadedCmd_Execute, null);
ClosedCmd = new RelayCommand(ClosedCmd_Execute, null);
ExcluirProdutoNotaCmd = new RelayCommand <ProdutoVO>(ExcluirProdutoNotaCmd_Execute, null);
ExcluirPagamentoCmd = new RelayCommand <PagamentoVO>(ExcluirPagamentoCmd_Execute, null);
_dialogService = dialogService;
_enviarNotaController = enviarNotaController;
_naturezaOperacaoService = naturezaOperacaoService;
_configuracaoService = configuracaoService;
_produtoService = produtoService;
_destinatarioService = destinatarioService;
destinatarioViewModel.DestinatarioSalvoEvent += DestinatarioVM_DestinatarioSalvoEvent;
Finalidades = new List <string>()
{
"Normal",
"Complementar",
"Ajuste",
"Devolução"
};
FormasPagamento = new Dictionary <string, string>()
{
{ "Dinheiro", "Dinheiro" },
{ "Cheque", "Cheque" },
{ "CartaoCredito", "Cartão de Crédito" },
{ "CartaoDebito", "Cartão de Débito" }
//{ "CreditoLoja", "Crédito Loja" },
//{ "ValeAlimentacao", "Vale Alimentação" },
//{ "ValeRefeicao", "Vale Refeição" },
//{ "ValePresente", "Vale Presente"},
//{ "ValeCombustivel", "Vale Combustível"},
//{ "Outros", "Outros" }
};
Parcelas = new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
};
}
public async Task DeveCadastarProdutoValido()
{
IProdutoService produtoService = _serviceProvider.GetRequiredService <IProdutoService>();
var usuario = await produtoService.CadastrarAsync(new ProdutoDto
{
Nome = "Teste",
Preco = Convert.ToDecimal(10.5)
});
usuario.Should().NotBeNull(StringHelper.JoinHtmlMensagem(produtoService.MensagensValidacao));
}
public ProdutoController(INotificador notificador, IAspNetUser appUser,
ICategoriaRepository categoriaRepository,
IProdutoRepository produtoRepository,
IProdutoService produtoService,
IMapper mapper) : base(notificador, appUser)
{
_categoriaRepository = categoriaRepository;
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
}
public PedidoController(IPedidoService pedidoService, IHttpContextAccessor httpContextAccessor, IClienteService clienteService, IProdutoService produtoService, IAlbumService albumService, IFotoService fotoService, IPedidoFotoProdutoService pedidoFotoProdutoService, IFotoProdutoService fotoProdutoService)
{
_pedidoService = pedidoService;
_httpContextAccessor = httpContextAccessor;
_clienteService = clienteService;
_produtoService = produtoService;
_albumService = albumService;
_fotoService = fotoService;
_pedidoFotoProdutoService = pedidoFotoProdutoService;
_fotoProdutoService = fotoProdutoService;
}
private async Task CadastrarNovoProdutoCoMesmoLogin()
{
IProdutoService service = serviceProvider.GetRequiredService <IProdutoService>();
Produto produto = new Produto();
produto.Nome = $"Produto de teste2";
produto.Preco = 10;
await service.Add(produto);
service.Result.Any().Should().BeTrue();
}
public ProdutosController(INotificador notificador,
IProdutoRepository produtoRepository,
IProdutoService produtoService,
IMapper mapper,
IWebHostEnvironment env) : base(notificador)
{
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
_env = env;
}
public ProdutoServiceClient()
{
var binding = new BasicHttpBinding();
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
binding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
this.channelFactory = new ChannelFactory <IProdutoService>(binding, "http://localhost:7171/Produto.svc");
this.channelFactory.Credentials.UserName.UserName = "******";
this.channelFactory.Credentials.UserName.Password = "******";
this.Service = channelFactory.CreateChannel();
}
public ProdutosController(IProdutoRepository produtoRepository,
IProdutoService produtoService,
IConfiguration configuration,
IMapper mapper,
INotificador notificador,
IUser user) : base(notificador, user)
{
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
_configuration = configuration;
}
public ProdutosController(
INotificador notificador,
IProdutoRep produtoRep,
IProdutoService produtoServ,
IMapper mapper,
IUser user)
: base(user, notificador)
{
_produtoRep = produtoRep;
_produtoServ = produtoServ;
_mapper = mapper;
}
public ProdutoAdminController(INotificador notificador,
IProdutoRepository produtoRepository,
IProdutoService produtoService,
IRelatorioService relatorioService,
IMapper mapper,
IAspNetUser user) : base(notificador, user)
{
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
_relatorioService = relatorioService;
}
public MovimentacaoSaidaProdutoService(IMovimentacaoSaidaProdutoRepository movimentacaoSaidaProdutoRepository,
IRequestNotificator notifications,
IProdutoService produtoService,
IEstoqueService estoqueService,
IMediator mediator)
{
_movimentacaoSaidaProdutoRepository = movimentacaoSaidaProdutoRepository;
_produtoService = produtoService;
_estoqueService = estoqueService;
_mediator = mediator;
_notifications = notifications;
}
public ProdutosController()
{
_service = new ProdutoService();
_imageTypes = new string[] {
"image/gif",
"image/jpeg",
"image/jpg",
"image/pjpeg",
"image/png"
};
}
public CompraProdutoService(ICompraProdutoRepository repositoryBase,
IEntradaProdutoEstoqueService entradaProdutoEstoqueService,
IEstoqueService estoqueService,
IEstoqueProdutoService estoqueProdutoService,
IProdutoService produtoService) : base(repositoryBase)
{
_compraProdutoRepository = repositoryBase;
_entradaProdutoEstoqueService = entradaProdutoEstoqueService;
_estoqueService = estoqueService;
_estoqueProdutoService = estoqueProdutoService;
_produtoService = produtoService;
}
public VendaProdutoService(IVendaProdutoRepository vendaProdutoRepository,
ISaidaProdutoEstoqueService saidaProdutoEstoqueService,
IEstoqueService estoqueService,
IProdutoService produtoService,
IEstoqueProdutoService estoqueProdutoService) : base(vendaProdutoRepository)
{
_vendaProdutoRepository = vendaProdutoRepository;
_saidaProdutoEstoqueService = saidaProdutoEstoqueService;
_estoqueService = estoqueService;
_produtoService = produtoService;
_estoqueProdutoService = estoqueProdutoService;
}
public ProdutosController(
IProdutoRepository fornecedorRepository,
IProdutoService fornecedorService,
IEnderecoRepository enderecoRepository,
IMapper mapper,
INotificador notificador,
IUser user
) : base(notificador, user)
{
_produtoRepository = fornecedorRepository;
_produtoService = fornecedorService;
_mapper = mapper;
}
public async Task NaoDeveCadastarCasoNomeNulo()
{
IProdutoService produtoService = _serviceProvider.GetRequiredService <IProdutoService>();
var usuario = await produtoService.CadastrarAsync(new ProdutoDto
{
Nome = null,
Preco = Convert.ToDecimal(10.5)
});
usuario.Should().BeNull();
produtoService.MensagensValidacao.Should().NotBeNull(StringHelper.JoinHtmlMensagem(produtoService.MensagensValidacao));
produtoService.MensagensValidacao.Any(c => c == ProdutoMessage.NomeObrigatorio).Should().BeTrue();
}
public async Task NaoDeveCadastarCasoPrecoInvalido()
{
IProdutoService produtoService = _serviceProvider.GetRequiredService <IProdutoService>();
var usuario = await produtoService.CadastrarAsync(new ProdutoDto
{
Nome = "Coca Cola",
Preco = 0
});
usuario.Should().BeNull();
produtoService.MensagensValidacao.Should().NotBeNull(StringHelper.JoinHtmlMensagem(produtoService.MensagensValidacao));
produtoService.MensagensValidacao.Any(c => c == ProdutoMessage.PrecoObrigatorio).Should().BeTrue();
}
public Service(
IUnitOfWork unitOfWork, IMapper mapper, IUsuarioService usuarioService,
IClienteService clienteService, ITransportadorService transportadorService,
IClienteTransportadora clienteTransportadora, IProdutoService produtoService)
{
_unitOfWork = unitOfWork;
_mapper = mapper;
UsuarioService = usuarioService;
ClienteService = clienteService;
TransportadorService = transportadorService;
ClienteTransportadora = clienteTransportadora;
ProdutoService = produtoService;
}
public ProdutosController(IProdutoService produtoService,
UserManager <IdentityUser> userManager,
IProdutoRepository produtoRepository,
IMapper mapper,
INotificador notificador,
IUser user
) : base(notificador, user)
{
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
_userManager = userManager;
}
public ProdutosController(
IMapper mapper,
IProdutoService produtoService,
IProdutoRepository produtoRepository,
INotificationHandler <DomainNotification> notifications,
IUser user,
IMediatorHandler mediator)
: base(notifications, user, mediator)
{
_mapper = mapper;
_produtoService = produtoService;
_produtoRepository = produtoRepository;
}
public ProdutosController(IMapper mapper,
IProdutoService produtoService,
IProdutoRepository produtoRepository,
IVendaProdutoRepository vendaProdutoRepository,
ICompraProdutoRepository compraProdutoRepository,
INotificador notificador) : base(notificador)
{
_mapper = mapper;
_produtoService = produtoService;
_produtoRepository = produtoRepository;
_vendaProdutoRepository = vendaProdutoRepository;
_compraProdutoRepository = compraProdutoRepository;
}
public ProdutoViewModel(IProdutoService produtoService, ImpostoService impostoService)
{
UnidadesComerciais = new List <string>()
{
"UN"
};
AlterarProdutoCmd = new RelayCommand <string>(AlterarProduto_Execute, null);
SalvarCmd = new RelayCommand <IClosable>(SalvarCmd_Execute, null);
CancelarCmd = new RelayCommand <object>(CancelarCmd_Execute, null);
LoadedCmd = new RelayCommand(LoadedCmd_Execute, null);
_produtoService = produtoService;
_impostoService = impostoService;
}
public ProdutosController
(
IProdutoRepository produtoRepository,
IProdutoService produtoService,
IMapper mapper,
INotificador notificador,
IOptions <RCNSettings> settings
) : base(notificador)
{
_produtoRepository = produtoRepository;
_produtoService = produtoService;
_mapper = mapper;
_settings = settings;
}
public CatalogoController(
IProdutoStore produtoStore,
IGeoposicaoService geoposicaoService,
IFreteService freteService,
IProdutoService produtoService,
ICategoriaStore categoriaStore,
IMarcaStore marcaStore)
{
_produtoStore = produtoStore;
_geoposicaoService = geoposicaoService;
_freteService = freteService;
_produtoService = produtoService;
_categoriaStore = categoriaStore;
_marcaStore = marcaStore;
}
#pragma warning disable S107 // Methods should not have too many parameters
public PactoAppService(IUsuarioService usuarioService, IUnitOfWork uow, IPactoService pactoService, ILogService logService, IProdutoService produtoService, IHistoricoService historicoService, IFeriadoService feriadoService, IUnidadeService unidadeService,
ICronogramaService cronogramaService, ISituacaoPactoService situacaoPactoService, INotificadorAppService notificadorAppService, IAvaliacaoProdutoService avaliacaoProdutoService)
#pragma warning restore S107 // Methods should not have too many parameters
: base(uow)
{
_usuarioService = usuarioService;
_pactoService = pactoService;
_logService = logService;
_produtoService = produtoService;
_historicoService = historicoService;
_feriadoService = feriadoService;
_unidadeService = unidadeService;
_notificadorAppService = notificadorAppService;
_avaliacaoProdutoService = avaliacaoProdutoService;
}
public ProdutoMutation(IProdutoService service)
{
Name = "Mutation";
Field <ProdutoType>(
"createProduto",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ProdutoInputType> > {
Name = "produto"
}
),
resolve: context =>
{
var item = context.GetArgument <Produto>("produto");
return(service.Save(item));
});
}
public VendasController(IClienteService clienteService,
IProdutoService produtoService,
ITipoPagamentoService tipoPagamentoService,
IVendedorService vendedorService,
IPedidoService pedidoService,
IItemPedidoService itemPedidoService,
IFormaPagamentoService formaPagamentoService)
{
_clienteService = clienteService;
_produtoService = produtoService;
_tipoPagamentoService = tipoPagamentoService;
_vendedorService = vendedorService;
_pedidoService = pedidoService;
_itemPedidoService = itemPedidoService;
_formaPagamentoService = formaPagamentoService;
}
public ProdutoAppService(IProdutoService produtoService, IUnitOfWork unitOfWork)
: base(unitOfWork)
{
this.produtoService = produtoService;
}
public ProdutoDataManagerImpl()
{
_service = new ProdutoService();
_control = new ProdutoControl();
}
protected void DataManagerBase(IProdutoService repositorio, BaseControl control)
{
if (repositorio == null)
throw new ArgumentNullException("repositorio");
if (control == null)
throw new ArgumentNullException("control");
_service = repositorio;
Controle = control;
RefreshAll();
}
public ProdutoAppService(IProdutoService service)
{
_service = service;
}
public CarroDeComprasController(IProdutoService produtoService, IPedidoService pedidoService)
{
this._pedidoService = pedidoService;
this._produtoService = produtoService;
}
public ProdutoController(IProdutoService produtoService)
{
_produtoService = produtoService;
}
public void InserirProduto_ProdutoConsistente_Sucesso_True()
{
var produto = new Produto()
{
Nome = "Sabonete",
Preco = 5
};
var stubRepository = MockRepository.GenerateMock<IProdutoRepository>();
stubRepository.Stub(p => p.Inserir(produto)).Return(produto);
this.produtoService = new ProdutoService(stubRepository);
var produtoResult = this.produtoService.Inserir(produto);
Assert.IsTrue(produtoResult.ResultadoValidacao.IsValid);
}
public void InserirProduto_ProdutoInconsistente_Sucesso_False()
{
var produto = new Produto();
var stubRepository = MockRepository.GenerateMock<IProdutoRepository>();
stubRepository.Stub(p => p.Inserir(produto)).Return(produto);
this.produtoService = new ProdutoService(stubRepository);
var produtoResult = this.produtoService.Inserir(produto);
Assert.IsFalse(produtoResult.ResultadoValidacao.IsValid);
Assert.AreEqual(produtoResult.ResultadoValidacao.Erros.Count(), 2);
Assert.IsTrue(produtoResult.ResultadoValidacao.Erros.Contains(ProdutoErrors.messageProdutoNaoPossuiNome));
Assert.IsTrue(produtoResult.ResultadoValidacao.Erros.Contains(ProdutoErrors.messageProdutoNaoPossuiPreco));
}
public void SelecionarTodos_Sucesso_True()
{
var produto = new Produto()
{
ProdutoId = 1,
Nome = "Sabonete",
Preco = 5
};
var produto2 = new Produto()
{
ProdutoId = 2,
Nome = "Carro",
Preco = 10
};
var produto3 = new Produto()
{
ProdutoId = 3,
Nome = "Moto",
Preco = 20
};
IList<Produto> produtos = new List<Produto>()
{
produto,
produto2,
produto3
};
var stubRepository = MockRepository.GenerateMock<IProdutoRepository>();
stubRepository.Stub(p => p.SelecionarTodos()).Return(produtos);
this.produtoService = new ProdutoService(stubRepository);
var produtoResult = this.produtoService.SelecionarTodos();
Assert.IsTrue(produtos.Contains(produto));
Assert.IsTrue(produtos.Contains(produto2));
Assert.IsTrue(produtos.Contains(produto3));
}
public void DeletarProduto_Sucesso_True()
{
var produto = new Produto()
{
ProdutoId = 1,
Nome = "Sabonete",
Preco = 5
};
var stubRepository = MockRepository.GenerateMock<IProdutoRepository>();
stubRepository.Stub(p => p.Inserir(produto)).Return(produto);
stubRepository.Stub(p => p.SelecionarPorId(produto.ProdutoId)).Return(produto);
stubRepository.Stub(p => p.Deletar(produto)).Return(produto);
this.produtoService = new ProdutoService(stubRepository);
var produtoResult = this.produtoService.Deletar(produto.ProdutoId);
Assert.AreEqual(produto, produtoResult);
}