Update all tests to JUnit 5

Author: henryju

lib/pom.xml

@@ -72,12 +72,7 @@
     <!-- unit tests -->
     <dependency>
       <groupId>org.junit.jupiter</groupId>
-      <artifactId>junit-jupiter-engine</artifactId>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>org.junit.vintage</groupId>
-      <artifactId>junit-vintage-engine</artifactId>
+      <artifactId>junit-jupiter</artifactId>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -119,12 +114,6 @@
       <version>1.5.6</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.awaitility</groupId>
-      <artifactId>awaitility</artifactId>
-      <version>4.2.0</version>
-      <scope>test</scope>
-    </dependency>
   </dependencies>
 
   <build>

lib/src/test/java/org/sonarsource/scanner/lib/DirsTest.java

@@ -22,21 +22,17 @@
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class DirsTest {
+class DirsTest {
 
   private final Map<String, String> p = new HashMap<>();
 
-  @Rule
-  public TemporaryFolder temp = new TemporaryFolder();
-
   @Test
-  public void should_init_default_project_dirs() throws Exception {
+  void should_init_default_project_dirs() throws Exception {
     new Dirs().init(p);
 
     File projectDir = new File(p.get(AnalysisProperties.PROJECT_BASEDIR));
@@ -50,8 +46,7 @@ public void should_init_default_project_dirs() throws Exception {
   }
 
   @Test
-  public void should_set_relative_path_to_project_work_dir() throws Exception {
-    File initialProjectDir = temp.getRoot();
+  void should_set_relative_path_to_project_work_dir(@TempDir File initialProjectDir) throws Exception {
     p.put(ScannerProperties.WORK_DIR, "relative/path");
     p.put(AnalysisProperties.PROJECT_BASEDIR, initialProjectDir.getAbsolutePath());
     new Dirs().init(p);

lib/src/test/java/org/sonarsource/scanner/lib/internal/BootstrapIndexDownloaderTest.java

@@ -22,34 +22,30 @@
 import java.io.IOException;
 import java.util.Collection;
 import org.assertj.core.groups.Tuple;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.sonarsource.scanner.lib.internal.BootstrapIndexDownloader.JarEntry;
 import org.sonarsource.scanner.lib.internal.http.ServerConnection;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-public class BootstrapIndexDownloaderTest {
+class BootstrapIndexDownloaderTest {
   private ServerConnection connection;
   private BootstrapIndexDownloader bootstrapIndexDownloader;
 
-  @Rule
-  public ExpectedException exception = ExpectedException.none();
-
-  @Before
-  public void setUp() {
+  @BeforeEach
+  void setUp() {
     connection = mock(ServerConnection.class);
     bootstrapIndexDownloader = new BootstrapIndexDownloader(connection);
   }
 
   @Test
-  public void should_download_jar_files() throws Exception {
+  void should_download_jar_files() throws Exception {
     // index of the files to download
     when(connection.callWebApi("/batch/index")).thenReturn(
       "cpd.jar|CA124VADFSDS\n" +
@@ -63,37 +59,38 @@ public void should_download_jar_files() throws Exception {
   }
 
   @Test
-  public void test_invalid_index() throws Exception {
+  void test_invalid_index() throws Exception {
     when(connection.callWebApi("/batch/index")).thenReturn("cpd.jar\n");
 
-    exception.expect(IllegalStateException.class);
-    exception.expectMessage("Fail to parse entry in bootstrap index: cpd.jar");
-
-    bootstrapIndexDownloader.getIndex();
+    assertThatThrownBy(() -> bootstrapIndexDownloader.getIndex())
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessage("Fail to parse entry in bootstrap index: cpd.jar");
   }
 
   @Test
-  public void test_handles_empty_line_gracefully() throws Exception {
+  void test_handles_empty_line_gracefully() throws Exception {
     when(connection.callWebApi("/batch/index")).thenReturn("\n");
 
     Collection<JarEntry> index = bootstrapIndexDownloader.getIndex();
     assertThat(index).hasSize(0);
     verify(connection, times(1)).callWebApi("/batch/index");
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void test_handles_empty_string_with_exception() throws Exception {
+  @Test
+  void test_handles_empty_string_with_exception() throws Exception {
     when(connection.callWebApi("/batch/index")).thenReturn("");
 
-    bootstrapIndexDownloader.getIndex();
+    assertThatThrownBy(() -> bootstrapIndexDownloader.getIndex())
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessage("Fail to parse entry in bootstrap index: ");
   }
 
   @Test
-  public void should_fail() throws IOException {
+  void should_fail() throws IOException {
     when(connection.callWebApi("/batch/index")).thenThrow(new IOException("io error"));
 
-    exception.expect(IllegalStateException.class);
-    exception.expectMessage("Fail to get bootstrap index from server");
-    bootstrapIndexDownloader.getIndex();
+    assertThatThrownBy(() -> bootstrapIndexDownloader.getIndex())
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessage("Fail to get bootstrap index from server");
   }
 }

lib/src/test/java/org/sonarsource/scanner/lib/internal/ClassloadRulesTest.java

@@ -19,27 +19,26 @@
  */
 package org.sonarsource.scanner.lib.internal;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.HashSet;
 import java.util.Set;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import org.junit.Test;
-import org.junit.Before;
+import static org.assertj.core.api.Assertions.assertThat;
 
-public class ClassloadRulesTest {
+class ClassloadRulesTest {
   private ClassloadRules rules;
   private Set<String> maskRules;
   private Set<String> unmaskRules;
 
-  @Before
-  public void setUp() {
+  @BeforeEach
+  void setUp() {
     maskRules = new HashSet<>();
     unmaskRules = new HashSet<>();
   }
 
   @Test
-  public void testUnmask() {
+  void testUnmask() {
     unmaskRules.add("org.apache.ant.");
     rules = new ClassloadRules(maskRules, unmaskRules);
 
@@ -50,12 +49,12 @@ public void testUnmask() {
     assertThat(rules.canLoad("org.apache.ant.Foo")).isTrue();
     assertThat(rules.canLoad("org.apache.ant.project.Project")).isTrue();
   }
-  
+
   @Test
-  public void testUnmaskAll() {
+  void testUnmaskAll() {
     unmaskRules.add("");
     rules = new ClassloadRules(maskRules, unmaskRules);
-    
+
     assertThat(rules.canLoad("org.sonar.runner.Foo")).isTrue();
     assertThat(rules.canLoad("org.objectweb.asm.ClassVisitor")).isTrue();
     assertThat(rules.canLoad("org.apache")).isTrue();
@@ -65,13 +64,13 @@ public void testUnmaskAll() {
   }
 
   @Test
-  public void testDefault() {
+  void testDefault() {
     rules = new ClassloadRules(maskRules, unmaskRules);
     assertThat(rules.canLoad("org.sonar.runner.Foo")).isFalse();
   }
 
   @Test
-  public void testMaskAndUnmask() throws ClassNotFoundException {
+  void testMaskAndUnmask() {
     unmaskRules.add("org.apache.ant.");
     maskRules.add("org.apache.ant.foo.");
     rules = new ClassloadRules(maskRules, unmaskRules);
@@ -80,27 +79,27 @@ public void testMaskAndUnmask() throws ClassNotFoundException {
     assertThat(rules.canLoad("org.apache.ant.foo.something")).isFalse();
     assertThat(rules.canLoad("org.apache")).isFalse();
   }
-  
+
   @Test
-  public void testUsedByMaven() {
-    maskRules.add( "org.slf4j.LoggerFactory" );
+  void testUsedByMaven() {
+    maskRules.add("org.slf4j.LoggerFactory");
     // Include slf4j Logger that is exposed by some Sonar components
-    unmaskRules.add( "org.slf4j.Logger" );
-    unmaskRules.add( "org.slf4j.ILoggerFactory" );
+    unmaskRules.add("org.slf4j.Logger");
+    unmaskRules.add("org.slf4j.ILoggerFactory");
     // Exclude other slf4j classes
     // .unmask("org.slf4j.impl.")
-    maskRules.add( "org.slf4j." );
+    maskRules.add("org.slf4j.");
     // Exclude logback
-    maskRules.add( "ch.qos.logback." );
-    maskRules.add( "org.sonar." );
+    maskRules.add("ch.qos.logback.");
+    maskRules.add("org.sonar.");
     unmaskRules.add("org.sonar.runner.batch.");
     // Guava is not the same version in SonarQube classloader
-    maskRules.add( "com.google.common" );
+    maskRules.add("com.google.common");
     // Include everything else
-    unmaskRules.add( "" );
-    
+    unmaskRules.add("");
+
     rules = new ClassloadRules(maskRules, unmaskRules);
-    
+
     assertThat(rules.canLoad("org.sonar.runner.batch.IsolatedLauncher")).isTrue();
   }
 }

lib/src/test/java/org/sonarsource/scanner/lib/internal/IsolatedClassloaderTest.java

@@ -50,16 +50,16 @@ void should_use_isolated_system_classloader_when_parent_is_excluded() throws Cla
     // JUnit is available in the parent classloader (classpath used to execute this test) but not in the core JVM
     assertThat(classLoader.loadClass("java.lang.String", false)).isNotNull();
 
-    assertThatThrownBy(() -> classLoader.loadClass("org.junit.Test", false)).isInstanceOf(ClassNotFoundException.class).hasMessageContaining("org.junit.Test");
+    assertThatThrownBy(() -> classLoader.loadClass("org.junit.jupiter.api.Test", false)).isInstanceOf(ClassNotFoundException.class).hasMessageContaining("org.junit.jupiter.api.Test");
     classLoader.close();
   }
 
   @Test
   void should_use_parent_to_load() throws ClassNotFoundException {
     ClassloadRules rules = mock(ClassloadRules.class);
-    when(rules.canLoad("org.junit.Test")).thenReturn(true);
+    when(rules.canLoad("org.junit.jupiter.api.Test")).thenReturn(true);
     classLoader = new IsolatedClassloader(getClass().getClassLoader(), rules);
-    assertThat(classLoader.loadClass("org.junit.Test", false)).isNotNull();
+    assertThat(classLoader.loadClass("org.junit.jupiter.api.Test", false)).isNotNull();
   }
 
   @Test

lib/src/test/java/org/sonarsource/scanner/lib/internal/IsolatedLauncherProxyTest.java

@@ -22,48 +22,51 @@
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.concurrent.Callable;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-public class IsolatedLauncherProxyTest {
+class IsolatedLauncherProxyTest {
   private ClassLoader cl = null;
 
-  @Before
+  @BeforeEach
   public void setUp() {
     cl = new URLClassLoader(new URL[0], Thread.currentThread().getContextClassLoader());
   }
 
   @Test
-  public void delegate_proxied() {
+  void delegate_proxied() {
     String str = "test";
     CharSequence s = IsolatedLauncherProxy.create(cl, str, CharSequence.class);
     assertThat(s).isEqualTo(str);
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void exceptions_unwrapped() throws ReflectiveOperationException {
+  @Test
+  void exceptions_unwrapped() throws ReflectiveOperationException {
     Runnable r = IsolatedLauncherProxy.create(cl, Runnable.class, ExceptionThrower.class.getName());
-    r.run();
+
+    assertThatThrownBy(r::run)
+      .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
-  public void create_proxied() throws Exception {
+  void create_proxied() throws Exception {
     Callable<?> c = IsolatedLauncherProxy.create(cl, Callable.class, SimpleClass.class.getName());
     assertThat(c.getClass().getClassLoader()).isEqualTo(cl);
     assertThat(c.getClass().getClassLoader()).isNotEqualTo(Thread.currentThread().getContextClassLoader());
     assertThat(c.call()).isEqualTo(URLClassLoader.class.getSimpleName());
   }
 
-  public static class ExceptionThrower implements Runnable {
+  static class ExceptionThrower implements Runnable {
     @Override
     public void run() {
       throw new IllegalStateException("message");
     }
   }
 
-  public static class SimpleClass implements Callable<String> {
+  static class SimpleClass implements Callable<String> {
     @Override
     public String call() throws Exception {
       return Thread.currentThread().getContextClassLoader().getClass().getSimpleName();

lib/src/test/java/org/sonarsource/scanner/lib/internal/JarExtractorTest.java

@@ -19,29 +19,29 @@
  */
 package org.sonarsource.scanner.lib.internal;
 
-import org.junit.Test;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.fail;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class JarExtractorTest {
+
+  private final JarExtractor underTest = new JarExtractor();
 
-public class JarExtractorTest {
   @Test
-  public void test_extract() throws Exception {
-    Path jarFile = new JarExtractor().extractToTemp("fake");
+  void test_extract() throws Exception {
+    Path jarFile = underTest.extractToTemp("fake");
     assertThat(jarFile).exists();
-    assertThat(new String(Files.readAllBytes(jarFile), StandardCharsets.UTF_8)).isEqualTo("Fake jar for unit tests");
+    assertThat(Files.readString(jarFile)).isEqualTo("Fake jar for unit tests");
     assertThat(jarFile.toUri().toURL().toString()).doesNotContain("jar:file");
   }
 
   @Test
-  public void should_fail_to_extract() throws Exception {
-    try {
-      new JarExtractor().extractToTemp("unknown");
-      fail();
-    } catch (IllegalStateException e) {
-      assertThat(e).hasMessage("Fail to extract unknown.jar");
-    }
+  void should_fail_to_extract() {
+    assertThatThrownBy(() -> underTest.extractToTemp("unknown"))
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessage("Fail to extract unknown.jar");
   }
 }