public void ContaExistenteMasNotificacaoNaoFuncionando_ChamadoDocumentoValido_RetornarFalha()
        {
            // Arrange
            var fixture       = new Fixture();
            var contaCorrente = fixture.Create <ContaCorrente>();

            var respostaNotificacaoViewModel = RespostaNotificacaoViewModelFactory.ObterRespostaFalha();

            var contaCorrenteRepositoryMock = new Mock <IContaCorrenteRepository>();
            var notificacaoServiceMock      = new Mock <INotificacaoService>();

            contaCorrenteRepositoryMock.Setup(ccr => ccr.ObterPorDocumento(contaCorrente.Documento)).Returns(contaCorrente);
            notificacaoServiceMock.Setup(ns => ns.Notificar(contaCorrente)).Returns(respostaNotificacaoViewModel);

            var contaCorrenteService = new ContaCorrenteService(notificacaoServiceMock.Object, contaCorrenteRepositoryMock.Object);

            // Act
            var resposta = contaCorrenteService.NotificarContaCorrente(contaCorrente.Documento);

            // Assert
            contaCorrenteRepositoryMock.Verify(ccr => ccr.ObterPorDocumento(contaCorrente.Documento), Times.Once);
            notificacaoServiceMock.Verify(ns => ns.Notificar(It.IsAny <ContaCorrente>()), Times.Once);

            Assert.False(resposta);
        }
Ejemplo n.º 2
0
        public ContaCorrenteServiceTest()
        {
            var contaCorrenteRepository = new Mock <IContaCorrenteRepository>();

            contaCorrenteRepository.Setup(x => x.SelectByNumber("111")).Returns((string i) =>
            {
                return(new ContaCorrente()
                {
                    Id = 1,
                    Numero = "111"
                });
            });

            var lancamentoRepository = new Mock <ILancamentoRepository>();

            lancamentoRepository.Setup(x => x.Select(1)).Returns((int i) =>
            {
                return(new Lancamento()
                {
                    Id = 1,
                    IDContaOrigem = 1,
                    IDContaDestino = 2,
                    Valor = 200,
                });
            });

            _contaCorrenteService = new ContaCorrenteService(contaCorrenteRepository.Object, lancamentoRepository.Object);
        }
        public void ContaExistenteNotificacaoFuncionando_ChamadoDocumentoValido_RetornarSucesso()
        {
            // Arrange
            var fixture       = new Fixture();
            var contaCorrente = fixture.Create <ContaCorrente>();

            // ANTES: var contaCorrente = ContaCorrenteFactory.GetContaOrigemValida();

            fixture.RepeatCount = 5;
            var operacoes = fixture.CreateMany <OperacaoContaCorrente>().ToList();

            var respostaNotificacaoViewModel = RespostaNotificacaoViewModelFactory.ObterRespostaSucesso();

            var contaCorrenteRepositoryMock = new Mock <IContaCorrenteRepository>();
            var notificacaoServiceMock      = new Mock <INotificacaoService>();

            contaCorrenteRepositoryMock.Setup(ccr => ccr.ObterPorDocumento(contaCorrente.Documento)).Returns(contaCorrente);
            notificacaoServiceMock.Setup(ns => ns.Notificar(contaCorrente)).Returns(respostaNotificacaoViewModel);

            var contaCorrenteService = new ContaCorrenteService(notificacaoServiceMock.Object, contaCorrenteRepositoryMock.Object);

            // Act
            var resposta = contaCorrenteService.NotificarContaCorrente(contaCorrente.Documento);

            // Assert
            contaCorrenteRepositoryMock.Verify(ccr => ccr.ObterPorDocumento(contaCorrente.Documento), Times.Once);
            notificacaoServiceMock.Verify(ns => ns.Notificar(It.IsAny <ContaCorrente>()), Times.Once);

            Assert.True(resposta);
        }
        public void ContaCorrenteService_ObterPorId_Return_Be_Sucess()
        {
            _contaCorrenteRepositoryMock.Setup(x => x.ObterPorId(1)).Returns(new ContaCorrente
            {
                IdConta    = 1,
                ValorAtual = 100
            });

            var contaCorrenteService = new ContaCorrenteService(_contaCorrenteRepositoryMock.Object);
            var contaCorrente        = contaCorrenteService.ObterPorId(1);

            _contaCorrenteRepositoryMock.Verify(r => r.ObterPorId(
                                                    It.Is <int>(v => v == contaCorrente.IdConta)));
        }
        public void DepositoConta_Inexistente()
        {
            Mock <IContaCorrenteRepository> fakeRepo = new Mock <IContaCorrenteRepository>();
            Guid             guid       = Guid.NewGuid();
            List <Transacao> transacoes = new List <Transacao>();
            ContaCorrente    conta      = new ContaCorrente(Guid.NewGuid(), Guid.NewGuid(), transacoes);

            fakeRepo.Setup(mock => mock.Load(guid)).Returns(conta);

            ContaCorrenteService service = new ContaCorrenteService(fakeRepo.Object);

            Exception e = Assert.Throws <Exception>(() => service.Depositar(Guid.NewGuid(), 10, "deposito"));

            Assert.Equal("Conta não encontrada", e.Message);
        }
        public void DepositoConta_OK()
        {
            Mock <IContaCorrenteRepository> fakeRepo = new Mock <IContaCorrenteRepository>();
            Guid             guid       = Guid.NewGuid();
            List <Transacao> transacoes = new List <Transacao>();
            ContaCorrente    conta      = new ContaCorrente(Guid.NewGuid(), Guid.NewGuid(), transacoes);

            fakeRepo.Setup(mock => mock.Load(guid)).Returns(conta);

            ContaCorrenteService service = new ContaCorrenteService(fakeRepo.Object);

            service.Depositar(guid, 10, "deposito");

            Assert.Equal(10, conta.Saldo);
        }
        public void ContaCorrenteService_Adicionar_Return_Be_Sucess()
        {
            var contaCorrente = new ContaCorrente
            {
                ValorAtual = 100
            };


            var contaCorrenteService = new ContaCorrenteService(_contaCorrenteRepositoryMock.Object);

            contaCorrenteService.Adicionar(contaCorrente);

            _contaCorrenteRepositoryMock.Verify(r => r.Adicionar(
                                                    It.Is <ContaCorrente>(v => v.ValorAtual == contaCorrente.ValorAtual)));
        }
Ejemplo n.º 8
0
        public void ContaService_RealizarDeposito_ValidarTransacaoComSucesso()
        {
            // Arrange
            var conta    = new ContaCorrente(100, 0, 100);
            var deposito = 500M;
            var repo     = new Mock <IContaCorrenteRepository>();

            // Quando chamar o método ObterContaPorNumer com parametro 01234, retorna o object conta criado anteriormente
            repo.Setup(r => r.ObterContaPorNumero("01234")).Returns(conta);

            var contaService = new ContaCorrenteService(repo.Object);

            // Act
            var transacao = contaService.EfetuarDeposito("01234", deposito);

            // Assert
            repo.Verify(r => r.Atualizar(conta), Times.Once);
            Assert.Equal("Depósito efetuado com sucesso.", transacao.Mensagem);
            Assert.Equal(TipoRetorno.Sucesso, transacao.Retorno);
        }
        private ContaCorrenteService GetContaCorrente()
        {
            var contaCorrente = new ContaCorrenteService(
                Mock.Of <IAgenciaRepository>(),
                Mock.Of <IContaRepository>(),
                Mock.Of <IExtratoRepository>()

                );

            var agencia = new Agencia()
            {
                Id = 8792, Nome = "Agência Zona Oeste"
            };
            var agencia2 = new Agencia()
            {
                Id = 200, Nome = "Agência Zona Leste"
            };

            Mock.Get(contaCorrente.AgenciaRepository).Setup(x => x.GetById(8792)).Returns(agencia);
            Mock.Get(contaCorrente.AgenciaRepository).Setup(x => x.GetById(200)).Returns(agencia);

            var conta = new Conta()
            {
                Id = 3621, AgenciaId = 8792, Cliente = new Cliente()
                {
                    Nome = "Jéssica Nathany", CPF = "004.887.380-24"
                }, Saldo = 100m
            };
            var conta2 = new Conta()
            {
                Id = 700, AgenciaId = 200, Cliente = new Cliente()
                {
                    Nome = "Peter Pan", CPF = "014.121.350-50"
                }, Saldo = 700m
            };

            Mock.Get(contaCorrente.ContaRepository).Setup(c => c.GetById(8792, 3621)).Returns(conta);
            Mock.Get(contaCorrente.ContaRepository).Setup(c => c.GetById(200, 700)).Returns(conta2);

            return(contaCorrente);
        }
Ejemplo n.º 10
0
        public void Deve_Dizer_Que_ContaCorrente_Nao_Existe()
        {
            // arrange
            var contaCorrente = new ContaCorrente()
            {
                Agencia = 9104,
                Conta   = 01550
            };

            var mock = new Mock <IContaCorrenteRepository>();

            mock.Setup(m => m.Obtem(9104, 01550)).Returns(contaCorrente);

            var contaCorrenteService = new ContaCorrenteService(mock.Object);

            // act
            var existe = contaCorrenteService.ContaCorrenteExiste(9101, 01550);

            // assert
            Assert.False(existe);
        }
Ejemplo n.º 11
0
        public void Deve_Retornar_ContaCorrente_Nao_Encontrada()
        {
            // arrange
            var contaCorrente = new ContaCorrente()
            {
                Agencia = 9104,
                Conta   = 01550
            };

            var mock = new Mock <IContaCorrenteRepository>();

            mock.Setup(m => m.Obtem(9104)).Returns(contaCorrente);

            var contaCorrenteService = new ContaCorrenteService(mock.Object);

            // act
            var ex = Assert.Throws <Exception>(() => contaCorrenteService.Obtem(9105));

            // assert
            Assert.Equal("Conta corrente não encontrada", ex.Message);
        }
Ejemplo n.º 12
0
        public void ContaCorrente_Nao_Pode_Realizar_Debito()
        {
            // arrange
            var contaCorrente = new ContaCorrente()
            {
                Agencia = 9104,
                Conta   = 01550
            };

            var mock = new Mock <IContaCorrenteRepository>();

            mock.Setup(m => m.Obtem(1234)).Returns(contaCorrente);

            var contaCorrenteService = new ContaCorrenteService(mock.Object);

            // act
            var contaCorrenteObtida = contaCorrenteService.Obtem(1234);
            var valorSolicitado     = 100001;

            // assert
            Assert.False(contaCorrenteObtida.PossoDebitar(valorSolicitado));
        }
Ejemplo n.º 13
0
        public void Deve_Retornar_ContaCorrente()
        {
            // arrange

            var contaCorrente = new ContaCorrente()
            {
                Agencia = 9104,
                Conta   = 01550
            };

            var mock = new Mock <IContaCorrenteRepository>();

            mock.Setup(m => m.Obtem(1234)).Returns(contaCorrente);

            var contaCorrenteService = new ContaCorrenteService(mock.Object);

            // act
            var contaCorrenteEsperada = contaCorrenteService.Obtem(1234);

            // assert
            Assert.Equal(contaCorrenteEsperada, contaCorrente);
        }
 public ContaCorrenteController(DataContext db, IConfiguration configuration)
 {
     this.db            = db;
     this.configuration = configuration;
     this.service       = new ContaCorrenteService(db, configuration);
 }
Ejemplo n.º 15
0
 public ContaCorrenteTests()
 {
     this.ContaCorrenteService = new ContaCorrenteService();
     this.SpbQueueService      = new SPBQueueService();
     this.TransferenciaService = new TransferenciaService(this.ContaCorrenteService, this.SpbQueueService);
 }
Ejemplo n.º 16
0
        static void Main(string[] args)
        {
            Console.WriteLine("Digite seu nome");
            var nome = Console.ReadLine();

            Console.WriteLine("Por favor informe o tipo da sua conta:\n Digite o numeral 1 para Conta Corrente (Pessoa Física) \n Digite o numeral 2 para Conta Investimento (Pessoa Jurídica)");
            var tipoConta = Convert.ToInt32(Console.ReadLine());

            if (tipoConta == 1)
            {
                Console.WriteLine("\n" + nome + ", agora você pode realizar algumas operações:\n Digite o numeral 1 para Saque \n Digite o numeral 2 para Depósito \n Digite o numeral 3 para Transferência");
                try
                {
                    int operacao = Convert.ToInt32(Console.ReadLine());

                    ContaCorrenteService contaCorrenteService = new ContaCorrenteService();
                    switch (operacao)
                    {
                    case 1:
                        contaCorrenteService.OperacaoSaque();
                        break;

                    case 2:
                        contaCorrenteService.OperacaoDeposito();
                        break;

                    case 3:
                        contaCorrenteService.OperacaoTransferencia();
                        break;
                    }
                }
                catch (Exception)
                {
                    Console.WriteLine("Operação falhou, " + nome + " por favor verifique se você digitou um número!");
                    throw;
                }
            }
            else if (tipoConta == 2)
            {
                Console.WriteLine("\n" + nome + ", agora você pode realizar algumas operações:\n Digite o numeral 1 para Saque \n Digite o numeral 2 para Depósito \n Digite o numeral 3 para Transferência");
                try
                {
                    int operacao = Convert.ToInt32(Console.ReadLine());

                    InvestimentoService InvestimentoService = new InvestimentoService();
                    switch (operacao)
                    {
                    case 1:
                        InvestimentoService.OperacaoSaque();
                        break;

                    case 2:
                        InvestimentoService.OperacaoDeposito();
                        break;

                    case 3:
                        InvestimentoService.OperacaoTransferencia();
                        break;
                    }
                }
                catch (Exception)
                {
                    Console.WriteLine("Operação falhou, " + nome + " por favor verifique se você digitou um número!");
                    throw;
                }
            }

            else
            {
                Console.WriteLine("Por favor digite um tipo de conta válida!");
                throw new Exception();
            }
        }