Ruby Academy · Lezione

Test e versionamento

Qualità e semver

Test e versionamento è una lezione Ruby Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Perché testare un gem?

Poiché un gem viene utilizzato da molti progetti, un bug si ripercuote su tutti. I test automatizzati consentono di modificare il codice con sicurezza e dimostrano che il gem continua a funzionare.

I test documentano il comportamento previsto.
Individuano le regressioni prima del rilascio.
Gli utenti più esigenti li richiedono prima di adottare un gem.

Scegliere un framework

Le due opzioni più diffuse sono Minitest (incluso in Ruby e leggero) e RSpec (DSL ricco e molto diffuso). Entrambe vanno bene: ne scelga una e la aggiunga come dipendenza di sviluppo nel gemspec.

Un esempio con Minitest

I test Minitest sono semplici classi con metodi di asserzione. Ecco un esempio autonomo che esegue la logica del gem e ne verifica il risultato.

require "minitest/autorun"

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

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

Asserzioni comuni

Asserzioni Minitest utili:

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

Ogni test dovrebbe verificare un comportamento chiaro.

require "minitest/autorun"

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

  def test_truth
    refute_nil 5
  end
end

Eseguire e automatizzare i test

Di solito si aggiunge un'attività Rake affinché rake test esegua l'intera suite. L'integrazione continua esegue quindi la stessa attività a ogni push, su diverse versioni di Ruby, per individuare tempestivamente i problemi.

Che cos'è il versionamento semantico?

Il Versionamento semantico (semver) attribuisce un significato al numero di versione MAJOR.MINOR.PATCH:

MAJOR: modifiche incompatibili all'API.
MINOR: nuove funzionalità compatibili con le versioni precedenti.
PATCH: correzioni di bug compatibili con le versioni precedenti.

Gli utenti si affidano a questo sistema per aggiornare in sicurezza.

Leggere una versione

Data 2.4.1: major è 2, minor è 4 e patch è 1. Scomponendo la stringa se ne visualizzano le parti.

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

Quando incrementare ciascuna parte

Regole decisionali:

Ha corretto un bug senza modificare l'API? Incrementi patch.
Ha aggiunto una funzionalità e il vecchio codice continua a funzionare? Incrementi minor e reimposti patch su 0.
Ha rimosso o modificato un comportamento esistente? Incrementi major e reimposti minor e patch su 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")

Vincoli di versione

Gli utenti vincolano il suo gem con operatori nel proprio Gemfile:

'~> 1.4' consente versioni dalla 1.4 fino a prima della 2.0 (vincolo pessimistico).
'>= 1.4' consente qualsiasi versione successiva.
'= 1.4.2' blocca una versione esatta.

L'operatore pessimistico ~> è il più comune, perché bilancia aggiornamenti e sicurezza.

Mantenere un changelog

Mantenga un CHANGELOG.md che elenchi le modifiche apportate in ogni versione. Indica agli utenti cosa c'è di nuovo, cosa ha smesso di funzionare e come effettuare la migrazione. Abbini ogni incremento di versione a una voce nel changelog.

Versioni preliminari

Versioni come 2.0.0.beta1 indicano anteprime instabili. Gli utenti devono scegliere esplicitamente di installarle, così può distribuire versioni iniziali per i test senza influire sulle installazioni normali.

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

Verifica rapida

Verifichi la comprensione del versionamento.

Riepilogo: test e versionamento

Ha appreso come mantenere affidabile un gem:

Scriva test con Minitest o RSpec e li automatizzi con Rake e CI.
Segua semver: MAJOR.MINOR.PATCH.
Incrementi la parte corretta per correzioni, funzionalità o modifiche incompatibili.
Utilizzi vincoli ~> e mantenga un changelog.

Ora pubblicherà il gem su RubyGems.

Domande Frequenti

La lezione «Test e versionamento» è gratuita?

Sì — il testo completo di «Test e versionamento» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Test e versionamento»?

Qualità e semver Eserciti Ruby Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Test e versionamento»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Ruby Academy?

Sì. Ogni lezione Ruby Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Ruby Academy