Buscar
Minha Conta

Atendimento(21) 2262-3111 / (21) 2262-3111

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á.

VITRINE Os TOP de vendas !!

+-

Quem viu este produto , comprou

Quem viu este produto , também se interessou

  • 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

Não encontrou seu produto? Deixe aqui sua Sugestão para novos produtos!

Enviar sugestão

Políticas

Informações

Atendimento

(21) 2262-3111

(21) 2262-3111

Pague com

Visa, mastercard, Diners, Boleto, American Express , VisaElectron, Discover , Elo , Maestro

Segurança e certificados

© 2015 Livraria Ciência Moderna Ltda - Avenida Rio Branco 156 – subsolo 126 – Centro – RJ – Cep:20040-003 | Cnpj :33.412.271/0001-03 | Inscrição Estadual: 85.853.198 *Os preços e condições de pagamento podem ser exclusivos para compras via internet , o que quer dizer que podem variar das lojas físicas. Vendas Sujeitas á analise e confirmação de dados.
VTEXOriginal Media

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!