MUnit Documentation

Starting with MUnit v0.5.0, the library provides true cross-platform support for asynchronous tests. In previous versions (v0.4.x), async tests on platforms like JavaScript could incorrectly pass even if they returned a failing Future. In v0.5.0 and later, MUnit correctly tracks and waits for the completion of Futures, ensuring that failing futures trigger test failures as expected.

test("should fail after 100 milliseconds") {
  val p = Promise[Unit]()
  setTimeout(100) {
    p.failure(new RuntimeException("boom"))
  }
  p.future
}

MUnit is implemented as a JUnit runner. This means any tool that supports JUnit can run MUnit test suites without custom configuration. Supported integrations include:

• IntelliJ IDEA: Automatically detects and runs MUnit suites.
• Build Tools: Gradle and Pants can run MUnit tests via their existing JUnit integrations.

To migrate from ScalaTest's property-based testing to MUnit:

1. From ScalaCheck style (Checkers trait): Replace FunSuite with ScalaCheckSuite, replace test with property, and replace check with forAll.
2. From ScalaTest style (GeneratorDrivenPropertyChecks): Replace FunSuite with ScalaCheckSuite, replace test with property, and convert ScalaTest matchers to MUnit assertions (e.g., should be becomes assertEquals).

import munit.ScalaCheckSuite
import org.scalacheck.Prop._

class IntegerSuite extends ScalaCheckSuite {

  property("addition and multiplication are commutative") {
    forAll { (n1: Int, n2: Int) =>
      assertEquals(n1 + n2, n2 + n1)
      assertEquals(n1 * n2, n2 * n1)
    }
  }

}

If you have existing properties defined using the ScalaCheck Properties class, you can port them to MUnit by creating a PropertiesAdapter trait that iterates through the properties and registers them using MUnit's property method.

import org.scalacheck.Properties
import munit.ScalaCheckSuite
import org.scalacheck.Prop._

trait PropertiesAdapter {
  self: ScalaCheckSuite =>
  def include(ps: Properties): Unit =
    for ((name, prop) <- ps.properties) property(name)(prop)
}

object LegacyIntProps extends Properties("Int") {
  property("commutative") = forAll((x: Int, y: Int) => x + y == y + x)
  property("identity") = forAll((x: Int) => x + 0 == x)
}

class IntSuite extends ScalaCheckSuite with PropertiesAdapter {

  include(LegacyIntProps)

  property("addition is associative") = forAll { (x: Int, y: Int, z: Int) =>
    x + y + z == x + (y + z)
  }

}

Comprehensive documentation for MUnit, including guides and API references, is available on the official website.

https://scalameta.org/munit/

You can control the amount of test output printed using the --log=LEVEL flag. This allows you to filter output from just errors to highly detailed trace information. This setting is independent of your logger configuration (e.g., --logger=sbt).

Available levels:

• --log=error: Prints failing tests only.
• --log=warn: Prints failing tests and non-successful tests (like ignored or skipped tests).
• --log=info (default): Prints failing tests, suite-finished events, and entire-run started/finished events.
• --log=debug: Prints everything in info plus suite-started and test-succeeded events.
• --log=trace: Prints everything in debug plus test-started events (equivalent to --verbose).

$ sbt
> myproject/testOnly -- --log=warn

To use MUnit, add the dependency to your build.sbt and register the MUnit test framework.

After setup, you can write tests by extending munit.FunSuite and using the test method with assertions like assert.

Supported Scala versions and platforms:

• Scala 2.11.x, 2.12.x, 2.13.x: JVM, Scala.js (0.6.x, 1.x)
• Scala 0.21.x (Dotty): JVM
• Scala 2.11.x: Native (0.4.x)

// build.sbt
libraryDependencies += "org.scalameta" %% "munit" % "0.4.3"
testFrameworks += new TestFramework("munit.Framework")

// src/test/scala/com/MySuite.scala
class MySuite extends munit.FunSuite {
  test("hello") {
    assert(41 == 42)
  }
}