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-2020 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-2020 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)
+}