Advertisement
Guest User

Testes

a guest
Nov 25th, 2014
446
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 31.53 KB | None | 0 0
  1. package facema.teste;
  2.  
  3. import java.math.BigDecimal;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.List;
  7.  
  8. import org.junit.Assert;
  9. import org.junit.BeforeClass;
  10. import org.junit.Test;
  11.  
  12. import facema.modelo.banco.Agencia;
  13. import facema.modelo.banco.Cliente;
  14. import facema.modelo.banco.Conta;
  15. import facema.modelo.banco.Pessoa;
  16. import facema.modelo.banco.Poupanca;
  17. import facema.modelo.operacional.Deposito;
  18. import facema.modelo.operacional.Extrato;
  19. import facema.modelo.operacional.Operacao;
  20. import facema.modelo.operacional.Saque;
  21. import facema.regras.RegrasDepositoEnum;
  22. import facema.regras.RegrasExtratoEnum;
  23. import facema.regras.RegrasSaqueEnum;
  24.  
  25. public class TesteRegras {
  26.  
  27.     Extrato extrato = new Extrato();
  28.     Saque saque = new Saque();
  29.     List<Operacao> operacoes;
  30.     Deposito deposito = new Deposito();
  31.     Pessoa pessoa = new Pessoa();
  32.     Cliente cliente = new Cliente();
  33.     Agencia agencia = new Agencia();
  34.     List<Conta> contas;
  35.     Poupanca poupanca = new Poupanca();
  36.  
  37.     private static Conta conta;
  38.  
  39.     @BeforeClass
  40.     public static void configurarConta() {
  41.         conta = new Conta();
  42.         conta.setSaldo(new BigDecimal("250"));
  43.     }
  44.  
  45.     @Test
  46.     public void testeValorSaqueMaiorQueZero() throws Exception {
  47.  
  48.         saque.setConta(conta);
  49.         saque.setValor(new BigDecimal("100"));
  50.  
  51.         boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  52.  
  53.         Assert.assertTrue(aplicavel);
  54.  
  55.     }
  56.  
  57.     @Test
  58.     public void testeValorSaqueIgualAZero() throws Exception {
  59.  
  60.         BigDecimal valor = new BigDecimal("0.00");
  61.  
  62.         saque.setConta(conta);
  63.         saque.setValor(valor);
  64.  
  65.         boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  66.  
  67.         Assert.assertFalse(aplicavel);
  68.  
  69.     }
  70.  
  71.     @Test
  72.     public void testeValorSaqueMenorQueZero() throws Exception {
  73.  
  74.         BigDecimal valor = new BigDecimal("-100");
  75.  
  76.         saque.setConta(conta);
  77.         saque.setValor(valor);
  78.  
  79.         boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  80.  
  81.         Assert.assertFalse(aplicavel);
  82.  
  83.     }
  84.  
  85.     @Test
  86.     public void testeLimiteDiarioValorSuperiorLimitePorDia() throws Exception {
  87.  
  88.         saque.setConta(conta);
  89.         saque.setValor(new BigDecimal("100.00"));
  90.         conta.setSaqueHoje(new BigDecimal("50.00"));
  91.  
  92.         boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  93.  
  94.         Assert.assertTrue(aplicavel);
  95.     }
  96.  
  97.     @Test
  98.     public void testeLimiteDiarioValorInferiorLimitePorDia() throws Exception {
  99.  
  100.         BigDecimal valor = new BigDecimal("150.00");
  101.  
  102.         Saque saque = new Saque();
  103.         saque.setConta(conta);
  104.         saque.setValor(valor);
  105.  
  106.         boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  107.  
  108.         Assert.assertTrue(aplicavel);
  109.     }
  110.  
  111.     @Test
  112.     public void testeLimiteDiarioValorIgualAoLimite() throws Exception {
  113.  
  114.         BigDecimal valor = new BigDecimal("200.00");
  115.  
  116.         Saque saque = new Saque();
  117.         saque.setConta(conta);
  118.         saque.setValor(valor);
  119.  
  120.         boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  121.  
  122.         Assert.assertFalse(aplicavel);
  123.     }
  124.  
  125.     @Test
  126.     public void testeValorInferiorDisponivelParaSaqueNaConta() throws Exception {
  127.  
  128.         saque.setConta(conta);
  129.         saque.setValor(new BigDecimal("100.00"));
  130.  
  131.         boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);
  132.  
  133.         Assert.assertTrue(aplicavel);
  134.     }
  135.  
  136.     @Test
  137.     public void testeValorIgualDisponivelParaSaqueNaConta() throws Exception {
  138.  
  139.         saque.setConta(conta);
  140.         saque.setValor(new BigDecimal("250.00"));
  141.  
  142.         boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);
  143.  
  144.         Assert.assertTrue(aplicavel);
  145.     }
  146.  
  147.     @Test
  148.     public void testeValorSuperiorAoDisponivelParaSaqueNaConta()
  149.             throws Exception {
  150.  
  151.         saque.setConta(conta);
  152.         saque.setValor(new BigDecimal("300.00"));
  153.  
  154.         boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);
  155.  
  156.         Assert.assertFalse(aplicavel);
  157.     }
  158.  
  159.     @Test
  160.     public void testeFullDadosCliente() throws Exception {
  161.  
  162.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  163.         Date dataInicial = formatador.parse("10/11/2014");
  164.         Date dataFinal = formatador.parse("22/11/2014");
  165.  
  166.         // Dados da agência
  167.  
  168.         agencia.setContas(contas);
  169.         agencia.setEndereco("Rua 20 de Abril");
  170.         agencia.setNome("Volta Redonda");
  171.  
  172.         // Dados do cliente
  173.  
  174.         cliente.setPessoa(pessoa);
  175.         cliente.setAgencia(agencia);
  176.         cliente.setConta(conta);
  177.         cliente.getPessoa().setNome("Israel de Sousa Costa");
  178.         cliente.getPessoa().setContato("9998152-7619");
  179.         cliente.getPessoa().setCpf("99192213-11");
  180.  
  181.         // Dados de depósito
  182.  
  183.         BigDecimal valorDeposito = new BigDecimal("100.00");
  184.         deposito.setConta(new BigDecimal("2302"));
  185.         deposito.setDepositante(pessoa);
  186.         deposito.setValor(valorDeposito);
  187.  
  188.         // Dados da conta
  189.  
  190.         BigDecimal saldo = new BigDecimal("500.00");
  191.  
  192.         conta.setCliente(cliente);
  193.         conta.setExtratosMes(2);
  194.         conta.setNumero("2302");
  195.         conta.setPoupanca(poupanca);
  196.         conta.setSaldo(saldo.add(valorDeposito));
  197.         conta.setSaqueHoje(new BigDecimal("200.00"));
  198.         conta.setTipoConta("Fisica");
  199.  
  200.         // Dados da poupança
  201.  
  202.         poupanca.setConta(conta);
  203.         poupanca.setSaldo(new BigDecimal("500.00"));
  204.  
  205.         // Dados de extrato
  206.  
  207.         extrato.setDataInicial(dataInicial);
  208.         extrato.setDataFinal(dataFinal);
  209.         extrato.setConta(conta);
  210.         extrato.setOperacoes(operacoes);
  211.  
  212.         // Dados de saque
  213.  
  214.         BigDecimal saqueValor = new BigDecimal("50.00");
  215.         saque.setConta(conta);
  216.         saque.setValor(saqueValor);
  217.  
  218.         // Saque menor que zero
  219.         BigDecimal saqueValorMenorQueZero = new BigDecimal("-0.50");
  220.         saque.setConta(conta);
  221.         saque.setValor(saqueValorMenorQueZero);
  222.  
  223.         // Saque igual limite diário
  224.         BigDecimal saqueiHoje = new BigDecimal("0.00");
  225.         saque.setConta(conta);
  226.         saque.setValor(saqueiHoje);
  227.         conta.setSaqueHoje(new BigDecimal("200.00"));
  228.  
  229.         // Saque acima limite diário
  230.         BigDecimal saqueiHojeAcima = new BigDecimal("0.00");
  231.         saque.setConta(conta);
  232.         saque.setValor(saqueiHojeAcima);
  233.         conta.setSaqueHoje(new BigDecimal("500.00"));
  234.  
  235.         // Saque inferior limite diário
  236.         BigDecimal saqueiHojeInferior = new BigDecimal("0.00");
  237.         saque.setConta(conta);
  238.         saque.setValor(saqueiHojeInferior);
  239.         conta.setSaqueHoje(new BigDecimal("100.00"));
  240.  
  241.         // Saque inferior limite diário menor que zero
  242.         BigDecimal saqueiHojeInferiorMenorQueZero = new BigDecimal("0.00");
  243.         saque.setConta(conta);
  244.         saque.setValor(saqueiHojeInferiorMenorQueZero);
  245.         conta.setSaqueHoje(new BigDecimal("-20.00"));
  246.  
  247.         boolean aplicavel2 = RegrasDepositoEnum.DADOS_DEPOSITANTE
  248.                 .aplicavel(deposito);
  249.  
  250.         Assert.assertTrue(aplicavel2);
  251.  
  252.         boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);
  253.  
  254.         Assert.assertTrue(aplicavel);
  255.  
  256.         boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  257.  
  258.         Assert.assertFalse(aplicavel1);
  259.  
  260.         boolean aplicavel3 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  261.         Assert.assertFalse(aplicavel3);
  262.  
  263.         boolean aplicavel4 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  264.         Assert.assertTrue(aplicavel4);
  265.  
  266.         boolean aplicavel5 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  267.         Assert.assertTrue(aplicavel5);
  268.  
  269.         boolean aplicavel6 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  270.         Assert.assertTrue(aplicavel6);
  271.  
  272.         boolean aplicavel7 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
  273.         Assert.assertTrue(aplicavel7);
  274.  
  275.         System.out.println("- Dados da Agência - \n" + "Nome: "
  276.                 + agencia.getNome() + "\nEndereço: " + agencia.getEndereco());
  277.  
  278.         System.out.println("\n- Dados de Depósito recente - " + "\nValor: R$ "
  279.                 + deposito.getValor() + "\nDepositante: "
  280.                 + cliente.getPessoa().getNome() + "\nContato: "
  281.                 + cliente.getPessoa().getContato() + "\nCPF: "
  282.                 + cliente.getPessoa().getCpf());
  283.  
  284.         System.out.println("\n- Dados de extrato - " + "\nCliente: "
  285.                 + cliente.getPessoa().getNome() + "\nAgência: "
  286.                 + agencia.getNome() + "\nConta: "
  287.                 + extrato.getConta().getNumero() + "\nData inicial: "
  288.                 + extrato.getDataInicial() + "\nData final: "
  289.                 + extrato.getDataFinal() + "\nMês do extrato: "
  290.                 + extrato.getConta().getExtratosMes() + "\nSaldo da conta: R$ "
  291.                 + extrato.getConta().getSaldo());
  292.  
  293.         System.out.println("\n- Dados de saque: " + "\nCliente: "
  294.                 + cliente.getPessoa().getNome() + "\nAgência: "
  295.                 + agencia.getNome() + "\nConta: "
  296.                 + saque.getConta().getNumero() + "\nValor: R$ "
  297.                 + saque.getValor());
  298.  
  299.         System.out.println("\n- Dados da poupança após o saque - "
  300.                 + "\nNúmero: " + poupanca.getConta().getNumero()
  301.                 + "\nSaldo: R$ " + poupanca.getConta().getSaldo());
  302.  
  303.         System.out.println(conta.getSaldo());
  304.  
  305.     }
  306.  
  307.     @Test
  308.     public void testeDeposito01() throws Exception {
  309.  
  310.         // Este é o teste feito com todos os campos vazios e valor inferior ao
  311.         // mínimo permitido.
  312.  
  313.         pessoa.setCpf("");
  314.         pessoa.setNome("");
  315.         pessoa.setContato("");
  316.         cliente.setPessoa(pessoa);
  317.         conta.setCliente(cliente);
  318.  
  319.         BigDecimal conta = new BigDecimal("2394");
  320.  
  321.         deposito.setConta(conta);
  322.         deposito.setValor(new BigDecimal("0.50"));
  323.         deposito.setDepositante(pessoa);
  324.  
  325.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  326.                 .aplicavel(deposito);
  327.  
  328.         Assert.assertFalse(aplicavel);
  329.  
  330.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  331.                 .aplicavel(deposito);
  332.  
  333.         Assert.assertFalse(aplicavel1);
  334.  
  335.     }
  336.  
  337.     @Test
  338.     public void testeDeposito026() throws Exception {
  339.  
  340.         // Este é o teste feito com todos os campos vazios e valor igual ao
  341.         // mínimo permitido.
  342.  
  343.         pessoa.setCpf("");
  344.         pessoa.setNome("");
  345.         pessoa.setContato("");
  346.         cliente.setPessoa(pessoa);
  347.         conta.setCliente(cliente);
  348.  
  349.         BigDecimal conta = new BigDecimal("2394");
  350.  
  351.         deposito.setConta(conta);
  352.         deposito.setValor(new BigDecimal("1.00"));
  353.         deposito.setDepositante(pessoa);
  354.  
  355.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  356.                 .aplicavel(deposito);
  357.  
  358.         Assert.assertFalse(aplicavel);
  359.  
  360.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  361.                 .aplicavel(deposito);
  362.  
  363.         Assert.assertTrue(aplicavel1);
  364.  
  365.     }
  366.  
  367.     @Test
  368.     public void testeDeposito027() throws Exception {
  369.  
  370.         // Este é o teste feito com todos os campos vazios e valor superior ao
  371.         // mínimo permitido.
  372.  
  373.         pessoa.setCpf("");
  374.         pessoa.setNome("");
  375.         pessoa.setContato("");
  376.         cliente.setPessoa(pessoa);
  377.         conta.setCliente(cliente);
  378.  
  379.         BigDecimal conta = new BigDecimal("2394");
  380.  
  381.         deposito.setConta(conta);
  382.         deposito.setValor(new BigDecimal("2.00"));
  383.         deposito.setDepositante(pessoa);
  384.  
  385.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  386.                 .aplicavel(deposito);
  387.  
  388.         Assert.assertFalse(aplicavel);
  389.  
  390.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  391.                 .aplicavel(deposito);
  392.  
  393.         Assert.assertTrue(aplicavel1);
  394.  
  395.     }
  396.  
  397.     @Test
  398.     public void testeDeposito02() throws Exception {
  399.  
  400.         // Este é o teste feito apenas com os campos CPF e Nome vazios e valor
  401.         // acima do mínimo permitido.
  402.  
  403.         pessoa.setCpf("");
  404.         pessoa.setNome("");
  405.         cliente.setPessoa(pessoa);
  406.         conta.setCliente(cliente);
  407.  
  408.         BigDecimal conta = new BigDecimal("2394");
  409.  
  410.         deposito.setConta(conta);
  411.         deposito.setValor(new BigDecimal("2.00"));
  412.         deposito.setDepositante(pessoa);
  413.  
  414.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  415.                 .aplicavel(deposito);
  416.  
  417.         Assert.assertFalse(aplicavel);
  418.  
  419.     }
  420.  
  421.     @Test
  422.     public void testeDeposito03() throws Exception {
  423.  
  424.         // Este é o teste com identificação anônima feito com os campos CPF e
  425.         // Contato vazio e valor acima do mínimo permitido.
  426.  
  427.         pessoa.setCpf("");
  428.         pessoa.setContato("");
  429.         cliente.setPessoa(pessoa);
  430.         conta.setCliente(cliente);
  431.  
  432.         BigDecimal conta = new BigDecimal("2394");
  433.  
  434.         deposito.setConta(conta);
  435.         deposito.setValor(new BigDecimal("2.00"));
  436.         deposito.setDepositante(pessoa);
  437.  
  438.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  439.                 .aplicavel(deposito);
  440.  
  441.         Assert.assertFalse(aplicavel);
  442.  
  443.     }
  444.  
  445.     @Test
  446.     public void testeDeposito04() throws Exception {
  447.  
  448.         // Este é o teste com identificação anônima com os campos CPF e Nome
  449.         // vazios, e valor inferior ao mínimo permitido.
  450.  
  451.         pessoa.setCpf("");
  452.         pessoa.setNome("");
  453.         cliente.setPessoa(pessoa);
  454.         conta.setCliente(cliente);
  455.  
  456.         BigDecimal conta = new BigDecimal("2394");
  457.  
  458.         deposito.setConta(conta);
  459.         deposito.setValor(new BigDecimal("0.50"));
  460.         deposito.setDepositante(pessoa);
  461.  
  462.         boolean aplicavel = RegrasDepositoEnum.VALOR_MINIMO.aplicavel(deposito);
  463.  
  464.         Assert.assertFalse(aplicavel);
  465.  
  466.     }
  467.  
  468.     @Test
  469.     public void testeDeposito05() throws Exception {
  470.  
  471.         // Este é o teste com depósito identificado com todos os campos
  472.         // preenchidos e valor superior ao mínimo permitido.
  473.  
  474.         pessoa.setCpf("39485819123");
  475.         pessoa.setNome("Israel de Sousa Costa");
  476.         pessoa.setContato("9998152-7619");
  477.         cliente.setPessoa(pessoa);
  478.         conta.setCliente(cliente);
  479.  
  480.         BigDecimal conta = new BigDecimal("2394");
  481.  
  482.         deposito.setConta(conta);
  483.         deposito.setValor(new BigDecimal("2.00"));
  484.         deposito.setDepositante(pessoa);
  485.  
  486.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  487.                 .aplicavel(deposito);
  488.  
  489.         Assert.assertTrue(aplicavel);
  490.  
  491.     }
  492.  
  493.     @Test
  494.     public void testeDeposito06() throws Exception {
  495.  
  496.         // Este é o teste com depósito identificado com todos os campos
  497.         // preenchidos e valor inferior ao mínimo permitido.
  498.  
  499.         pessoa.setCpf("39485819123");
  500.         pessoa.setNome("Israel de Sousa Costa");
  501.         pessoa.setContato("9998152-7619");
  502.         cliente.setPessoa(pessoa);
  503.         conta.setCliente(cliente);
  504.  
  505.         BigDecimal conta = new BigDecimal("2394");
  506.  
  507.         deposito.setConta(conta);
  508.         deposito.setValor(new BigDecimal("0.50"));
  509.         deposito.setDepositante(pessoa);
  510.  
  511.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  512.                 .aplicavel(deposito);
  513.  
  514.         Assert.assertTrue(aplicavel);
  515.  
  516.     }
  517.  
  518.     @Test
  519.     public void testeDeposito07() throws Exception {
  520.  
  521.         // Este é o teste com depósito identificado com todos os campos
  522.         // preenchidos e valor igual ao mínimo permitido.
  523.  
  524.         pessoa.setCpf("39485819123");
  525.         pessoa.setNome("Israel de Sousa Costa");
  526.         pessoa.setContato("9998152-7619");
  527.         cliente.setPessoa(pessoa);
  528.         conta.setCliente(cliente);
  529.  
  530.         BigDecimal conta = new BigDecimal("2394");
  531.  
  532.         deposito.setConta(conta);
  533.         deposito.setValor(new BigDecimal("1.00"));
  534.         deposito.setDepositante(pessoa);
  535.  
  536.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  537.                 .aplicavel(deposito);
  538.  
  539.         Assert.assertTrue(aplicavel);
  540.  
  541.     }
  542.  
  543.     @Test
  544.     public void testeDeposito08() throws Exception {
  545.  
  546.         // Este é o teste feito com depósito identificado apenas com o campo
  547.         // Contato preenchido e valor inferior ao mínimo permitido.
  548.  
  549.         pessoa.setContato("9998152-7619");
  550.         cliente.setPessoa(pessoa);
  551.         conta.setCliente(cliente);
  552.  
  553.         BigDecimal conta = new BigDecimal("2394");
  554.  
  555.         deposito.setConta(conta);
  556.         deposito.setValor(new BigDecimal("0.50"));
  557.         deposito.setDepositante(pessoa);
  558.  
  559.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  560.                 .aplicavel(deposito);
  561.  
  562.         Assert.assertFalse(aplicavel);
  563.  
  564.     }
  565.  
  566.     @Test
  567.     public void testeDeposito09() throws Exception {
  568.  
  569.         // Este é o teste feito com depósito identificado apenas com o campo
  570.         // Contato preenchido e valor igual ao mínimo permitido.
  571.  
  572.         pessoa.setContato("9998152-7619");
  573.         cliente.setPessoa(pessoa);
  574.         conta.setCliente(cliente);
  575.  
  576.         BigDecimal conta = new BigDecimal("2394");
  577.  
  578.         deposito.setConta(conta);
  579.         deposito.setValor(new BigDecimal("1.00"));
  580.         deposito.setDepositante(pessoa);
  581.  
  582.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  583.                 .aplicavel(deposito);
  584.  
  585.         Assert.assertFalse(aplicavel);
  586.  
  587.     }
  588.  
  589.     @Test
  590.     public void testeDeposito10() throws Exception {
  591.  
  592.         // Este é o teste feito com depósito identificado apenas com o campo
  593.         // Contato preenchido e valor superior ao mínimo permitido.
  594.  
  595.         pessoa.setContato("9998152-7619");
  596.         cliente.setPessoa(pessoa);
  597.         conta.setCliente(cliente);
  598.  
  599.         BigDecimal conta = new BigDecimal("2394");
  600.  
  601.         deposito.setConta(conta);
  602.         deposito.setValor(new BigDecimal("2.00"));
  603.         deposito.setDepositante(pessoa);
  604.  
  605.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  606.                 .aplicavel(deposito);
  607.  
  608.         Assert.assertFalse(aplicavel);
  609.  
  610.     }
  611.  
  612.     @Test
  613.     public void testeDeposito11() throws Exception {
  614.  
  615.         // Este é o teste com depósito identificado apenas com o campo CPF e
  616.         // valor inferior ao mínimo permitido
  617.  
  618.         pessoa.setCpf("991231311231");
  619.         cliente.setPessoa(pessoa);
  620.         conta.setCliente(cliente);
  621.  
  622.         BigDecimal conta = new BigDecimal("2394");
  623.  
  624.         deposito.setConta(conta);
  625.         deposito.setValor(new BigDecimal("0.50"));
  626.         deposito.setDepositante(pessoa);
  627.  
  628.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  629.                 .aplicavel(deposito);
  630.  
  631.         Assert.assertFalse(aplicavel);
  632.  
  633.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  634.                 .aplicavel(deposito);
  635.  
  636.         Assert.assertFalse(aplicavel1);
  637.  
  638.     }
  639.  
  640.     @Test
  641.     public void testeDeposito12() throws Exception {
  642.  
  643.         // Este é o teste com depósito identificado apenas com o campo CPF e
  644.         // valor igual ao mínimo permitido
  645.  
  646.         pessoa.setCpf("991231311231");
  647.         cliente.setPessoa(pessoa);
  648.         conta.setCliente(cliente);
  649.  
  650.         BigDecimal conta = new BigDecimal("2394");
  651.  
  652.         deposito.setConta(conta);
  653.         deposito.setValor(new BigDecimal("1.00"));
  654.         deposito.setDepositante(pessoa);
  655.  
  656.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  657.                 .aplicavel(deposito);
  658.  
  659.         Assert.assertFalse(aplicavel);
  660.  
  661.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  662.                 .aplicavel(deposito);
  663.  
  664.         Assert.assertTrue(aplicavel1);
  665.  
  666.     }
  667.  
  668.     @Test
  669.     public void testeDeposito13() throws Exception {
  670.  
  671.         // Este é o teste com depósito identificado apenas com o campo CPF e
  672.         // valor superior ao mínimo permitido
  673.  
  674.         pessoa.setCpf("991231311231");
  675.         cliente.setPessoa(pessoa);
  676.         conta.setCliente(cliente);
  677.  
  678.         BigDecimal conta = new BigDecimal("2394");
  679.  
  680.         deposito.setConta(conta);
  681.         deposito.setValor(new BigDecimal("2.00"));
  682.         deposito.setDepositante(pessoa);
  683.  
  684.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  685.                 .aplicavel(deposito);
  686.  
  687.         Assert.assertFalse(aplicavel);
  688.  
  689.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  690.                 .aplicavel(deposito);
  691.  
  692.         Assert.assertTrue(aplicavel1);
  693.  
  694.     }
  695.  
  696.     @Test
  697.     public void testeDeposito14() throws Exception {
  698.  
  699.         // Este é o teste com depósito identificao apenas com o campo Nome e
  700.         // valor inferior ao mínimo permitido.
  701.  
  702.         pessoa.setNome("Israel de Sousa Costa");
  703.         cliente.setPessoa(pessoa);
  704.         conta.setCliente(cliente);
  705.  
  706.         BigDecimal conta = new BigDecimal("2394");
  707.  
  708.         deposito.setConta(conta);
  709.         deposito.setValor(new BigDecimal("0.50"));
  710.         deposito.setDepositante(pessoa);
  711.  
  712.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  713.                 .aplicavel(deposito);
  714.  
  715.         Assert.assertFalse(aplicavel);
  716.  
  717.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  718.                 .aplicavel(deposito);
  719.  
  720.         Assert.assertFalse(aplicavel1);
  721.  
  722.     }
  723.  
  724.     @Test
  725.     public void testeDeposito15() throws Exception {
  726.  
  727.         // Este é o teste com depósito identificao apenas com o campo Nome e
  728.         // valor igual ao mínimo permitido.
  729.  
  730.         pessoa.setNome("Israel de Sousa Costa");
  731.         cliente.setPessoa(pessoa);
  732.         conta.setCliente(cliente);
  733.  
  734.         BigDecimal conta = new BigDecimal("2394");
  735.  
  736.         deposito.setConta(conta);
  737.         deposito.setValor(new BigDecimal("1.00"));
  738.         deposito.setDepositante(pessoa);
  739.  
  740.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  741.                 .aplicavel(deposito);
  742.  
  743.         Assert.assertFalse(aplicavel);
  744.  
  745.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  746.                 .aplicavel(deposito);
  747.  
  748.         Assert.assertTrue(aplicavel1);
  749.  
  750.     }
  751.  
  752.     @Test
  753.     public void testeDeposito16() throws Exception {
  754.  
  755.         // Este é o teste com depósito identificao apenas com o campo Nome e
  756.         // valor superior ao mínimo permitido.
  757.  
  758.         pessoa.setNome("Israel de Sousa Costa");
  759.         cliente.setPessoa(pessoa);
  760.         conta.setCliente(cliente);
  761.  
  762.         BigDecimal conta = new BigDecimal("2394");
  763.  
  764.         deposito.setConta(conta);
  765.         deposito.setValor(new BigDecimal("2.00"));
  766.         deposito.setDepositante(pessoa);
  767.  
  768.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  769.                 .aplicavel(deposito);
  770.  
  771.         Assert.assertFalse(aplicavel);
  772.  
  773.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  774.                 .aplicavel(deposito);
  775.  
  776.         Assert.assertTrue(aplicavel1);
  777.  
  778.     }
  779.  
  780.     @Test
  781.     public void testeDeposito17() throws Exception {
  782.  
  783.         // Este é o teste feito com depósito identificado com o campo Nome
  784.         // preenchido e CPF vazio e valor inferior ao mínimo permitido.
  785.  
  786.         pessoa.setNome("Israel de Sousa Costa");
  787.         pessoa.setCpf("");
  788.         cliente.setPessoa(pessoa);
  789.         conta.setCliente(cliente);
  790.  
  791.         BigDecimal conta = new BigDecimal("2394");
  792.  
  793.         deposito.setConta(conta);
  794.         deposito.setValor(new BigDecimal("0.50"));
  795.         deposito.setDepositante(pessoa);
  796.  
  797.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  798.                 .aplicavel(deposito);
  799.  
  800.         Assert.assertFalse(aplicavel);
  801.  
  802.     }
  803.  
  804.     @Test
  805.     public void testeDeposito18() throws Exception {
  806.  
  807.         // Este é o teste feito com depósito identificado com o campo Nome
  808.         // preenchido e CPF vazio e valor igual ao mínimo permitido.
  809.  
  810.         pessoa.setNome("Israel de Sousa Costa");
  811.         pessoa.setCpf("");
  812.         cliente.setPessoa(pessoa);
  813.         conta.setCliente(cliente);
  814.  
  815.         BigDecimal conta = new BigDecimal("2394");
  816.  
  817.         deposito.setConta(conta);
  818.         deposito.setValor(new BigDecimal("1.00"));
  819.         deposito.setDepositante(pessoa);
  820.  
  821.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  822.                 .aplicavel(deposito);
  823.  
  824.         Assert.assertFalse(aplicavel);
  825.  
  826.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  827.                 .aplicavel(deposito);
  828.  
  829.         Assert.assertTrue(aplicavel1);
  830.  
  831.     }
  832.  
  833.     @Test
  834.     public void testeDeposito19() throws Exception {
  835.  
  836.         // Este é o teste feito com depósito identificado com o campo Nome
  837.         // preenchido e CPF vazio e valor superior ao mínimo permitido.
  838.  
  839.         pessoa.setNome("Israel de Sousa Costa");
  840.         pessoa.setCpf("");
  841.         cliente.setPessoa(pessoa);
  842.         conta.setCliente(cliente);
  843.  
  844.         BigDecimal conta = new BigDecimal("2394");
  845.  
  846.         deposito.setConta(conta);
  847.         deposito.setValor(new BigDecimal("2.00"));
  848.         deposito.setDepositante(pessoa);
  849.  
  850.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  851.                 .aplicavel(deposito);
  852.  
  853.         Assert.assertFalse(aplicavel);
  854.  
  855.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  856.                 .aplicavel(deposito);
  857.  
  858.         Assert.assertTrue(aplicavel1);
  859.  
  860.     }
  861.  
  862.     @Test
  863.     public void testeDeposito20() throws Exception {
  864.  
  865.         // Este é o teste feito com depósito identificado apenas com o campo CPF
  866.         // preenchido e Nome vazio com valor inferior ao mínimo permitido.
  867.  
  868.         pessoa.setCpf("39485819123");
  869.         pessoa.setNome("");
  870.         cliente.setPessoa(pessoa);
  871.         conta.setCliente(cliente);
  872.  
  873.         BigDecimal conta = new BigDecimal("2394");
  874.  
  875.         deposito.setConta(conta);
  876.         deposito.setValor(new BigDecimal("0.50"));
  877.         deposito.setDepositante(pessoa);
  878.  
  879.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  880.                 .aplicavel(deposito);
  881.  
  882.         Assert.assertFalse(aplicavel);
  883.  
  884.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  885.                 .aplicavel(deposito);
  886.  
  887.         Assert.assertFalse(aplicavel1);
  888.     }
  889.  
  890.     @Test
  891.     public void testeDeposito21() throws Exception {
  892.  
  893.         // Este é o teste feito com depósito identificado apenas com o campo CPF
  894.         // preenchido e Nome vazio com valor igual ao mínimo permitido.
  895.  
  896.         pessoa.setCpf("39485819123");
  897.         pessoa.setNome("");
  898.         cliente.setPessoa(pessoa);
  899.         conta.setCliente(cliente);
  900.  
  901.         BigDecimal conta = new BigDecimal("2394");
  902.  
  903.         deposito.setConta(conta);
  904.         deposito.setValor(new BigDecimal("2.00"));
  905.         deposito.setDepositante(pessoa);
  906.  
  907.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  908.                 .aplicavel(deposito);
  909.  
  910.         Assert.assertFalse(aplicavel);
  911.  
  912.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  913.                 .aplicavel(deposito);
  914.  
  915.         Assert.assertTrue(aplicavel1);
  916.  
  917.     }
  918.  
  919.     @Test
  920.     public void testeDeposito22() throws Exception {
  921.  
  922.         // Este é o teste feito com depósito identificado apenas com o campo CPF
  923.         // preenchido e Nome vazio com valor superior ao mínimo permitido.
  924.  
  925.         pessoa.setCpf("39485819123");
  926.         pessoa.setNome("");
  927.         cliente.setPessoa(pessoa);
  928.         conta.setCliente(cliente);
  929.  
  930.         BigDecimal conta = new BigDecimal("2394");
  931.  
  932.         deposito.setConta(conta);
  933.         deposito.setValor(new BigDecimal("2.00"));
  934.         deposito.setDepositante(pessoa);
  935.  
  936.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  937.                 .aplicavel(deposito);
  938.  
  939.         Assert.assertFalse(aplicavel);
  940.  
  941.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  942.                 .aplicavel(deposito);
  943.  
  944.         Assert.assertTrue(aplicavel1);
  945.  
  946.     }
  947.  
  948.     @Test
  949.     public void testeDeposito23() throws Exception {
  950.  
  951.         // Este é o teste feito com depósito identificado com apenas com o campo
  952.         // CPF preenchido e contato vazio e valor inferior ao mínimo permitido.
  953.  
  954.         pessoa.setCpf("39485819123");
  955.         pessoa.setContato("");
  956.         cliente.setPessoa(pessoa);
  957.         conta.setCliente(cliente);
  958.  
  959.         BigDecimal conta = new BigDecimal("2394");
  960.  
  961.         deposito.setConta(conta);
  962.         deposito.setValor(new BigDecimal("0.50"));
  963.         deposito.setDepositante(pessoa);
  964.  
  965.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  966.                 .aplicavel(deposito);
  967.  
  968.         Assert.assertFalse(aplicavel);
  969.  
  970.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  971.                 .aplicavel(deposito);
  972.  
  973.         Assert.assertFalse(aplicavel1);
  974.  
  975.     }
  976.  
  977.     @Test
  978.     public void testeDeposito24() throws Exception {
  979.  
  980.         // Este é o teste feito com depósito identificado com apenas com o campo
  981.         // CPF preenchido e contato vazio e valor igual ao mínimo permitido.
  982.  
  983.         pessoa.setCpf("39485819123");
  984.         pessoa.setContato("");
  985.         cliente.setPessoa(pessoa);
  986.         conta.setCliente(cliente);
  987.  
  988.         BigDecimal conta = new BigDecimal("2394");
  989.  
  990.         deposito.setConta(conta);
  991.         deposito.setValor(new BigDecimal("1.00"));
  992.         deposito.setDepositante(pessoa);
  993.  
  994.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  995.                 .aplicavel(deposito);
  996.  
  997.         Assert.assertFalse(aplicavel);
  998.  
  999.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  1000.                 .aplicavel(deposito);
  1001.  
  1002.         Assert.assertTrue(aplicavel1);
  1003.  
  1004.     }
  1005.  
  1006.     @Test
  1007.     public void testeDeposito25() throws Exception {
  1008.  
  1009.         // Este é o teste feito com depósito identificado com apenas com o campo
  1010.         // CPF preenchido e contato vazio e valor superior ao mínimo permitido.
  1011.  
  1012.         pessoa.setCpf("39485819123");
  1013.         pessoa.setContato("");
  1014.         cliente.setPessoa(pessoa);
  1015.         conta.setCliente(cliente);
  1016.  
  1017.         BigDecimal conta = new BigDecimal("2394");
  1018.  
  1019.         deposito.setConta(conta);
  1020.         deposito.setValor(new BigDecimal("2.00"));
  1021.         deposito.setDepositante(pessoa);
  1022.  
  1023.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  1024.                 .aplicavel(deposito);
  1025.  
  1026.         Assert.assertFalse(aplicavel);
  1027.  
  1028.         boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
  1029.                 .aplicavel(deposito);
  1030.  
  1031.         Assert.assertTrue(aplicavel1);
  1032.  
  1033.     }
  1034.  
  1035.     @Test
  1036.     public void testeDepositoESaque() throws Exception {
  1037.  
  1038.         // Este é o teste feito com depósito identificado com apenas com o campo
  1039.         // CPF preenchido e contato vazio e valor superior ao mínimo permitido.
  1040.  
  1041.         Saque saque = new Saque();
  1042.         Conta conta = new Conta();
  1043.  
  1044.         pessoa.setCpf("39485819123");
  1045.         pessoa.setContato("");
  1046.         cliente.setPessoa(pessoa);
  1047.         conta.setCliente(cliente);
  1048.  
  1049.         BigDecimal numConta = new BigDecimal("2394");
  1050.  
  1051.         deposito.setConta(numConta);
  1052.         deposito.setValor(new BigDecimal("2.00"));
  1053.         deposito.setDepositante(pessoa);
  1054.         saque.setConta(conta);
  1055.         saque.setValor(new BigDecimal("100"));
  1056.  
  1057.         boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
  1058.                 .aplicavel(deposito);
  1059.  
  1060.         Assert.assertFalse(aplicavel);
  1061.  
  1062.         boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  1063.  
  1064.         Assert.assertTrue(aplicavel1);
  1065.  
  1066.     }
  1067.  
  1068.     @Test
  1069.     public void testeSaqueEExtratoEmPeriodoDeUmAno() throws Exception {
  1070.  
  1071.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1072.         Date dataInicial = formatador.parse("10/11/2014");
  1073.         Date dataFinal = formatador.parse("22/11/2014");
  1074.  
  1075.         saque.setConta(conta);
  1076.         saque.setValor(new BigDecimal("120"));
  1077.  
  1078.         conta.setExtratosMes(2);
  1079.         extrato.setDataInicial(dataInicial);
  1080.         extrato.setDataFinal(dataFinal);
  1081.  
  1082.         boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);
  1083.  
  1084.         Assert.assertTrue(aplicavel);
  1085.  
  1086.         boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  1087.  
  1088.         Assert.assertTrue(aplicavel1);
  1089.     }
  1090.  
  1091.     @Test
  1092.     public void testeSaqueEExtratoComDiferencaDeUmAno() throws Exception {
  1093.  
  1094.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1095.         Date dataInicial = formatador.parse("10/11/2013");
  1096.         Date dataFinal = formatador.parse("22/11/2014");
  1097.  
  1098.         saque.setConta(conta);
  1099.         saque.setValor(new BigDecimal("120"));
  1100.  
  1101.         conta.setExtratosMes(2);
  1102.         extrato.setDataInicial(dataInicial);
  1103.         extrato.setDataFinal(dataFinal);
  1104.  
  1105.         boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);
  1106.  
  1107.         Assert.assertFalse(aplicavel);
  1108.  
  1109.         boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
  1110.  
  1111.         Assert.assertTrue(aplicavel1);
  1112.     }
  1113.  
  1114.     @Test
  1115.     public void testeExtratoDiferencaDeUmAno() throws Exception {
  1116.  
  1117.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1118.         Date dataInicial = formatador.parse("10/11/2011");
  1119.         Date dataFinal = formatador.parse("22/11/2014");
  1120.  
  1121.         conta.setExtratosMes(2);
  1122.         extrato.setDataInicial(dataInicial);
  1123.         extrato.setDataFinal(dataFinal);
  1124.  
  1125.         boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);
  1126.  
  1127.         Assert.assertFalse(aplicavel);
  1128.  
  1129.     }
  1130.  
  1131.     @Test
  1132.     public void testeExtratoMensalGratuito() throws Exception {
  1133.  
  1134.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1135.         Date dataInicial = formatador.parse("10/11/2014");
  1136.         Date dataFinal = formatador.parse("22/11/2014");
  1137.  
  1138.         conta.setExtratosMes(1);
  1139.         extrato.setDataInicial(dataInicial);
  1140.         extrato.setDataFinal(dataFinal);
  1141.         extrato.setConta(conta);
  1142.  
  1143.         boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
  1144.                 .aplicavel(extrato);
  1145.  
  1146.         Assert.assertFalse(aplicavel);
  1147.     }
  1148.  
  1149.     @Test
  1150.     public void testeExtratoMensalGratuitoPeriodoUmAno() throws Exception {
  1151.  
  1152.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1153.         Date dataInicial = formatador.parse("10/11/2014");
  1154.         Date dataFinal = formatador.parse("22/11/2014");
  1155.  
  1156.         conta.setExtratosMes(5);
  1157.         extrato.setDataInicial(dataInicial);
  1158.         extrato.setDataFinal(dataFinal);
  1159.         extrato.setConta(conta);
  1160.  
  1161.         boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
  1162.                 .aplicavel(extrato);
  1163.  
  1164.         Assert.assertFalse(aplicavel);
  1165.     }
  1166.  
  1167.     @Test
  1168.     public void testeExtratoMensalGratuitoDiferencaUmAno() throws Exception {
  1169.  
  1170.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1171.         Date dataInicial = formatador.parse("10/11/2010");
  1172.         Date dataFinal = formatador.parse("22/11/2014");
  1173.  
  1174.         conta.setExtratosMes(5);
  1175.         extrato.setDataInicial(dataInicial);
  1176.         extrato.setDataFinal(dataFinal);
  1177.         extrato.setConta(conta);
  1178.  
  1179.         boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
  1180.                 .aplicavel(extrato);
  1181.  
  1182.         Assert.assertFalse(aplicavel);
  1183.     }
  1184.  
  1185.     @Test
  1186.     public void testeExtratoMensalCobrado() throws Exception {
  1187.  
  1188.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1189.         Date dataInicial = formatador.parse("10/11/2014");
  1190.         Date dataFinal = formatador.parse("22/11/2014");
  1191.  
  1192.         conta.setExtratosMes(0);
  1193.         extrato.setDataInicial(dataInicial);
  1194.         extrato.setDataFinal(dataFinal);
  1195.         extrato.setConta(conta);
  1196.  
  1197.         boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
  1198.                 .aplicavel(extrato);
  1199.  
  1200.         Assert.assertTrue(aplicavel);
  1201.     }
  1202.  
  1203.     @Test
  1204.     public void testeExtratoMensalCobradoDiferencaDeUmAno() throws Exception {
  1205.  
  1206.         SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
  1207.         Date dataInicial = formatador.parse("10/11/2011");
  1208.         Date dataFinal = formatador.parse("22/11/2014");
  1209.  
  1210.         conta.setExtratosMes(0);
  1211.         extrato.setDataInicial(dataInicial);
  1212.         extrato.setDataFinal(dataFinal);
  1213.         extrato.setConta(conta);
  1214.  
  1215.         boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
  1216.                 .aplicavel(extrato);
  1217.  
  1218.         Assert.assertTrue(aplicavel);
  1219.     }
  1220.  
  1221. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement