public PaginaConta()
{
InitializeComponent();
_contaServico = new ContaServico();
numValor.Select();
numValor.Focus();
}
public ExibirFinanceiro()
{
InitializeComponent();
_contaServico = new ContaServico();
cbTipo.SelectedItem = "ABERTAS";
ExibirTodas();
}
////////////////////////////////////// APAGAR CADASTRO /////////////////////////////////////////////
private void BtnDeletar_Click(object sender, EventArgs e)
{
try
{
_contaServico = new ContaServico();
_animalServico = new AnimalServico();
if (_contaServico.Buscar(x => x.CadastroID == _cadastro.ID && x.ValorPago < x.Total).Count != 0)
{
throw new AcaoProibidaException("NÃO É POSSÍVEL EXCLUIR UM CADASTRO QUE POSSUI CONTAS PENDENTES!");
}
if (_animalServico.Buscar(x => x.CadastroID == _cadastro.ID).Count != 0)
{
throw new AcaoProibidaException("NÃO É POSSÍVEL EXCLUIR UM CADASTRO QUE POSSUI ANIMAIS RELACIONADOS!");
}
if (MessageBox.Show("TEM CERTEZA QUE DESEJA APAGAR ESSE REGISTRO?\n\nOBS:\nESSA AÇÃO NÃO PODE SER DESFEITA!", "ATENÇÃO!", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.OK)
{
_cadastroServico = new CadastroServico();
_cadastroServico.Excluir(_cadastro);
MessageBox.Show("CADASTRO APAGADO!", "INFO", MessageBoxButtons.OK, MessageBoxIcon.None);
Close();
}
}
catch (AcaoProibidaException erro)
{
MessageBox.Show($"ATENÇÃO!\n\n{erro.Message}", "ERRO", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
private void AtualizarInfoConta()
{
_contaServico = new ContaServico();
_conta = _contaServico.Buscar(x => x.ContaID == _atendimento.ContaID).FirstOrDefault();
txtPreco.Text = Convert.ToString(_conta.Total);
cbMetodoPagamento.SelectedItem = _conta.MetodoPagamento;
dtVencimento.Text = _conta.Data_Vencimento.ToShortDateString();
numParcelas.Value = _conta.Parcelas;
txtPreco.Enabled = cbMetodoPagamento.Enabled = dtVencimento.Enabled = numParcelas.Enabled = false;
lblAviso.Visible = true;
}
public void IniciarCenario()
{
_contaRepositorioMoq = new Mock <IContaRepositorio>();
_clienteRepositorioMoq = new Mock <IClienteRepositorio>();
_contaServico = new ContaServico(_contaRepositorioMoq.Object, _clienteRepositorioMoq.Object);
_clienteMock = new Mock <Cliente>();
_contaMoq = new Mock <Conta>();
_extratoMock = new Mock <Extrato>();
_contaMoq.Setup(c => c.Titular).Returns(_clienteMock.Object);
_contaBuscadaNoBancoMoq = new Mock <Conta>();
}
public void ValidarConta_IdValido_NaoDeveLancarExcecao()
{
// Arrange
int contaId = 1;
var contaRepositorio = Substitute.For <IContaRepositorio>();
contaRepositorio.Any(contaId).Returns(true);
var contaServico = new ContaServico(contaRepositorio);
// Act and Assert
contaServico.ValidarConta(contaId);
}
private void AtualizarConta()
{
if (_internamento.ContaID != null)
{
_contaServico = new ContaServico();
Conta conta = _contaServico.Buscar(x => x.ContaID == _internamento.ContaID).FirstOrDefault();
txtPreco.Text = Convert.ToString(conta.Total);
cbMetodoPagamento.SelectedItem = conta.MetodoPagamento;
numParcelas.Value = conta.Parcelas;
dtVencimento.Text = conta.Data_Vencimento.ToShortDateString();
txtPreco.Enabled = cbMetodoPagamento.Enabled = dtVencimento.Enabled = numParcelas.Enabled = false;
lblAviso1.Visible = lblAviso2.Visible = true;
}
}
private void EditarConta()
{
_contaServico = new ContaServico();
Conta conta = _contaServico.Buscar(x => x.ContaID == _internamento.ContaID).FirstOrDefault();
if (conta != null)
{
Animal animal = _animalServico.Buscar(x => x.AnimalID == Convert.ToInt64(cbPaciente.Text.Split(' ')[0])).FirstOrDefault();
if (animal != null)
{
conta.CadastroID = animal.CadastroID;
_contaServico.Editar(conta);
}
}
}
public void ValidarConta_IdInvalido_DeveLancarExcecao()
{
// Arrange
int contaId = 1;
var contaRepositorio = Substitute.For <IContaRepositorio>();
contaRepositorio.Any(contaId).Returns(false);
var contaServico = new ContaServico(contaRepositorio);
// Act
Action acao = () => contaServico.ValidarConta(contaId);
//Assert
var excecao = Assert.ThrowsException <CarteiraDigitalException>(acao);
Assert.IsTrue(excecao.Message.Contains("A conta informada é inválida!"));
}
public async Task Gerar_CashOutValido_DeveRetornarOCashOutECalcularTaxa()
{
// Arrange
var conta = new Conta {
Id = 1
};
var valor = 10m;
var descricao = "Teste unitário.";
CashOut cashOutGerado = null;
var cashOutRepositorio = Substitute.For <ICashOutRepositorio>();
cashOutRepositorio.When(x => x.Post(Arg.Any <CashOut>()))
.Do(x => cashOutGerado = x.Arg <CashOut>());
var configuracaoServico = Substitute.For <IConfiguracaoServico>();
configuracaoServico.ObterPercentualTaxa().Returns(0.01m);
configuracaoServico.ObterTamanhoMaximoDescricao().Returns((short)15);
var contaRepositorio = Substitute.For <IContaRepositorio>();
contaRepositorio.Any(conta.Id).Returns(true);
contaRepositorio.Get(conta.Id).Returns(conta);
var contaServico = new ContaServico(contaRepositorio);
var operacaoServico = new OperacaoServico(configuracaoServico);
var produtorClient = Substitute.For <IProdutorOperacoesClient>();
var cashOutServico = new CashOutServico(cashOutRepositorio, operacaoServico, contaServico, configuracaoServico, null, produtorClient);
// Act
await cashOutServico.Gerar(new OperacaoUnariaDto(conta.Id, valor, descricao));
// Assert
Assert.IsNotNull(cashOutGerado);
Assert.AreEqual(valor, cashOutGerado.Valor);
Assert.AreEqual(0.1m, cashOutGerado.ValorTaxa);
Assert.AreEqual(descricao, cashOutGerado.Descricao);
Assert.AreEqual(StatusOperacao.Pendente, cashOutGerado.Status);
Assert.AreNotEqual(default, cashOutGerado.Data);
public void VincularTransferencia_PassandoPorParametro_DeveVincular()
{
// Arrange
var conta = new Conta {
Transferencias = new List <Transferencia>()
};
var transferencia = new Transferencia();
var contaRepositorio = Substitute.For <IContaRepositorio>();
var contaServico = new ContaServico(contaRepositorio);
// Act
contaServico.VincularTransferencia(conta, transferencia);
// Assert
contaRepositorio.Received(1).Update(conta);
Assert.IsTrue(conta.Transferencias.Any());
Assert.AreSame(transferencia, conta.Transferencias.First());
}
public void VincularCashOut_PassandoPorParametro_DeveVincular()
{
// Arrange
var conta = new Conta {
CashOuts = new List <CashOut>()
};
var cashOut = new CashOut();
var contaRepositorio = Substitute.For <IContaRepositorio>();
var contaServico = new ContaServico(contaRepositorio);
// Act
contaServico.VincularCashOut(conta, cashOut);
// Assert
contaRepositorio.Received(1).Update(conta);
Assert.IsTrue(conta.CashOuts.Any());
Assert.AreSame(cashOut, conta.CashOuts.First());
}
public void Nova_ContaVazia_DeveCriarESalvar()
{
// Arrange
var usuario = "teste123";
Conta contaCriada = null;
var contaRepositorio = Substitute.For <IContaRepositorio>();
contaRepositorio.When(x => x.Post(Arg.Any <Conta>()))
.Do(x => contaCriada = x.Arg <Conta>());
var contaServico = new ContaServico(contaRepositorio);
// Act
contaServico.Cadastrar(usuario);
// Assert
contaRepositorio.Received(1).Post(contaCriada);
Assert.IsNotNull(contaCriada);
Assert.AreEqual(usuario, contaCriada.UsuarioTitular);
}
public void ObterConta_IdValido_DeveRetornarAConta()
{
// Arrange
var conta = new Conta {
Id = 1
};
var contaRepositorio = Substitute.For <IContaRepositorio>();
contaRepositorio.Any(conta.Id).Returns(true);
contaRepositorio.Get(conta.Id).Returns(conta);
var contaServico = new ContaServico(contaRepositorio);
// Act
var result = contaServico.ObterConta(conta.Id);
// Assert
Assert.IsNotNull(result);
Assert.AreSame(conta, result);
}
private long CadastrarConta()
{
Animal animal = _animalServico.Buscar(x => x.AnimalID == Convert.ToInt64(cbPaciente.Text.Split(' ')[0]), "Cadastro").FirstOrDefault();
if (animal != null)
{
int parcelas = 1;
if (cbMetodoPagamento.Text.Contains("A Prazo"))
{
parcelas = Convert.ToInt32(numParcelas.Value);
}
Conta conta = new Conta("Entrada", cbTipo.Text, Convert.ToDateTime(dtVencimento.Text), Convert.ToDouble(txtPreco.Text), cbMetodoPagamento.Text, parcelas, animal.Cadastro.ID);
_contaServico = new ContaServico();
_contaServico.Salvar(conta);
return(_contaServico.Ultimo());
}
else
{
throw new Exception();
}
}
public void GerarPeloTipo_InformacoesValidasDeSaida_DeveGerarTransferencia()
{
// Arrange
var valor = 10m;
var conta = new Conta
{
Id = 1,
Saldo = valor
};
var tipoTransferencia = TipoMovimentacao.Saida;
Transferencia transferenciaGerada = null;
var transferenciaRepositorio = Substitute.For <ITransferenciaRepositorio>();
transferenciaRepositorio.When(x => x.Post(Arg.Any <Transferencia>()))
.Do(x => transferenciaGerada = x.Arg <Transferencia>());
var operacaoServico = new OperacaoServico(null);
var contaRepositorio = Substitute.For <IContaRepositorio>();
contaRepositorio.Any(Arg.Any <int>()).Returns(true);
contaRepositorio.Get(conta.Id).Returns(conta);
var contaServico = new ContaServico(contaRepositorio);
var transferenciaServico = new TransferenciaServico(transferenciaRepositorio, operacaoServico, contaServico, null, null);
// Act
transferenciaServico.GerarPeloTipo(conta.Id, valor, "Teste unitário.", tipoTransferencia);
// Assert
Assert.IsNotNull(transferenciaGerada);
Assert.AreEqual(tipoTransferencia, transferenciaGerada.TipoMovimentacao);
Assert.AreEqual(StatusOperacao.Pendente, transferenciaGerada.Status);
Assert.AreEqual(valor, transferenciaGerada.SaldoAnterior);
Assert.AreEqual(valor, transferenciaGerada.Valor);
Assert.AreNotEqual(default, transferenciaGerada.Data);
public ExibirCaixa()
{
InitializeComponent();
_contaServico = new ContaServico();
_caixaServico = new CaixaServico();
}