Ruby Academy · Aula

Testes e versionamento

Qualidade e semver.

Aula 3 de 413 etapas

Testes e versionamento é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Por que testar uma gema?

Como uma gema é usada por muitos projetos, um erro afeta todos eles. Testes automatizados permitem alterar o código com confiança e comprovar que a gema continua funcionando.

Os testes documentam o comportamento esperado.
Eles detectam regressões antes do lançamento.
Usuários experientes exigem testes antes de adotar uma gema.

Escolhendo uma estrutura

As duas opções mais populares são Minitest (vem com o Ruby e é leve) e RSpec (tem uma DSL completa e é muito comum). Qualquer uma serve; escolha uma e adicione-a como dependência de desenvolvimento no arquivo de especificação da gema.

Um exemplo com Minitest

Os testes do Minitest são classes simples com métodos de asserção. Veja aqui um exemplo independente que executa a lógica da sua gema e verifica o resultado.

require "minitest/autorun"

def greet(name)
  "Hi, " + name
end

class GreetTest < Minitest::Test
  def test_greet
    assert_equal "Hi, Sam", greet("Sam")
  end
end

Asserções comuns

Asserções úteis do Minitest:

assert_equal expected, actual
assert obj e refute obj
assert_nil value
assert_raises(Error) { ... }

Cada teste deve verificar um comportamento claro.

require "minitest/autorun"

class MathTest < Minitest::Test
  def test_addition
    assert_equal 4, 2 + 2
  end

  def test_truth
    refute_nil 5
  end
end

Executando e automatizando testes

Geralmente, você adiciona uma tarefa do Rake para que rake test execute todo o conjunto de testes. A integração contínua então executa a mesma tarefa a cada envio, em várias versões do Ruby, para detectar problemas antecipadamente.

O que é versionamento semântico?

O Versionamento Semântico (semver) atribui significado a um número de versão MAJOR.MINOR.PATCH:

MAJOR: alterações incompatíveis na API.
MINOR: novos recursos compatíveis com versões anteriores.
PATCH: correções de erros compatíveis com versões anteriores.

Os usuários dependem disso para atualizar com segurança.

Lendo uma versão

Dada a versão 2.4.1: a parte principal é 2, a secundária é 4 e a de correção é 1. Dividir a cadeia de caracteres mostra essas partes.

version = "2.4.1"
major, minor, patch = version.split(".")
puts "Major: " + major
puts "Minor: " + minor
puts "Patch: " + patch

Quando incrementar cada parte

Regras de decisão:

Corrigiu um erro sem alterar a API? Incremente a parte de correção.
Adicionou um recurso e o código antigo continua funcionando? Incremente a parte secundária e redefina a parte de correção para 0.
Removeu ou alterou um comportamento existente? Incremente a parte principal e redefina as partes secundária e de correção para 0.

def bump_minor(version)
  major, minor, _patch = version.split(".").map(&:to_i)
  major.to_s + "." + (minor + 1).to_s + ".0"
end

puts bump_minor("1.3.5")

Restrições de versão

Os usuários fixam a versão da sua gema com operadores no Gemfile:

'~> 1.4' permite versões a partir de 1.4, até antes de 2.0 (restrição pessimista).
'>= 1.4' permite qualquer versão mais recente.
'= 1.4.2' fixa uma versão exata.

O operador pessimista ~> é o mais comum, pois equilibra atualizações e segurança.

Mantenha um registro de alterações

Mantenha um CHANGELOG.md que liste o que mudou em cada versão. Ele informa aos usuários o que há de novo, o que deixou de funcionar e como fazer a migração. Associe cada incremento de versão a uma entrada no registro de alterações.

Versões de pré-lançamento

Versões como 2.0.0.beta1 indicam versões de teste instáveis. Os usuários precisam optar explicitamente por instalá-las, para que você possa disponibilizar versões iniciais para testes sem afetar as instalações normais.

version = "2.0.0.beta1"
puts "Pre-release? " + version.include?("beta").to_s

Verificação rápida

Teste sua compreensão sobre versionamento.

Responda na aula interativa

Recapitulação: testes e versionamento

Você aprendeu a manter uma gema confiável:

Escreva testes com Minitest ou RSpec; automatize-os com Rake e integração contínua.
Siga o semver: MAJOR.MINOR.PATCH.
Incremente a parte correta para correções, recursos ou alterações incompatíveis.
Use restrições ~> e mantenha um registro de alterações.

Em seguida, vamos publicar a gema no RubyGems.

Grátis para começar

Aprenda Ruby com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 29
Aulas: 109

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Testes e versionamento” é grátis?

Sim — o texto completo de “Testes e versionamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Testes e versionamento”?

Qualidade e semver. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Testes e versionamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy