Testing
Akka Streams introduces a different testing challenge from regular actors. Streams are lazy, composable, and backpressure-aware — properties that make them powerful but also make naive testing approaches fail. The akka-stream-testkit module provides the right primitives for verifying stream behavior without races or flakiness. Setup Add the testkit
Scala
Akka TestKit provides specialised tools for testing actor-based systems: TestProbe intercepts messages, expectMsg asserts on received messages with configurable timeouts, and TestFSMRef exposes FSM internals for white-box testing. This post covers every layer from simple unit tests to complex multi-actor scenarios. Testing actors is fundamentally different from
Scala
ZIO Test is the native testing framework for ZIO applications. It integrates deeply with ZIO's effect system, giving you precise control over concurrency, timing, and resource management in tests. Unlike JUnit or ScalaTest, ZIO Test treats tests as effects — first-class ZIO values that compose, retry, and parallelize
Scala
Apache Pekko is the community-maintained fork of Akka (post-BSL license change). Its testing API mirrors Akka's closely, with the same ActorTestKit, BehaviorTestKit, and TestProbe tools — making migration from Akka to Pekko straightforward. This guide focuses on Pekko Typed actor testing patterns. Setup // build.sbt libraryDependencies ++= Seq(
Scala
http4s is a purely functional HTTP library for Scala built on cats-effect. Its route handlers are values — HttpRoutes[F] is just a function from Request[F] to OptionT[F, Response[F]]. This makes testing routes trivial: construct a request, run it through the routes, inspect the response — all without
Scala
Testing cats-effect applications requires a test framework that understands IO. Running IO in tests naively—calling .unsafeRunSync()—works but loses meaningful error messages, leaks resources, and breaks in concurrent scenarios. munit-cats-effect provides native IO support for MUnit, making tests composable and resource-safe. This guide covers munit-
Scala
Akka actors are concurrent by nature — they communicate asynchronously through message passing, which makes traditional unit testing approaches fail. akka-testkit provides TestKit and TestProbe to write deterministic tests for actor behavior: message routing, state transitions, supervision strategies, and timing. This guide covers the classic Akka (untyped) testkit and Akka
Testing
Apache Spark applications are notoriously hard to test. The framework was designed for distributed execution at scale, but your tests need to run fast and locally. The good news: Spark runs in local mode, and with the right setup, you can have a test suite that gives real confidence without
Testing
Specs2 takes a different philosophy from ScalaTest: rather than providing multiple testing styles, it treats tests as specifications — executable documents that describe how software should behave. If you want tests that read like documentation and double as acceptance criteria, Specs2 is worth considering. Installation libraryDependencies ++= Seq( "org.specs2"
Testing
Property-based testing doesn't replace example-based tests — it answers a different question. Where unit tests ask "does this specific input produce this output?", property-based tests ask "does this property hold for ALL inputs of this shape?" ScalaCheck, the original property-based testing
Testing
ScalaTest is the most widely used testing framework in the Scala ecosystem. It supports multiple testing styles, integrates with popular mocking libraries, and works with both Scala and Java code. Whether you prefer unit tests that look like specs or simple function-based tests, ScalaTest has a style that fits.
Testing
sbt is Scala's primary build tool, and understanding its test system is essential for managing a well-organized test suite. From running specific tests to configuring parallel execution and separating unit from integration tests, sbt's test configuration has more depth than most developers use. Basic Test