Migrate MockWebServer to JUnit 5

dialogue-annotations-processor/build.gradle

@@ -43,7 +43,7 @@ dependencies {
     testImplementation 'com.google.guava:guava'
     testImplementation 'com.google.testing.compile:compile-testing'
     testImplementation 'com.palantir.safe-logging:preconditions-assertj'
-    testImplementation 'com.squareup.okhttp3:mockwebserver'
+    testImplementation 'com.squareup.okhttp3:mockwebserver3-junit5'
     testImplementation 'org.assertj:assertj-core'
     testImplementation 'org.junit.jupiter:junit-jupiter'
 }

dialogue-apache-hc5-client/src/test/java/com/palantir/dialogue/hc5/ApacheHttpClientChannelsTest.java

@@ -47,10 +47,17 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.OptionalLong;
-import okhttp3.mockwebserver.RecordedRequest;
+import mockwebserver3.MockWebServer;
+import mockwebserver3.RecordedRequest;
+import mockwebserver3.junit5.internal.MockWebServerExtension;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
+@ExtendWith(MockWebServerExtension.class)
 public final class ApacheHttpClientChannelsTest extends AbstractChannelTest {
+    ApacheHttpClientChannelsTest(MockWebServer server) {
+        super(server);
+    }
 
     @Override
     protected Channel createChannel(ClientConfiguration config) {

dialogue-apache-hc5-client/src/test/java/com/palantir/dialogue/hc5/ApacheProxyConfigTest.java

@@ -18,8 +18,16 @@
 import com.palantir.conjure.java.client.config.ClientConfiguration;
 import com.palantir.dialogue.AbstractProxyConfigTest;
 import com.palantir.dialogue.Channel;
+import mockwebserver3.MockWebServer;
+import mockwebserver3.junit5.internal.MockWebServerExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
 
+@ExtendWith(MockWebServerExtension.class)
 public final class ApacheProxyConfigTest extends AbstractProxyConfigTest {
+    ApacheProxyConfigTest(MockWebServer server, MockWebServer proxyServer) {
+        super(server, proxyServer);
+    }
+
     @Override
     protected Channel create(ClientConfiguration config) {
         return ApacheHttpClientChannels.create(config);

dialogue-client-verifier/build.gradle

@@ -30,7 +30,6 @@ dependencies {
     testImplementation project('verification-server-api')
     testImplementation project(':dialogue-clients')
     testImplementation project(':dialogue-example:dialogue-example-dialogue')
-    testImplementation 'junit:junit'
     testImplementation 'org.assertj:assertj-core'
     testImplementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml'
     testImplementation 'com.palantir.conjure.java.runtime:conjure-java-jackson-serialization'
@@ -42,9 +41,7 @@ dependencies {
     testRuntimeOnly 'org.apache.logging.log4j:log4j-core'
     testImplementation 'com.palantir.safe-logging:logger'
     testImplementation 'org.junit.jupiter:junit-jupiter'
-    testRuntimeOnly 'org.junit.vintage:junit-vintage-engine', {
-        because 'allows JUnit 3 and JUnit 4 tests to run'
-    }
+    testImplementation 'org.junit.jupiter:junit-jupiter-api'
 }
 
 subprojects {

dialogue-client-verifier/src/test/java/com/palantir/verification/AutoDeserializeTest.java

@@ -30,79 +30,66 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.IntStream;
-import org.junit.Assume;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
-@RunWith(Parameterized.class)
 public class AutoDeserializeTest {
 
-    @ClassRule
-    public static final VerificationServerRule server = new VerificationServerRule();
+    @RegisterExtension
+    public static final VerificationServerExtension server = new VerificationServerExtension();
 
     private static final SafeLogger log = SafeLoggerFactory.get(AutoDeserializeTest.class);
     private static final AutoDeserializeServiceBlocking testService =
             server.client(AutoDeserializeServiceBlocking.class);
     private static final AutoDeserializeConfirmServiceBlocking confirmService =
             server.client(AutoDeserializeConfirmServiceBlocking.class);
 
-    @Parameterized.Parameter(0)
-    public EndpointName endpointName;
-
-    @Parameterized.Parameter(1)
-    public int index;
-
-    @Parameterized.Parameter(2)
-    public boolean shouldSucceed;
-
-    @Parameterized.Parameter(3)
-    public String jsonString;
-
-    @Parameterized.Parameters(name = "{0}({3}) -> should succeed {2}")
-    public static Collection<Object[]> data() {
-        List<Object[]> objects = new ArrayList<>();
+    public static Collection<Arguments> data() {
+        List<Arguments> objects = new ArrayList<>();
         Cases.TEST_CASES.getAutoDeserialize().forEach((endpointName, positiveAndNegativeTestCases) -> {
             int positiveSize = positiveAndNegativeTestCases.getPositive().size();
             int negativeSize = positiveAndNegativeTestCases.getNegative().size();
 
             IntStream.range(0, positiveSize)
-                    .forEach(i -> objects.add(new Object[] {
-                        endpointName,
-                        i,
-                        true,
-                        positiveAndNegativeTestCases.getPositive().get(i)
-                    }));
+                    .forEach(i -> objects.add(Arguments.of(
+                            endpointName,
+                            i,
+                            true,
+                            positiveAndNegativeTestCases.getPositive().get(i))));
 
             IntStream.range(0, negativeSize)
-                    .forEach(i -> objects.add(new Object[] {
-                        endpointName,
-                        positiveSize + i,
-                        false,
-                        positiveAndNegativeTestCases.getNegative().get(i)
-                    }));
+                    .forEach(i -> objects.add(Arguments.of(
+                            endpointName,
+                            positiveSize + i,
+                            false,
+                            positiveAndNegativeTestCases.getNegative().get(i))));
         });
         return objects;
     }
 
-    @Test
+    @ParameterizedTest(name = "{0}({3}) -> should succeed {2}")
+    @MethodSource("data")
     @SuppressWarnings("IllegalThrows")
-    public void runTestCase() throws Error, NoSuchMethodException {
+    public void runTestCase(EndpointName endpointName, int index, boolean shouldSucceed, String jsonString)
+            throws Error, NoSuchMethodException {
         boolean shouldIgnore = Cases.shouldIgnore(endpointName, jsonString);
         Method method = testService.getClass().getMethod(endpointName.get(), int.class);
         // Need to set accessible true work around dialogues anonymous class impl
         method.setAccessible(true);
-        System.out.println(String.format(
-                "[%s%s test case %s]: %s(%s), expected client to %s",
+        System.out.printf(
+                "[%s%s test case %s]: %s(%s), expected client to %s%n",
                 shouldIgnore ? "ignored " : "",
                 shouldSucceed ? "positive" : "negative",
                 index,
                 endpointName,
                 jsonString,
-                shouldSucceed ? "succeed" : "fail"));
+                shouldSucceed ? "succeed" : "fail");
 
-        Optional<Error> expectationFailure = shouldSucceed ? expectSuccess(method) : expectFailure(method);
+        Optional<Error> expectationFailure =
+                shouldSucceed ? expectSuccess(method, endpointName, index) : expectFailure(method, index);
 
         if (shouldIgnore) {
             assertThat(expectationFailure)
@@ -111,14 +98,14 @@ public void runTestCase() throws Error, NoSuchMethodException {
                     .isNotEmpty();
         }
 
-        Assume.assumeFalse(shouldIgnore);
+        Assumptions.assumeFalse(shouldIgnore);
 
         if (expectationFailure.isPresent()) {
             throw expectationFailure.get();
         }
     }
 
-    private Optional<Error> expectSuccess(Method method) {
+    private Optional<Error> expectSuccess(Method method, EndpointName endpointName, int index) {
         try {
             Object resultFromServer = method.invoke(testService, index);
             log.info(
@@ -133,13 +120,13 @@ private Optional<Error> expectSuccess(Method method) {
         }
     }
 
-    private Optional<Error> expectFailure(Method method) {
+    private Optional<Error> expectFailure(Method method, Object index) {
         try {
             Object result = method.invoke(testService, index);
             return Optional.of(new AssertionError(
                     String.format("Result should have caused an exception but deserialized to: %s", result)));
         } catch (Exception e) {
-            return Optional.empty(); // we expected the method to throw and it did, so this expectation was satisifed
+            return Optional.empty(); // we expected the method to throw, and it did, so this expectation was satisfied
         }
     }
 }

dialogue-client-verifier/src/test/java/com/palantir/verification/SingleParamServicesTest.java

@@ -16,6 +16,8 @@
 
 package com.palantir.verification;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableMap;
 import com.palantir.conjure.java.api.errors.RemoteException;
@@ -35,70 +37,58 @@
 import java.util.List;
 import java.util.stream.IntStream;
 import org.apache.commons.lang3.ClassUtils;
-import org.junit.Assume;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
-@RunWith(Parameterized.class)
 public class SingleParamServicesTest {
 
-    @ClassRule
-    public static final VerificationServerRule server = new VerificationServerRule();
+    @RegisterExtension
+    public static final VerificationServerExtension server = new VerificationServerExtension();
 
     private static final SafeLogger log = SafeLoggerFactory.get(SingleParamServicesTest.class);
     private static final ObjectMapper objectMapper = ObjectMappers.newClientObjectMapper();
-    private static ImmutableMap<String, Object> servicesMaps = ImmutableMap.of(
+    private static final ImmutableMap<String, Object> servicesMaps = ImmutableMap.of(
             "singlePathParamService",
             server.client(SinglePathParamServiceBlocking.class),
             "singleHeaderService",
             server.client(SingleHeaderServiceBlocking.class),
             "singleQueryParamService",
             server.client(SingleQueryParamServiceBlocking.class));
 
-    @Parameterized.Parameter(0)
-    public String serviceName;
-
-    @Parameterized.Parameter(1)
-    public EndpointName endpointName;
-
-    @Parameterized.Parameter(2)
-    public int index;
-
-    @Parameterized.Parameter(3)
-    public String jsonString;
-
-    @Parameterized.Parameters(name = "{0}/{1}({3})")
-    public static Collection<Object[]> data() {
-        List<Object[]> objects = new ArrayList<>();
+    static Collection<Arguments> data() {
+        List<Arguments> objects = new ArrayList<>();
         Cases.TEST_CASES.getSingleHeaderService().forEach((endpointName, singleHeaderTestCases) -> {
             int size = singleHeaderTestCases.size();
             IntStream.range(0, size)
                     .forEach(i -> objects.add(
-                            new Object[] {"singleHeaderService", endpointName, i, singleHeaderTestCases.get(i)}));
+                            Arguments.of("singleHeaderService", endpointName, i, singleHeaderTestCases.get(i))));
         });
 
         Cases.TEST_CASES.getSinglePathParamService().forEach((endpointName, singleHeaderTestCases) -> {
             int size = singleHeaderTestCases.size();
             IntStream.range(0, size)
                     .forEach(i -> objects.add(
-                            new Object[] {"singlePathParamService", endpointName, i, singleHeaderTestCases.get(i)}));
+                            Arguments.of("singlePathParamService", endpointName, i, singleHeaderTestCases.get(i))));
         });
 
         Cases.TEST_CASES.getSingleQueryParamService().forEach((endpointName, singleQueryTestCases) -> {
             int size = singleQueryTestCases.size();
             IntStream.range(0, size)
                     .forEach(i -> objects.add(
-                            new Object[] {"singleQueryParamService", endpointName, i, singleQueryTestCases.get(i)}));
+                            Arguments.of("singleQueryParamService", endpointName, i, singleQueryTestCases.get(i))));
         });
 
         return objects;
     }
 
-    @Test
-    public void runTestCase() throws Exception {
-        Assume.assumeFalse(Cases.shouldIgnore(endpointName, jsonString));
+    @ParameterizedTest(name = "{0}/{1}({3})")
+    @MethodSource("data")
+    public void runTestCase(String serviceName, EndpointName endpointName, int index, String jsonString)
+            throws Exception {
+        Assumptions.assumeFalse(Cases.shouldIgnore(endpointName, jsonString));
 
         log.info(
                 "Invoking {} {}({})",
@@ -107,7 +97,8 @@ public void runTestCase() throws Exception {
                 SafeArg.of("jsonString", jsonString));
 
         Object service = servicesMaps.get(serviceName);
-        for (Method method : servicesMaps.get(serviceName).getClass().getMethods()) {
+        assertThat(service).as("Invalid service: '%s'", serviceName).isNotNull();
+        for (Method method : service.getClass().getMethods()) {
             String name = method.getName();
             // Need to set accessible true work around dialogues anonymous class impl
             method.setAccessible(true);

dialogue-client-verifier/src/test/java/com/palantir/verification/VerificationServerRule.java → dialogue-client-verifier/src/test/java/com/palantir/verification/VerificationServerExtension.java

@@ -33,14 +33,16 @@
 import java.nio.file.Paths;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
-import org.junit.rules.ExternalResource;
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
 
 /**
  * Spins up the 'verification-server' executable which will bind to port 8000, and tears it down at the end of the test.
  */
-public final class VerificationServerRule extends ExternalResource {
+public final class VerificationServerExtension implements BeforeAllCallback, AfterAllCallback {
 
-    private static final SafeLogger log = SafeLoggerFactory.get(VerificationServerRule.class);
+    private static final SafeLogger log = SafeLoggerFactory.get(VerificationServerExtension.class);
     private static final SslConfiguration TRUST_STORE_CONFIGURATION = new SslConfiguration.Builder()
             .trustStorePath(Paths.get("../dialogue-test-common/src/main/resources/trustStore.jks"))
             .build();
@@ -61,7 +63,7 @@ public <T> T client(Class<T> service) {
     }
 
     @Override
-    public void before() throws Exception {
+    public void beforeAll(ExtensionContext _context) throws Exception {
         ProcessBuilder processBuilder = new ProcessBuilder(
                         "build/verification/verifier",
                         "build/test-cases/test-cases.json",
@@ -106,7 +108,7 @@ private static void blockUntilServerStarted(InputStream inputStream) throws Inte
     }
 
     @Override
-    protected void after() {
+    public void afterAll(ExtensionContext _context) {
         process.destroyForcibly();
         try {
             process.waitFor(5, TimeUnit.SECONDS);

dialogue-test-common/build.gradle

@@ -12,11 +12,10 @@ dependencies {
     api 'com.palantir.conjure.java.runtime:client-config'
     api 'com.palantir.conjure.java.runtime:keystores'
     api 'com.palantir.tracing:tracing-test-utils'
-    api 'com.squareup.okhttp3:mockwebserver'
+    api 'com.squareup.okhttp3:mockwebserver3-junit5'
     api 'org.assertj:assertj-core'
     api 'org.assertj:assertj-guava'
     api 'org.junit.jupiter:junit-jupiter'
-    api 'org.junit.jupiter:junit-jupiter-migrationsupport'
     api 'org.mockito:mockito-core'
     api 'org.mockito:mockito-junit-jupiter'
     api 'io.undertow:undertow-core'