Scala for Backend Engineering & Functional Programming · Leçon

Simulations et appareils de test

Configuration des tests

Simulations et appareils de test est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 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 Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Préparation et nettoyage des tests

De nombreux tests nécessitent des dispositifs de test partagés : des données ou des ressources préparées avant un test, puis nettoyées après. ScalaTest propose plusieurs façons de les gérer sans dupliquer le code de préparation.

Dispositif simple : une méthode

Le dispositif le plus simple est une méthode auxiliaire qui construit un état vierge. Chaque test l’appelle, ce qui garantit l’isolation.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

class StackSpec extends AnyFlatSpec with Matchers {
  def emptyStack(): scala.collection.mutable.Stack[Int] =
    scala.collection.mutable.Stack.empty[Int]

  "a stack" should "start empty" in {
    emptyStack().size shouldBe 0
  }
}

BeforeAndAfter

Ajoutez BeforeAndAfter pour exécuter du code avant et après chaque test à l’aide des blocs before { } et after { }.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatest.BeforeAndAfter

class DbSpec extends AnyFlatSpec with Matchers with BeforeAndAfter {
  var counter = 0
  before { counter = 10 }
  after  { counter = 0 }

  "counter" should "be initialized" in {
    counter shouldBe 10
  }
}

BeforeAndAfterAll

Pour les ressources coûteuses partagées par tous les tests d’une suite (une connexion à une base de données ou un serveur intégré), utilisez BeforeAndAfterAll avec beforeAll et afterAll.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.BeforeAndAfterAll

class ServerSpec extends AnyFlatSpec with BeforeAndAfterAll {
  override def beforeAll(): Unit = println("start server")
  override def afterAll(): Unit  = println("stop server")

  "server" should "respond" in {
    assert(true)
  }
}

Schéma du prêt de ressource

Le schéma du prêt de ressource transmet une ressource fraîchement créée au corps du test et garantit son nettoyage dans un bloc finally, même si le test échoue.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

class FileSpec extends AnyFlatSpec with Matchers {
  def withBuffer(test: StringBuilder => Any): Unit = {
    val buf = new StringBuilder("init")
    try test(buf)
    finally buf.clear()
  }

  "a buffer" should "start with init" in withBuffer { buf =>
    buf.toString shouldBe "init"
  }
}

Pourquoi utiliser la simulation ?

Un simulacre remplace une dépendance réelle (une base de données ou un client HTTP) afin qu’un test unitaire reste rapide et déterministe. Vous contrôlez ce que le simulacre renvoie et vérifiez comment il a été appelé.

Ajouter Mockito

ScalaTest s’intègre à Mockito via scalatestplus. Ajoutez la dépendance et mélangez MockitoSugar.

libraryDependencies += "org.scalatestplus" %% "mockito-5-10" % "3.2.18.0" % Test

Simuler une méthode

Créez un simulacre et définissez son comportement avec when(...).thenReturn(...). Le test exécute ensuite le code qui en dépend.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatestplus.mockito.MockitoSugar
import org.mockito.Mockito.when

trait Repo { def find(id: Int): String }

class RepoSpec extends AnyFlatSpec with Matchers with MockitoSugar {
  "a repo" should "return stubbed value" in {
    val repo = mock[Repo]
    when(repo.find(1)).thenReturn("Alice")
    repo.find(1) shouldBe "Alice"
  }
}

Vérifier les interactions

Au-delà des valeurs renvoyées, vous pouvez vérifier qu’une méthode a été appelée le nombre de fois attendu avec verify.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatestplus.mockito.MockitoSugar
import org.mockito.Mockito.{verify, times}

trait Logger { def log(msg: String): Unit }

class LogSpec extends AnyFlatSpec with MockitoSugar {
  "a service" should "log once" in {
    val logger = mock[Logger]
    logger.log("hi")
    verify(logger, times(1)).log("hi")
  }
}

Simulacres, bouchons et doublures

Terminologie :

Bouchon : renvoie des réponses prédéfinies.
Simulacre : permet également de vérifier les interactions.
Doublure : implémentation fonctionnelle légère (par exemple, un dépôt en mémoire).

Privilégiez les doublures ou les objets réels lorsque c’est simple ; utilisez un simulacre uniquement pour les véritables dépendances externes.

Garder les tests isolés

Les dispositifs de test et les simulacres poursuivent un seul objectif : chaque test s’exécute dans un état connu et indépendant. Réinitialisez l’état mutable partagé avant chaque test et évitez de partager des dispositifs de test mutables entre les tests afin de prévenir les échecs instables et dépendants de l’ordre d’exécution.

Vérification rapide

Vérifiez vos connaissances sur les dispositifs de test et la simulation.

Récapitulatif

Vous avez découvert les dispositifs de test et la simulation :

Dispositifs de test : méthodes auxiliaires, BeforeAndAfter, BeforeAndAfterAll et schéma du prêt de ressource.
Simulacres (via MockitoSugar) : utilisez un bouchon avec when().thenReturn() et vérifiez les appels avec verify.
Privilégiez les doublures dans les cas simples ; simulez les dépendances externes.
Gardez chaque test isolé et indépendant de l’ordre d’exécution.

Questions Fréquemment Posées

La leçon « Simulations et appareils de test » est-elle gratuite ?

Oui — le texte complet de « Simulations et appareils de test » 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 Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Simulations et appareils de test » ?

Configuration des tests Tu pratiques Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming 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 4 sur 4.

Combien de temps prend la leçon « Simulations et appareils de test » ?

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 Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming 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 à Scala for Backend Engineering & Functional Programming