Enable examples in CI

.github/workflows/release.yml

@@ -0,0 +1,16 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '**'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: release
+        run: sbt ci-release

.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Test
+
+on: pull_request
+
+jobs:
+  test:
+    timeout-minutes: 50
+    runs-on: ubuntu-latest
+    name: test-${{ matrix.type }}
+    strategy:
+      matrix:
+        type: [probe 2.12.10, probe 2.13.1, scala 2.13.1]
+    steps:
+      - uses: actions/checkout@v2
+      - name: generate scripts
+        run: sbt ci/generateScripts
+      - name: build image
+        run: sh ci/tests/build_image
+      - name: test
+        run: sh ci/tests/run ${{ matrix.type }}
+
+  examples:
+    timeout-minutes: 120
+    runs-on: ubuntu-latest
+    name: test-examples 2.13.1
+    steps:
+      - uses: actions/checkout@v2
+      - name: generate scripts
+        run: sbt ci/generateScripts
+      - name: build image
+        run: sh ci/tests/build_image
+      - name: test
+        run: sh ci/tests/run examples 2.13.1

build.sbt

@@ -202,7 +202,6 @@ lazy val scalaTests213 = scalaTests(scala213)
   .usesIdeaPlugin(scalaProbePlugin213)
 
 lazy val examples = testModule("examples", "examples")
-  .settings(libraryDependencies ++= Dependencies.junit5)
   .cross
   .dependsOn(driver, robotDriver, scalaProbeDriver)
 

examples/src/test/resources/ideprobe.conf

@@ -5,9 +5,9 @@ probe {
     ]
   }
   endpoints.awaitIdle {
-    initialWait = "0 seconds"
-    newTaskWait = "1 second"
-    checkFrequency = "100 millis"
+    initialWait = "5 seconds"
+    newTaskWait = "2 second"
+    checkFrequency = "50 millis"
   }
   paths.screenshots = ${?IDEPROBE_SCREENSHOTS_DIR}
 }

examples/src/test/resources/projects/dokka.conf

@@ -6,5 +6,5 @@ probe {
 
 modules {
     verify = ["dokka.core.main", "dokka.kotlin-analysis.main", "dokka.plugins.javadoc.main"]
-    test = ["dokka.integration-tests.gradle.integrationTest", "dokka.plugins.javadoc.test"]
+    test = ["dokka.integration-tests.cli.integrationTest", "dokka.plugins.javadoc.test"]
 }

examples/src/test/scala/org/virtuslab/ideprobe/ModuleTest.scala

@@ -1,73 +1,64 @@
 package org.virtuslab.ideprobe
 
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.ValueSource
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import org.junit.runners.Parameterized.Parameters
 import org.junit.{Assert, Test}
 import org.virtuslab.ideprobe.Extensions._
+import org.virtuslab.ideprobe.dependencies.{IntelliJVersion, Plugin}
 import org.virtuslab.ideprobe.protocol._
 import org.virtuslab.ideprobe.robot.RobotPluginExtension
 import org.virtuslab.ideprobe.scala.ScalaPluginExtension
 import org.virtuslab.ideprobe.scala.protocol.SbtProjectSettingsChangeRequest
 
-class ModuleTest extends IdeProbeFixture with ScalaPluginExtension with RobotPluginExtension {
+@RunWith(classOf[Parameterized])
+class ModuleTest(configName: String) extends IdeProbeFixture with ScalaPluginExtension with RobotPluginExtension {
+    registerFixtureTransformer(_.withAfterIntelliJStartup((fixture, intelliJ) => {
+      deleteIdeaSettings(intelliJ)
+      intelliJ.probe.withRobot.openProject(intelliJ.workspace)
+      useSbtShell(intelliJ)
+    }))
 
-  registerFixtureTransformer(_.withAfterIntelliJStartup((fixture, intelliJ) => {
-    deleteIdeaSettings(intelliJ)
-    intelliJ.probe.withRobot.openProject(intelliJ.workspace)
-    useSbtShell(intelliJ)
-  }))
-
-  @ParameterizedTest
-  @ValueSource(
-    strings = Array(
-      "projects/io.conf",
-      "projects/librarymanagement.conf",
-      "projects/dokka.conf"
-    )
-  )
-  @Test def runTestsInDifferentScopes(configName: String): Unit = fixtureFromConfig(configName).run { intelliJ =>
-    val runnerToSelect = intelliJ.config.get[String]("runner")
-    val modulesToTest = intelliJ.config[Seq[String]]("modules.test")
-    intelliJ.probe.build().assertSuccess()
-    modulesToTest.foreach { moduleName =>
-      val scope = TestScope.Module(ModuleRef(moduleName))
-      val result = intelliJ.probe.runTestsFromGenerated(scope, runnerToSelect)
-      Assert.assertTrue(s"Test result $result should not be empty", result.suites.nonEmpty)
+    @Test def verifyModulesPresent: Unit = fixtureFromConfig(configName).run { intelliJ =>
+      val project = intelliJ.probe.projectModel()
+      val expectedModules = intelliJ.config[Seq[String]]("modules.verify")
+      val missingModules = expectedModules.diff(project.moduleNames)
+      Assert.assertTrue(s"Modules $missingModules are missing", missingModules.isEmpty)
     }
-  }
 
-  @ParameterizedTest
-  @ValueSource(
-    strings = Array(
-      "projects/io.conf",
-      "projects/librarymanagement.conf",
-      "projects/dokka.conf"
-    )
-  )
-  def verifyModulesPresent(configName: String): Unit = fixtureFromConfig(configName).run { intelliJ =>
-    val project = intelliJ.probe.projectModel()
-    val expectedModules = intelliJ.config[Seq[String]]("modules.verify")
-    val missingModules = expectedModules.diff(project.moduleNames)
-    Assert.assertTrue(s"Modules $missingModules are missing", missingModules.isEmpty)
-  }
+    @Test def runTestsInDifferentScopes: Unit = fixtureFromConfig(configName).run { intelliJ =>
+      val runnerToSelect = intelliJ.config.get[String]("runner")
+      val modulesToTest = intelliJ.config[Seq[String]]("modules.test")
+      intelliJ.probe.build().assertSuccess()
+      modulesToTest.foreach { moduleName =>
+        val scope = TestScope.Module(ModuleRef(moduleName))
+        val result = intelliJ.probe.runTestsFromGenerated(scope, runnerToSelect)
+        Assert.assertTrue(s"Test result $result should not be empty", result.suites.nonEmpty)
+      }
+    }
 
-  protected def useSbtShell(intelliJ: RunningIntelliJFixture): Unit = {
-    if (intelliJ.workspace.resolve("build.sbt").isFile) {
-      intelliJ.probe.setSbtProjectSettings(
-        SbtProjectSettingsChangeRequest(
-          useSbtShellForImport = Setting.Changed(true),
-          useSbtShellForBuild = Setting.Changed(true)
+    protected def useSbtShell(intelliJ: RunningIntelliJFixture): Unit = {
+      if (intelliJ.workspace.resolve("build.sbt").isFile) {
+        intelliJ.probe.setSbtProjectSettings(
+          SbtProjectSettingsChangeRequest(
+            useSbtShellForImport = Setting.Changed(true),
+            useSbtShellForBuild = Setting.Changed(true)
+          )
         )
-      )
+      }
     }
-  }
 
-  /**
-   * The presence of .idea can prevent automatic import of gradle project
-   */
-  private def deleteIdeaSettings(intelliJ: RunningIntelliJFixture): Unit = {
-    val path = intelliJ.workspace.resolve(".idea")
-    if (path.isDirectory) path.delete()
-  }
+    /**
+     * The presence of .idea can prevent automatic import of gradle project
+     */
+    private def deleteIdeaSettings(intelliJ: RunningIntelliJFixture): Unit = {
+      val path = intelliJ.workspace.resolve(".idea")
+      if (path.isDirectory) path.delete()
+    }
+}
 
+object ModuleTest {
+  @Parameters(name = "{0}") def data: java.util.Collection[String] = {
+    java.util.Arrays.asList("projects/io.conf", "projects/librarymanagement.conf", "projects/dokka.conf")
+  }
 }

project/CI.scala

@@ -4,14 +4,15 @@ import sbt.Keys.loadedBuild
 import sbt.{Def, ProjectRef, _}
 
 object CI {
-  private val excluded = Set("ci", "ide-probe", "ideprobe", "probe", "examples")
+  private val excluded = Set("ci", "ide-probe", "ideprobe", "probe")
   lazy val generateScripts = taskKey[Seq[File]]("Generate CI scripts")
 
   private def scalaVersionToModulePostfix(scalaVersion: String): String =
     scalaVersion.split("\\.").dropRight(1).mkString("_")
 
   def groupedProjects(scalaVersions: List[String]): Def.Initialize[Task[Map[String, Seq[ProjectRef]]]] = Def.task {
     val extensionDir = Paths.get(loadedBuild.value.root).resolve("extensions")
+    val examplesDir = Paths.get(loadedBuild.value.root).resolve("examples")
     val excludedCross = for {
       version <- scalaVersions
       module <- excluded
@@ -23,6 +24,7 @@ object CI {
         case (_, project) =>
           val projectPath = project.base.toPath
           if (projectPath.startsWith(extensionDir)) extensionDir.relativize(projectPath).getName(0).toString
+          else if (projectPath.startsWith(examplesDir)) "examples"
           else "probe"
       }
       .mapValues(_.map(_._1))

project/Dependencies.scala

@@ -29,11 +29,6 @@ object Dependencies {
     } ++ Seq(typesafeConfig, shapeless)
   }
 
-  val junit5 = Seq(
-    "org.junit.jupiter" % "junit-jupiter-params" % "5.4.2",
-    "net.aichler" % "jupiter-interface" % "0.8.3" % Test
-  )
-
   val intellijScala = "org.intellij.scala:2020.2.753:nightly"
 
 }