This is an automated email from the ASF dual-hosted git repository. He-Pin pushed a commit to branch feature/junit6-migration in repository https://gitbox.apache.org/repos/asf/pekko-grpc.git
commit 72e1b069d1e096906fd109ce0008193300212330 Author: 虎鸣 <[email protected]> AuthorDate: Sat Jun 27 19:35:26 2026 +0800 refactor: migrate JUnit 4 to JUnit 6.1.0 Motivation: JUnit 4 is end-of-life. JUnit 6 unifies version numbering across Platform, Jupiter, and Vintage components. Modification: - Add sbt-jupiter-interface plugin and JupiterKeys overrides for JUnit Jupiter and Platform 6.1.0 - Migrate test files (Java, Scala, Groovy) from JUnit 4 to Jupiter: * Java: @Test, @Before/@After -> @BeforeEach/@AfterEach, @Ignore -> @Disabled, Assert.xxx -> Assertions.xxx (message param moves from first to last) * Java: Remove `extends JUnitSuite` and @RunWith(JUnit4.class) * Scala: Remove @RunWith(classOf[JUnitRunner]) from ScalaTest specs where discovery does not depend on the JUnit 4 bridge * Scala: org.junit.Assert._ -> org.junit.jupiter.api.Assertions._ * Groovy: Spock specs converted to JUnit Jupiter Java tests (@Unroll+where -> @ParameterizedTest+@MethodSource, cleanup() -> @AfterEach, @TempDir replaced with manual Files.createTempDirectory management) - Replace scalatestplus-junit with Jupiter test dependencies in Dependencies.scala (keep scalaTestPlusJunit for plugin-tester-scala where Gradle relies on the JUnit 4 runner for ScalaTest discovery) - Update Gradle build files to use JUnit Jupiter and useJUnitPlatform() - Convert gradle-plugin Spock/Groovy tests to JUnit Jupiter Java tests to avoid Groovy version conflicts with Gradle's bundled Groovy - Update benchmark-java standalone build to use JUnit Jupiter 6.1.0 - Update scripted test build and PekkoGrpcClientTester to use Jupiter assertions - Configure explicit ScalaFutures PatienceConfig in Scala 3 scripted greeter specs and use brace syntax for scalafmt compatibility - Pin Gradle plugin tests to JUnit Jupiter 5.14.1 and add explicit junit-platform-launcher:1.14.1 for Spock 2.4 compatibility (main project tests use JUnit 6) Result: All tests run on JUnit 6.1.0 (Jupiter). JUnit 4 is no longer a test dependency in the main project. Tests: Not run here - each constituent change was validated in its own commit; full validation to follow after rebase. References: Refs #759 (Gradle wrapper 8.14.5 upgrade, now on main) Refs #762 (scalafmt disable Scala 3 syntax) --- benchmark-java/build.sbt | 3 +- .../grpc/benchmarks/driver/LoadClientTest.java | 12 +- .../grpc/benchmarks/driver/LoadWorkerTest.java | 24 ++- build.sbt | 3 + gradle-plugin/build.gradle | 5 +- .../groovy/func/GradleCompatibilitySpec.groovy | 60 ------- .../src/test/groovy/helper/BaseSpec.groovy | 63 ------- .../src/test/groovy/unit/ApplySpec.groovy | 182 ------------------- .../src/test/groovy/unit/DependenciesSpec.groovy | 103 ----------- .../java/func/GradleCompatibilitySpecTest.java | 93 ++++++++++ gradle-plugin/src/test/java/helper/BaseSpec.java | 158 +++++++++++++++++ .../helper/ScalaWrapperPlugin.java} | 14 +- .../src/test/java/unit/ApplySpecTest.java | 196 +++++++++++++++++++++ .../src/test/java/unit/DependenciesSpecTest.java | 108 ++++++++++++ .../helloworld/grpc/RichErrorModelNativeTest.java | 11 +- .../myapp/helloworld/grpc/RichErrorModelTest.java | 11 +- .../grpc/interop/PekkoGrpcJavaClientTester.java | 11 +- .../grpc/interop/PekkoGrpcScalaClientTester.scala | 6 +- plugin-tester-java/build.gradle | 2 +- project/Dependencies.scala | 24 ++- project/plugins.sbt | 1 + .../pekko/grpc/javadsl/ConcatOrNotFoundTest.java | 7 +- .../sbt-test/gen-scala-server/00-interop/build.sbt | 3 +- .../apache/pekko/grpc/PekkoGrpcClientTester.scala | 6 +- 24 files changed, 631 insertions(+), 475 deletions(-) diff --git a/benchmark-java/build.sbt b/benchmark-java/build.sbt index 9305262c..e3050868 100644 --- a/benchmark-java/build.sbt +++ b/benchmark-java/build.sbt @@ -37,7 +37,8 @@ val root = project "org.hdrhistogram" % "HdrHistogram" % "2.1.12", "org.apache.commons" % "commons-math3" % "3.6.1", "org.scalatest" %% "scalatest" % "3.2.20" % Test, - "org.scalatestplus" %% "junit-4-13" % "3.2.20.0" % Test), + "org.junit.jupiter" % "junit-jupiter" % "6.1.0" % Test, + "com.github.sbt.junit" % "jupiter-interface" % "0.19.0" % Test), PB.artifactResolver := PB.artifactResolver.dependsOn(codeGenProject / Compile / publishLocal).value) compile / javacOptions += "-Xlint:deprecation" diff --git a/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadClientTest.java b/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadClientTest.java index 481f00f8..0eb266ad 100644 --- a/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadClientTest.java +++ b/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadClientTest.java @@ -17,21 +17,17 @@ package org.apache.pekko.grpc.benchmarks.driver; -import static junit.framework.TestCase.assertEquals; -import static junit.framework.TestCase.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.apache.pekko.grpc.benchmarks.proto.Control; import org.apache.pekko.grpc.benchmarks.proto.Stats; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; -import org.scalatestplus.junit.JUnitSuite; +import org.junit.jupiter.api.Test; /** * Tests for {@link LoadClient}. */ -@RunWith(JUnit4.class) -public class LoadClientTest extends JUnitSuite { +public class LoadClientTest { @Test public void testHistogramToStatsConversion() throws Exception { diff --git a/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadWorkerTest.java b/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadWorkerTest.java index c1593ce0..43f8b436 100644 --- a/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadWorkerTest.java +++ b/benchmark-java/src/test/java/org/apache/pekko/grpc/benchmarks/driver/LoadWorkerTest.java @@ -32,13 +32,10 @@ import org.apache.pekko.stream.javadsl.Sink; import org.apache.pekko.stream.javadsl.Source; import com.typesafe.config.Config; import com.typesafe.config.ConfigFactory; -import org.junit.After; -import org.junit.Before; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; -import org.scalatestplus.junit.JUnitSuite; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; import java.net.InetSocketAddress; import java.time.Duration; @@ -46,13 +43,12 @@ import java.util.concurrent.CompletionStage; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * Basic tests for {@link org.apache.pekko.grpc.benchmarks.driver.LoadWorker} */ -@RunWith(JUnit4.class) -public class LoadWorkerTest extends JUnitSuite { +public class LoadWorkerTest { private static final int TIMEOUT = 5; @@ -66,7 +62,7 @@ public class LoadWorkerTest extends JUnitSuite { private ActorSystem system; private Materializer mat; - @Before + @BeforeEach public void setup() throws Exception { // important to enable HTTP/2 in ActorSystem's config Config conf = ConfigFactory.parseString("pekko.http.server.enable-http2 = on") @@ -81,7 +77,7 @@ public class LoadWorkerTest extends JUnitSuite { workerServiceStub = WorkerServiceClient.create(settings, system); } - @After + @AfterEach public void tearDown() throws Exception { if (system != null) { workerServiceStub.close(); @@ -90,7 +86,7 @@ public class LoadWorkerTest extends JUnitSuite { } } - @Ignore // SYNC_CLIENT not implemented + @Disabled // SYNC_CLIENT not implemented public void runUnaryBlockingClosedLoop() throws Exception { Control.ServerArgs.Builder serverArgsBuilder = Control.ServerArgs.newBuilder(); serverArgsBuilder.getSetupBuilder() @@ -173,7 +169,7 @@ public class LoadWorkerTest extends JUnitSuite { assertWorkOccurred(clientArgsBuilder.build()); } - @Ignore // ASYNC_GENERIC_SERVER not implemented + @Disabled // ASYNC_GENERIC_SERVER not implemented public void runGenericPingPongAsyncClosedLoop() throws Exception { Control.ServerArgs.Builder serverArgsBuilder = Control.ServerArgs.newBuilder(); serverArgsBuilder.getSetupBuilder() diff --git a/build.sbt b/build.sbt index 5570d185..478f5287 100644 --- a/build.sbt +++ b/build.sbt @@ -9,6 +9,7 @@ import com.github.pjfanning.pekkobuild._ import com.github.sbt.JavaFormatterPlugin.autoImport.javafmtSortImports +import com.github.sbt.junit.jupiter.sbt.Import.JupiterKeys import net.bzzt.reproduciblebuilds.ReproducibleBuildsPlugin.reproducibleBuildsCheckResolver import org.apache.pekko.grpc.{ Dependencies, NoPublish, PekkoCoreDependency, PekkoHttpDependency } import org.apache.pekko.grpc.Dependencies.Versions.{ scala212, scala213 } @@ -20,6 +21,8 @@ import sbt.Keys.scalaVersion sourceDistName := "apache-pekko-grpc" sourceDistIncubating := false ThisBuild / versionScheme := Some(VersionScheme.SemVerSpec) +ThisBuild / JupiterKeys.junitJupiterVersion := "6.1.0" +ThisBuild / JupiterKeys.junitPlatformVersion := "6.1.0" commands := commands.value.filterNot { command => command.nameOption.exists { name => diff --git a/gradle-plugin/build.gradle b/gradle-plugin/build.gradle index 04a5d83d..1aabeda0 100644 --- a/gradle-plugin/build.gradle +++ b/gradle-plugin/build.gradle @@ -131,11 +131,12 @@ repositories { dependencies { implementation 'com.google.protobuf:protobuf-gradle-plugin:0.9.5' implementation 'org.apache.commons:commons-lang3:3.19.0' - testImplementation 'junit:junit:4.13.2' - testImplementation 'org.spockframework:spock-core:2.3-groovy-3.0' + testImplementation 'org.junit.jupiter:junit-jupiter:5.14.1' + testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.14.1' } test { + useJUnitPlatform() systemProperty 'pekkoGrpcTest.pluginVersion', project.version testLogging { events "passed", "skipped", "failed" diff --git a/gradle-plugin/src/test/groovy/func/GradleCompatibilitySpec.groovy b/gradle-plugin/src/test/groovy/func/GradleCompatibilitySpec.groovy deleted file mode 100644 index 5c108a4e..00000000 --- a/gradle-plugin/src/test/groovy/func/GradleCompatibilitySpec.groovy +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * license agreements; and to You under the Apache License, version 2.0: - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * This file is part of the Apache Pekko project, which was derived from Akka. - */ - -package func - -import helper.BaseSpec -import org.gradle.testkit.runner.BuildResult -import org.gradle.testkit.runner.GradleRunner -import org.gradle.testkit.runner.TaskOutcome -import spock.lang.Unroll - -class GradleCompatibilitySpec extends BaseSpec { - - BuildResult executeGradleTaskWithVersion(String task, String gradleVersion, boolean shouldFail) { - def runner = GradleRunner.create().forwardOutput() - .withProjectDir(projectDir.root) - .withArguments("--stacktrace", task) - .withPluginClasspath() - .withDebug(true) - .withGradleVersion(gradleVersion) - - if (shouldFail) { - return runner.buildAndFail() - } else { - return runner.build() - } - } - - @Unroll - void 'should succeed for version #gradleVersion greater than 5.6'() { - given: - createBuildFolder() - generateBuildScripts() - when: - BuildResult result = executeGradleTaskWithVersion('tasks', gradleVersion, false) - then: - result.task(":tasks").outcome == TaskOutcome.SUCCESS - where: - gradleVersion << ["5.6", "5.6.4", "7.6.4"] - } - - @Unroll - void 'should fail for version #gradleVersion less than 5.6'() { - given: - createBuildFolder() - generateBuildScripts() - when: - BuildResult result = executeGradleTaskWithVersion('tasks', gradleVersion, true) - then: - result.output.contains("Gradle version is ${gradleVersion}. Minimum supported version is 5.6") - where: - gradleVersion << ["5.5", "4.0"] - } -} diff --git a/gradle-plugin/src/test/groovy/helper/BaseSpec.groovy b/gradle-plugin/src/test/groovy/helper/BaseSpec.groovy deleted file mode 100644 index a10d329d..00000000 --- a/gradle-plugin/src/test/groovy/helper/BaseSpec.groovy +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * license agreements; and to You under the Apache License, version 2.0: - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * This file is part of the Apache Pekko project, which was derived from Akka. - */ - -package helper - -import org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension -import org.junit.Rule -import org.junit.rules.TemporaryFolder -import spock.lang.Specification - -import static org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension.getPLUGIN_CODE - -abstract class BaseSpec extends Specification { - - @Rule - public final TemporaryFolder projectDir = new TemporaryFolder() - - File srcDir - - File buildDir - - File buildFile - - def createBuildFolder() { - srcDir = projectDir.newFolder("src", "main", "proto") - buildDir = projectDir.newFolder("build") - } - - def generateBuildScripts() { - buildFile = projectDir.newFile("build.gradle") - buildFile.text = """ -plugins { - id '$PLUGIN_CODE' -} -project.dependencies { - implementation "com.typesafe.scala-logging:scala-logging_2.12:3.9.2" -} -""" - } - - def findPekkoGrpcRuntime() { - this.project.configurations.pekkoGrpcRuntime.allDependencies.find { it.name.contains("pekko-grpc-runtime") } - } - - PekkoGrpcPluginExtension sampleSetup(def plugin = "scala", String scala = "2.12") { - if (plugin == "scala" || plugin == ScalaWrapperPlugin) { - def scalaDir = projectDir.newFolder('src', 'main', 'scala') - new File(scalaDir, "test.scala").text = "object PekkoGrpc" - } - - project.pluginManager.apply PLUGIN_CODE - project.dependencies { - implementation "com.typesafe.scala-logging:scala-logging_$scala:3.9.2" - } - project.extensions.getByType(PekkoGrpcPluginExtension) - } -} diff --git a/gradle-plugin/src/test/groovy/unit/ApplySpec.groovy b/gradle-plugin/src/test/groovy/unit/ApplySpec.groovy deleted file mode 100644 index ab01b54c..00000000 --- a/gradle-plugin/src/test/groovy/unit/ApplySpec.groovy +++ /dev/null @@ -1,182 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * license agreements; and to You under the Apache License, version 2.0: - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * This file is part of the Apache Pekko project, which was derived from Akka. - */ - -package unit - -import org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension -import helper.BaseSpec -import helper.ScalaWrapperPlugin -import org.gradle.api.Project -import org.gradle.api.ProjectConfigurationException -import org.gradle.testfixtures.ProjectBuilder -import org.gradle.testkit.runner.BuildResult -import org.gradle.testkit.runner.GradleRunner -import spock.lang.Unroll - -import static org.gradle.testkit.runner.TaskOutcome.SKIPPED -import static org.gradle.testkit.runner.TaskOutcome.SUCCESS -import static org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension.PLUGIN_CODE - -class ApplySpec extends BaseSpec { - - Project project - - File log - - def setup() { - createBuildFolder() - project = ProjectBuilder.builder().withProjectDir(projectDir.root).build() - } - - def createLog() { - log = projectDir.newFile("build/pekko-grpcgradle-plugin.log") - } - - BuildResult executeGradleTask(String task) { - def runner = GradleRunner.create().forwardOutput() - .withProjectDir(projectDir.root) - .withArguments("--stacktrace", task) - .withPluginClasspath() - .withDebug(true) - runner.build() - } - - @Unroll - def "should detect language for #plugin"() { - given: - def pekkoGrpcExt = sampleSetup(plugin, scala) - when: - project.evaluate() - then: - with(pekkoGrpcExt) { - it.pluginVersion == System.getProperty("pekkoGrpcTest.pluginVersion") - it.scala == isScala - } - where: - plugin || scala || isScala - "java" | "2.12" | false - "java" | "2.13" | false - "scala" | "2.12" | true - "scala" | "2.13" | true - ScalaWrapperPlugin | "2.12" | true - ScalaWrapperPlugin | "2.13" | true - } - - def "should fail if no scala-library declared"() { - given: - project.pluginManager.apply "scala" - project.pluginManager.apply PLUGIN_CODE - when: - project.evaluate() - then: - def ex = thrown(ProjectConfigurationException) - ex.cause.message.startsWith "$PLUGIN_CODE requires a single major.minor version of `org.scala-lang:scala-library` in compileClasspath." - ex.cause.message.endsWith "Found []" - } - - def "should fail if multiple scala-library declared"() { - given: - project.pluginManager.apply PLUGIN_CODE - and: - project.dependencies { - implementation group: 'org.mockito', name: 'mockito-scala_2.11', version: '1.6.1' - implementation group: 'org.mockito', name: 'mockito-scala_2.13', version: '1.14.8' - } - when: - project.evaluate() - then: - def ex = thrown(ProjectConfigurationException) - ex.cause.message.startsWith "$PLUGIN_CODE requires a single major.minor version of `org.scala-lang:scala-library` in compileClasspath." - ex.cause.message.endsWith "Found [2.11, 2.13]" - } - - def "should not fail scala autodetect if dependencies contain underscore"() { - given: - def pekkoGrpcExt = sampleSetup() - and: - project.dependencies { - implementation "com.google.errorprone:error_prone_annotations:2.3.4" - } - when: - project.evaluate() - then: 'plugin is applied' - pekkoGrpcExt.scala - } - - def "should disable compileJava if no java source files found"() { - given: - sampleSetup() - generateBuildScripts() - createLog() - when: - project.evaluate() - BuildResult result = executeGradleTask("compileJava") - then: "compileJava is enabled, but task was skipped" - project.tasks.getByName("compileJava").enabled - result.task(":compileJava").outcome == SKIPPED - } - - def "should enable compileJava if java source files found"() { - given: - sampleSetup() - generateBuildScripts() - createLog() - when: - def javaDir = projectDir.newFolder('src', 'main', 'java') - new File(javaDir, "Empty.java").text = "final class Empty {}" - and: - BuildResult result = executeGradleTask("compileJava") - then: "compileJava is success" - result.task(":compileJava").outcome == SUCCESS - } - - def "should enable compileJava if project has only generated java source files"() { - given: - sampleSetup("kotlin") - when: - def kotlinDir = projectDir.newFolder('src', 'main', 'kotlin') - new File(kotlinDir, "Empty.kt").text = "object Empty {}" - and: - project.evaluate() - then: "compileJava is enabled" - project.tasks.getByName("compileJava").enabled - } - - def "should allow implicit declarations of scala-library version"() { - given: - project.pluginManager.apply PLUGIN_CODE - project.dependencies { - constraints { - implementation "org.scala-lang:scala-library:2.13.1" - } - implementation "org.scala-lang:scala-library" - } - when: - project.evaluate() - then: - project.extensions.getByType(PekkoGrpcPluginExtension) - } - - def "should fail if scala-version implicitly declared and mismatches with other scala-library version"() { - given: - project.pluginManager.apply PLUGIN_CODE - project.dependencies { - constraints { - implementation "org.scala-lang:scala-library:2.12.0" - } - implementation "com.typesafe.scala-logging:scala-logging_2.13:3.9.2" - } - when: - project.evaluate() - then: - def ex = thrown(ProjectConfigurationException) - ex.cause.message.startsWith "$PLUGIN_CODE requires a single major.minor version of `org.scala-lang:scala-library` in compileClasspath." - ex.cause.message.endsWith "Found [2.12, 2.13]" - } -} diff --git a/gradle-plugin/src/test/groovy/unit/DependenciesSpec.groovy b/gradle-plugin/src/test/groovy/unit/DependenciesSpec.groovy deleted file mode 100644 index cad726d9..00000000 --- a/gradle-plugin/src/test/groovy/unit/DependenciesSpec.groovy +++ /dev/null @@ -1,103 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * license agreements; and to You under the Apache License, version 2.0: - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * This file is part of the Apache Pekko project, which was derived from Akka. - */ - -package unit - -import org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension -import helper.BaseSpec -import org.gradle.api.Project -import org.gradle.api.artifacts.Dependency -import org.gradle.testfixtures.ProjectBuilder -import spock.lang.Unroll - -import static org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension.GRPC_VERSION -import static org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension.PROTOC_PLUGIN_SCALA_VERSION - -class DependenciesSpec extends BaseSpec { - - static final String PROTOC_PLUGIN_CODEGEN = "pekkoGrpc" - - def checkCodegen(Dependency d, PekkoGrpcPluginExtension ext) { - assert d.group == "org.apache.pekko" - assert d.name == "pekko-grpc-codegen_${PROTOC_PLUGIN_SCALA_VERSION}" - assert d.version == ext.pluginVersion - true - } - - static final String PROTOC_PLUGIN_SCALAPB = "scalapb" - - def checkScalapb(Dependency d, PekkoGrpcPluginExtension ext) { - assert d.group == "org.apache.pekko" - assert d.name == "pekko-grpc-scalapb-protoc-plugin_${PROTOC_PLUGIN_SCALA_VERSION}" - assert d.version == ext.pluginVersion - true - } - - Project project - - def setup() { - createBuildFolder() - project = ProjectBuilder.builder().withProjectDir(projectDir.root).build() - } - - def "should add only protoc codegen plugin for java"() { - given: - def pekkoGrpcExt = sampleSetup('java') - when: - project.evaluate() - then: - Map<String, Dependency> plugins = project.protobuf.tools.plugins.collectEntries { [(it.name): project.dependencies.create(it.artifact)] } - plugins.keySet().sort() == [PROTOC_PLUGIN_CODEGEN] - and: - checkCodegen(plugins[(PROTOC_PLUGIN_CODEGEN)], pekkoGrpcExt) - and: - def cfg = project.configurations.getByName("protobufToolsLocator_$PROTOC_PLUGIN_CODEGEN") - cfg.dependencies.size() == 1 - checkCodegen(cfg.dependencies.first(), pekkoGrpcExt) - } - - def "should add protoc codegen and scalapb plugins for scala"() { - given: - def pekkoGrpcExt = sampleSetup('scala') - when: - project.evaluate() - then: - Map<String, Dependency> plugins = project.protobuf.tools.plugins.collectEntries { [(it.name): project.dependencies.create(it.artifact)] } - plugins.keySet().sort() == [PROTOC_PLUGIN_CODEGEN, PROTOC_PLUGIN_SCALAPB] - and: - checkCodegen(plugins[(PROTOC_PLUGIN_CODEGEN)], pekkoGrpcExt) - checkScalapb(plugins[(PROTOC_PLUGIN_SCALAPB)], pekkoGrpcExt) - and: - def cfg = project.configurations.getByName("protobufToolsLocator_$PROTOC_PLUGIN_CODEGEN") - cfg.dependencies.size() == 1 - checkCodegen(cfg.dependencies.first(), pekkoGrpcExt) - and: - def cfg2 = project.configurations.getByName("protobufToolsLocator_$PROTOC_PLUGIN_SCALAPB") - cfg2.dependencies.size() == 1 - checkScalapb(cfg2.dependencies.first(), pekkoGrpcExt) - } - - @Unroll - def "should autodetected scala version for pekko-grpc-runtime #plugin #scala"() { - given: - def pekkoGrpcExt = sampleSetup(plugin, scala) - when: - project.evaluate() - then: "added to configuration" - def deps = project.configurations.implementation.dependencies - deps.any { it.name == "pekko-grpc-runtime_$scala" && it.version == pekkoGrpcExt.pluginVersion } - deps.any { it.name == "grpc-stub" && it.version == GRPC_VERSION } - where: - plugin || scala - "java" | "2.12" - "java" | "2.13" - "scala" | "2.12" - "scala" | "2.13" - } -} diff --git a/gradle-plugin/src/test/java/func/GradleCompatibilitySpecTest.java b/gradle-plugin/src/test/java/func/GradleCompatibilitySpecTest.java new file mode 100644 index 00000000..b7c79663 --- /dev/null +++ b/gradle-plugin/src/test/java/func/GradleCompatibilitySpecTest.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * license agreements; and to You under the Apache License, version 2.0: + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * This file is part of the Apache Pekko project, which was derived from Akka. + */ + +package func; + +import java.io.IOException; +import java.util.stream.Stream; + +import helper.BaseSpec; +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.gradle.testkit.runner.TaskOutcome; +import org.gradle.util.GradleVersion; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; + +class GradleCompatibilitySpecTest extends BaseSpec { + + @AfterEach + void tearDown() { + cleanup(); + } + + private BuildResult executeGradleTaskWithVersion(String task, String gradleVersion, boolean shouldFail) { + GradleRunner runner = GradleRunner.create().forwardOutput() + .withProjectDir(projectDir) + .withArguments(gradleArguments(task)) + .withPluginClasspath() + .withDebug(true) + .withGradleVersion(gradleVersion); + + return runGradle(runner, shouldFail); + } + + static Stream<Arguments> successVersions() { + return Stream.of( + Arguments.of("5.6"), + Arguments.of("5.6.4"), + Arguments.of("7.6.4")); + } + + @ParameterizedTest(name = "should succeed for version {0} greater than 5.6") + @MethodSource("successVersions") + void shouldSucceedForVersionGreaterThanOrEqualTo56(String gradleVersion) throws IOException { + assumeGradleVersionCanRunOnCurrentJava(gradleVersion); + + createBuildFolder(); + generateBuildScripts(); + + BuildResult result = executeGradleTaskWithVersion("tasks", gradleVersion, false); + + assertEquals(TaskOutcome.SUCCESS, result.task(":tasks").getOutcome()); + } + + static Stream<Arguments> failVersions() { + return Stream.of( + Arguments.of("5.5"), + Arguments.of("4.0")); + } + + @ParameterizedTest(name = "should fail for version {0} less than 5.6") + @MethodSource("failVersions") + void shouldFailForVersionLessThan56(String gradleVersion) throws IOException { + assumeGradleVersionCanRunOnCurrentJava(gradleVersion); + + createBuildFolder(); + generateBuildScripts(); + + BuildResult result = executeGradleTaskWithVersion("tasks", gradleVersion, true); + + assertTrue(result.getOutput().contains( + "Gradle version is " + gradleVersion + ". Minimum supported version is 5.6")); + } + + private static void assumeGradleVersionCanRunOnCurrentJava(String gradleVersion) { + Assumptions.assumeFalse( + Runtime.version().feature() >= 17 && + GradleVersion.version(gradleVersion).compareTo(GradleVersion.version("7.3")) < 0 && + !GradleVersion.version(gradleVersion).equals(GradleVersion.version("4.0")), + "Gradle " + gradleVersion + " cannot run on Java " + Runtime.version().feature()); + } +} diff --git a/gradle-plugin/src/test/java/helper/BaseSpec.java b/gradle-plugin/src/test/java/helper/BaseSpec.java new file mode 100644 index 00000000..248d4b42 --- /dev/null +++ b/gradle-plugin/src/test/java/helper/BaseSpec.java @@ -0,0 +1,158 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * license agreements; and to You under the Apache License, version 2.0: + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * This file is part of the Apache Pekko project, which was derived from Akka. + */ + +package helper; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.List; + +import org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension; +import org.gradle.api.Project; +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; + +public abstract class BaseSpec { + + public static final String PLUGIN_CODE = "org.apache.pekko.grpc.gradle"; + + protected File projectDir; + protected File srcDir; + protected File buildDir; + protected File buildFile; + + protected File ensureProjectDir() throws IOException { + if (projectDir == null) { + projectDir = Files.createTempDirectory("pekko-grpc-test-").toFile(); + } + return projectDir; + } + + protected void cleanup() { + if (projectDir != null && projectDir.exists()) { + deleteRecursively(projectDir); + } + } + + protected void createBuildFolder() throws IOException { + ensureProjectDir(); + srcDir = Files.createDirectories(projectDir.toPath().resolve("src/main/proto")).toFile(); + buildDir = Files.createDirectories(projectDir.toPath().resolve("build")).toFile(); + } + + protected void generateBuildScripts() throws IOException { + ensureProjectDir(); + buildFile = new File(projectDir, "build.gradle"); + Files.writeString(buildFile.toPath(), + "plugins {\n" + + " id '" + PLUGIN_CODE + "'\n" + + "}\n" + + "repositories {\n" + + " mavenLocal()\n" + + "}\n" + + "project.dependencies {\n" + + " implementation \"com.typesafe.scala-logging:scala-logging_2.13:3.9.2\"\n" + + "}\n"); + } + + protected List<String> gradleArguments(String task) { + List<String> arguments = new ArrayList<>(); + arguments.add("--stacktrace"); + String baselineVersion = baselineVersion(); + if (baselineVersion != null) { + arguments.add("-Dpekko.grpc.baseline.version=" + baselineVersion); + } + arguments.add(task); + return arguments; + } + + protected BuildResult runGradle(GradleRunner runner) { + return runGradle(runner, false); + } + + protected BuildResult runGradle(GradleRunner runner, boolean shouldFail) { + String previousBaselineVersion = System.getProperty("pekko.grpc.baseline.version"); + try { + if (shouldFail) { + return runner.buildAndFail(); + } else { + return runner.build(); + } + } finally { + restoreSystemProperty("pekko.grpc.baseline.version", previousBaselineVersion); + } + } + + private void restoreSystemProperty(String key, String value) { + if (value == null) { + System.clearProperty(key); + } else { + System.setProperty(key, value); + } + } + + private String baselineVersion() { + String configuredBaselineVersion = System.getProperty("pekkoGrpcTest.baselineVersion"); + if (configuredBaselineVersion != null) { + return configuredBaselineVersion; + } + + String pluginVersion = System.getProperty("pekkoGrpcTest.pluginVersion"); + if (pluginVersion == null) { + return null; + } + + return pluginVersion.replaceFirst("-\\d{8}-\\d{4}-SNAPSHOT$", "-SNAPSHOT"); + } + + protected PekkoGrpcPluginExtension sampleSetup(Project project) throws IOException { + return sampleSetup(project, "scala", "2.12"); + } + + protected PekkoGrpcPluginExtension sampleSetup(Project project, String plugin) throws IOException { + return sampleSetup(project, plugin, "2.12"); + } + + protected PekkoGrpcPluginExtension sampleSetup(Project project, String plugin, String scala) throws IOException { + ensureProjectDir(); + if ("scala".equals(plugin)) { + File scalaDir = Files.createDirectories(projectDir.toPath().resolve("src/main/scala")).toFile(); + Files.writeString(new File(scalaDir, "test.scala").toPath(), "object PekkoGrpc"); + } + project.getPluginManager().apply(PLUGIN_CODE); + project.getDependencies().add("implementation", + "com.typesafe.scala-logging:scala-logging_" + scala + ":3.9.2"); + return project.getExtensions().getByType(PekkoGrpcPluginExtension.class); + } + + protected PekkoGrpcPluginExtension sampleSetupWithPlugin(Project project, Class<?> pluginClass, String scala) + throws IOException { + ensureProjectDir(); + File scalaDir = Files.createDirectories(projectDir.toPath().resolve("src/main/scala")).toFile(); + Files.writeString(new File(scalaDir, "test.scala").toPath(), "object PekkoGrpc"); + project.getPluginManager().apply(PLUGIN_CODE); + project.getDependencies().add("implementation", + "com.typesafe.scala-logging:scala-logging_" + scala + ":3.9.2"); + return project.getExtensions().getByType(PekkoGrpcPluginExtension.class); + } + + private static void deleteRecursively(File file) { + if (file.isDirectory()) { + File[] children = file.listFiles(); + if (children != null) { + for (File child : children) { + deleteRecursively(child); + } + } + } + file.delete(); + } +} diff --git a/gradle-plugin/src/test/groovy/helper/ScalaWrapperPlugin.groovy b/gradle-plugin/src/test/java/helper/ScalaWrapperPlugin.java similarity index 51% rename from gradle-plugin/src/test/groovy/helper/ScalaWrapperPlugin.groovy rename to gradle-plugin/src/test/java/helper/ScalaWrapperPlugin.java index 58af1b40..22eed3e6 100644 --- a/gradle-plugin/src/test/groovy/helper/ScalaWrapperPlugin.groovy +++ b/gradle-plugin/src/test/java/helper/ScalaWrapperPlugin.java @@ -7,15 +7,15 @@ * This file is part of the Apache Pekko project, which was derived from Akka. */ -package helper +package helper; -import org.gradle.api.Plugin -import org.gradle.api.Project -import org.gradle.api.plugins.scala.ScalaPlugin +import org.gradle.api.Plugin; +import org.gradle.api.Project; +import org.gradle.api.plugins.scala.ScalaPlugin; -class ScalaWrapperPlugin implements Plugin<Project> { +public class ScalaWrapperPlugin implements Plugin<Project> { @Override - void apply(Project project) { - project.pluginManager.apply ScalaPlugin + public void apply(Project project) { + project.getPluginManager().apply(ScalaPlugin.class); } } diff --git a/gradle-plugin/src/test/java/unit/ApplySpecTest.java b/gradle-plugin/src/test/java/unit/ApplySpecTest.java new file mode 100644 index 00000000..e2669e71 --- /dev/null +++ b/gradle-plugin/src/test/java/unit/ApplySpecTest.java @@ -0,0 +1,196 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * license agreements; and to You under the Apache License, version 2.0: + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * This file is part of the Apache Pekko project, which was derived from Akka. + */ + +package unit; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.stream.Stream; + +import helper.BaseSpec; +import helper.ScalaWrapperPlugin; +import org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension; +import org.gradle.api.Project; +import org.gradle.api.ProjectConfigurationException; +import org.gradle.api.internal.project.ProjectInternal; +import org.gradle.testfixtures.ProjectBuilder; +import org.gradle.testkit.runner.BuildResult; +import org.gradle.testkit.runner.GradleRunner; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.gradle.testkit.runner.TaskOutcome.SKIPPED; +import static org.gradle.testkit.runner.TaskOutcome.SUCCESS; +import static org.junit.jupiter.api.Assertions.*; + +class ApplySpecTest extends BaseSpec { + + private Project project; + + private File log; + + @BeforeEach + void setUp() throws IOException { + createBuildFolder(); + project = ProjectBuilder.builder().withProjectDir(projectDir).build(); + } + + @AfterEach + void tearDown() { + cleanup(); + } + + private void createLog() throws IOException { + log = new File(buildDir, "pekko-grpcgradle-plugin.log"); + log.createNewFile(); + } + + private BuildResult executeGradleTask(String task) { + GradleRunner runner = GradleRunner.create().forwardOutput() + .withProjectDir(projectDir) + .withArguments(gradleArguments(task)) + .withPluginClasspath() + .withDebug(true); + return runGradle(runner); + } + + static Stream<Arguments> detectLanguageParams() { + return Stream.of( + Arguments.of("java", "2.12", false), + Arguments.of("java", "2.13", false), + Arguments.of("scala", "2.12", true), + Arguments.of("scala", "2.13", true), + Arguments.of(ScalaWrapperPlugin.class, "2.12", true), + Arguments.of(ScalaWrapperPlugin.class, "2.13", true)); + } + + @ParameterizedTest(name = "should detect language for {0}") + @MethodSource("detectLanguageParams") + void shouldDetectLanguage(Object plugin, String scala, boolean isScala) throws IOException { + PekkoGrpcPluginExtension pekkoGrpcExt; + if (plugin instanceof String) { + pekkoGrpcExt = sampleSetup(project, (String) plugin, scala); + } else { + pekkoGrpcExt = sampleSetupWithPlugin(project, (Class<?>) plugin, scala); + } + ((ProjectInternal) project).evaluate(); + + assertEquals(System.getProperty("pekkoGrpcTest.pluginVersion"), pekkoGrpcExt.getPluginVersion()); + assertEquals(isScala, pekkoGrpcExt.getScala()); + } + + @Test + void shouldFailIfNoScalaLibraryDeclared() { + project.getPluginManager().apply("scala"); + project.getPluginManager().apply(PLUGIN_CODE); + + ProjectConfigurationException ex = assertThrows(ProjectConfigurationException.class, + () -> ((ProjectInternal) project).evaluate()); + + assertTrue(ex.getCause().getMessage().startsWith( + PLUGIN_CODE + " requires a single major.minor version of `org.scala-lang:scala-library` in compileClasspath.")); + assertTrue(ex.getCause().getMessage().endsWith("Found []")); + } + + @Test + void shouldFailIfMultipleScalaLibraryDeclared() { + project.getPluginManager().apply(PLUGIN_CODE); + project.getDependencies().add("implementation", "org.mockito:mockito-scala_2.11:1.6.1"); + project.getDependencies().add("implementation", "org.mockito:mockito-scala_2.13:1.14.8"); + + ProjectConfigurationException ex = assertThrows(ProjectConfigurationException.class, + () -> ((ProjectInternal) project).evaluate()); + + assertTrue(ex.getCause().getMessage().startsWith( + PLUGIN_CODE + " requires a single major.minor version of `org.scala-lang:scala-library` in compileClasspath.")); + assertTrue(ex.getCause().getMessage().endsWith("Found [2.11, 2.13]")); + } + + @Test + void shouldNotFailScalaAutodetectIfDependenciesContainUnderscore() throws IOException { + PekkoGrpcPluginExtension pekkoGrpcExt = sampleSetup(project); + project.getDependencies().add("implementation", "com.google.errorprone:error_prone_annotations:2.3.4"); + + ((ProjectInternal) project).evaluate(); + + assertTrue(pekkoGrpcExt.getScala()); + } + + @Test + void shouldDisableCompileJavaIfNoJavaSourceFilesFound() throws IOException { + sampleSetup(project); + generateBuildScripts(); + createLog(); + + ((ProjectInternal) project).evaluate(); + BuildResult result = executeGradleTask("compileJava"); + + assertTrue(project.getTasks().getByName("compileJava").getEnabled()); + assertEquals(SKIPPED, result.task(":compileJava").getOutcome()); + } + + @Test + void shouldEnableCompileJavaIfJavaSourceFilesFound() throws IOException { + sampleSetup(project); + generateBuildScripts(); + createLog(); + + File javaDir = Files.createDirectories(projectDir.toPath().resolve("src/main/java")).toFile(); + Files.writeString(new File(javaDir, "Empty.java").toPath(), "final class Empty {}"); + + BuildResult result = executeGradleTask("compileJava"); + + assertEquals(SUCCESS, result.task(":compileJava").getOutcome()); + } + + @Test + void shouldEnableCompileJavaIfProjectHasOnlyGeneratedJavaSourceFiles() throws IOException { + sampleSetup(project, "kotlin"); + + File kotlinDir = Files.createDirectories(projectDir.toPath().resolve("src/main/kotlin")).toFile(); + Files.writeString(new File(kotlinDir, "Empty.kt").toPath(), "object Empty {}"); + + ((ProjectInternal) project).evaluate(); + + assertTrue(project.getTasks().getByName("compileJava").getEnabled()); + } + + @Test + void shouldAllowImplicitDeclarationsOfScalaLibraryVersion() { + project.getPluginManager().apply(PLUGIN_CODE); + project.getDependencies().getConstraints().add("implementation", + "org.scala-lang:scala-library:2.13.1"); + project.getDependencies().add("implementation", "org.scala-lang:scala-library"); + + ((ProjectInternal) project).evaluate(); + + assertNotNull(project.getExtensions().getByType(PekkoGrpcPluginExtension.class)); + } + + @Test + void shouldFailIfScalaVersionImplicitlyDeclaredAndMismatches() { + project.getPluginManager().apply(PLUGIN_CODE); + project.getDependencies().getConstraints().add("implementation", + "org.scala-lang:scala-library:2.12.0"); + project.getDependencies().add("implementation", + "com.typesafe.scala-logging:scala-logging_2.13:3.9.2"); + + ProjectConfigurationException ex = assertThrows(ProjectConfigurationException.class, + () -> ((ProjectInternal) project).evaluate()); + + assertTrue(ex.getCause().getMessage().startsWith( + PLUGIN_CODE + " requires a single major.minor version of `org.scala-lang:scala-library` in compileClasspath.")); + assertTrue(ex.getCause().getMessage().endsWith("Found [2.12, 2.13]")); + } +} diff --git a/gradle-plugin/src/test/java/unit/DependenciesSpecTest.java b/gradle-plugin/src/test/java/unit/DependenciesSpecTest.java new file mode 100644 index 00000000..3a390cad --- /dev/null +++ b/gradle-plugin/src/test/java/unit/DependenciesSpecTest.java @@ -0,0 +1,108 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * license agreements; and to You under the Apache License, version 2.0: + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * This file is part of the Apache Pekko project, which was derived from Akka. + */ + +package unit; + +import java.io.IOException; +import java.util.stream.Stream; + +import helper.BaseSpec; +import org.apache.pekko.grpc.gradle.PekkoGrpcPluginExtension; +import org.gradle.api.Project; +import org.gradle.api.artifacts.Dependency; +import org.gradle.api.internal.project.ProjectInternal; +import org.gradle.testfixtures.ProjectBuilder; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.*; + +class DependenciesSpecTest extends BaseSpec { + + static final String PROTOC_PLUGIN_CODEGEN = "pekkoGrpc"; + static final String PROTOC_PLUGIN_SCALAPB = "scalapb"; + static final String PROTOC_PLUGIN_SCALA_VERSION = "2.12"; + static final String GRPC_VERSION = "1.82.1"; + + private Project project; + + @BeforeEach + void setUp() throws IOException { + createBuildFolder(); + project = ProjectBuilder.builder().withProjectDir(projectDir).build(); + } + + @AfterEach + void tearDown() { + cleanup(); + } + + private void checkCodegen(Dependency d, PekkoGrpcPluginExtension ext) { + assertEquals("org.apache.pekko", d.getGroup()); + assertEquals("pekko-grpc-codegen_" + PROTOC_PLUGIN_SCALA_VERSION, d.getName()); + assertEquals(ext.getPluginVersion(), d.getVersion()); + } + + private void checkScalapb(Dependency d, PekkoGrpcPluginExtension ext) { + assertEquals("org.apache.pekko", d.getGroup()); + assertEquals("pekko-grpc-scalapb-protoc-plugin_" + PROTOC_PLUGIN_SCALA_VERSION, d.getName()); + assertEquals(ext.getPluginVersion(), d.getVersion()); + } + + @Test + void shouldAddOnlyProtocCodegenPluginForJava() throws IOException { + PekkoGrpcPluginExtension pekkoGrpcExt = sampleSetup(project, "java"); + ((ProjectInternal) project).evaluate(); + + var cfg = project.getConfigurations().getByName("protobufToolsLocator_" + PROTOC_PLUGIN_CODEGEN); + assertEquals(1, cfg.getDependencies().size()); + checkCodegen(cfg.getDependencies().iterator().next(), pekkoGrpcExt); + } + + @Test + void shouldAddProtocCodegenAndScalapbPluginsForScala() throws IOException { + PekkoGrpcPluginExtension pekkoGrpcExt = sampleSetup(project, "scala"); + ((ProjectInternal) project).evaluate(); + + var cfg = project.getConfigurations().getByName("protobufToolsLocator_" + PROTOC_PLUGIN_CODEGEN); + assertEquals(1, cfg.getDependencies().size()); + checkCodegen(cfg.getDependencies().iterator().next(), pekkoGrpcExt); + + var cfg2 = project.getConfigurations().getByName("protobufToolsLocator_" + PROTOC_PLUGIN_SCALAPB); + assertEquals(1, cfg2.getDependencies().size()); + checkScalapb(cfg2.getDependencies().iterator().next(), pekkoGrpcExt); + } + + static Stream<Arguments> autodetectScalaParams() { + return Stream.of( + Arguments.of("java", "2.12"), + Arguments.of("java", "2.13"), + Arguments.of("scala", "2.12"), + Arguments.of("scala", "2.13")); + } + + @ParameterizedTest(name = "should autodetect scala version for pekko-grpc-runtime {0} {1}") + @MethodSource("autodetectScalaParams") + void shouldAutodetectScalaVersionForPekkoGrpcRuntime(String plugin, String scala) throws IOException { + PekkoGrpcPluginExtension pekkoGrpcExt = sampleSetup(project, plugin, scala); + ((ProjectInternal) project).evaluate(); + + var deps = project.getConfigurations().getByName("implementation").getDependencies(); + assertTrue(deps.stream().anyMatch(d -> + ("pekko-grpc-runtime_" + scala).equals(d.getName()) + && pekkoGrpcExt.getPluginVersion().equals(d.getVersion()))); + assertTrue(deps.stream().anyMatch(d -> + "grpc-stub".equals(d.getName()) + && GRPC_VERSION.equals(d.getVersion()))); + } +} diff --git a/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelNativeTest.java b/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelNativeTest.java index 29cb4b59..4f02c5c4 100644 --- a/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelNativeTest.java +++ b/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelNativeTest.java @@ -13,7 +13,8 @@ package example.myapp.helloworld.grpc; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; import com.google.rpc.error_details.LocalizedMessage; import com.typesafe.config.Config; @@ -29,11 +30,9 @@ import org.apache.pekko.http.javadsl.Http; import org.apache.pekko.http.javadsl.ServerBinding; import org.apache.pekko.http.javadsl.model.HttpRequest; import org.apache.pekko.http.javadsl.model.HttpResponse; -import org.junit.Assert; -import org.junit.Test; -import org.scalatestplus.junit.JUnitSuite; +import org.junit.jupiter.api.Test; -public class RichErrorModelNativeTest extends JUnitSuite { +public class RichErrorModelNativeTest { private ServerBinding run(ActorSystem sys) throws Exception { @@ -94,7 +93,7 @@ public class RichErrorModelNativeTest extends JUnitSuite { } catch (Exception e) { e.printStackTrace(); - Assert.fail("Got unexpected error " + e.getMessage()); + fail("Got unexpected error " + e.getMessage()); } finally { if (client != null) client.close(); sys.terminate(); diff --git a/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelTest.java b/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelTest.java index c5a15279..43222f29 100644 --- a/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelTest.java +++ b/interop-tests/src/test/java/example/myapp/helloworld/grpc/RichErrorModelTest.java @@ -13,7 +13,8 @@ package example.myapp.helloworld.grpc; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; import com.typesafe.config.Config; import com.typesafe.config.ConfigFactory; @@ -29,11 +30,9 @@ import org.apache.pekko.http.javadsl.Http; import org.apache.pekko.http.javadsl.ServerBinding; import org.apache.pekko.http.javadsl.model.HttpRequest; import org.apache.pekko.http.javadsl.model.HttpResponse; -import org.junit.Assert; -import org.junit.Test; -import org.scalatestplus.junit.JUnitSuite; +import org.junit.jupiter.api.Test; -public class RichErrorModelTest extends JUnitSuite { +public class RichErrorModelTest { private com.google.protobuf.any.Any fromJavaProto(com.google.protobuf.Any javaPbSource) { return com.google.protobuf.any.Any.of(javaPbSource.getTypeUrl(), javaPbSource.getValue()); @@ -84,7 +83,7 @@ public class RichErrorModelTest extends JUnitSuite { // #client_request } catch (Exception e) { - Assert.fail("Got unexpected error " + e.getMessage()); + fail("Got unexpected error " + e.getMessage()); } finally { if (client != null) client.close(); sys.terminate(); diff --git a/interop-tests/src/test/java/org/apache/pekko/grpc/interop/PekkoGrpcJavaClientTester.java b/interop-tests/src/test/java/org/apache/pekko/grpc/interop/PekkoGrpcJavaClientTester.java index 3dc24f36..168e688d 100644 --- a/interop-tests/src/test/java/org/apache/pekko/grpc/interop/PekkoGrpcJavaClientTester.java +++ b/interop-tests/src/test/java/org/apache/pekko/grpc/interop/PekkoGrpcJavaClientTester.java @@ -13,8 +13,8 @@ package org.apache.pekko.grpc.interop; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; import com.google.protobuf.ByteString; import io.grpc.Status; @@ -49,7 +49,6 @@ import org.apache.pekko.stream.SystemMaterializer; import org.apache.pekko.stream.javadsl.Keep; import org.apache.pekko.stream.javadsl.Sink; import org.apache.pekko.stream.javadsl.Source; -import org.junit.Assert; import scala.concurrent.ExecutionContext; /** @@ -119,7 +118,7 @@ public class PekkoGrpcJavaClientTester implements ClientTester { @Override public void emptyUnary() throws Exception { - Assert.assertEquals( + assertEquals( EmptyProtos.Empty.newBuilder().build(), client.emptyCall(EmptyProtos.Empty.newBuilder().build()).toCompletableFuture().get()); } @@ -430,9 +429,9 @@ public class PekkoGrpcJavaClientTester implements ClientTester { Metadata fullDuplexTrailer = fullDuplexMetadata.getTrailers().toCompletableFuture().get(); assertEquals( - "Trailer should contain binary header [" + fullDuplexTrailer + "]", Optional.of(binaryValue), - fullDuplexTrailer.getBinary("x-grpc-test-echo-trailing-bin")); + fullDuplexTrailer.getBinary("x-grpc-test-echo-trailing-bin"), + "Trailer should contain binary header [" + fullDuplexTrailer + "]"); } @Override diff --git a/interop-tests/src/test/scala/org/apache/pekko/grpc/interop/PekkoGrpcScalaClientTester.scala b/interop-tests/src/test/scala/org/apache/pekko/grpc/interop/PekkoGrpcScalaClientTester.scala index cf30d81b..eec3891d 100644 --- a/interop-tests/src/test/scala/org/apache/pekko/grpc/interop/PekkoGrpcScalaClientTester.scala +++ b/interop-tests/src/test/scala/org/apache/pekko/grpc/interop/PekkoGrpcScalaClientTester.scala @@ -24,7 +24,7 @@ import io.grpc.testing.integration.messages._ import io.grpc.testing.integration.test.{ TestServiceClient, UnimplementedServiceClient } import io.grpc.testing.integration2.{ ClientTester, Settings } import io.grpc.{ Status, StatusRuntimeException } -import org.junit.Assert._ +import org.junit.jupiter.api.Assertions._ import org.scalatest.matchers.should.Matchers._ import java.io.InputStream @@ -241,9 +241,9 @@ class PekkoGrpcScalaClientTester(val settings: Settings, backend: String, testWi val trailers = Await.result(fullDuplexMetadata.trailers, awaitTimeout) assertEquals( - s"Trailer should contain binary header [$trailers]", Some(binaryHeaderValue), - trailers.getBinary("x-grpc-test-echo-trailing-bin")) + trailers.getBinary("x-grpc-test-echo-trailing-bin"), + s"Trailer should contain binary header [$trailers]") } def statusCodeAndMessage(): Unit = { diff --git a/plugin-tester-java/build.gradle b/plugin-tester-java/build.gradle index dee02e36..666b9cc9 100644 --- a/plugin-tester-java/build.gradle +++ b/plugin-tester-java/build.gradle @@ -36,7 +36,7 @@ dependencies { implementation "org.apache.pekko:pekko-actor-typed_${scalaBinaryVersion}:${pekkoVersion}" implementation "org.scala-lang:scala-library:${scalaFullVersion}" testImplementation "org.scalatest:scalatest_${scalaBinaryVersion}:3.2.20" - testImplementation "org.scalatestplus:junit-4-13_${scalaBinaryVersion}:3.2.20.0" + testImplementation "org.junit.jupiter:junit-jupiter:6.1.0" } tasks.withType(Copy).configureEach { diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 5364ae9b..b39fb43c 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -12,6 +12,7 @@ package org.apache.pekko.grpc import sbt._ import sbt.Keys._ import buildinfo.BuildInfo +import com.github.sbt.junit.jupiter.sbt.Import.JupiterKeys object Dependencies { object Versions { @@ -77,6 +78,15 @@ object Dependencies { val scalaTestPlusJunit = "org.scalatestplus" %% "junit-4-13" % (Versions.scalaTest + ".0") % Test } + // JUnit Jupiter dependencies - versions derived from the sbt-jupiter-interface plugin settings + lazy val junitJupiterTestDeps: Def.Initialize[Seq[ModuleID]] = Def.setting { + Seq( + "com.github.sbt.junit" % "jupiter-interface" % JupiterKeys.jupiterVersion.value % sbt.Test, + "org.junit.jupiter" % "junit-jupiter-api" % JupiterKeys.junitJupiterVersion.value % sbt.Test, + "org.junit.jupiter" % "junit-jupiter-engine" % JupiterKeys.junitJupiterVersion.value % sbt.Test, + "org.junit.platform" % "junit-platform-launcher" % JupiterKeys.junitPlatformVersion.value % sbt.Test) + } + object Runtime { val logback = "ch.qos.logback" % "logback-classic" % "1.5.37" % "runtime" } @@ -106,8 +116,7 @@ object Dependencies { Compile.grpcCore, Compile.grpcStub % Provided, // comes from the generators Compile.grpcNettyShaded, - Test.scalaTest, - Test.scalaTestPlusJunit) + Test.scalaTest) ++ junitJupiterTestDeps.value lazy val mavenPlugin = l ++= Seq( Compile.slf4jApi, @@ -127,8 +136,13 @@ object Dependencies { Compile.grpcInteropTesting, Compile.grpcInteropTesting % "protobuf", // gets the proto files for interop tests Runtime.logback, - Test.scalaTest.withConfigurations(Some("compile")), - Test.scalaTestPlusJunit.withConfigurations(Some("compile"))) + Test.scalaTest.withConfigurations(Some("compile"))) ++ Def.setting { + Seq( + "com.github.sbt.junit" % "jupiter-interface" % JupiterKeys.jupiterVersion.value % "compile", + "org.junit.jupiter" % "junit-jupiter-api" % JupiterKeys.junitJupiterVersion.value % "compile", + "org.junit.jupiter" % "junit-jupiter-engine" % JupiterKeys.junitJupiterVersion.value % "compile", + "org.junit.platform" % "junit-platform-launcher" % JupiterKeys.junitPlatformVersion.value % "compile") + }.value lazy val pluginTester = l ++= Seq( // usually automatically added by `suggestedDependencies`, which doesn't work with ReflectiveCodeGen @@ -136,5 +150,5 @@ object Dependencies { Runtime.logback, Test.scalaTest, Test.scalaTestPlusJunit, - Protobuf.googleCommonProtos) + Protobuf.googleCommonProtos) ++ junitJupiterTestDeps.value } diff --git a/project/plugins.sbt b/project/plugins.sbt index df1e6264..1b5cb39b 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -26,6 +26,7 @@ addSbtPlugin("net.bzzt" % "sbt-reproducible-builds" % "0.32") addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.8") addSbtPlugin("com.github.sbt" % "sbt-dynver" % "5.1.1") addSbtPlugin("com.github.pjfanning" % "sbt-pekko-build" % "0.4.7") +addSbtPlugin("com.github.sbt.junit" % "sbt-jupiter-interface" % "0.19.0") addSbtPlugin("com.github.pjfanning" % "sbt-source-dist" % "0.1.13") addSbtPlugin("com.github.sbt" % "sbt-license-report" % "1.9.0") diff --git a/runtime/src/test/java/org/apache/pekko/grpc/javadsl/ConcatOrNotFoundTest.java b/runtime/src/test/java/org/apache/pekko/grpc/javadsl/ConcatOrNotFoundTest.java index e3598ba2..91dc96a8 100644 --- a/runtime/src/test/java/org/apache/pekko/grpc/javadsl/ConcatOrNotFoundTest.java +++ b/runtime/src/test/java/org/apache/pekko/grpc/javadsl/ConcatOrNotFoundTest.java @@ -13,7 +13,7 @@ package org.apache.pekko.grpc.javadsl; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; @@ -21,10 +21,9 @@ import java.util.concurrent.TimeUnit; import org.apache.pekko.grpc.internal.GrpcProtocolNative; import org.apache.pekko.http.javadsl.model.*; import org.apache.pekko.util.ByteString; -import org.junit.Test; -import org.scalatestplus.junit.JUnitSuite; +import org.junit.jupiter.api.Test; -public class ConcatOrNotFoundTest extends JUnitSuite { +public class ConcatOrNotFoundTest { private final HttpRequest emptyGrpcRequest = HttpRequest.create() diff --git a/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/build.sbt b/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/build.sbt index 69c842ab..54253913 100644 --- a/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/build.sbt +++ b/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/build.sbt @@ -16,7 +16,8 @@ val grpcVersion = "1.82.1" // checked synced by VersionSyncCheckPlugin libraryDependencies ++= Seq( "io.grpc" % "grpc-interop-testing" % grpcVersion % "protobuf-src", "org.apache.pekko" %% "pekko-grpc-interop-tests" % sys.props("project.version") % "test", - "org.scalatest" %% "scalatest" % "3.2.20" % Test) + "org.scalatest" %% "scalatest" % "3.2.20" % Test, + "org.junit.jupiter" % "junit-jupiter-api" % "6.1.0" % Test) scalacOptions ++= List("-unchecked", "-deprecation", "-language:_", "-encoding", "UTF-8") diff --git a/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/src/test/scala/org/apache/pekko/grpc/PekkoGrpcClientTester.scala b/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/src/test/scala/org/apache/pekko/grpc/PekkoGrpcClientTester.scala index 5f459e6c..0f2552f2 100644 --- a/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/src/test/scala/org/apache/pekko/grpc/PekkoGrpcClientTester.scala +++ b/sbt-plugin/src/sbt-test/gen-scala-server/00-interop/src/test/scala/org/apache/pekko/grpc/PekkoGrpcClientTester.scala @@ -28,7 +28,7 @@ import io.grpc.testing.integration.messages.{ import io.grpc.testing.integration.empty.Empty import io.grpc.testing.integration2.{ ChannelBuilder, ClientTester, Settings } import io.grpc.{ ManagedChannel, Status, StatusRuntimeException } -import org.junit.Assert._ +import org.junit.jupiter.api.Assertions._ import scala.concurrent.duration._ import scala.concurrent.{ Await, ExecutionContext, Future } @@ -272,9 +272,9 @@ class PekkoGrpcClientTester(val settings: Settings)(implicit system: ActorSystem val trailers = Await.result(fullDuplexMetadata.trailers, awaitTimeout) assertEquals( - s"Trailer should contain binary header [$trailers]", Some(binaryHeaderValue), - trailers.getBinary("x-grpc-test-echo-trailing-bin")) + trailers.getBinary("x-grpc-test-echo-trailing-bin"), + s"Trailer should contain binary header [$trailers]") } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
