scalajs-gradle/src/main/scala/org/podval/tools/build/TestFramework.scala at 6b8daaebf67242d37ab0ebd6d39834d9db4269d7 · dubinsky/scalajs-gradle · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package org.podval.tools.build

import org.gradle.api.GradleException
import org.podval.tools.test.framework
import org.podval.tools.util.Scala212Collections.arrayFind
import sbt.testing.{Fingerprint, Runner, Framework as FrameworkSBT}

// Based on sbt.TestFramework.
abstract class TestFramework(
  val name: String,
  val nameSbt: String, // Name as reported by the framework
  val className: String,
  val sharedPackages: List[String],
  val tagOptions: Option[TagOptions],
  val usesTestSelectorAsNested: Boolean,
  val additionalOptions: Array[String]
) derives CanEqual:
  final override def toString: String = name

  def isBackendSupported(backend: Backend): Boolean = true

  // Note: `isScala3` parameter is needed only to accommodate AirSpec,
  // so if the need goes away, this can be simplified ;)
  def isBackendSupported(backend: Backend, isScala3: Boolean): Boolean = isBackendSupported(backend)

  // Note: `isScala3` parameter is needed only to accommodate specs2,
  // so if the need goes away, this can be simplified ;)
  def versionDefault(isScala3: Boolean): Option[Version] = None

  // Note: `isJvm` parameter is needed only to accommodate MUnit,
  // which as of v1.2.4 throws an exception if a JVM-specific parameter is supplied on Scala.js or Scala Native.
  def additionalOptions(isJvm: Boolean): Array[String] = additionalOptions

  def dependency: JvmDependency

  final def withVersion(
    backend: Backend,
    scalaLibrary: ScalaLibrary,
    version: Option[Version]
  ): DependencyVersion =
    val dependencyForBackend: JvmDependency = dependency.forBackend(Some(backend))
    dependencyForBackend
      .withVersion(
        scalaLibrary,
        version
          .orElse(versionDefault(scalaLibrary.scalaVersion.binaryVersion.isScala3))
          .getOrElse(dependencyForBackend.versionDefault)
      )

  final def loaded(frameworkSBT: FrameworkSBT) = TestFramework.Loaded(this, frameworkSBT)

  final def load: TestFramework.Loaded = tryLoad.getOrElse(throw GradleException(s"Failed to load test framework $this!"))

  final def tryLoad: Option[TestFramework.Loaded] =
    try Class
      .forName(className)
      .getDeclaredConstructor()
      .newInstance()
    match
      case frameworkSBT: FrameworkSBT => Some(loaded(frameworkSBT))
      case other => throw GradleException(s"${other.getClass.getName} is not an SBT framework!")
    catch
      case _: ClassNotFoundException => None

object TestFramework:
  final class Loaded(
    val framework: TestFramework,
    frameworkSBT: FrameworkSBT
  ):
    require(framework.nameSbt == nameSbt)

    def nameSbt: String = frameworkSBT.name

    def fingerprints: Array[Fingerprint] = frameworkSBT.fingerprints

    def runner(args: Array[String]): Runner = frameworkSBT.runner(
      args,
      Array.empty,
      frameworkSBT.getClass.getClassLoader
    )

  def forNameSbt(nameSbt: String): TestFramework = find(_.nameSbt == nameSbt, nameSbt)

  def find(p: TestFramework => Boolean, what: String): TestFramework =
    arrayFind(all, p).getOrElse(throw GradleException(s"Test framework for '$what' not found"))

  val all: Array[TestFramework] = Array(
    org.podval.tools.jvm.JUnit4Jvm,
    org.podval.tools.scalajs.JUnit4ScalaJS,
    org.podval.tools.scalanative.JUnit4ScalaNative,
    framework.AirSpec,
    framework.Hedgehog,
    framework.MUnit,
    framework.ScalaCheck,
    framework.Scalaprops,
    framework.ScalaTest,
    framework.Specs2,
    framework.UTest,
    framework.WeaverTest,
    framework.ZioTest
  )