Add cats-effect support for FunSuite and FunFixtures

build.sbt

@@ -206,6 +206,23 @@ lazy val plugin = project
     )
   )
 
+lazy val munitCatsEffect = crossProject(JSPlatform, JVMPlatform)
+  .in(file("munit-cats-effect"))
+  .dependsOn(munit)
+  .settings(
+    moduleName := "munit-cats-effect",
+    sharedSettings,
+    libraryDependencies += ("org.typelevel" %%% "cats-effect" % "2.1.3")
+      .withDottyCompat(scalaVersion.value)
+  )
+  .jvmSettings(
+    sharedJVMSettings,
+    skip in publish := customScalaJSVersion.isDefined
+  )
+  .jsSettings(sharedJSSettings)
+lazy val munitCatsEffectJVM = munitCatsEffect.jvm
+lazy val munitCatsEffectJS = munitCatsEffect.js
+
 lazy val munitScalacheck = crossProject(JSPlatform, JVMPlatform, NativePlatform)
   .in(file("munit-scalacheck"))
   .dependsOn(munit)
@@ -229,33 +246,43 @@ lazy val munitScalacheckJVM = munitScalacheck.jvm
 lazy val munitScalacheckJS = munitScalacheck.js
 lazy val munitScalacheckNative = munitScalacheck.native
 
-lazy val tests = crossProject(JSPlatform, JVMPlatform, NativePlatform)
-  .dependsOn(munit, munitScalacheck)
+lazy val testsSettings = List(
+  buildInfoPackage := "munit",
+  buildInfoKeys := Seq[BuildInfoKey](
+    "sourceDirectory" ->
+      baseDirectory.in(ThisBuild).value / "tests" / "shared" / "src" / "main",
+    scalaVersion
+  ),
+  skip in publish := true
+)
+lazy val tests = crossProject(JSPlatform, JVMPlatform)
+  .dependsOn(munit, munitCatsEffect, munitScalacheck)
   .enablePlugins(BuildInfoPlugin)
   .settings(
     sharedSettings,
-    buildInfoPackage := "munit",
-    buildInfoKeys := Seq[BuildInfoKey](
-      "sourceDirectory" ->
-        baseDirectory.in(ThisBuild).value / "tests" / "shared" / "src" / "main",
-      scalaVersion
-    ),
-    skip in publish := true
+    testsSettings
   )
-  .nativeConfigure(sharedNativeConfigure)
-  .nativeSettings(sharedNativeSettings)
   .jsSettings(sharedJSSettings)
   .jvmSettings(
     sharedJVMSettings,
     fork := true
   )
+lazy val testsN = crossProject(NativePlatform)
+  .dependsOn(munit, munitScalacheck)
+  .enablePlugins(BuildInfoPlugin)
+  .settings(
+    sharedSettings,
+    testsSettings
+  )
+  .nativeConfigure(sharedNativeConfigure)
+  .nativeSettings(sharedNativeSettings)
 lazy val testsJVM = tests.jvm
 lazy val testsJS = tests.js
-lazy val testsNative = tests.native
+lazy val testsNative = testsN.native
 
 lazy val docs = project
   .in(file("munit-docs"))
-  .dependsOn(munitJVM, munitScalacheckJVM)
+  .dependsOn(munitJVM, munitCatsEffectJVM, munitScalacheckJVM)
   .enablePlugins(MdocPlugin, MUnitReportPlugin, DocusaurusPlugin)
   .settings(
     sharedSettings,

munit-cats-effect/shared/src/main/scala/munit/CatsEffectFunFixtures.scala

@@ -0,0 +1,55 @@
+package munit
+
+import cats.effect.{IO, Resource}
+import cats.syntax.flatMap._
+
+import scala.concurrent.Promise
+
+trait CatsEffectFunFixtures extends FunFixtures { self: CatsEffectSuite =>
+
+  object CatsEffectFixture {
+
+    def fromResource[T](
+        resource: Resource[IO, T]
+    ): FunFixture[T] = fromResource(
+      resource,
+      (_, _) => IO.pure(()),
+      _ => IO.pure(())
+    )
+
+    def fromResource[T](
+        resource: Resource[IO, T],
+        setup: (TestOptions, T) => IO[Unit],
+        teardown: T => IO[Unit]
+    ): FunFixture[T] = {
+      val promise = Promise[IO[Unit]]()
+
+      FunFixture.async(
+        setup = { testOptions =>
+          implicit val ec = munitExecutionContext
+
+          val resourceEffect = resource.allocated
+          val setupEffect =
+            resourceEffect
+              .map {
+                case (t, release) =>
+                  promise.success(release)
+                  t
+              }
+              .flatTap(t => setup(testOptions, t))
+
+          setupEffect.unsafeToFuture()
+        },
+        teardown = { argument: T =>
+          implicit val cs = munitContextShift
+
+          teardown(argument)
+            .flatMap(_ => IO.fromFuture(IO(promise.future)).flatten)
+            .unsafeToFuture()
+        }
+      )
+    }
+
+  }
+
+}

munit-cats-effect/shared/src/main/scala/munit/CatsEffectSuite.scala

@@ -0,0 +1,19 @@
+package munit
+
+import cats.effect.{ContextShift, IO, Timer}
+
+abstract class CatsEffectSuite extends FunSuite {
+
+  def munitContextShift: ContextShift[IO] =
+    IO.contextShift(munitExecutionContext)
+
+  def munitTimer: Timer[IO] =
+    IO.timer(munitExecutionContext)
+
+  override def munitValueTransforms: List[ValueTransform] =
+    super.munitValueTransforms ++ List(munitIOTransform)
+
+  final def munitIOTransform: ValueTransform =
+    new ValueTransform("IO", { case e: IO[_] => e.unsafeToFuture() })
+
+}

tests/jvm/src/test/scala/munit/IOFixtureSuite.scala

@@ -0,0 +1,61 @@
+package munit
+
+import cats.effect.{IO, Resource}
+
+import scala.concurrent.{Future, Promise}
+
+class IOFixtureSuite extends CatsEffectSuite with CatsEffectFunFixtures {
+  val latch: Promise[Unit] = Promise[Unit]
+  var completedFromTest: Option[Boolean] = None
+  var completedFromTeardown: Option[Boolean] = None
+
+  var completedFromResourceAcquire: Option[Boolean] = None
+  var completedFromResourceRelease: Option[Boolean] = None
+
+  val latchOnTeardown: FunFixture[String] =
+    CatsEffectFixture.fromResource[String](
+      resource = Resource.make[IO, String](
+        IO {
+          completedFromResourceAcquire = Some(true)
+          "test"
+        }
+      )(_ =>
+        IO {
+          completedFromResourceRelease = Some(true)
+        }
+      ),
+      setup = { (_: TestOptions, _: String) =>
+        IO {
+          completedFromResourceAcquire = Some(false)
+        }
+      },
+      teardown = { _: String =>
+        IO {
+          completedFromResourceRelease = Some(false)
+          completedFromTeardown = Some(latch.trySuccess(()));
+        }
+      }
+    )
+
+  override def afterAll(): Unit = {
+    // resource was created before setup
+    assertEquals(completedFromResourceAcquire, Some(false))
+    // resource was released after teardown
+    assertEquals(completedFromResourceRelease, Some(true))
+    // promise was completed first by the test
+    assertEquals(completedFromTest, Some(true))
+    // and then there was a completion attempt by the teardown
+    assertEquals(completedFromTeardown, Some(false))
+  }
+
+  latchOnTeardown.test("teardown runs only after test completes") { _ =>
+    import scala.concurrent.ExecutionContext.Implicits.global
+    Future {
+      // Simulate some work here, which increases the certainty that this test
+      // will fail by design and not by lucky scheduling if the happens-before
+      // relationship between the test and teardown is removed.
+      Thread.sleep(50)
+      completedFromTest = Some(latch.trySuccess(()))
+    }
+  }
+}

tests/jvm/src/test/scala/munit/IOSuite.scala

@@ -0,0 +1,41 @@
+package munit
+
+import cats.effect.IO
+
+import scala.concurrent.duration._
+
+class IOSuite extends CatsEffectSuite {
+
+  test("nested fail".fail) {
+    IO {
+      IO.sleep(2.millis)(munitTimer)
+        .flatMap { _ =>
+          IO {
+            IO.sleep(2.millis)(munitTimer)
+              .flatMap { _ =>
+                IO {
+                  IO.sleep(2.millis)(munitTimer)
+                    .map(_ => assertEquals(false, true))
+                }
+              }
+          }
+        }
+    }
+  }
+  test("nested success") {
+    IO {
+      IO.sleep(2.millis)(munitTimer)
+        .flatMap { _ =>
+          IO {
+            IO.sleep(2.millis)(munitTimer)
+              .flatMap { _ =>
+                IO {
+                  IO.sleep(2.millis)(munitTimer)
+                    .map(_ => assertEquals(true, true))
+                }
+              }
+          }
+        }
+    }
+  }
+}