TDD com Python - Siga o bode dos testes: usando Django, Selenium e JavaScript

Ao conduzir você pelo desenvolvimento de uma verdadeira aplicação web do início ao fim, a segunda edição deste guia “mão na massa” mostra as vantagens práticas do TDD (Test-Driven Development, ou Desenvolvimento Orientado a Testes) com Python. Você aprenderá a escrever e a executar testes antes de construir cada parte de sua aplicação, e então desenvolverá a quantidade mínima de código necessária para que os testes passem. O resultado? Um código limpo, que funcionará.

De: R$ 139,00Por: R$ 99,90

Preço a vista: R$ 99,90

Economia de R$ 39,10

+-
Comprar
Opções de Parcelamento:
  • à vista R$ 99,90
Outras formas de pagamento

Quem viu este produto , comprou

  • Expressões Regulares - 5ª Edição - Uma Abordagem Divertida

    Você procura uma sigla em um texto longo, mas não lembra direito quais eram as letras. Só lembra que era uma sigla de quatro letras. Simples, procure por [A-Z]{4}.
    Revisando aquela tese de mestrado, você percebe que digitou errado o nome daquele pesquisador alemão famoso. E foram várias vezes. Escreveu Miller, Mueller e Müler, quando na verdade era Müller. Que tal corrigir todos de uma vez? Fácil, use a expressão M(i|ue|ü)ll?er. ... Ler mais +

    QUERO VER
  • TDD com Python - Siga o bode dos testes: usando Django, Selenium e JavaScript

    Ao conduzir você pelo desenvolvimento de uma verdadeira aplicação web do início ao fim, a segunda edição deste guia “mão na massa” mostra as vantagens práticas do TDD (Test-Driven Development, ou Desenvolvimento Orientado a Testes) com Python. Você aprenderá a escrever e a executar testes antes de construir cada parte de sua aplicação, e então desenvolverá a quantidade mínima de código necessária para que os testes passem. O resultado? Um código limpo, que funcionará. ... Ler mais +

    QUERO VER
  • Introdução à Programação com PYTHON

    VITRINE Os Livros mais Vendidos !

    Python é uma linguagem de programação de alto nível, interpretada, de script, imperativa, orientada a objetos, funcional. Lançada por Guido van Rossum em 1991. Atualmente é uma das Linguagens de Programação mais utilizadas no mundo. Python foi criada para produzir código bom e fácil de manter, de maneira rápida e suporta múltiplos paradigmas de programação. A programação procedimental pode ser usada para programas simples e rápidos, mas estruturas de dados avançadas estão disponíveis para facilitar o desenvolvimento de algoritmos complexos. Grandes projetos podem ser feitos usando técnicas de orientação a objetos, que é completamente suportada em Python. Assim, o Python se aplica na solução de problemas de várias complexidades. Além disso, por ser uma linguagem livre e multiplataforma, possibilita que os programas escritos em uma plataforma sejam executados sem nenhum problema na maioria das plataformas existentes e sem nenhuma modificação. ... Ler mais +

    QUERO VER
  • Python para análise de dados: Tratamento de dados com Pandas, NumPy e IPython

    VITRINE Os Livros mais Vendidos !

    Obtenha instruções completas para manipular, processar, limpar e extrair informações de conjuntos de dados em Python. Atualizada para Python 3.6, este guia prático está repleto de casos de estudo práticos que mostram como resolver um amplo conjunto de problemas de análise de dados de forma eficiente. Você conhecerá as versões mais recentes do pandas, da NumPy, do IPython e do Jupyter no processo. ... Ler mais +

    QUERO VER
  • Python Eficaz - 59 maneiras de programar melhor em Python

    Python Eficaz ajudará o leitor a dominar o mais verdadeiro estilo “pythônico” da arte de programar, empregando todo o potencial do Python para escrever códigos robustos e de desempenho exemplar. Usando o estilo conciso e baseado em cenários, visto no best-seller C++ Eficaz, de Scott Meyers, o autor Brett Slatkin reúne 59 das melhores práticas e dicas em Python, e as explica com exemplos realistas de código. ... Ler mais +

    QUERO VER

Quem viu este produto , também se interessou

  • Pense em Python - Pense como um cientista da computação

    Se você quer aprender como programar, usar Python é uma ótima forma de começar. Este guia prático apresenta a linguagem passo a passo, começando com conceitos de programação básicos antes de chegar a funções, recursividade, estruturas de dados e design orientado a objeto. Esta edição e seu código de apoio foram atualizados para o Python 3. ... Ler mais +

    QUERO VER
  • Programação em Baixo Nível: C, Assembly e execução de programas na arquitetura Intel 64

    Conheça a linguagem Assembly e a arquitetura do Intel 64, torne-se proficiente em C e entenda como os programas são compilados e executados até o nível das instruções de máquina, permitindo-lhe escrever um código robusto e de alto desempenho. ... Ler mais +

    QUERO VER
  • E-BOOK Tópicos de Física Matemática (envio por e-mail)

    *** ATENÇÃO ***
    PRODUTO DIGITAL PARA DOWNLOAD.
    RECEBERÁ O LINK E AS INSTRUÇÕES VIA E-MAIL EM ATÉ 2 DIAS ÚTEIS APÓS A CONFIRMAÇÃO DA COMPRA.
    NÃO REALIZAMOS DEVOLUÇÕES DESTE PRODUTO.
    ANTES DE COMPRAR VERIFIQUE SE SEU PC OU DISPOSITIVO ESTÁ APTO À BAIXAR O ARQUIVO. VEJA MAIS EM INFORMAÇÕES ABAIXO.
    *CASO TENHA ESCOLHIDO JUNTO AO E-BOOK UM PRODUTO FÍSICO, O MESMO APARECERÁ NO CARRINHO COM O PRAZO DE ENTREGA E O CUSTO DO FRETE
    NESTE CASO, A OPÇÃO ENVIO POR EMAIL DESAPARECERÁ , POREM NÃO SE PREOCUPE, POIS SEU E-BOOK SERÁ ENVIADO EM ATÉ 2 DIAS ÚTEIS PARA O SEU EMAIL .
    ... Ler mais +

    QUERO VER
  • O Guia do Mochileiro Python - Melhores práticas para desenvolvimento

    VITRINE Os Livros mais Vendidos !

    Escrito de forma colaborativa por mais de uma centena de membros da comunidade Python, este livro tem três seções. Primeiro, você aprenderá como instalar e usar ferramentas de edição para Python. Em seguida, examinará exemplos de códigos modelares com o estilo da linguagem. Para concluir, verá as bibliotecas mais usadas pela comunidade. ... Ler mais +

    QUERO VER
  • CSS Grid Layout: Criando layouts CSS profissionais

    VITRINE Os Livros mais Vendidos !

    A criação de Layout CSS sempre foi uma tarefa trabalhosa, mas agora os profissionais têm uma ferramenta poderosa ao seu alcance, o CSS Grid Layout, uma nova especificação do W3C, que veio para resolver praticamente todos os problemas de posicionamento na tela. Utilizando um novo método de layout CSS, bidimensional, com linhas e colunas, mais simples e muito mais fácil de usar, permite controlar o tamanho e a posição dos componentes da interface e seus conteúdos. Não será mais necessário inflar a marcação HTML com elementos desnecessários para a criação de layouts CSS. ... Ler mais +

    QUERO VER
  • Teste de desempenho com JMeter 3: Melhore o desempenho de sua aplicação web

    O JMeter é uma aplicação Java projetado para carregar e testar o desempenho de aplicações web. Este livro é um ótimo ponto de partida para conhecê-lo. Ele aborda os novos recursos introduzidos com o JMeter3 e permite conhecer a fundo as novas técnicas necessárias para a avaliação do desempenho de um site. ... Ler mais +

    QUERO VER
  • Introdução ao Desenvolvimento de Jogos em Python com PyGame

    Introdução ao Desenvolvimento de Jogos em Python com PyGame, ensina você a criar jogos atraentes usando o Python e a biblioteca PyGame para desenvolvimento de jogos. O livro ensinará você a criar o visual, tratar eventos, criar jogos 3D, acrescentar elementos de mídia e integrar a OpenGL ao seu jogo Python. ... Ler mais +

    QUERO VER
  • Raspberry Pi: Guia do Usuário - Tradução da 4ª edição

    O Guia totalmente atualizado para o revolucionário Raspberry Pi. Raspberry Pi Guia do Usuário, Tradução da 4ª edição, é uma introdução ampla e totalmente atualizada para o Raspberry Pi e sua grande variedade de configurações de hardware, linguagens de programação e aplicações educativas. Escrita pelo cocriador do Raspberry Pi, Eben Upton, e pelo respeitado autor técnico Gareth Halfacree, esta quarta edição do popular best-seller é o recurso perfeito para novos usuários de Pi e hackers curiosos que desejam explorar as infinitas possibilidades desse revolucionário computador. ... Ler mais +

    QUERO VER
  • Curso Intensivo de Python - Uma introdução prática e baseada em projetos à programação

    Aprenda Python – rapidamente!
    Curso Intensivo de Python é uma introdução completa e em ritmo acelerado à linguagem Python, que fará você escrever programas, resolver problemas e criar soluções que funcionarão em um piscar de olhos.
    Na primeira metade do livro você conhecerá os conceitos básicos de programação, como listas, dicionários, classes e laços, e praticará a escrita de códigos limpos e legíveis, com exercícios para cada assunto. Você também aprenderá a deixar seus programas interativos e a testar seu código de modo seguro antes de adicioná-lo a um projeto. Na segunda metade do livro você colocará seu novo conhecimento em prática com três projetos substanciais: um jogo de arcade, inspirado no Space Invaders, visualizações de dados com as bibliotecas extremamente práticas de Python, e uma aplicação web simples que poderá ser implantada online. ... Ler mais +

    QUERO VER
  • Python Cookbook - Receitas para dominar Python 3

    Se precisar de ajuda para escrever programas em Python 3 ou desejar atualizar códigos antigos que estejam em Python 2, este livro é seu passaporte para isso. Cheio de receitas práticas, escritas e testadas com Python 3.3, este cookbook único está voltado para programadores experientes de Python que querem focar em ferramentas e recursos modernos.
    Neste livro, você encontrará receitas completas para mais de uma dúzia de tópicos que abordam a parte essencial da linguagem Python, bem como tarefas comuns a uma ampla variedade de áreas de aplicação. Toda receita contém exemplos de código que podem ser utilizados imediatamente em seus projetos, juntamente com uma discussão sobre como e por que a solução funciona. ... Ler mais +

    QUERO VER
  • Python Fluente - Programação clara, concisa e eficaz

    R$ 114,90 ou 2x de R$ 57,45

    A simplicidade de Python permite que você se torne produtivo rapidamente, porém isso muitas vezes significa que você não estará usando tudo que ela tem a oferecer. Com este guia prático, você aprenderá a escrever um código Python eficiente e idiomático aproveitando seus melhores recursos ... ... Ler mais +

    QUERO VER
  • Automatize tarefas maçantes com Python - Programação prática para verdadeiros iniciantes

    APRENDA PYTHON. FAÇA O QUE TEM DE SER FEITO.
    Se você já passou horas renomeando arquivos ou atualizando centenas de células de planilhas, sabe quão maçantes podem ser esses tipos de tarefa. Que tal se você pudesse fazer o seu computador executá-las para você?
    Em Automatize tarefas maçantes com Python, você aprenderá a usar o Python para criar programas que farão em minutos o que exigiria horas para ser feito manualmente – sem que seja necessário ter qualquer experiência anterior com programação. Após ter dominado o básico sobre programação, você criará programas Python que realizarão proezas úteis e impressionantes de automação sem nenhum esforço:... ... Ler mais +

    QUERO VER
  • Aprendendo Pentest com Python - Utilize scripts Python para executar pentests eficazes e eficientes

    Python é uma poderosa plataforma de script da nova era que permite construir exploits, auditar serviços, automatizar e vincular soluções com facilidade. Python é uma linguagem de programação multiparadigma adequada tanto para o desenvolvimento de aplicações orientadas a objeto quanto para padrões de design funcional.
    Este livro destaca como você pode avaliar uma organização de maneira metódica e realista. São abordadas técnicas comerciais e experiências específicas que mostram exatamente quando e onde as ferramentas da indústria podem e devem ser usadas. ... Ler mais +

    QUERO VER
  • White Hat Linux: Análise de vulnerabilidades e técnicas de defesas com software livre

    Sabemos que a informação gera conhecimento e nesse sentido devemos proteger as informações de ataques de pessoas mal intencionadas. Empresas e órgãos governamentais sofrem ataques diariamente e cada vez mais se torna necessário que tenham profissionais qualificados para a proteção das informações. Mas como proteger, se nem sei como o ataque funciona? O livro traz tudo o que você precisa saber para iniciar seus estudos na área de segurança da informação de forma simples e didática. ... Ler mais +

    QUERO VER
  • Data Smart - Usando Data Science para transformar informação em insight

    Não quero te desiludir, mas os cientistas de dados não são feiticeiros místicos usuários da arte da magia. Data science é algo que você pode fazer. De verdade. Este livro mostra técnicas significativas, como elas funcionam, como usá-las, e como elas trazem benefícios para o seu negócio, seja ele pequeno ou grande. Não é apenas trabalhar com códigos ou tecnologias de base de dados. É transformar seus dados brutos em insight para que você possa operá-los da forma mais rápida e prática possível. Erga as mangas e vamos lá. ... Ler mais +

    QUERO VER
  • Python para análise de dados: Tratamento de dados com Pandas, NumPy e IPython

    VITRINE Os Livros mais Vendidos !

    Obtenha instruções completas para manipular, processar, limpar e extrair informações de conjuntos de dados em Python. Atualizada para Python 3.6, este guia prático está repleto de casos de estudo práticos que mostram como resolver um amplo conjunto de problemas de análise de dados de forma eficiente. Você conhecerá as versões mais recentes do pandas, da NumPy, do IPython e do Jupyter no processo. ... Ler mais +

    QUERO VER
  • Black Hat Python - Programação Python para hackers e pentesters

    Quando se trata de criar ferramentas eficazes e eficientes de hacking, o Python é a linguagem preferida da maioria dos analistas da área de segurança. Mas como a mágica acontece?
    Em Black Hat Python, o livro mais recente de Justin Seitz (autor do best-seller Gray Hat Python), você explorará o lado mais obscuro dos recursos do Python – fará a criação de sniffers de rede, manipulará pacotes, infectará máquinas virtuais, criará cavalos de Troia discretos e muito mais. Você aprenderá a:... ... Ler mais +

    QUERO VER
  • Python Eficaz - 59 maneiras de programar melhor em Python

    Python Eficaz ajudará o leitor a dominar o mais verdadeiro estilo “pythônico” da arte de programar, empregando todo o potencial do Python para escrever códigos robustos e de desempenho exemplar. Usando o estilo conciso e baseado em cenários, visto no best-seller C++ Eficaz, de Scott Meyers, o autor Brett Slatkin reúne 59 das melhores práticas e dicas em Python, e as explica com exemplos realistas de código. ... Ler mais +

    QUERO VER
  • Introdução à Orientação a Objetos com C++ e Python - Uma abordagem prática

    VITRINE Os Livros mais Vendidos !

    Um dos grandes desafios nos cursos de Tecnologia da Informação e em cursos correlatos é o ensino do paradigma orientação a objetos. Aprender o conceito de classe, objeto, herança, polimorfismo e outros conceitos do paradigma não basta. É necessário entender a aplicabilidade desses conceitos em dividir o software em pequenas unidades que trocam mensagens entre si, aproveitando as reais vantagens desse paradigma. ... Ler mais +

    QUERO VER
  • Descrição
    TDD com Python - Siga o bode dos testes: usando Django, Selenium e JavaScript

    Ao conduzir você pelo desenvolvimento de uma verdadeira aplicação web do início ao fim, a segunda edição deste guia “mão na massa” mostra as vantagens práticas do TDD (Test-Driven Development, ou Desenvolvimento Orientado a Testes) com Python. Você aprenderá a escrever e a executar testes antes de construir cada parte de sua aplicação, e então desenvolverá a quantidade mínima de código necessária para que os testes passem. O resultado? Um código limpo, que funcionará.

    Durante o processo, você conhecerá o básico sobre Django, Selenium, Git, jQuery e Mock, junto com as técnicas atuais para desenvolvimento web. Se estiver pronto para levar suas habilidades com Python para o próximo patamar, este livro – atualizado com Python 3.6 – mostrará claramente como o TDD incentiva você a criar designs simples e pode lhe inspirar confiança.

    mergulhe no fluxo de trabalho de TDD, incluindo o ciclo de testes de unidade/código e refatoração;
    utilize testes de unidade para classes e funções, e testes funcionais para interações com usuários no navegador;
    saiba quando e como usar objetos simulados e conheça os prós e contras dos testes isolados versus testes integrados;
    teste e automatize suas implantações com um servidor de staging;
    aplique testes nos plugins de terceiros que você integrar ao seu site;
    execute testes automaticamente usando um ambiente de Integração Contínua;
    utilize TDD para construir uma API REST com uma interface de frontend Ajax.
  • Sobre o Autor
  • Especificação

    Características

    AssuntosTDD
    Tipo de LivroLivro Físico

    Especificações

    Sobre o AutorHarry J.W. Percival

    Após uma infância idílica brincando com BASIC em computadores franceses de 8 bits como o Thomson T-07, cujas teclas faziam “blip” quando pressionadas, Harry passou alguns anos profundamente infeliz dando consultoria em economia e administração. Logo redescobriu sua verdadeira natureza geek e teve sorte o bastante para acabar com um grupo de fanáticos por XP, trabalhando na pioneira, porém infelizmente extinta, planilha Resolver One. Atualmente trabalha na PythonAnywhere LLP e divulga a boa-nova sobre TDD pelo mundo afora em palestras, workshops e conferências com toda paixão e entusiasmo de um recém-convertido.
    Informações TécnicasSumário
    Elogios para TDD com Python.....................................................................................................................1
    Prefácio ..................................................................................................................................17
    Pré-requisitos e suposições......................................................................................................23
    Vídeo complementar...............................................................................................................33
    Agradecimentos......................................................................................................................34

    Parte I ¦ Básico sobre TDD e Django...................................................................... 37

    Capítulo 1 ¦ Configurando o Django com um teste funcional.....................................................38
    Obedeça ao Testing Goat! Não faça nada até ter um teste ...........................................38
    Deixando o Django pronto para funcionar.................................................................41
    Iniciando um repositório no Git.................................................................................43

    Capítulo 2 ¦ Estendendo nosso teste funcional usando unittest................................................48
    Usando teste funcional para definir o escopo de uma aplicação mínima viável ............48
    Módulo unittest da biblioteca-padrão de Python........................................................52
    Commit....................................................................................................................54

    Capítulo 3 ¦ Testando uma página inicial simples com testes de unidade..................................56
    Nossa primeira aplicação Django e nosso primeiro teste de unidade ...........................57
    Testes de unidade e como eles diferem dos testes funcionais.......................................58
    Testes de unidade no Django .....................................................................................59
    MVC de Django, URLs e funções de view..................................................................60
    Finalmente! Vamos realmente escrever um pouco de código de aplicação!...................62
    urls.py ..................................................................................................................... 64
    Fazendo testes de unidade em uma view....................................................................67
    O ciclo de testes de unidade/código ......................................................................68

    Capítulo 4 ¦ O que estamos fazendo com todos esses testes? (E a refatoração) ..........................72
    Programar é como puxar um balde de água de um poço.............................................73
    Usando o Selenium para testar interações com o usuário............................................75
    A regra “Não teste constantes’’, e os templates que vêm para nos salvar ......................78
    Refatorando de modo a usar um template .............................................................79
    Django Test Client ...............................................................................................82
    Sobre a refatoração....................................................................................................85
    Um pouco mais sobre a nossa página inicial...............................................................87
    Revisão: o processo de TDD......................................................................................89

    Capítulo 5 ¦ Salvando a entrada do usuário: testando o banco de dados....................................92
    Preparando o nosso formulário para enviar uma requisição POST..............................93
    Processando uma requisição POST no servidor..........................................................96
    Passando variáveis Python para serem renderizadas no template.................................97
    Três acertos e refatorar ............................................................................................102
    ORM do Django e o nosso primeiro modelo ............................................................105
    Nossa primeira migração de banco de dados.......................................................107
    Os testes vão surpreendentemente longe .............................................................108
    Um novo campo implica uma nova migração......................................................109
    Salvando o POST no banco de dados.......................................................................110
    Redirecionar após um POST ...................................................................................113
    Melhor prática para testes de unidade: cada teste deve testar somente um aspecto115
    Renderizando itens no template...............................................................................116
    Criando nosso banco de dados de produção com migrate.........................................118
    Revisão...................................................................................................................121

    Capítulo 6 ¦ Melhorando os testes funcionais: garantindo o isolamento e removendo sleeps vodus...124
    Garantindo o isolamento dos testes em testes funcionais..........................................124
    Executando somente os testes de unidade...........................................................128
    Informação extra: atualizando o Selenium e o Geckodriver ......................................129
    Sobre esperas implícitas e explícitas, e time.sleeps vodus..........................................130

    Capítulo 7 ¦ Trabalhando de forma incremental..................................................................... 136
    Design pequeno quando necessário .........................................................................136
    Sem um grande design logo no início..................................................................137
    YAGNI! .............................................................................................................138
    (No estilo) REST................................................................................................138
    Implementando o novo design de forma incremental usando TDD ...........................139
    Garantindo que teremos um teste de regressão.........................................................140
    Iterando em direção ao novo design.........................................................................143
    Dando um primeiro passo autocontido: um novo URL.............................................145
    Um novo URL ...................................................................................................146
    Uma nova função de view...................................................................................146
    Verde? Refatorar......................................................................................................149
    Outro pequeno passo: um template separado para visualizar listas...........................150
    Um terceiro passo pequeno: um URL para adicionar itens de lista ............................152
    Uma classe de testes para a criação de uma nova lista..........................................153
    Um URL e uma view para a criação de uma nova lista.........................................154
    Removendo código e testes não redundantes ......................................................155
    Uma regressão! Apontando nossos formulários para o novo URL........................156
    Encarando a situação de frente: ajustando nossos modelos.......................................158
    Um relacionamento de chave estrangeira.............................................................160
    Adaptando o restante do mundo aos novos modelos ...........................................161
    Cada lista deve ter o próprio URL............................................................................164
    Capturando parâmetros de URLs.......................................................................165
    Adaptando new_list para o novo mundo.............................................................166
    Os testes funcionais detectam outra regressão..........................................................168
    Mais uma view para tratar a adição de itens em uma lista existente ..........................169
    Tome cuidado com expressões regulares gulosas!................................................170
    Último URL novo ..............................................................................................171
    Última nova view...............................................................................................171
    Testando os objetos de contexto de resposta diretamente ....................................172
    Uma última refatoração usando inclusões de URL ...................................................175

    Parte II ¦ Sine qua nons do desenvolvimento web................................................178

    Capítulo 8 ¦ Embelezamento: layout e estilização, e o que testar sobre eles............................ 179
    O que testar funcionalmente quanto ao layout e ao estilo .........................................179
    Embelezamento: usando um framework CSS ...........................................................183
    Herança de templates do Django .............................................................................185
    Integrando o Bootstrap ...........................................................................................188
    Linhas e colunas................................................................................................188
    Arquivos estáticos no Django ..................................................................................189
    Mudando para StaticLiveServerTestCase.............................................................191
    Usando componentes do Bootstrap para melhorar a aparência do site.......................192
    Jumbotron!........................................................................................................192
    Entradas maiores ...............................................................................................193
    Estilização de tabelas.........................................................................................193
    Usando o nosso próprio CSS ...................................................................................194
    O que não havíamos revelado: collectstatic e outros diretórios estáticos....................195
    Alguns pontos que ficaram de fora...........................................................................199
    8 TDD com Python

    Capítulo 9 ¦ Testando a implantação usando um site de staging.............................................200
    TDD e as áreas perigosas da implantação.................................................................201
    Como sempre, comece com um teste .......................................................................203
    Obtendo um nome de domínio................................................................................206
    Provisionamento manual de um servidor para hospedar o nosso site.........................206
    Escolhendo o lugar para hospedar o nosso site....................................................206
    Iniciando um servidor........................................................................................207
    Contas de usuário, SSH e privilégios...................................................................208
    Instalando o Nginx............................................................................................208
    Instalando o Python 3.6 .....................................................................................209
    Configurando domínios para o ambiente de staging e o ambiente live .................210
    Usando o FT para confirmar que o domínio funciona e que o Nginx está executando210
    Implantando o nosso código manualmente ..............................................................211
    Acertando a localização do banco de dados ........................................................212
    Criando um virtualenv manualmente e usando requirements.txt......................... 214
    Configuração simples do Nginx..........................................................................215
    Criando o banco de dados com migrate ..............................................................218
    Sucesso! Nossa implantação hack funciona..............................................................220

    Capítulo 10 ¦ Chegando a uma implantação pronta para produção .........................................221
    Passando a usar o Gunicorn ....................................................................................221
    Fazendo o Nginx servir arquivos estáticos ...............................................................223
    Passando a usar sockets Unix ..................................................................................224
    Alterando DEBUG para false e configurando ALLOWED_HOSTS ..........................225
    Usando Systemd para garantir que o Gunicorn inicie no boot...................................226
    Salvando nossas alterações: adicionando o Gunicorn ao nosso requirements.txt ..227
    Pensando em automatizar........................................................................................228
    Salvando templates para os arquivos de configuração de nosso provisionamento..228
    Salvando o nosso progresso.....................................................................................231

    Capítulo 11 ¦ Automatizando a implantação com o Fabric.......................................................233
    Detalhando um script do Fabric para a nossa implantação .......................................234
    Criando a estrutura de diretórios........................................................................235
    Obtendo nosso código-fonte com o Git...............................................................235
    Atualizando settings.py......................................................................................236
    Atualizando o virtualenv....................................................................................237
    Migrando o banco de dados se for necessário......................................................238
    Testando.................................................................................................................239
    Implantação no ambiente live .............................................................................241
    Configuração de Nginx e de Gunicorn usando sed..............................................243
    Atribua uma tag do Git à versão ..............................................................................245
    Leituras complementares.........................................................................................245

    Capítulo 12 ¦ Separando testes em vários arquivos e criando método auxiliar genérico para espera...247
    Comece com um FT de validação: evitando itens em branco.....................................247
    Ignorando um teste ............................................................................................248
    Separando os testes funcionais em vários arquivos..............................................250
    Executando um único arquivo de teste ...............................................................253
    Uma nova ferramenta para testes funcionais: um método auxiliar genérico para espera
    explícita.............................................................................................................254
    Finalizando o FT ....................................................................................................258
    Refatorando os testes de unidade em vários arquivos................................................259

    Capítulo 13 ¦ Validação na camada do banco de dados ...........................................................263
    Validação na camada do modelo..............................................................................264
    Gerenciador de contexto self.assertRaises ..........................................................264
    Idiossincrasia do Django: salvar o modelo não faz a validação ser executada ........265
    Mostrando erros de validação do modelo na view ....................................................266
    Verificando se uma entrada inválida não é salva no banco de dados.....................270
    Padrão Django: processando requisições POST na mesma view em que o formulário é
    renderizado........................................................................................................272
    Refatorar: transferindo a funcionalidade new_item para view_list .......................273
    Impondo a validação do modelo em view_list .....................................................276
    Refatorar: removendo os URLs fixos no código........................................................278
    Tag de template {% url %} .................................................................................278
    Usando get_absolute_url para redirecionamentos...............................................279

    Capítulo 14 ¦ Um formulário simples .....................................................................................283
    Passando a lógica de validação para um formulário ..................................................283
    Explorando a API dos formulários com um teste de unidade ...............................284
    Passando para um ModelForm do Django ..........................................................286
    Testando e personalizando a validação de formulário..........................................287
    Usando o formulário em nossas views......................................................................290
    Usando o formulário em uma view com uma requisição GET..............................290
    Uma grande operação de localizar e substituir ....................................................291
    Usando o formulário em uma view que aceita requisições POST...............................294
    Adaptando os testes de unidade para a view new_list .........................................295
    Usando o formulário na view .............................................................................296
    Usando o formulário para exibir erros no template..............................................297
    Usando o formulário na outra view..........................................................................298
    Um método auxiliar para vários testes pequenos.................................................299
    Um benefício inesperado: validação gratuita no lado cliente pelo HTML5 ...........301
    Um tapinha nas costas ............................................................................................303
    No entanto, desperdiçamos muito tempo?................................................................304
    Usando o método do próprio formulário para salvar dados.......................................305

    Capítulo 15 ¦ Formulários mais sofisticados ...........................................................................308
    Outro FT para itens duplicados...............................................................................308
    Evitando duplicações na camada do modelo .......................................................309
    Uma pequena digressão sobre ordenação de querysets e representações de string.312
    Reescrevendo o teste antigo do modelo...............................................................315
    Alguns erros de integridade aparecem quando salvamos os dados ....................... 316
    Fazendo experimentos com validação de itens duplicados na camada de views ......... 317
    Um formulário mais complexo para tratar a validação de unicidade..........................319
    Usando o formulário de item de lista existente na view de lista .................................321
    Conclusão: o que aprendemos sobre testar o Django ................................................324

    Capítulo 16 ¦ Mergulhando os pés, cautelosamente, no JavaScript.......................................... 327
    Começando com um FT..........................................................................................327
    Configurando um executor de testes básico de JavaScript.........................................329
    Usando a jQuery e a div de fixture...........................................................................332
    Construindo um teste de unidade de JavaScript para a funcionalidade desejada........335
    Fixtures, ordem de execução e o estado global: principais desafios nos testes de JavaScript.337
    console.log para prints de depuração ..................................................................337
    Usando uma função de inicialização para ter mais controle sobre o tempo de execução.339
    Boilerplate para onload e namespacing ....................................................................342
    Testes de JavaScript no ciclo de TDD.......................................................................343
    Alguns tópicos que não puderam ser abordados.......................................................344

    Capítulo 17 ¦ Implantando o nosso novo código .....................................................................346
    Implantação no servidor de staging..........................................................................346
    Implantação no servidor live....................................................................................347
    O que fazer se você vir um erro de banco de dados...................................................347
    Conclusão: atribua uma tag no git para a nova versão...............................................347

    Parte III ¦ Tópicos mais avançados sobre testes................................................... 349

    Capítulo 18 ¦ Autenticação de usuário, spiking e de-spiking....................................................350
    Autenticação sem senha ..........................................................................................350
    Programação exploratória, também conhecida como “spiking” ................................351
    Iniciando um branch para o spike.......................................................................352
    UI de login no frontend......................................................................................352
    Enviando emails a partir do Django....................................................................353
    Usando variáveis de ambiente para evitar segredos no código-fonte .....................356
    Armazenando tokens no banco de dados............................................................356
    Modelos personalizados para autenticação .........................................................357
    Finalizando a autenticação personalizada do Django...........................................359
    De-spiking..............................................................................................................364
    Revertendo o nosso código de spiking ................................................................366
    Um modelo de usuário personalizado mínimo .........................................................367
    Testes como documentação................................................................................370
    Um modelo de token para associar emails a um ID único.........................................372

    Capítulo 19 ¦ Usando mocks para testar dependências externas ou reduzir a duplicação ......... 375
    Antes de começar: definindo a infraestrutura básica.................................................375
    Fazendo uma simulação manual, também conhecida como monkeypatching............376
    Biblioteca Mock de Python......................................................................................380
    Usando unittest.patch ........................................................................................381
    Avançando um pouco mais no FT ......................................................................384
    Testando o framework de mensagens do Django .................................................384
    Adicionando mensagens em nosso HTML ..........................................................387
    Começando pelo URL de login...........................................................................388
    Verificando se enviamos um link com um token para o usuário...........................389
    De-spiking de nosso backend personalizado de autenticação ....................................391
    Um if = mais um teste ........................................................................................392
    Método get_user ...............................................................................................396
    Usando o nosso backend de autenticação na view de login ..................................398
    Uma razão alternativa para usar mocks: reduzir a duplicação ...................................399
    Usando mock.return_value ................................................................................402
    Patching no nível de classe................................................................................. 404
    Hora da verdade: o FT passará?.............................................................................. 406
    Teoricamente o FT funciona! Ele funciona na prática?..............................................409
    Terminando o nosso FT, testando o logout .............................................................. 410

    Capítulo 20 ¦ Fixtures de teste e um decorador para esperas explícitas ................................... 414
    Pulando o processo de login e criando previamente uma sessão................................ 414
    Verificando se o código funciona ........................................................................ 417
    Nossa função auxiliar final de espera explícita: um decorador wait...........................420

    Capítulo 21 ¦ Depuração no lado do servidor..........................................................................425
    Prova definitiva: usando o servidor de staging para capturar os últimos bugs ...........425
    Configurando o logging .....................................................................................426
    Definindo variáveis de ambiente secretas no servidor ...............................................428
    12 TDD com Python
    Adaptando o nosso FT para que possamos testar emails de verdade via POP3 ..........429
    Administrando o banco de dados de testes no ambiente de staging...........................433
    Um comando de gerenciamento do Django para criar sessões..............................434
    Fazendo o FT executar o comando de gerenciamento no servidor........................436
    Usando o Fabric diretamente de Python..............................................................437
    Revisão: criando sessões localmente versus no ambiente de staging......................438
    Incluindo o nosso código de logging ....................................................................... 440
    Conclusão...............................................................................................................441

    Capítulo 22 ¦ Finalizando “My Lists”: TDD Outside-In ..............................................................443
    A alternativa: “Inside-Out”......................................................................................443
    Por que dar preferência para a abordagem “Outside-In”?......................................... 444
    FT para “My Lists” ................................................................................................ 444
    Camada mais externa: apresentação e templates ......................................................447
    Descendo uma camada, em direção às funções de view (o controlador).....................448
    Outro teste que passa usando a abordagem Outside-In ............................................449
    Uma reestruturação rápida da hierarquia de herança dos templates .....................450
    Fazendo o design de nossa API usando o template ..............................................451
    Descendo para a próxima camada: o que a view passa para o template ................452
    Próximo “requisito” da camada de views: novas listas devem registrar o proprietário 454
    Ponto de decisão: devemos prosseguir para a próxima camada com um teste em falha?.455
    Descendo para a camada de modelo ........................................................................455
    Último passo: passando dados pela API .name do template .................................458

    Capítulo 23 ¦ Isolamento de testes e “Ouvindo os seus testes”................................................461
    Voltando ao nosso ponto de decisão: a camada de views depende de um código não
    escrito para modelos ..........................................................................................461
    Primeira tentativa de usar mocks para isolamento ....................................................463
    Usando side_effects de mocks para verificar a sequência de eventos.....................464
    Ouça os seus testes: testes feios sinalizam a necessidade de refatorar ........................466
    Reescrevendo nossos testes para a view de modo totalmente isolado.........................467
    Mantenha a antiga suíte de testes integrados presente, como verificação de sanidade .467
    Uma nova suíte de testes com total isolamento....................................................468
    Pensando em termos de colaboradores................................................................468
    Descendo para a camada de formulários.................................................................. 474
    Continue ouvindo os seus testes: removendo o código de ORM de nossa aplicação.475
    Finalmente descendo para a camada de modelos......................................................479
    De volta às views................................................................................................482
    A hora da verdade (e os riscos da simulação)............................................................483
    Pensando nas interações entre as camadas como sendo “contratos” ..........................485
    Identificando contratos implícitos.......................................................................486
    Corrigindo o que deixamos passar......................................................................487
    Mais um teste .........................................................................................................489
    Organizando o código: o que deve ser mantido em nossa suíte de testes integrados...490
    Removendo código redundante da camada de formulários ..................................490
    Removendo a antiga implementação da view.......................................................491
    Removendo código redundante da camada de formulários ..................................493
    Conclusões: quando escrever testes isolados versus testes integrados........................494
    Deixe que a complexidade seja o seu guia ...........................................................495
    Você deve ter ambos? .........................................................................................495
    Em frente!..........................................................................................................496

    Capítulo 24 ¦ Integração Contínua (CI)....................................................................................498
    Instalando o Jenkins ...............................................................................................498
    Configurando o Jenkins..........................................................................................500
    Desbloqueio inicial ............................................................................................500
    Plugins sugeridos, por enquanto .........................................................................501
    Configurando o usuário administrador...............................................................501
    Adicionando plugins..........................................................................................502
    Informando ao Jenkins o local para encontrar o Python 3 e o Xvfb......................502
    Concluindo com HTTPS....................................................................................503
    Configurando o nosso projeto .................................................................................504
    Primeira construção! ...............................................................................................505
    Configurando um display virtual para que FTs possam executar em modo headless .507
    Capturando imagens de tela ....................................................................................510
    Na dúvida, tente aumentar o timeout!......................................................................513
    Executando nossos testes de JavaScript com QUnit no Jenkins com o PhantomJS ..... 514
    Instalando o node .............................................................................................. 514
    Acrescentando os passos de construção no Jenkins.............................................516
    Outras tarefas que um servidor de CI pode fazer......................................................518

    Capítulo 25 ¦ Aspecto social, padrão Page e exercício para o leitor..........................................520
    Um FT com vários usuários, e a função addCleanup ................................................520
    Padrão Page ............................................................................................................522
    Estendendo o FT para um segundo usuário, e a página “My Lists” ...........................525
    Um exercício para o leitor........................................................................................527

    Capítulo 26 ¦ Testes rápidos, testes lentos e Lava Quente........................................................530
    Tese: testes de unidade são super-rápidos e bons, além de tudo.................................532
    Testes mais rápidos significam desenvolvimento mais rápido...............................532
    O sagrado estado de fluxo ..................................................................................532
    Testes lentos não são executados com tanta frequência, o que resulta em código ruim533
    Não há problemas agora, mas os testes integrados se tornam mais lentos com o passar
    do tempo.................................................................................................533
    Não sou eu quem está falando............................................................................533
    E os testes de unidade levam a um bom design....................................................534
    Os problemas com os testes de unidade “puros”.......................................................534
    Testes isolados podem ser mais difíceis de ler e de escrever..................................534
    Testes isolados não testam automaticamente a integração....................................534
    Testes de unidade raramente capturam bugs inesperados ....................................534
    Testes com simulação podem se tornar extremamente vinculados à implementação 535
    Entretanto todos os problemas podem ser superados...........................................535
    Síntese: afinal de contas, o que queremos de nossos testes?.......................................536
    Aplicação correta ...............................................................................................536
    Código limpo, possível de manter.......................................................................536
    Fluxo de trabalho produtivo ...............................................................................536
    Avalie seus testes em relação aos benefícios que você quer que eles proporcionem 537
    Soluções arquitetônicas...........................................................................................537
    Portas e adaptadores/arquitetura hexagonal/limpa ..............................................538
    Functional Core, Imperative Shell.......................................................................539
    Conclusão...............................................................................................................540
    Leituras complementares....................................................................................540

    Epílogo ¦ Obedeça ao Testing Goat! .......................................................................................542
    Testar é difícil .........................................................................................................542
    Mantenha suas construções no CI com sinal verde..............................................543
    Tenha orgulho de seus testes, assim como você tem de seu código.......................543
    Lembre-se de dar gorjetas para o pessoal do bar.......................................................543
    Não seja um desconhecido! .....................................................................................543

    Apêndice A ¦ PythonAnywhere..............................................................................................544
    Apêndice B ¦ Views baseadas em classe do Django .................................................................549
    Apêndice C ¦ Provisionamento com o Ansible.........................................................................562
    Apêndice D ¦ Testando migrações de banco de dados .............................................................567
    Apêndice E ¦ Desenvolvimento orientado a comportamento (BDD) ......................................... 574
    Apêndice F ¦ Construindo uma API REST: JSON, Ajax e simulação com JavaScript...................... 591
    Apêndice G ¦ Django-Rest-Framework................................................................................... 615
    Apêndice H ¦ Folha de cola....................................................................................................629
    Apêndice I ¦ O que fazer em seguida......................................................................................634
    Apêndice J ¦ Código-fonte dos exemplos................................................................................639

    Bibliografia...........................................................................................................................642

    Informações Técnicas

    Nº de páginas:648
    Origem:Internacional
    Editora:Editora Novatec
    Idioma:Português
    Edição:1ª Edição
    Ano:2017
    ISBN:9788575226421
    Encadernação:Brochura
    Autor:Harry J.W. Percival
  • Informações

Avaliação técnica sobre o livro

Olá! Seja Bem Vindo (a)!

Eu sou o Moderninho , o Mascote da Ciência Moderna Online!
Além de bonito, o novo site tem Minhas Dicas :) #ficaadica

A 1ª Dica é -> Deixe aqui seu contato para receber nossas
NOVIDADES, PROMOÇÕES E CUPONS DE DESCONTOS ;)

Navegue SEM Moderação!