Testes

package facema.teste;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import facema.modelo.banco.Agencia;
import facema.modelo.banco.Cliente;
import facema.modelo.banco.Conta;
import facema.modelo.banco.Pessoa;
import facema.modelo.banco.Poupanca;
import facema.modelo.operacional.Deposito;
import facema.modelo.operacional.Extrato;
import facema.modelo.operacional.Operacao;
import facema.modelo.operacional.Saque;
import facema.regras.RegrasDepositoEnum;
import facema.regras.RegrasExtratoEnum;
import facema.regras.RegrasSaqueEnum;

public class TesteRegras {

    Extrato extrato = new Extrato();
    Saque saque = new Saque();
    List<Operacao> operacoes;
    Deposito deposito = new Deposito();
    Pessoa pessoa = new Pessoa();
    Cliente cliente = new Cliente();
    Agencia agencia = new Agencia();
    List<Conta> contas;
    Poupanca poupanca = new Poupanca();

    private static Conta conta;

    @BeforeClass
    public static void configurarConta() {
        conta = new Conta();
        conta.setSaldo(new BigDecimal("250"));
    }

    @Test
    public void testeValorSaqueMaiorQueZero() throws Exception {

        saque.setConta(conta);
        saque.setValor(new BigDecimal("100"));

        boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertTrue(aplicavel);

    }

    @Test
    public void testeValorSaqueIgualAZero() throws Exception {

        BigDecimal valor = new BigDecimal("0.00");

        saque.setConta(conta);
        saque.setValor(valor);

        boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeValorSaqueMenorQueZero() throws Exception {

        BigDecimal valor = new BigDecimal("-100");

        saque.setConta(conta);
        saque.setValor(valor);

        boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeLimiteDiarioValorSuperiorLimitePorDia() throws Exception {

        saque.setConta(conta);
        saque.setValor(new BigDecimal("100.00"));
        conta.setSaqueHoje(new BigDecimal("50.00"));

        boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);

        Assert.assertTrue(aplicavel);
    }

    @Test
    public void testeLimiteDiarioValorInferiorLimitePorDia() throws Exception {

        BigDecimal valor = new BigDecimal("150.00");

        Saque saque = new Saque();
        saque.setConta(conta);
        saque.setValor(valor);

        boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);

        Assert.assertTrue(aplicavel);
    }

    @Test
    public void testeLimiteDiarioValorIgualAoLimite() throws Exception {

        BigDecimal valor = new BigDecimal("200.00");

        Saque saque = new Saque();
        saque.setConta(conta);
        saque.setValor(valor);

        boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);

        Assert.assertFalse(aplicavel);
    }

    @Test
    public void testeValorInferiorDisponivelParaSaqueNaConta() throws Exception {

        saque.setConta(conta);
        saque.setValor(new BigDecimal("100.00"));

        boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);

        Assert.assertTrue(aplicavel);
    }

    @Test
    public void testeValorIgualDisponivelParaSaqueNaConta() throws Exception {

        saque.setConta(conta);
        saque.setValor(new BigDecimal("250.00"));

        boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);

        Assert.assertTrue(aplicavel);
    }

    @Test
    public void testeValorSuperiorAoDisponivelParaSaqueNaConta()
            throws Exception {

        saque.setConta(conta);
        saque.setValor(new BigDecimal("300.00"));

        boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);

        Assert.assertFalse(aplicavel);
    }

    @Test
    public void testeFullDadosCliente() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2014");
        Date dataFinal = formatador.parse("22/11/2014");

        // Dados da agência

        agencia.setContas(contas);
        agencia.setEndereco("Rua 20 de Abril");
        agencia.setNome("Volta Redonda");

        // Dados do cliente

        cliente.setPessoa(pessoa);
        cliente.setAgencia(agencia);
        cliente.setConta(conta);
        cliente.getPessoa().setNome("Israel de Sousa Costa");
        cliente.getPessoa().setContato("9998152-7619");
        cliente.getPessoa().setCpf("99192213-11");

        // Dados de depósito

        BigDecimal valorDeposito = new BigDecimal("100.00");
        deposito.setConta(new BigDecimal("2302"));
        deposito.setDepositante(pessoa);
        deposito.setValor(valorDeposito);

        // Dados da conta

        BigDecimal saldo = new BigDecimal("500.00");

        conta.setCliente(cliente);
        conta.setExtratosMes(2);
        conta.setNumero("2302");
        conta.setPoupanca(poupanca);
        conta.setSaldo(saldo.add(valorDeposito));
        conta.setSaqueHoje(new BigDecimal("200.00"));
        conta.setTipoConta("Fisica");

        // Dados da poupança

        poupanca.setConta(conta);
        poupanca.setSaldo(new BigDecimal("500.00"));

        // Dados de extrato

        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);
        extrato.setConta(conta);
        extrato.setOperacoes(operacoes);

        // Dados de saque

        BigDecimal saqueValor = new BigDecimal("50.00");
        saque.setConta(conta);
        saque.setValor(saqueValor);

        // Saque menor que zero
        BigDecimal saqueValorMenorQueZero = new BigDecimal("-0.50");
        saque.setConta(conta);
        saque.setValor(saqueValorMenorQueZero);

        // Saque igual limite diário
        BigDecimal saqueiHoje = new BigDecimal("0.00");
        saque.setConta(conta);
        saque.setValor(saqueiHoje);
        conta.setSaqueHoje(new BigDecimal("200.00"));

        // Saque acima limite diário
        BigDecimal saqueiHojeAcima = new BigDecimal("0.00");
        saque.setConta(conta);
        saque.setValor(saqueiHojeAcima);
        conta.setSaqueHoje(new BigDecimal("500.00"));

        // Saque inferior limite diário
        BigDecimal saqueiHojeInferior = new BigDecimal("0.00");
        saque.setConta(conta);
        saque.setValor(saqueiHojeInferior);
        conta.setSaqueHoje(new BigDecimal("100.00"));

        // Saque inferior limite diário menor que zero
        BigDecimal saqueiHojeInferiorMenorQueZero = new BigDecimal("0.00");
        saque.setConta(conta);
        saque.setValor(saqueiHojeInferiorMenorQueZero);
        conta.setSaqueHoje(new BigDecimal("-20.00"));

        boolean aplicavel2 = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel2);

        boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

        Assert.assertTrue(aplicavel);

        boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertFalse(aplicavel1);

        boolean aplicavel3 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
        Assert.assertFalse(aplicavel3);

        boolean aplicavel4 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
        Assert.assertTrue(aplicavel4);

        boolean aplicavel5 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
        Assert.assertTrue(aplicavel5);

        boolean aplicavel6 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
        Assert.assertTrue(aplicavel6);

        boolean aplicavel7 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
        Assert.assertTrue(aplicavel7);

        System.out.println("- Dados da Agência - \n" + "Nome: "
                + agencia.getNome() + "\nEndereço: " + agencia.getEndereco());

        System.out.println("\n- Dados de Depósito recente - " + "\nValor: R$ "
                + deposito.getValor() + "\nDepositante: "
                + cliente.getPessoa().getNome() + "\nContato: "
                + cliente.getPessoa().getContato() + "\nCPF: "
                + cliente.getPessoa().getCpf());

        System.out.println("\n- Dados de extrato - " + "\nCliente: "
                + cliente.getPessoa().getNome() + "\nAgência: "
                + agencia.getNome() + "\nConta: "
                + extrato.getConta().getNumero() + "\nData inicial: "
                + extrato.getDataInicial() + "\nData final: "
                + extrato.getDataFinal() + "\nMês do extrato: "
                + extrato.getConta().getExtratosMes() + "\nSaldo da conta: R$ "
                + extrato.getConta().getSaldo());

        System.out.println("\n- Dados de saque: " + "\nCliente: "
                + cliente.getPessoa().getNome() + "\nAgência: "
                + agencia.getNome() + "\nConta: "
                + saque.getConta().getNumero() + "\nValor: R$ "
                + saque.getValor());

        System.out.println("\n- Dados da poupança após o saque - "
                + "\nNúmero: " + poupanca.getConta().getNumero()
                + "\nSaldo: R$ " + poupanca.getConta().getSaldo());

        System.out.println(conta.getSaldo());

    }

    @Test
    public void testeDeposito01() throws Exception {

        // Este é o teste feito com todos os campos vazios e valor inferior ao
        // mínimo permitido.

        pessoa.setCpf("");
        pessoa.setNome("");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel1);

    }

    @Test
    public void testeDeposito026() throws Exception {

        // Este é o teste feito com todos os campos vazios e valor igual ao
        // mínimo permitido.

        pessoa.setCpf("");
        pessoa.setNome("");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito027() throws Exception {

        // Este é o teste feito com todos os campos vazios e valor superior ao
        // mínimo permitido.

        pessoa.setCpf("");
        pessoa.setNome("");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito02() throws Exception {

        // Este é o teste feito apenas com os campos CPF e Nome vazios e valor
        // acima do mínimo permitido.

        pessoa.setCpf("");
        pessoa.setNome("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito03() throws Exception {

        // Este é o teste com identificação anônima feito com os campos CPF e
        // Contato vazio e valor acima do mínimo permitido.

        pessoa.setCpf("");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito04() throws Exception {

        // Este é o teste com identificação anônima com os campos CPF e Nome
        // vazios, e valor inferior ao mínimo permitido.

        pessoa.setCpf("");
        pessoa.setNome("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.VALOR_MINIMO.aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito05() throws Exception {

        // Este é o teste com depósito identificado com todos os campos
        // preenchidos e valor superior ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setNome("Israel de Sousa Costa");
        pessoa.setContato("9998152-7619");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel);

    }

    @Test
    public void testeDeposito06() throws Exception {

        // Este é o teste com depósito identificado com todos os campos
        // preenchidos e valor inferior ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setNome("Israel de Sousa Costa");
        pessoa.setContato("9998152-7619");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel);

    }

    @Test
    public void testeDeposito07() throws Exception {

        // Este é o teste com depósito identificado com todos os campos
        // preenchidos e valor igual ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setNome("Israel de Sousa Costa");
        pessoa.setContato("9998152-7619");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel);

    }

    @Test
    public void testeDeposito08() throws Exception {

        // Este é o teste feito com depósito identificado apenas com o campo
        // Contato preenchido e valor inferior ao mínimo permitido.

        pessoa.setContato("9998152-7619");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito09() throws Exception {

        // Este é o teste feito com depósito identificado apenas com o campo
        // Contato preenchido e valor igual ao mínimo permitido.

        pessoa.setContato("9998152-7619");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito10() throws Exception {

        // Este é o teste feito com depósito identificado apenas com o campo
        // Contato preenchido e valor superior ao mínimo permitido.

        pessoa.setContato("9998152-7619");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito11() throws Exception {

        // Este é o teste com depósito identificado apenas com o campo CPF e
        // valor inferior ao mínimo permitido

        pessoa.setCpf("991231311231");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel1);

    }

    @Test
    public void testeDeposito12() throws Exception {

        // Este é o teste com depósito identificado apenas com o campo CPF e
        // valor igual ao mínimo permitido

        pessoa.setCpf("991231311231");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito13() throws Exception {

        // Este é o teste com depósito identificado apenas com o campo CPF e
        // valor superior ao mínimo permitido

        pessoa.setCpf("991231311231");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito14() throws Exception {

        // Este é o teste com depósito identificao apenas com o campo Nome e
        // valor inferior ao mínimo permitido.

        pessoa.setNome("Israel de Sousa Costa");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel1);

    }

    @Test
    public void testeDeposito15() throws Exception {

        // Este é o teste com depósito identificao apenas com o campo Nome e
        // valor igual ao mínimo permitido.

        pessoa.setNome("Israel de Sousa Costa");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito16() throws Exception {

        // Este é o teste com depósito identificao apenas com o campo Nome e
        // valor superior ao mínimo permitido.

        pessoa.setNome("Israel de Sousa Costa");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito17() throws Exception {

        // Este é o teste feito com depósito identificado com o campo Nome
        // preenchido e CPF vazio e valor inferior ao mínimo permitido.

        pessoa.setNome("Israel de Sousa Costa");
        pessoa.setCpf("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeDeposito18() throws Exception {

        // Este é o teste feito com depósito identificado com o campo Nome
        // preenchido e CPF vazio e valor igual ao mínimo permitido.

        pessoa.setNome("Israel de Sousa Costa");
        pessoa.setCpf("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito19() throws Exception {

        // Este é o teste feito com depósito identificado com o campo Nome
        // preenchido e CPF vazio e valor superior ao mínimo permitido.

        pessoa.setNome("Israel de Sousa Costa");
        pessoa.setCpf("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito20() throws Exception {

        // Este é o teste feito com depósito identificado apenas com o campo CPF
        // preenchido e Nome vazio com valor inferior ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setNome("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel1);
    }

    @Test
    public void testeDeposito21() throws Exception {

        // Este é o teste feito com depósito identificado apenas com o campo CPF
        // preenchido e Nome vazio com valor igual ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setNome("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito22() throws Exception {

        // Este é o teste feito com depósito identificado apenas com o campo CPF
        // preenchido e Nome vazio com valor superior ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setNome("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito23() throws Exception {

        // Este é o teste feito com depósito identificado com apenas com o campo
        // CPF preenchido e contato vazio e valor inferior ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("0.50"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel1);

    }

    @Test
    public void testeDeposito24() throws Exception {

        // Este é o teste feito com depósito identificado com apenas com o campo
        // CPF preenchido e contato vazio e valor igual ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("1.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDeposito25() throws Exception {

        // Este é o teste feito com depósito identificado com apenas com o campo
        // CPF preenchido e contato vazio e valor superior ao mínimo permitido.

        pessoa.setCpf("39485819123");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal conta = new BigDecimal("2394");

        deposito.setConta(conta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
                .aplicavel(deposito);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeDepositoESaque() throws Exception {

        // Este é o teste feito com depósito identificado com apenas com o campo
        // CPF preenchido e contato vazio e valor superior ao mínimo permitido.

        Saque saque = new Saque();
        Conta conta = new Conta();

        pessoa.setCpf("39485819123");
        pessoa.setContato("");
        cliente.setPessoa(pessoa);
        conta.setCliente(cliente);

        BigDecimal numConta = new BigDecimal("2394");

        deposito.setConta(numConta);
        deposito.setValor(new BigDecimal("2.00"));
        deposito.setDepositante(pessoa);
        saque.setConta(conta);
        saque.setValor(new BigDecimal("100"));

        boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
                .aplicavel(deposito);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertTrue(aplicavel1);

    }

    @Test
    public void testeSaqueEExtratoEmPeriodoDeUmAno() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2014");
        Date dataFinal = formatador.parse("22/11/2014");

        saque.setConta(conta);
        saque.setValor(new BigDecimal("120"));

        conta.setExtratosMes(2);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);

        boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

        Assert.assertTrue(aplicavel);

        boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertTrue(aplicavel1);
    }

    @Test
    public void testeSaqueEExtratoComDiferencaDeUmAno() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2013");
        Date dataFinal = formatador.parse("22/11/2014");

        saque.setConta(conta);
        saque.setValor(new BigDecimal("120"));

        conta.setExtratosMes(2);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);

        boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

        Assert.assertFalse(aplicavel);

        boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

        Assert.assertTrue(aplicavel1);
    }

    @Test
    public void testeExtratoDiferencaDeUmAno() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2011");
        Date dataFinal = formatador.parse("22/11/2014");

        conta.setExtratosMes(2);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);

        boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

        Assert.assertFalse(aplicavel);

    }

    @Test
    public void testeExtratoMensalGratuito() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2014");
        Date dataFinal = formatador.parse("22/11/2014");

        conta.setExtratosMes(1);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);
        extrato.setConta(conta);

        boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
                .aplicavel(extrato);

        Assert.assertFalse(aplicavel);
    }

    @Test
    public void testeExtratoMensalGratuitoPeriodoUmAno() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2014");
        Date dataFinal = formatador.parse("22/11/2014");

        conta.setExtratosMes(5);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);
        extrato.setConta(conta);

        boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
                .aplicavel(extrato);

        Assert.assertFalse(aplicavel);
    }

    @Test
    public void testeExtratoMensalGratuitoDiferencaUmAno() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2010");
        Date dataFinal = formatador.parse("22/11/2014");

        conta.setExtratosMes(5);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);
        extrato.setConta(conta);

        boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
                .aplicavel(extrato);

        Assert.assertFalse(aplicavel);
    }

    @Test
    public void testeExtratoMensalCobrado() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2014");
        Date dataFinal = formatador.parse("22/11/2014");

        conta.setExtratosMes(0);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);
        extrato.setConta(conta);

        boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
                .aplicavel(extrato);

        Assert.assertTrue(aplicavel);
    }

    @Test
    public void testeExtratoMensalCobradoDiferencaDeUmAno() throws Exception {

        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        Date dataInicial = formatador.parse("10/11/2011");
        Date dataFinal = formatador.parse("22/11/2014");

        conta.setExtratosMes(0);
        extrato.setDataInicial(dataInicial);
        extrato.setDataFinal(dataFinal);
        extrato.setConta(conta);

        boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
                .aplicavel(extrato);

        Assert.assertTrue(aplicavel);
    }

}