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

RSpec Crie especificações executáveis em Ruby

Mauro George
Capa

RSpec

Agradecimentos

Muito obrigado à minha Mãe e ao meu Pai, Maria Nilza e José Mauro, por me apoiarem em tudo e estarem sempre ao meu lado.

Como o livro não poderia existir sem o Ruby, obrigado ao Matz e ao Ruby Core team por criar uma linguagem orientada a objetos tão divertida e expressiva. E ao David Heinemeier Hansson e todo o Rails team por criar um framework web que torna o nosso trabalho muito mais divertido. E a todos os criadores, mantenedores e contribuidores das ferramentas que veremos aqui como WebMock, VCR e factory_girl.

Obrigado a todos da Casa do Código por acreditarem no projeto e ajudarem a torná-lo realidade. Especialmente ao Adriano e à Vivian, por terem que lidar diretamente com o meu excelente conhecimento de português.

Obrigado à HE:labs por tudo o que tenho aprendido e produzido. Obrigado ao Rafael Lima e ao Sylvestre Mergulhão, donos da HE:labs, por apoiarem o meu projeto do livro e torná-lo uma parceria com a HE:labs.

Obrigado ao Cayo Medeiros(Yogodoshi), por sempre me dar excelentes dicas em qualquer novo projeto que inicio ou iniciamos juntos.

Obrigado à Jéssica, minha namorada e futura esposa. =) Por me aturar há mais de 6 anos e sempre estar ao meu lado me apoiando nas minhas decisões e fazendo a minha vida muito mais feliz!

Sobre o Autor

Mauro George atualmente é desenvolvedor de software na HE:labs, onde trabalha com Ruby e Agile no seu dia a dia. Com mais de seis anos de experiência com desenvolvimento web, tem contribuído em diversos projetos open source, incluindo o shoulda-matchers, já tendo feito uma pequena contribuição no Rails. É palestrante e apaixonado por vídeo game desde sempre, também e sócio do Estou Jogando.

A HE:labs

A HE:labs faz produtos web fantásticos desde a ideia ao lançamento. Isso inclui aplicativos, e-commerce, sistemas corporativos, aplicativos em cloud e qualquer tipo de software para internet. Utilizando de Design Thinking, Lean Startup e Desenvolvimento Ágil para transformar a sua ideia em um produto real. Possui uma equipe multidisciplinar composta por programadores, analistas, designers e hackers. Para conhecer um pouco mais, acesse: http://helabs.com.br.

Introdução

Seja bem-vindo! O Ruby tem um excelente ambiente de testes com ferramentas como MiniTest, RSpec e Cucumber. Mas o que podemos melhorar no nosso TDD do dia a dia? Qual o próximo passo? Além de padrões e convenções bem definidas que podemos seguir, temos diversas ferramentas que ajudam enquanto escrevemos nossos testes. Trabalhando em diversos times e em projetos open source, pude notar que certos testes eram escritos de forma complicada, sem padrões, apenas happy paths eram testados, projetos com baixa cobertura de testes, falta de conhecimento de bibliotecas que ajudariam no processo de teste etc.

E destes e outros problemas surgiu a ideia do livro: mostrar técnicas e ferramentas que tendem a melhorar o nosso processo de escrever testes.

Sendo assim o objetivo do livro é que você saia daqui:

  • escrevendo melhor os seus testes, seguindo convenções e boas práticas que serão abordadas;
  • esteja equipado com uma coleção de ferramentas e técnicas para quando enfrentar problemas durante o processo de TDD.

 

Eu vou aprender a escrever testes em Ruby?

 

O livro não é uma introdução ao RSpec ou TDD. Assume-se que o leitor tenha conhecimento do RSpec ou qualquer outra biblioteca de testes em Ruby e que esteja habituado ao processo de TDD.

 

Utilizo o Minitest/Test::Unit, este livro serve para mim?

 

Sim. Utilizamos o RSpec nos exemplos, mas muitas das técnicas e ferramentas podem ser utilizadas independente da ferramenta de testes. Lembrando que também passamos por características exclusivas do RSpec.

 

Sobre a abordagem

 

Utilizamos na maior parte do tempo TDD enquanto estamos escrevendo os exemplos, começando pelo teste e seguindo para a implementação.

Propositalmente, utilizamos um domínio da aplicação simples, dado que o nosso foco aqui é na parte dos testes.

Utilizamos uma aplicação em Ruby on Rails, dado que a maioria dos iniciantes começa pelo Rails para só depois aprender Ruby. Sendo assim, os mais experientes não terão dificuldade de acompanhar os exemplos mesmo que nunca tenham trabalhado com Rails, bem como os iniciantes que estão acostumados apenas com o ambiente do Rails.

Os exemplos de código podem ser encontrados em https://github.com/maurogeorge/rspecbf-exemplos.

Todo o código é escrito em português, devido ao fato de o livro ser em português. No entanto, recomendo que se você não escreve o seu código em inglês procure fazê-lo no próximo projeto, afinal os projetos open source possuem seu código e documentação escritos originalmente em inglês. Além do mais, é bem provável que você venha a trabalhar com alguém de outro país e que esta pessoa tenha uma grande chance de não falar o nosso português.

Sumário

  • 1 - O bom e velho RSpec
    • 1.1 - Bah, mas por que testar?
    • 1.2 - Meu primeiro teste, agora com RSpec
    • 1.3 - O tal do RSpec
    • 1.4 - A sintaxe de expectativa
    • 1.5 - Descrevendo bem o seu teste
    • 1.6 - Não teste apenas o ::happy path::
    • 1.7 - Definindo o sujeito
    • 1.8 - No dia a dia não se esqueça de ...
    • 1.9 - Conclusão
  • 2 - Testes que acessam rede... WTF!?!
    • 2.1 - Introdução
    • 2.2 - Consumindo uma API
    • 2.3 - WebMock ao resgate
    • 2.4 - Utilizando o cURL
    • 2.5 - Mas eu quero automatizar isso...
    • 2.6 - VCR??? É o videocassete de que meu pai fala?
    • 2.7 - Utilizando o VCR
    • 2.8 - Dados sensíveis no VCR
    • 2.9 - URIs não determinísticas
    • 2.10 - Conclusão
  • 3 - Fixtures são tão chatas! Conheça a factory_girl
    • 3.1 - Introdução
    • 3.2 - Instalação
    • 3.3 - Criando nossa primeira factory
    • 3.4 - Utilizando a factory
    • 3.5 - Factories nos testes
    • 3.6 - Sendo DRY
    • 3.7 - Atributos dinâmicos nas factories
    • 3.8 - Associações
    • 3.9 - Bah, mas só funciona com Active Record?
    • 3.10 - Conhecendo as estratégias
    • 3.11 - E quando as factories não são mais válidas?
    • 3.12 - Conclusão
  • 4 - Precisamos ir... de volta para o futuro
    • 4.1 - Introdução
    • 4.2 - Congelando o tempo com timecop
    • 4.3 - Removendo repetição
    • 4.4 - Rails 4.1 e o ActiveSupport<::Testing<:timehelpers li="">
    • 4.5 - Conclusão
  • 5 - Será que testei tudo?
    • 5.1 - Introdução
    • 5.2 - O falso 100%
    • 5.3 - Meu objetivo é ter 100% de cobertura de testes?
    • 5.4 - Mas e você senhor autor, quanto faz de cobertura de testes?
    • 5.5 - Conclusão
  • 6 - Copiar e colar não é uma opção!
    • 6.1 - Introdução
    • 6.2 - O shared example
    • 6.3 - Criando um Matcher
    • 6.4 - O shoulda-matchers
    • 6.5 - Matchers de terceiros
    • 6.6 - Conclusão
  • 7 - O tal dos mocks e stubs
    • 7.1 - Conhecendo o stub
    • 7.2 - Os dublês
    • 7.3 - Expectativas em mensagens
    • 7.4 - Matchers de argumentos
    • 7.5 - Um pouco mais sobre stubs, dublês e message expectations
    • 7.6 - Mockar ou não mockar?
    • 7.7 - Conclusão
  • 8 - Não debugamos com puts, certo?
    • 8.1 - Por um melhor console
    • 8.2 - Conhecendo o Pry
    • 8.3 - Conclusão
  • 9 - Conclusão
    Capítulo1

    O bom e velho RSpec

    1.1 - Bah, mas por que testar?

    Se você ainda não sabe quais as vantagens de ter testes automatizados no seu sistema, vamos a uma historinha.

    Mauro e Rodrigo trabalham em um projeto que possui um cadastro de produto que é feito em três passos. Hoje, o cadastro de produto funciona muito bem, no entanto é preciso adicionar um novo passo entre o segundo e o terceiro. Mauro e Rodrigo começam a criar este novo passo, mas o processo é bastante repetitivo e passivo a erro, dado que depois que o usuário atinge um passo não pode voltar. Sendo assim, a cada linha alterada e a cada tentativa de implementar algo, eles devem passar por todo o processo para só depois conseguir testar. Além do feedback lento, a cada vez que alteram um passo recebem um erro inesperado na tela devido à falta de parâmetro de um método ou um objeto que não foi instanciado e gera NoMethodError: undefined method `metodo' for nil:NilClass para todo o lado.

    Se nossos heróis continuarem assim, não obterão sucesso nesta jornada. É uma história bem comum de um time de pessoas que não utiliza testes unitários. Vamos ver como estes testes podem nos ajudar:

    • Feedback constante: a cada vez que rodamos nossos testes, sabemos se uma funcionalidade está funcionando ou não em segundos.
    • Fácil manutenção: caso algo esteja errado, o teste quebrará, sendo assim o desenvolvedor tem total confiança de alterar algo.
    • Reduz bugs: como testamos cada um dos nossos métodos unitariamente, temos casos de pontas garantindo que cada uma das partes do software se comporte como devido.
    • Melhor design: assim como temos confiança de adicionar coisa nova, também temos total confiança de refatorar o que já foi feito.
    • Documentação: cada teste é uma especificação de como um método ou uma parte do sistema funciona, ficando disponível e atualizado para todos do time.
    • Divertido: além de todas as vantagens, escrever testes é sempre divertido.

    A comunidade Ruby é muito focada em testes, projetos open source como o rails, devise, cancan etc., que possuem seus testes automatizados. Na realidade a exceção são projetos que não possuem testes.

    Então, sem desculpas: vamos escrever nosso primeiro teste.

     

    Meu primeiro teste

     

    O Ruby já possui na sua biblioteca padrão seu framework de testes chamado de Test::Unit, no entanto, a partir do Ruby 2.1.0 é recomendado o uso do MiniTest para quando estamos criando um projeto novo. O Minitest também já faz parte da biblioteca padrão do Ruby.

    Em aplicações rails temos definido o ActiveSupport::TestCase, que é a classe de testes que devemos herdar para definirmos nossos testes.

    Dados do produto

    Número de páginas:
    155
    ISBN:
    978-85-66250-52-7
    Data publicação:
    07/2014

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter