Mockning och fixtures
Testförberedelser.
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" % TestStubbning 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,BeforeAndAfterAlloch utlåningsmönstret. - Mockar via MockitoSugar: stubbning med
when().thenReturn(), kontroll av anrop medverify. - Föredra fakes i enkla fall; använd mockar för externa beroenden.
- Håll varje test isolerat och oberoende av körordningen.
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
- ScalaTest-stilar
- Matchers
- Egenskapsbaserad testning
- Mockning och fixtures