Scala för backendutveckling och funktionell programmering · Lektion

Mockning och fixtures

Testförberedelser.

Lektion 4 av 413 steg

Mockning och fixtures är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Testförberedelser och efterarbete

Många tester behöver gemensamma test-fixtures: data eller resurser som förbereds före ett test och städas bort efteråt. ScalaTest erbjuder flera sätt att hantera detta utan att duplicera förberedelsekod.

En enkel fixture: bara en metod

Den enklaste fixturen är en hjälpmetod som bygger upp ett nytt tillstånd. Varje test anropar den, vilket garanterar isolering.

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

Blanda in BeforeAndAfter för att köra kod före och efter varje test med before { }- och after { }-block.

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 kostsamma resurser som delas av alla tester i en svit, till exempel en databasanslutning eller en inbäddad server, använder ni BeforeAndAfterAll med beforeAll och 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)
  }
}

Mönstret med utlånad fixture

Utlåningsmönstret skickar en nybyggd resurs till testkroppen och garanterar städning i ett finally-block, även om testet misslyckas.

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

Varför använda mockar?

En mock är en ersättning för ett verkligt beroende, till exempel en databas eller en HTTP-klient, så att ett enhetstest förblir snabbt och deterministiskt. Ni styr vad mocken returnerar och verifierar hur den anropades.

Lägga till Mockito

ScalaTest integreras med Mockito via scalatestplus. Lägg till beroendet och blanda in MockitoSugar.

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

Stubbning av en metod

Skapa en mock och programmera dess beteende med when(...).thenReturn(...). Testet kör sedan kod som är beroende av den.

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

Verifiera interaktioner

Utöver returvärden kan ni verifiera att en metod anropades det förväntade antalet gånger med 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")
  }
}

Mockar kontra stubbar kontra fakes

Terminologi:

  • Stub: returnerar förutbestämda svar.
  • Mock: gör det dessutom möjligt att verifiera interaktioner.
  • Fake: en lättviktig fungerande implementation, till exempel ett minnesbaserat repository.

Föredra fakes eller verkliga objekt när det är enkelt; använd mockar endast för verkliga externa beroenden.

Hålla tester isolerade

Fixtures och mockar har ett gemensamt mål: varje test ska köras i ett känt och oberoende tillstånd. Återställ delat muterbart tillstånd före varje test och undvik att dela muterbara fixtures mellan tester för att förhindra instabila, ordningsberoende fel.

Snabb kontroll

Testa era kunskaper om fixtures och mockning.

Sammanfattning

Ni har lärt er om fixtures och mockning:

  • Fixtures: hjälpmetoder, BeforeAndAfter, BeforeAndAfterAll och utlåningsmönstret.
  • Mockar via MockitoSugar: stubbning med when().thenReturn(), kontroll av anrop med verify.
  • Föredra fakes i enkla fall; använd mockar för externa beroenden.
  • Håll varje test isolerat och oberoende av körordningen.
Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
39
Lektioner
143

Vanliga frågor

Är lektionen ”Mockning och fixtures” gratis?

Ja – hela texten till ”Mockning och fixtures” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Mockning och fixtures”?

Testförberedelser. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Mockning och fixtures”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. ScalaTest-stilar
  2. Matchers
  3. Egenskapsbaserad testning
  4. Mockning och fixtures
← Tillbaka till Scala för backendutveckling och funktionell programmering