Add doobie-munit package to integrate Doobie with the shiny new MUnit

build.sbt

@@ -16,6 +16,7 @@ lazy val postgresVersion      = "42.2.12"
 lazy val refinedVersion       = "0.9.13"
 lazy val scalaCheckVersion    = "1.14.2"
 lazy val scalatestVersion     = "3.1.1"
+lazy val munitVersion         = "0.7.9"
 lazy val shapelessVersion     = "2.3.3"
 lazy val silencerVersion      = "1.6.0"
 lazy val sourcecodeVersion    = "0.2.1"
@@ -114,6 +115,7 @@ lazy val doobie = project.in(file("."))
     quill,
     refined,
     scalatest,
+    munit,
     specs2,
   )
 
@@ -339,6 +341,22 @@ lazy val scalatest = project
     )
   )
 
+lazy val munit = project
+  .in(file("modules/munit"))
+  .enablePlugins(AutomateHeaderPlugin)
+  .dependsOn(core)
+  .settings(doobieSettings)
+  .settings(publishSettings)
+  .settings(
+    name := s"doobie-munit",
+    description := "MUnit support for doobie.",
+    testFrameworks += new TestFramework("munit.Framework"),
+    libraryDependencies ++= Seq(
+      "org.scalameta" %% "munit" % munitVersion,
+      "com.h2database"  %  "h2"  % h2Version % "test"
+    )
+  )
+
 lazy val bench = project
   .in(file("modules/bench"))
   .enablePlugins(AutomateHeaderPlugin)

modules/docs/src/main/mdoc/docs/06-Checking.md

@@ -99,7 +99,7 @@ def biggerThan2(minPop: Int) =
 biggerThan2(0).check.unsafeRunSync
 ```
 
-**doobie** supports `check` for queries and updates in three ways: programmatically, via YOLO mode in the REPL, and via the `doobie-specs2` and `doobie-scalatest` packages, which allow checking to become part of your unit test suite. We will investigate this in the chapter on testing.
+**doobie** supports `check` for queries and updates in four ways: programmatically, via YOLO mode in the REPL, and via the `doobie-specs2`, `doobie-scalatest` and `doobie-munit` packages, which allow checking to become part of your unit test suite. We will investigate this in the chapter on testing.
 
 ### Working Around Bad Metadata
 

modules/docs/src/main/mdoc/docs/13-Unit-Testing.md

@@ -1,6 +1,6 @@
 ## Unit Testing
 
-The YOLO-mode query checking feature demonstated in an earlier chapter is also available as a trait you can mix into your [Specs2](http://etorreborre.github.io/specs2/) or [ScalaTest](http://www.scalatest.org/) unit tests.
+The YOLO-mode query checking feature demonstated in an earlier chapter is also available as a trait you can mix into your [Specs2](http://etorreborre.github.io/specs2/), [ScalaTest](http://www.scalatest.org/) or [MUnit](https://scalameta.org/munit) unit tests.
 
 ### Setting Up
 
@@ -129,3 +129,25 @@ Details are shown for failing tests.
 // Run a test programmatically. Usually you would do this from sbt, bloop, etc.
 (new AnalysisTestScalaCheck).execute(color = false)
 ```
+
+### The MUnit Package
+
+The `doobie-munit` add-on provides a mix-in trait that we can add to any `Assertions` implementation (like `FunSuite`) much like the ScalaTest package above.
+
+```scala mdoc:silent
+import munit._
+
+class AnalysisTestScalaCheck extends FunSuite with doobie.munit.IOChecker {
+
+  override val colors = doobie.util.Colors.None // just for docs
+
+  val transactor = Transactor.fromDriverManager[IO](
+    "org.postgresql.Driver", "jdbc:postgresql:world", "postgres", ""
+  )
+
+  test("trivial")    { check(trivial)        }
+  test("biggerThan") { check(biggerThan(0))  }
+  test("update")     { check(update("", "")) }
+
+}
+```

modules/munit/src/main/scala/doobie/munit/Checker.scala

@@ -0,0 +1,68 @@
+// Copyright (c) 2013-2018 Rob Norris and Contributors
+// This software is licensed under the MIT License (MIT).
+// For more information see LICENSE or https://opensource.org/licenses/MIT
+
+package doobie.munit
+
+import cats.effect.{ Effect, IO }
+import doobie.util.query.{Query, Query0}
+import doobie.util.testing._
+import munit.Assertions
+import scala.reflect.runtime.universe.TypeTag
+
+/**
+  * Mix-in trait for specifications that enables checking of doobie `Query` and `Update` values.
+  * Users must provide an effect type `M` as well as a `Transactor[M]` and instances. As a
+  * convenience doobie provides specializations for common effect types (see other types in this
+  * package).
+  *
+  * {{{
+  * class ExampleSpec extends FunSuite with IOChecker {
+  *
+  *   // The transactor to use for the tests.
+  *   val transactor = Transactor.fromDriverManager[IO](
+  *     "org.postgresql.Driver",
+  *     "jdbc:postgresql:world",
+  *     "postgres", ""
+  *   )
+  *
+  *   // Now just mention the queries. Arguments are not used.
+  *   test("findByNameAndAge") { check(MyDaoModule.findByNameAndAge(null, 0)) }
+  *   test("allWoozles") { check(MyDaoModule.allWoozles) }
+  *
+  * }
+  * }}}
+  */
+trait Checker[M[_]] extends CheckerBase[M] { self: Assertions =>
+
+  def check[A: Analyzable](a: A) = checkImpl(Analyzable.unpack(a))
+
+  @SuppressWarnings(Array("org.wartremover.warts.Overloading"))
+  def checkOutput[A: TypeTag](q: Query0[A]) =
+    checkImpl(AnalysisArgs(
+      s"Query0[${typeName[A]}]", q.pos, q.sql, q.outputAnalysis
+    ))
+
+  @SuppressWarnings(Array("org.wartremover.warts.Overloading"))
+  def checkOutput[A: TypeTag, B: TypeTag](q: Query[A, B]) =
+    checkImpl(AnalysisArgs(
+      s"Query[${typeName[A]}, ${typeName[B]}]", q.pos, q.sql, q.outputAnalysis
+    ))
+
+  private def checkImpl(args: AnalysisArgs) = {
+    val report = analyzeIO(args, transactor).unsafeRunSync
+    if (!report.succeeded) {
+      fail(
+        formatReport(args, report, colors)
+          .padLeft("  ")
+          .toString
+      )
+    }
+  }
+}
+
+/** Implementation of Checker[IO] */
+trait IOChecker extends Checker[IO] {
+  self: Assertions =>
+  val M: Effect[IO] = implicitly
+}

modules/munit/src/test/scala/doobie/munit/CheckerTests.scala

@@ -0,0 +1,30 @@
+// Copyright (c) 2013-2018 Rob Norris and Contributors
+// This software is licensed under the MIT License (MIT).
+// For more information see LICENSE or https://opensource.org/licenses/MIT
+
+package doobie.munit
+
+import cats.effect.{ ContextShift, IO }
+import doobie.syntax.string._
+import doobie.util.transactor.Transactor
+import munit._
+import scala.concurrent.ExecutionContext
+
+trait CheckerChecks[M[_]] extends FunSuite with Checker[M] {
+
+  implicit def contextShift: ContextShift[M]
+
+  lazy val transactor = Transactor.fromDriverManager[M](
+    "org.h2.Driver",
+    "jdbc:h2:mem:queryspec;DB_CLOSE_DELAY=-1",
+    "sa", ""
+  )
+
+  test("trivial") { check(sql"select 1".query[Int]) }
+
+}
+
+class IOCheckerCheck extends CheckerChecks[IO] with IOChecker {
+  def contextShift: ContextShift[IO] =
+    IO.contextShift(ExecutionContext.global)
+}