Exemple #1
0
        public void CalcularImposto_de_livro_com_tema_educativo__deve_retornar_0()
        {
            Livro livro   = LivroBuilder.Novo().ComTema("Educativo").ConstruirCompleto();
            var   imposto = livro.CalculaImposto();

            Assert.Equal(expected: 0, actual: imposto);
        }
Exemple #2
0
        public void CalcularImposto_de_livro_com_outros_temas__deve_retornar_10porcento_do_preco()
        {
            Livro livro             = LivroBuilder.Novo().ConstruirCompleto();
            var   imposto           = livro.CalculaImposto();
            var   valorDe10porCento = livro.preco * 0.1;

            Assert.Equal(expected: valorDe10porCento, actual: imposto);
        }
        public void NaoDeveNotificarSeLivroNaoEncontrado()
        {
            //arrange
            var livro = LivroBuilder.Novo().Build();

            //act
            _validadorDeLivro.ValidarLivroEncontrado(livro);
            var resultado = _notify.IsValid();

            //asset
            Assert.True(resultado);
        }
Exemple #4
0
        public void NaoDeveCriarUmLivroComEdicaoInvalido()
        {
            //arrange
            var edicaoInvalida = Constantes.Zero;
            var livro          = LivroBuilder.Novo().ComEdicao(edicaoInvalida).Build();

            //act
            var resultado = livro.Validar();

            //assert
            Assert.False(resultado);
        }
Exemple #5
0
        public void NaoDeveCriarUmLivroComTituloMaiorQueLimite()
        {
            //arrange
            var tituloInvalido = _faker.Lorem.Paragraphs();
            var livro          = LivroBuilder.Novo().ComTitulo(tituloInvalido).Build();

            //act
            var resultado = livro.Validar();

            //assert
            Assert.False(resultado);
        }
        public void DeveRemoverLivro()
        {
            //arrange
            var livro = LivroBuilder.Novo().Build();

            _livroRepositorioMock.Setup(x => x.ObterPorIdAsync(It.IsAny <int>())).ReturnsAsync(livro);

            //act
            _removedorDeLivro.Remover(livro.Id);

            //assert
            _livroRepositorioMock.Verify(x => x.Remover(It.IsAny <Livro>()), Times.Once);
        }
        public void DeveNotificarSeLivroExiste()
        {
            //arrange
            var mensagemEsperada = Resources.LivroJaExiste;
            var livro            = LivroBuilder.Novo().Build();

            //act
            _validadorDeLivro.ValidarSeLivroExiste(livro);
            var resultado            = _notify.IsValid();
            var notificacaoExistente = _notify.GetNotifications().Any(x => x.Value.Equals(mensagemEsperada));

            //asset
            Assert.False(resultado);
            Assert.True(notificacaoExistente);
        }
Exemple #8
0
        public void DeveAlterarOLivro()
        {
            //arrange
            var livro = LivroBuilder.Novo().Build();
            var dto   = ObterDtoComAutorValido();

            //act
            _alteradorDeLivro.Alterar(livro, dto);

            //assert
            Assert.Equal(livro.Titulo, dto.Titulo);
            Assert.Equal(livro.AnoDePublicacao, dto.AnoDePublicacao);
            Assert.Equal(livro.Edicao, dto.Edicao);
            Assert.Equal(livro.AutorId, dto.AutorId);
        }
Exemple #9
0
        public void CalculaPatrimonio__deve_retornar_o_preco_total_com_imposto_de_todos_os_produtos()
        {
            var livros = new List <Livro>()
            {
                LivroBuilder
                .Novo()
                .ComPreco(10)
                .ComQtd(1)
                .ComTema("Educativo")
                .ConstruirCompleto(),             // (10 + 0) * 1 = 10

                LivroBuilder
                .Novo()
                .ComPreco(20)
                .ComQtd(2)
                .ComTema("Aventura")
                .ConstruirCompleto(), // 20 * 2 = 40
            };                        // Patrimonio -> 10 + 40 => 50

            var videoGames = new List <VideoGame>()
            {
                VideoGameBuilder
                .Novo()
                .ComPreco(100)
                .ComQtd(2)
                .Usado(false)
                .ConstruirCompleto(),             // 100 * 2 = 200

                VideoGameBuilder
                .Novo()
                .ComPreco(50)
                .ComQtd(4)
                .Usado(true)
                .ConstruirCompleto(), // 50 * 4 = 200
            };                        // Patrimonio -> 200 + 200 => 400


            Loja loja = LojaBuilder
                        .Novo()
                        .ComLivros(livros)
                        .ComVideoGames(videoGames)
                        .Construir();         // Patrimonio Total -> 50 + 400 => 450

            var patrimonio = loja.CalculaPatrimonio();

            Assert.Equal(expected: 450, actual: patrimonio);
        }
Exemple #10
0
        public void DeveCriarUmLivro()
        {
            //arrange
            var livroEsperado = LivroBuilder.Novo().Build();

            //act
            var livro = new Livro(
                livroEsperado.Titulo,
                livroEsperado.AnoDePublicacao,
                livroEsperado.Edicao,
                livroEsperado.AutorId);

            //assert
            Assert.Equal(livroEsperado.Titulo, livro.Titulo);
            Assert.Equal(livroEsperado.AnoDePublicacao, livro.AnoDePublicacao);
            Assert.Equal(livroEsperado.Edicao, livro.Edicao);
            Assert.Equal(livroEsperado.AutorId, livro.AutorId);
        }
        public async Task NaoDeveArmazenarLivro()
        {
            //arrange
            var   dto   = ObterDtoComAutorValido();
            Livro livro = LivroBuilder.Novo().ComTitulo(dto.Titulo).Build();

            CriaSetUpValidadorDeLivroValidarSeLivroExiste(livro);
            CriaSetUpRepositorioLivroObterPorTitulo(livro);


            //act
            await _armazenadorDeLivros.Armazenar(dto);

            //assert
            var achou = _notify.Invoke().GetNotifications().Any(x => x.Value == Resources.LivroJaExiste);

            Assert.True(achou);
            _livroRepositorioMock.Verify(x => x.AdicionarAsync(It.IsAny <Livro>()), Times.Never);
        }