Ruby Academy · Leçon

Tests et gestion des versions

Qualité et semver

Tests et gestion des versions est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Pourquoi tester une gemme ?

Comme une gemme est utilisée par de nombreux projets, un bogue touche tout le monde. Les tests automatisés vous permettent de modifier le code en toute confiance et de vérifier que la gemme fonctionne toujours.

Les tests documentent le comportement attendu.
Ils détectent les régressions avant la publication.
Les utilisateurs exigeants les demandent avant d’adopter une gemme.

Choisir un cadre de test

Les deux choix populaires sont Minitest (fourni avec Ruby et léger) et RSpec (DSL riche et très répandu). Les deux conviennent ; choisissez-en un et ajoutez-le comme dépendance de développement dans le fichier de spécification de gemme.

Exemple avec Minitest

Les tests Minitest sont de simples classes dotées de méthodes d’assertion. Voici un exemple autonome qui exécute la logique de votre gemme et vérifie le résultat.

require "minitest/autorun"

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

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

Assertions courantes

Assertions Minitest utiles :

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

Chaque test doit vérifier un comportement clairement défini.

require "minitest/autorun"

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

  def test_truth
    refute_nil 5
  end
end

Exécuter et automatiser les tests

Vous ajoutez généralement une tâche Rake afin que rake test exécute toute la suite. L’intégration continue exécute ensuite la même tâche à chaque envoi, avec plusieurs versions de Ruby, afin de détecter rapidement les problèmes.

Qu’est-ce que le versionnage sémantique ?

Le versionnage sémantique (semver) donne un sens au numéro de version MAJOR.MINOR.PATCH :

MAJOR : modifications incompatibles de l’interface.
MINOR : nouvelles fonctionnalités compatibles avec les versions précédentes.
PATCH : corrections de bogues compatibles avec les versions précédentes.

Les utilisateurs s’y fient pour effectuer leurs mises à niveau en toute sécurité.

Lire une version

Pour 2.4.1 : la version majeure est 2, la version mineure est 4 et le correctif est 1. Découper la chaîne permet d’en voir les différentes parties.

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

Quand incrémenter chaque partie

Règles de décision :

Vous avez corrigé un bogue sans modifier l’interface ? Incrémentez le correctif.
Vous avez ajouté une fonctionnalité et l’ancien code fonctionne toujours ? Incrémentez la version mineure et réinitialisez le correctif à 0.
Vous avez supprimé ou modifié un comportement existant ? Incrémentez la version majeure et réinitialisez la version mineure et le correctif à 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")

Contraintes de version

Les utilisateurs indiquent la version de votre gemme avec des opérateurs dans leur Gemfile :

'~> 1.4' autorise les versions 1.4 jusqu’à, mais sans l’inclure, la version 2.0 (contrainte pessimiste).
'>= 1.4' autorise toute version ultérieure.
'= 1.4.2' verrouille une version exacte.

La contrainte pessimiste ~> est la plus courante : elle équilibre mises à jour et sécurité.

Tenir un journal des modifications

Tenez à jour un CHANGELOG.md qui répertorie les changements de chaque version. Il indique aux utilisateurs les nouveautés, les éléments cassés et la manière d’effectuer la migration. Associez chaque changement de version à une entrée dans le journal des modifications.

Versions de prépublication

Des versions comme 2.0.0.beta1 signalent des aperçus instables. Les utilisateurs doivent choisir explicitement de les installer ; vous pouvez donc publier des versions préliminaires à des fins de test sans affecter les installations normales.

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

Vérification rapide

Vérifiez votre compréhension du versionnage.

Récapitulatif : tests et versionnage

Vous avez appris à maintenir la fiabilité d’une gemme :

Écrivez des tests avec Minitest ou RSpec ; automatisez-les avec Rake et l’intégration continue.
Suivez le versionnage sémantique : MAJOR.MINOR.PATCH.
Incrémentez la partie appropriée pour les corrections, les fonctionnalités ou les modifications incompatibles.
Utilisez les contraintes ~> et tenez un journal des modifications.

Vous allez maintenant publier la gemme sur RubyGems.

Questions Fréquemment Posées

La leçon « Tests et gestion des versions » est-elle gratuite ?

Oui — le texte complet de « Tests et gestion des versions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tests et gestion des versions » ?

Qualité et semver Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Tests et gestion des versions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy