Use o código e tenha 10% de desconto!

Cucumber e RSpec Construa aplicações Ruby com testes e especificações

Hugo Baraúna
Capa

Cucumber e RSpec

Dedicatória

Dedico este livro a duas pessoas: minha mãe e minha noiva.

Sem o trabalho árduo e constante suporte da minha mãe, eu não estaria aqui hoje, escrevendo um livro. Ela é minha heroína e a pessoa mais batalhadora que já conheci. Obrigado Lilian Pessoa por me dar as oportunidades que tive na vida.

Escrever um livro é uma empreitada bem mais trabalhosa que eu pensei. Centenas de horas de trabalho. Essas horas não foram um investimento apenas meu, foi também da minha noiva. Vários meses sem ter um final de semana tranquilo para passar ao lado dela. Obrigado Ana Raquel por segurar essa barra e por me apoiar até a última palavra deste livro.

Agradecimentos

Primeiro eu gostaria de agradecer ao Adriano Almeida, da Casa do Código, pelo convite para escrever este livro. Sem esse primeiro empurrão é muito improvável que esse livro existiria. Escrevê-lo foi não só um excelente desafio mas também uma grande oportunidade de aprendizado.

Gostaria de agradecer também à Plataformatec e a todo mundo que trabalha comigo lá. São os melhores profissionais com quem eu já trabalhei e me inspiram todo dia a ser um profissional melhor.

Não posso deixar também de agradecer a minha família e amigos como um todo. Ao fazer este livro, tive que abdicar de passar inúmeras horas com eles, decisão que não foi fácil de tomar e muito menos de manter.

Por fim, gostaria de agradecer às pessoas que investiram seu tempo revisando as primeiras versões deste livro. Eles não tinham nenhuma obrigação de fazê-lo, fizeram pela boa vontade, amizade, por serem colaborativos e pela vontade de aprender algo novo. São eles: Bernardo Chaves, Erich Kist, Danilo Inacio e Anna Cruz.

Sobre o autor

Hugo Baraúna é cofundador e sócio da Plataformatec, empresa de consultoria em desenvolvimento de software especializada em Ruby e Rails.

A Plataformatec é referência nacional e internacional no mundo Ruby, devido principalmente a seus projetos open source e sua colaboração com a comunidade. Ele atua tanto na direção da empresa quanto como desenvolvedor, tendo participado de projetos de consultoria, coaching e desenvolvimento para startups e empresas da Fortune 1000.

Hugo se formou em Engenharia de Computação pela Politécnica da USP. Durante a faculdade, passou pelo laboratório USP-Microsoft e por empresas como Procwork e IBM.

Para ele, só é possível fazer produtos e serviços de qualidade quando se ama o que faz.

Apresentação

Abordagem do livro

Este livro não é um manual do Cucumber e de RSpec. Já existem diversos lugares listando as funcionalidades, classes e métodos do Cucumber e RSpec. Portanto, o objetivo não é repetir o que já existe pronto em vários outros lugares.

A abordagem deste livro é apresentar como usar essas ferramentas, em vez de mostrar todos os detalhes de cada uma delas. Saber o que as ferramentas oferecem é diferente de saber como usá-las. Além da mostra do uso básico, várias boas práticas não documentadas previamente também são apresentadas, utilizando exemplos ao longo do livro inteiro.

 

Estrutura do livro

Este livro está estruturado em quatro partes:

  1. A primeira consiste em uma introdução ao conceito e histórico do TDD e BDD, assim como um primeiro contato com o RSpec e com o Cucumber. Ela é formada pelos capítulos * e *;
  2. A segunda é uma apresentação geral do RSpec. Passando pela estrutura básica de um teste de unidade feito com ele, pela organização de testes e pelo uso de test doubles como mocks e stubs. Ela é formada pelos capítulos * a *;
  3. A terceira parte consiste em uma apresentação do Cucumber e de como usá-lo para escrever especificações executáveis. Ela é formada pelos capítulos * a *;
  4. Por fim, na quarta e última parte, nós construiremos uma aplicação do zero seguindo o conceito de outside-in development do BDD, utilizando RSpec e Cucumber. Ela é formada pelos capítulos * a *.

 

Para quem é este livro?

 

Estou aprendendo ou já sei programar em Ruby mas nunca fiz TDD

Se você se enquadra no caso acima, este livro é perfeito para você. Você irá aprender como fazer testes automatizados e seguir o fluxo de TDD e BDD para fazer um código mais fácil de ser mantido e com mais qualidade.

Aprender uma habilidade nova não é simples, mas pode ser mais eficiente com a ajuda de uma apresentação estruturada e de um caminho definido. Este livro mostra passo a passo como usar o RSpec e o Cucumber para construir uma aplicação inteira seguindo o fluxo de TDD/BDD.

Já faço testes automatizados mas não sei se estou fazendo do jeito certo

Existem diversos fatores que influenciam o desenvolvimento de bons testes. O que testar? Como testar? Em qual camada testar? Por onde começo?

Fazer testes do jeito certo não é apenas ter cobertura de testes em 100%. Por exemplo, a maioria das pessoas não sabem que em um teste a clareza é muito mais importante do que o DRY (don't repeat yourself). A maioria das pessoas não sabem a diferença entre mocks e stubs e quando usar um ao invés do outro.

Este livro responde todas as dúvidas acima e mais várias outras, que o ajudarão a estruturar seu conhecimento em testes automatizados e a escrever testes de qualidade.

Já fiz testes de unidade, mas não conheço Cucumber, nem o conceito de especificação executável

Testes de unidade são uma parte muito importante na prática de TDD, mas existem outras camadas de teste, tal como a camada de testes de aceitação. Este livro mostra o que são testes de aceitação e como fazê-los utilizando Cucumber.

Na explicação do uso de Cucumber, este livro vai além dos testes de aceitação. O Cucumber é, na verdade, uma ferramenta de documentação, que une especificação e testes automatizados, formando o que conhecemos por "especificação executável".

Este livro mostra como usar o Cucumber do modo certo, quando vale a pena usá-lo e como usá-lo em conjunto com o RSpec para fechar o ciclo de outside-in development.

 

O que preciso ter instalado?

 

Ao longo do livro veremos vários exemplos de código, e na última parte construiremos um projeto de 0 a 100. Para ir desenvolvendo o código junto com o livro, você precisará de algumas coisas instaladas.

Você precisará ter instalado o Ruby 1.9 ou 2.0. Qualquer uma das duas versões deve funcionar, mas dê preferência para a 2.0.

Além do Ruby, será necessário instalar o Bundler, RSpec e Cucumber. A versão do Bundler utilizada é a 1.3.5. A versão do Cucumber é a 1.3.10. As versões do RSpec e de seus componentes usadas são:

  • rspec: 2.14.1
  • rspec-core: 2.14.7
  • rspec-expectations: 2.14.4
  • rspec-mocks: 2.14.4

Sobre o sistema operacional, você pode usar o Mac OS X, o Linux ou Windows. Dito isso, historicamente o Ruby funciona melhor no Linux e no Mac OS X do que no Windows. Portanto, se você for usuário de Windows e quiser programar em Ruby, uma boa opção é usar uma máquina virtual rodando Linux.

Um último detalhe sobre o sistema operacional, ao longo do livro alguns comandos de shell Unix-like são usados, tal como o mkdir para criar diretório, o cd para entrar em um diretório e o touch para criar um arquivo. Apesar de serem usados comandos de um shell Unix-like, a intenção de cada comando será explicada ao longo do livro, de modo que você possa saber o que deve ser feito, caso não esteja usando um shell Unix-like, como no Windows.

 

Você tem dúvidas ou achou algum erro no livro?

 

Este livro possui um grupo de discussão de email com o seguinte endereço: casadocodigo-tdd-ruby@googlegroups.com.

Se você tiver dúvidas sobre o conteúdo do livro ou algo relacionado, você pode enviar um e-mail para o endereço acima.

Caso você ache algum possível erro no livro, por favor o envie nessa lista de discussão.

Por fim, se você tiver alguma dúvida sobre o código desenvolvido na quarta parte deste livro, a parte do projeto, você pode verificar um repositório no Github com o código final como referência: https://github.com/hugobarauna/forca.

Sumário

  • 1 - Visão geral sobre TDD
    • 1.1 - TDD e sua história
    • 1.2 - E por qual motivo eu deveria usar TDD?
  • 2 - Primeiros passos com RSpec e Cucumber
    • 2.1 - Olá RSpec
    • 2.2 - Olá Cucumber
    • 2.3 - O que é BDD?
  • 3 - Introdução ao básico do RSpec
    • 3.1 - Aprendendo a estrutura básica de um teste com RSpec
    • 3.2 - Por que existem tantos matchers no RSpec
    • 3.3 - Conhecendo os RSpec built-in matchers
    • 3.4 - Custom matchers
    • 3.5 - Entendendo o protocolo interno de matcher do RSpec
    • 3.6 - Pontos-chave deste capítulo
  • 4 - Organização, refatoração e reuso de testes com o RSpec
    • 4.1 - Reduzindo duplicação com hooks do RSpec
    • 4.2 - DRY versus clareza nos testes
    • 4.3 - After hook
    • 4.4 - Around hook
    • 4.5 - Organizando seus testes
    • 4.6 - Reuso de testes
    • 4.7 - Pontos-chave deste capítulo
  • 5 - Mocks e stubs
    • 5.1 - Por que preciso de mocks?
    • 5.2 - Conhecendo o conceito de test doubles
    • 5.3 - Usando stubs com RSpec
    • 5.4 - Escrevendo mock expectations com RSpec
    • 5.5 - Quando usar mock e quando usar stub
    • 5.6 - Usando o método double para fazer testes isolados
    • 5.7 - Pontos-chave deste capítulo
  • 6 - Conhecendo o Cucumber
    • 6.1 - Por que usar cucumber?
    • 6.2 - Cucumber como estímulo de conversa sobre os requisitos
    • 6.3 - Cucumber: especificação e testes juntos!
    • 6.4 - Cucumber para construir uma documentação viva
    • 6.5 - Visão geral de cucumber
    • 6.6 - Pontos-chave deste capítulo
  • 7 - Especificando funcionalidades com Cucumber
    • 7.1 - Instalando e fazendo setup do Cucumber
    • 7.2 - Estrutura de uma feature com cucumber
    • 7.3 - Escrevendo um cenário
    • 7.4 - Escrevendo cenários expressivos com Cucumber
    • 7.5 - Pontos-chave deste capítulo
  • 8 - Automatizando especificações com cucumber
    • 8.1 - Escrevendo os primeiros step definitions
    • 8.2 - Escrevendo step definitions para cenários expressivos
    • 8.3 - Support code
    • 8.4 - Cucumber World
    • 8.5 - Usando Cucumber hooks
    • 8.6 - Pontos-chave deste capítulo
  • 9 - Boas práticas no uso de Cucumber
    • 9.1 - Use e abuse das descrições da funcionalidade e dos cenários
    • 9.2 - Evite detalhes desnecessários
    • 9.3 - Cenários imperativos VS cenários declarativos
    • 9.4 - Organizando os arquivos da minha especificação executável
    • 9.5 - Pontos-chave deste capítulo
  • 10 - BDD na prática, começando um projeto com BDD
    • 10.1 - Definindo o escopo da nossa aplicação: Jogo da Forca
    • 10.2 - Especificando uma funcionalidade com Cucumber
    • 10.3 - Usando RSpec no nosso primeiro teste
    • 10.4 - Usando Aruba para testar uma aplicação CLI
    • 10.5 - Reutilizando step definitions de um modo melhor
    • 10.6 - Pontos-chave deste capítulo
  • 11 - Começando o segundo cenário
    • 11.1 - Definindo o segundo cenário
    • 11.2 - Reduza duplicação através de support code
    • 11.3 - Implementando o fluxo do jogo no binário
    • 11.4 - Modificando nosso cenário para receber o feedback correto
    • 11.5 - Usando subject e let do RSpec para evitar duplicação nos testes
    • 11.6 - Refatorando o código para poder implementar o segundo cenário
    • 11.7 - Extraindo uma classe através de refatoração
    • 11.8 - Possibilitando ao jogador terminar o jogo no meio
    • 11.9 - Pontos-chave deste capítulo
  • 12 - Finalizando a primeira funcionalidade
    • 12.1 - Deixando o segundo cenário no verde
    • 12.2 - Finalizando a primeira funcionalidade
    • 12.3 - Pontos-chave deste capítulo
  • 13 - Refatorando nosso código
    • 13.1 - Identificado os pontos a serem refatorados
    • 13.2 - Extraindo uma classe de um método privado
    • 13.3 - Distribuindo responsabilidades para outras classes
    • 13.4 - Pontos-chave deste capítulo
  • 14 - Especificando a segunda funcionalidade
    • 14.1 - Documentando especificação e critério de aceite com Cucumber
    • 14.2 - Definindo o teste de aceitação do primeiro cenário
    • 14.3 - Melhore a testabilidade do seu software
    • 14.4 - Pontos-chave deste capítulo
  • 15 - Finalizando a segunda funcionalidade
    • 15.1 - Refatorando nosso jogo para ter uma máquina de estados
    • 15.2 - Refatorando o fluxo do jogo para usar a máquina de estados
    • 15.3 - Organizando seus testes otimizando para leitura
    • 15.4 - Interface discovery utilizando test doubles
    • 15.5 - Finalizando a funcionalidade Adivinhar letra
    • 15.6 - Pontos-chave deste capítulo
  • 16 - Finalizando nosso jogo
    • 16.1 - Especificando o fim do jogo
    • 16.2 - Jogador vence o jogo
    • 16.3 - Jogador perde o jogo
    • 16.4 - Próximos passos

Dados do produto

Número de páginas:
412
ISBN:
978-85-66250-34-3
Data publicação:
05/2013

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter