Migrate from JUnit 4 to JUnit 5

build.sbt

@@ -188,15 +188,47 @@ lazy val PlayJpaProject = PlayCrossBuiltProject("Play-Java-JPA", "persistence/pl
 
 lazy val PlayTestProject = PlayCrossBuiltProject("Play-Test", "testkit/play-test")
   .settings(
-    libraryDependencies ++= testDependencies ++ Seq(h2database % "test"),
+    libraryDependencies ++= testDependencies ++ Seq(h2database % Test),
     (Test / parallelExecution) := false
   )
   .dependsOn(
     PlayGuiceProject,
     PlayServerProject,
     // We still need a server provider when running Play-Test tests.
     // Since Akka HTTP is the default, we should use it here.
-    PlayAkkaHttpServerProject % "test"
+    PlayAkkaHttpServerProject % Test
+  )
+
+lazy val PlayTestJUnit4Project = PlayCrossBuiltProject("Play-Test-JUnit4", "testkit/play-test-junit4")
+  .settings(
+    mimaPreviousArtifacts := Set.empty,
+    mimaFailOnNoPrevious  := false,
+    libraryDependencies ++= Seq(junit4, junit4Interface),
+    (Test / parallelExecution) := false
+  )
+  .dependsOn(
+    PlayGuiceProject,
+    PlayServerProject,
+    // We still need a server provider when running Play-Test tests.
+    // Since Akka HTTP is the default, we should use it here.
+    PlayAkkaHttpServerProject % Test,
+    PlayTestProject
+  )
+
+lazy val PlayTestJUnit5Project = PlayCrossBuiltProject("Play-Test-JUnit5", "testkit/play-test-junit5")
+  .settings(
+    libraryDependencies ++= Seq(junit5, junit5Interface),
+    mimaPreviousArtifacts      := Set.empty,
+    mimaFailOnNoPrevious       := false,
+    (Test / parallelExecution) := false,
+  )
+  .dependsOn(
+    PlayGuiceProject,
+    PlayServerProject,
+    // We still need a server provider when running Play-Test tests.
+    // Since Akka HTTP is the default, we should use it here.
+    PlayAkkaHttpServerProject % Test,
+    PlayTestProject
   )
 
 lazy val PlaySpecs2Project = PlayCrossBuiltProject("Play-Specs2", "testkit/play-specs2")
@@ -471,6 +503,8 @@ lazy val userProjects = Seq[ProjectReference](
   PlayOpenIdProject,
   PlaySpecs2Project,
   PlayTestProject,
+  PlayTestJUnit4Project,
+  PlayTestJUnit5Project,
   PlayExceptionsProject,
   PlayFiltersHelpersProject,
   StreamsProject,

cache/play-caffeine-cache/src/test/java/play/cache/caffeine/NamedCaffeineCacheSpec.java

@@ -4,23 +4,23 @@
 
 package play.cache.caffeine;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.github.benmanes.caffeine.cache.Caffeine;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 
-public class NamedCaffeineCacheSpec {
+class NamedCaffeineCacheSpec {
 
   private NamedCaffeineCache<String, String> cache =
       new NamedCaffeineCache<>("testNamedCaffeineCache", Caffeine.newBuilder().buildAsync());
 
   @Test
-  public void getAll_shouldReturnAllValuesWithTheGivenKeys() throws Exception {
+  void getAll_shouldReturnAllValuesWithTheGivenKeys() throws Exception {
     String key1 = "key1";
     String value1 = "value1";
     String key2 = "key2";
@@ -37,11 +37,11 @@ public void getAll_shouldReturnAllValuesWithTheGivenKeys() throws Exception {
     expectedMap.put(key1, value1);
     expectedMap.put(key2, value2);
 
-    assertThat(resultMap, equalTo(expectedMap));
+    assertEquals(expectedMap, resultMap);
   }
 
   @Test
-  public void getAll_shouldCreateTheMissingValuesAndReturnAllWithTheGivenKeys() throws Exception {
+  void getAll_shouldCreateTheMissingValuesAndReturnAllWithTheGivenKeys() throws Exception {
     String key1 = "key1";
     String value1 = "value1";
     String key2 = "key2";
@@ -59,11 +59,11 @@ public void getAll_shouldCreateTheMissingValuesAndReturnAllWithTheGivenKeys() th
     expectedMap.put(key1, value1);
     expectedMap.put(key2, value2);
 
-    assertThat(resultMap, equalTo(expectedMap));
+    assertEquals(expectedMap, resultMap);
   }
 
   @Test
-  public void getAll_shouldNotReplaceAlreadyExistingValues() throws Exception {
+  void getAll_shouldNotReplaceAlreadyExistingValues() throws Exception {
     String key1 = "key1";
     String value1 = "value1";
     String key2 = "key2";
@@ -82,18 +82,18 @@ public void getAll_shouldNotReplaceAlreadyExistingValues() throws Exception {
     expectedMap.put(key1, value1);
     expectedMap.put(key2, value2);
 
-    assertThat(resultMap, equalTo(expectedMap));
+    assertEquals(expectedMap, resultMap);
   }
 
   @Test()
-  public void getAll_shouldReturnFailedFutureIfMappingFunctionIsCompletedExceptionally()
-      throws Exception {
+  void getAll_shouldReturnFailedFutureIfMappingFunctionIsCompletedExceptionally() {
     LoggerFactory.getLogger(NamedCaffeineCache.class);
     RuntimeException testException = new RuntimeException("test exception");
     CompletableFuture<Map<String, String>> future = new CompletableFuture<>();
     future.completeExceptionally(testException);
     CompletableFuture<Map<String, String>> resultFuture =
-        cache.getAll(new HashSet<>(Arrays.asList("key1")), (missingKeys, executor) -> future);
-    assertThat(resultFuture.isCompletedExceptionally(), equalTo(true));
+        cache.getAll(new HashSet<>(List.of("key1")), (missingKeys, executor) -> future);
+
+    assertTrue(resultFuture.isCompletedExceptionally());
   }
 }

core/play-guice/src/test/java/play/inject/guice/GuiceApplicationBuilderTest.java

@@ -4,10 +4,7 @@
 
 package play.inject.guice;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 import static play.inject.Bindings.bind;
 
 import com.google.common.collect.ImmutableList;
@@ -17,28 +14,28 @@
 import com.typesafe.config.ConfigFactory;
 import javax.inject.Inject;
 import javax.inject.Provider;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import play.Application;
 import play.api.inject.guice.GuiceApplicationBuilderSpec;
 import play.inject.Injector;
 import play.libs.Scala;
 
-public class GuiceApplicationBuilderTest {
+class GuiceApplicationBuilderTest {
 
   @Test
-  public void addBindings() {
+  void addBindings() {
     Injector injector =
         new GuiceApplicationBuilder()
             .bindings(new AModule())
             .bindings(bind(B.class).to(B1.class))
             .injector();
 
-    assertThat(injector.instanceOf(A.class), instanceOf(A1.class));
-    assertThat(injector.instanceOf(B.class), instanceOf(B1.class));
+    assertInstanceOf(A1.class, injector.instanceOf(A.class));
+    assertInstanceOf(B1.class, injector.instanceOf(B.class));
   }
 
   @Test
-  public void overrideBindings() {
+  void overrideBindings() {
     Application app =
         new GuiceApplicationBuilder()
             .bindings(new AModule())
@@ -56,31 +53,31 @@ public void overrideBindings() {
             .injector()
             .instanceOf(Application.class);
 
-    assertThat(app.config().getInt("a"), is(1));
-    assertThat(app.config().getInt("b"), is(2));
-    assertThat(app.injector().instanceOf(A.class), instanceOf(A2.class));
+    assertEquals(1, app.config().getInt("a"));
+    assertEquals(2, app.config().getInt("b"));
+    assertInstanceOf(A2.class, app.injector().instanceOf(A.class));
   }
 
   @Test
-  public void disableModules() {
+  void disableModules() {
     Injector injector =
         new GuiceApplicationBuilder().bindings(new AModule()).disable(AModule.class).injector();
-    assertThrows(ConfigurationException.class, () -> injector.instanceOf(A.class));
+    assertThrowsExactly(ConfigurationException.class, () -> injector.instanceOf(A.class));
   }
 
   @Test
-  public void setInitialConfigurationLoader() {
+  void setInitialConfigurationLoader() {
     Config extra = ConfigFactory.parseMap(ImmutableMap.of("a", 1));
     Application app =
         new GuiceApplicationBuilder()
             .withConfigLoader(env -> extra.withFallback(ConfigFactory.load(env.classLoader())))
             .build();
 
-    assertThat(app.config().getInt("a"), is(1));
+    assertEquals(1, app.config().getInt("a"));
   }
 
   @Test
-  public void setModuleLoader() {
+  void setModuleLoader() {
     Injector injector =
         new GuiceApplicationBuilder()
             .withModuleLoader(
@@ -93,11 +90,11 @@ public void setModuleLoader() {
                         Guiceable.bindings(bind(A.class).to(A1.class))))
             .injector();
 
-    assertThat(injector.instanceOf(A.class), instanceOf(A1.class));
+    assertInstanceOf(A1.class, injector.instanceOf(A.class));
   }
 
   @Test
-  public void setLoadedModulesDirectly() {
+  void setLoadedModulesDirectly() {
     Injector injector =
         new GuiceApplicationBuilder()
             .load(
@@ -108,7 +105,7 @@ public void setLoadedModulesDirectly() {
                 Guiceable.bindings(bind(A.class).to(A1.class)))
             .injector();
 
-    assertThat(injector.instanceOf(A.class), instanceOf(A1.class));
+    assertInstanceOf(A1.class, injector.instanceOf(A.class));
   }
 
   public static interface A {}

core/play-guice/src/test/java/play/inject/guice/GuiceApplicationLoaderTest.java

@@ -4,39 +4,37 @@
 
 package play.inject.guice;
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static play.inject.Bindings.bind;
 
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 import java.util.Properties;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import play.Application;
 import play.ApplicationLoader;
 import play.Environment;
 
-public class GuiceApplicationLoaderTest {
+class GuiceApplicationLoaderTest {
 
   private ApplicationLoader.Context fakeContext() {
     return ApplicationLoader.create(Environment.simple());
   }
 
   @Test
-  public void additionalModulesAndBindings() {
+  void additionalModulesAndBindings() {
     GuiceApplicationBuilder builder =
         new GuiceApplicationBuilder().bindings(new AModule()).bindings(bind(B.class).to(B1.class));
     ApplicationLoader loader = new GuiceApplicationLoader(builder);
     Application app = loader.load(fakeContext());
 
-    assertThat(app.injector().instanceOf(A.class), instanceOf(A1.class));
-    assertThat(app.injector().instanceOf(B.class), instanceOf(B1.class));
+    assertInstanceOf(A1.class, app.injector().instanceOf(A.class));
+    assertInstanceOf(B1.class, app.injector().instanceOf(B.class));
   }
 
   @Test
-  public void extendLoaderAndSetConfiguration() {
+  void extendLoaderAndSetConfiguration() {
     ApplicationLoader loader =
         new GuiceApplicationLoader() {
           @Override
@@ -50,11 +48,11 @@ public GuiceApplicationBuilder builder(Context context) {
         };
     Application app = loader.load(fakeContext());
 
-    assertThat(app.config().getInt("a"), is(1));
+    assertEquals(1, app.config().getInt("a"));
   }
 
   @Test
-  public void usingAdditionalConfiguration() {
+  void usingAdditionalConfiguration() {
     Properties properties = new Properties();
     properties.setProperty("play.http.context", "/tests");
 
@@ -67,7 +65,7 @@ public void usingAdditionalConfiguration() {
         ApplicationLoader.create(Environment.simple()).withConfig(config);
     Application app = loader.load(context);
 
-    assertThat(app.asScala().httpConfiguration().context(), equalTo("/tests"));
+    assertEquals("/tests", app.asScala().httpConfiguration().context());
   }
 
   public interface A {}