Retour au cours

tester son code avec rspec

Objectifs

  • Comprendre pourquoi les tests automatisés sont essentiels.
  • Découvrir RSpec, le framework de test de référence en Ruby.
  • Écrire un test unitaire simple en utilisant la syntaxe describe, context, et it.
  • Utiliser des “matchers” de base comme eq pour vérifier les résultats.

Pourquoi tester son code ?

Écrire des tests automatisés est une pratique fondamentale du développement logiciel moderne. Les tests permettent de :

  1. Garantir la correction : S’assurer que votre code fait bien ce que vous attendez de lui.
  2. Prévenir les régressions : S’assurer que les nouveaux changements ne cassent pas des fonctionnalités qui marchaient avant.
  3. Faciliter la refactorisation : Vous pouvez modifier et améliorer votre code en toute confiance, car la suite de tests vous alertera si vous cassez quelque chose.
  4. Servir de documentation : Les tests décrivent précisément comment votre code est censé se comporter.

RSpec : Tester en langage quasi naturel

RSpec est un framework de test qui s’inscrit dans la mouvance du BDD (Behavior-Driven Development). Il fournit un langage (DSL - Domain Specific Language) qui permet d’écrire des tests qui se lisent presque comme des phrases en anglais, en se concentrant sur le comportement attendu de votre code.

Structure d’un fichier de test RSpec

Par convention, les fichiers de test se terminent par _spec.rb et se placent dans un dossier spec/.

# spec/calculatrice_spec.rb

require_relative '../lib/calculatrice' # On charge le code à tester

# 'describe' ouvre un bloc de tests pour une classe ou une méthode
describe Calculatrice do
  # 'context' permet de regrouper des tests dans une situation donnée
  context "pour l'addition" do
    
    # 'it' décrit un comportement spécifique que l'on veut tester
    it "doit retourner 4 pour l'addition de 2 et 2" do
      # 1. Préparation (Setup)
      calc = Calculatrice.new
      
      # 2. Exécution (Exercise)
      resultat = calc.additionner(2, 2)
      
      # 3. Vérification (Verify) - C'est l'assertion
      # On s'attend (expect) à ce que le résultat soit égal (eq) à 4.
      expect(resultat).to eq(4)
    end

    it "doit gérer les nombres négatifs" do
      calc = Calculatrice.new
      resultat = calc.additionner(-5, 3)
      expect(resultat).to eq(-2)
    end
  end
end

L’assertion : expect(...).to

C’est le cœur du test. On vérifie une attente avec expect et un “matcher”.

  • expect(valeur).to eq(attendue) : Vérifie l’égalité de valeur.
  • expect(valeur).to be_truthy / be_falsey : Vérifie la “truthiness”.
  • expect(valeur).to be_nil : Vérifie que la valeur est nil.
  • expect(tableau).to include(element) : Vérifie qu’un tableau contient un élément.
  • expect { ... }.to raise_error(TypeError) : Vérifie qu’un bloc de code lève bien une exception.

Mettre en place RSpec

  1. Ajouter RSpec au Gemfile :

    # Gemfile
group :test do
  gem 'rspec'
end

  2. Installer : bundle install

  3. Initialiser RSpec (une seule fois) : bundle exec rspec --init Cette commande crée le dossier spec/ et un fichier spec_helper.rb.

  4. Écrire les tests dans des fichiers _spec.rb dans le dossier spec/.

  5. Lancer les tests : bundle exec rspec

Bonnes pratiques

  • Un test, une seule attente. Idéalement, un bloc it ne devrait contenir qu’une seule instruction expect.
  • Structure Arrange-Act-Assert (ou Given-When-Then) :
    1. Arrange : Préparez vos objets et vos données.
    2. Act : Exécutez la méthode que vous testez.
    3. Assert : Vérifiez le résultat avec expect.
  • Le nom de votre test (it "...") doit décrire un comportement. Il doit compléter la phrase “La classe/méthode … devrait …”.

Exercices

  1. Mise en place :

    • Créez un nouveau projet avec un Gemfile.
    • Ajoutez-y rspec et lancez bundle install, puis bundle exec rspec --init.

  2. Créer une classe simple :

    • Créez un dossier lib/ et à l’intérieur, un fichier salutations.rb.
    • Dans ce fichier, créez une classe Salutations avec une méthode message qui retourne “Bonjour tout le monde !”.

  3. Écrire le test :

    • Dans spec/, créez un fichier salutations_spec.rb.
    • Écrivez un test qui :
      1. Charge le fichier salutations.rb.
      2. Décrit la classe Salutations.
      3. Dans un bloc it, crée une instance de la classe, appelle la méthode message, et vérifie que le résultat est bien égal à “Bonjour tout le monde !”.
    • Lancez bundle exec rspec et observez le test passer au vert.

  4. Faire échouer le test :

    • Modifiez le test pour qu’il s’attende à une chaîne différente.
    • Relancez rspec et observez le message d’erreur détaillé que RSpec vous fournit.

Sujets abordés