Adapted snapshot test for reuse

build.sbt

@@ -216,7 +216,8 @@ lazy val tools = project
       "dev.zio"                       %% "zio-test"            % zioVersion     % Test,
       "dev.zio"                       %% "zio-test-sbt"        % zioVersion     % Test,
       "dev.zio"                       %% "zio-json"            % zioJsonVersion % Test
-    )
+    ),
+    Test / publishArtifact := true
   )
   .dependsOn(core, clientJVM, quickAdapter % Test)
 
@@ -270,15 +271,17 @@ lazy val codegenSbt = project
         Seq("-Xmx1024M", "-Xss4M", "-Dplugin.version=" + version.value)
     },
     scriptedBufferLog    := false,
-    scriptedDependencies := {
-      (macros / publishLocal).value
-      (core / publishLocal).value
-      (clientJVM / publishLocal).value
-      (tools / publishLocal).value
-      publishLocal.value
-    }
+    scriptedDependencies := scriptedDependencies
+      .dependsOn(
+        macros / publishLocal,
+        core / publishLocal,
+        clientJVM / publishLocal,
+        tools / publishLocal,
+        publishLocal
+      )
+      .value
   )
-  .dependsOn(tools)
+  .dependsOn(tools % "compile->compile;test->test")
 
 lazy val catsInterop = project
   .in(file("interop/cats"))

codegen-sbt/src/sbt-test/compiletime-codegen/test-compile/build.sbt

@@ -26,19 +26,20 @@ ThisBuild / crossScalaVersions := allScala
 
 // ### Dependencies ###
 
-lazy val calibanLib: Seq[ModuleID] =
-  sys.props.get("plugin.version") match {
-    case Some(x) => Seq("com.github.ghostdogpr" %% "caliban" % x)
-    case _       => sys.error("""|The system property 'plugin.version' is not defined.
-                           |Specify this property using the scriptedLaunchOpts -D.""".stripMargin)
-  }
+lazy val calibanLib = Seq(
+  "com.github.ghostdogpr" %% "caliban" % Version.pluginVersion,
+  "com.github.ghostdogpr" %% "caliban-tools" % Version.pluginVersion % "compile->compile;test->test"
+)
 
 lazy val sttp = Seq(
   "com.softwaremill.sttp.client3" %% "core" % "3.9.8",
   "com.softwaremill.sttp.client3" %% "zio"  % "3.9.8"
 )
 
-lazy val zioTest = Seq("dev.zio" %% "zio-test" % "2.1.9" % Test)
+lazy val zioTest = Seq(
+  "dev.zio" %% "zio-test" % "2.1.9" % Test,
+  "dev.zio" %% "zio-test-sbt" % "2.1.9" % Test
+)
 // ### App Modules ###
 
 /**
@@ -106,6 +107,7 @@ lazy val posts =
     )
     .settings(libraryDependencies ++= calibanLib ++ zioTest)
 
+
 lazy val potatoes =
   project
     .in(file("modules/potatoes"))

codegen-sbt/src/sbt-test/compiletime-codegen/test-compile/modules/posts/src/test/scala/ValidateGraphQlSpec.scala

@@ -1,24 +1,22 @@
 import poc.caliban.posts.GraphQLApi
 
 import scala.io.Source
-import java.io.File
-import java.nio.file.{Files, Paths}
 import zio.test.Assertion._
 import zio.test._
+import caliban.tools._
 
-class ValidateGraphQlSpec extends ZIOSpecDefault {
+object ValidateGraphQlSpec extends SnapshotTest {
+  override val testName: String = "ValidateGraphQlSpec"
+
+  val outFolder = SnapshotTest.projectRoot.resolve("codegen-sbt/src/sbt-test/compiletime-codegen/test-compile/modules/posts/src/test/resources/")
 
   override def spec =
     suite("Validate Postservice")(
       test("Render postservice as earlier") {
-        val filename = "postservice.graphql"
-        val expectedGraphQL: String = Source.fromResource(filename).getLines().mkString("\n")
         val gqlApi = GraphQLApi.api
         val renderContent: String = s"${gqlApi.render}"
 
-        //Files.writeString(Paths.get(File(s"/tmp/$filename").toURI), renderContent)
-
-        assertTrue(expectedGraphQL == renderContent)
+        writeAndCompare(outFolder.resolve("postservice.graphql"), renderContent, "Render postservice")
       }
     )
 }

codegen-sbt/src/sbt-test/compiletime-codegen/test-compile/project/Version.scala

@@ -0,0 +1,8 @@
+object Version {
+  def pluginVersion: String =
+    sys.props.get("plugin.version") match {
+      case Some(x) => x
+      case _       => sys.error("""|The system property 'plugin.version' is not defined.
+                             |Specify this property using the scriptedLaunchOpts -D.""".stripMargin)
+    }
+}

tools/src/test/scala/caliban/tools/SnapshotTest.scala

@@ -16,44 +16,45 @@ trait SnapshotTest extends ZIOSpecDefault {
   )(str: Task[String])(implicit sourceLocation: SourceLocation, trace: Trace): Spec[Any, Throwable] = {
     val label = label0.replace('/', '_').replace("'", "")
     zio.test.test[Task[TestResult]](label) {
-      str.map { str =>
-        val isCi = SnapshotTest.isCi
+      str.map { content =>
         val path = SnapshotTest.projectRoot.resolve(s"tools/src/test/resources/snapshots/$testName/${label + ".scala"}")
+        writeAndCompare(path, content, label)
+      }
+    }
+  }
 
-        def write(): TestResult = {
-          Files.createDirectories(path.getParent)
-          Files.writeString(path, str)
-          import scala.sys.process._
-          // at least don't take the git lock multiple times from same process. this can still fail if concurrent processes try to take it.
-          GitLock.synchronized {
-            // allow failing external command, but complain to stderr
-            try s"git add '$path'".!
-            catch {
-              case th: Throwable =>
-                System.err.println(s"Could not add snapshot file '$path' to git: ${th.getMessage}")
-            }
-          }
-          assert(())(Assertion.anything)
-        }
-
-        Try(Files.readString(path)) match {
-          case Success(existing) if isCi =>
-            assertTrue(str == existing).label(
-              s"generated result for test '$label' did not match snapshot contents in file '$path. Rerun with environment `CI` not set to 'true' to update and then check in the file"
-            )
-          case Success(_)                =>
-            write()
-          case Failure(_) if isCi        =>
-            assertTrue(false).label(
-              s"Could not read snapshot file '$path'. Rerun with environment `CI` not set to 'true' to create and then check in the file"
-            )
-          case Failure(_)                =>
-            write()
-        }
+  private def write(path: Path, str: String): TestResult = {
+    Files.createDirectories(path.getParent)
+    Files.writeString(path, str)
+    import scala.sys.process._
+    // at least don't take the git lock multiple times from same process. this can still fail if concurrent processes try to take it.
+    GitLock.synchronized {
+      // allow failing external command, but complain to stderr
+      try s"git add '$path'".!
+      catch {
+        case th: Throwable =>
+          System.err.println(s"Could not add snapshot file '$path' to git: ${th.getMessage}")
       }
     }
+    assert(())(Assertion.anything)
   }
 
+  def writeAndCompare(path: Path, content: String, label: String): TestResult =
+    Try(Files.readString(path)) match {
+      case Success(existing) if SnapshotTest.isCi =>
+        assertTrue(content == existing).label(
+          s"generated result for test '$label' did not match snapshot contents in file '$path. Rerun with environment `CI` not set to 'true' to update and then check in the file"
+        )
+      case Success(_)                             =>
+        write(path, content)
+      case Failure(_) if SnapshotTest.isCi        =>
+        assertTrue(false).label(
+          s"Could not read snapshot file '$path'. Rerun with environment `CI` not set to 'true' to create and then check in the file"
+        )
+      case Failure(_)                             =>
+        write(path, content)
+    }
+
 }
 
 object SnapshotTest {