Scala for Backend Engineering & Functional Programming · Lektion

Mocking und Fixtures

Testeinrichtung

Lektion 4 von 413 Schritte

Mocking und Fixtures ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Test-Setup und -Teardown

Viele Tests benötigen gemeinsame Fixtures: Daten oder Ressourcen, die vor einem Test vorbereitet und danach bereinigt werden. ScalaTest bietet mehrere Möglichkeiten, dies ohne duplizierten Setup-Code zu verwalten.

Einfache Fixture: nur eine Methode

Die einfachste Fixture ist eine Hilfsmethode, die einen frischen Zustand erstellt. Jeder Test ruft sie auf, wodurch die Isolation sichergestellt wird.

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

Binden Sie BeforeAndAfter ein, um mit den Blöcken before { } und after { } vor und nach jedem Test Code auszuführen.

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

Für aufwendige Ressourcen, die von allen Tests einer Suite gemeinsam genutzt werden (etwa eine Datenbankverbindung oder ein eingebetteter Server), verwenden Sie BeforeAndAfterAll mit beforeAll und 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)
  }
}

Loan-Fixture-Muster

Das Loan Pattern übergibt dem Testkörper eine frisch erstellte Ressource und garantiert die Bereinigung in einem finally-Block, selbst wenn der Test fehlschlägt.

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"
  }
}

Warum Mocking?

Ein Mock ist ein Ersatz für eine echte Abhängigkeit (etwa eine Datenbank oder ein HTTP-Client), damit ein Unit-Test schnell und deterministisch bleibt. Sie steuern, was der Mock zurückgibt, und prüfen, wie er aufgerufen wurde.

Mockito hinzufügen

ScalaTest lässt sich über scalatestplus in Mockito integrieren. Fügen Sie die Abhängigkeit hinzu und binden Sie MockitoSugar ein.

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

Eine Methode stubben

Erstellen Sie einen Mock und legen Sie sein Verhalten mit when(...).thenReturn(...) fest. Der Test führt anschließend Code aus, der von diesem Mock abhängt.

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"
  }
}

Interaktionen überprüfen

Neben Rückgabewerten können Sie mit verify überprüfen, ob eine Methode erwartungsgemäß oft aufgerufen wurde.

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")
  }
}

Mocks vs. Stubs vs. Fakes

Begriffe:

Stub: Gibt vorgefertigte Antworten zurück.
Mock: Ermöglicht zusätzlich die Überprüfung von Interaktionen.
Fake: Eine leichtgewichtige, funktionierende Implementierung (z. B. ein In-Memory-Repository).

Bevorzugen Sie einfache Fakes oder echte Objekte; verwenden Sie Mocks nur für tatsächlich externe Abhängigkeiten.

Tests isoliert halten

Fixtures und Mocks verfolgen ein Ziel: Jeder Test soll in einem bekannten, unabhängigen Zustand ausgeführt werden. Setzen Sie gemeinsam genutzten veränderlichen Zustand vor jedem Test zurück und vermeiden Sie gemeinsam genutzte veränderliche Fixtures, um instabile, von der Reihenfolge abhängige Fehler zu verhindern.

Kurzer Test

Testen Sie Ihr Wissen über Fixtures und Mocking.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben Fixtures und Mocking gelernt:

Fixtures: Hilfsmethoden, BeforeAndAfter, BeforeAndAfterAll und das Loan Pattern.
Mocks (über MockitoSugar): mit when().thenReturn() stubben, Aufrufe mit verify prüfen.
Bevorzugen Sie in einfachen Fällen Fakes; verwenden Sie Mocks für externe Abhängigkeiten.
Halten Sie jeden Test isoliert und unabhängig von der Reihenfolge.

Kostenlos starten

Lerne Scala mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 143

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Mocking und Fixtures“ kostenlos?

Ja — der vollständige Text von „Mocking und Fixtures“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Mocking und Fixtures“?

Testeinrichtung Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Mocking und Fixtures“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming