Migrate tests to JUnit5

pom.xml

@@ -89,7 +89,7 @@
       <dependency>
         <groupId>io.jenkins.tools.bom</groupId>
         <artifactId>bom-${jenkins.baseline}.x</artifactId>
-        <version>3893.v213a_42768d35</version>
+        <version>4136.vca_c3202a_7fd1</version>
         <scope>import</scope>
         <type>pom</type>
       </dependency>

src/test/java/jenkins/metrics/RoundTripJCascMetricsTest.java

@@ -2,24 +2,26 @@
 
 import hudson.ExtensionList;
 import hudson.util.Secret;
-import io.jenkins.plugins.casc.misc.RoundTripAbstractTest;
+import io.jenkins.plugins.casc.misc.junit.jupiter.AbstractRoundTripTest;
 import jenkins.metrics.api.MetricsAccessKey;
-import org.jvnet.hudson.test.RestartableJenkinsRule;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 
 import java.util.List;
 
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Configuration, validation, export and configuration during restart of the configuration of the metrics plugin.
  */
-public class RoundTripJCascMetricsTest extends RoundTripAbstractTest {
+@WithJenkins
+class RoundTripJCascMetricsTest extends AbstractRoundTripTest {
 
     @Override
-    public void assertConfiguredAsExpected(RestartableJenkinsRule j, String configContent) {
+    protected void assertConfiguredAsExpected(JenkinsRule j, String configContent) {
         List<MetricsAccessKey> accessKeys = ExtensionList.lookup(MetricsAccessKey.DescriptorImpl.class).get(0).getAccessKeys();
         assertThat("We have an access key of metrics configured in Configure System", accessKeys.size() == 4);
 
@@ -35,7 +37,7 @@ public void assertConfiguredAsExpected(RestartableJenkinsRule j, String configCo
     }
 
     @Override
-    public String stringInLogExpected() {
+    protected String stringInLogExpected() {
         return "MetricsAccessKey.key = ****";
     }
 }

src/test/java/jenkins/metrics/api/HealthCheckProviderForTesting.java

@@ -23,14 +23,13 @@
  */
 package jenkins.metrics.api;
 
-import java.util.Map;
-import java.util.Map.Entry;
-
 import com.codahale.metrics.health.HealthCheck;
-
 import edu.umd.cs.findbugs.annotations.NonNull;
 import hudson.Extension;
 
+import java.util.Map;
+import java.util.Map.Entry;
+
 @Extension
 public class HealthCheckProviderForTesting extends HealthCheckProvider {
 
@@ -47,7 +46,7 @@ private Entry<String, HealthCheck> check(int i) {
             @Override
             protected Result check() throws Exception {
                 runs++;
-                Thread.sleep(1 * 1000);
+                Thread.sleep(1000);
                 return Result.unhealthy("some error message");
             }
         });

src/test/java/jenkins/metrics/api/HealthCheckerTest.java

@@ -23,25 +23,22 @@
  */
 package jenkins.metrics.api;
 
-import static org.junit.Assert.*;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.jvnet.hudson.test.JenkinsRule;
-
 import jenkins.metrics.api.Metrics.HealthChecker;
 import jenkins.metrics.util.HealthChecksThreadPool;
+import org.junit.jupiter.api.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Test the {@link HealthChecker} execution of health checks
  */
-public class HealthCheckerTest {
-
-    @Rule
-    public JenkinsRule j = new JenkinsRule();
+@WithJenkins
+class HealthCheckerTest {
 
     @Test
-    public void testHealthChecksAreNotRejected() throws Exception {
+    void testHealthChecksAreNotRejected(JenkinsRule j) throws Exception {
         while (HealthCheckProviderForTesting.runs < 6 && HealthChecksThreadPool.getRejectedExecutions() == 0) {
             Thread.sleep(1000);
         }

src/test/java/jenkins/metrics/api/MetricsAccessKeyTest.java

@@ -1,12 +1,10 @@
 package jenkins.metrics.api;
 
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.RuleChain;
+import org.junit.jupiter.api.Test;
 import org.jvnet.hudson.test.Issue;
 import org.jvnet.hudson.test.JenkinsRule;
-import org.jvnet.hudson.test.LoggerRule;
-import org.jvnet.hudson.test.RealJenkinsRule;
+import org.jvnet.hudson.test.LogRecorder;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 import org.jvnet.hudson.test.recipes.LocalData;
 
 import java.util.logging.Level;
@@ -18,19 +16,18 @@
 import static org.hamcrest.Matchers.hasProperty;
 import static org.hamcrest.Matchers.startsWith;
 import static org.hamcrest.core.IsNot.not;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-public class MetricsAccessKeyTest {
-    public JenkinsRule j = new JenkinsRule();
-    public LoggerRule l = new LoggerRule().record("jenkins.metrics.api.MetricsAccessKey", Level.ALL).capture(1000);
-    @Rule
-    public RuleChain chain = RuleChain.outerRule(j).around(l);
+@WithJenkins
+class MetricsAccessKeyTest {
+
+    private final LogRecorder l = new LogRecorder().record("jenkins.metrics.api.MetricsAccessKey", Level.ALL).capture(1000);
 
     @Test
     @Issue("SECURITY-1624")
     @LocalData
-    public void oldKeysAreConvertedAfterStartup() throws Exception {
+    void oldKeysAreConvertedAfterStartup(JenkinsRule j) throws Exception {
         j.waitUntilNoActivityUpTo(5000);
         assertThat(l.getRecords(), hasItem(
                 allOf(
@@ -44,7 +41,7 @@ public void oldKeysAreConvertedAfterStartup() throws Exception {
     @Test
     @Issue("SECURITY-1624")
     @LocalData
-    public void newKeysStayTheSame() throws Exception {
+    void newKeysStayTheSame(JenkinsRule j) throws Exception {
         j.waitUntilNoActivityUpTo(5000);
         assertThat(l.getRecords(), not(hasItem(
                 allOf(

src/test/java/jenkins/metrics/api/MetricsTest.java

@@ -3,74 +3,77 @@
 import hudson.util.VersionNumber;
 import jenkins.model.Jenkins;
 import org.apache.commons.lang.ArrayUtils;
-import org.junit.AfterClass;
-import org.junit.Assume;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 import org.jvnet.hudson.test.Issue;
-import org.jvnet.hudson.test.RestartableJenkinsRule;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 
 import javax.management.MBeanServer;
 import javax.management.ObjectName;
+import java.io.File;
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.core.IsNot.not;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
-public class MetricsTest {
+@WithJenkins
+class MetricsTest {
 
-    private static final String SYSPROP_FOR_LOGS_PATH = "hudson.triggers.SafeTimerTask.logsTargetDir";
-    @Rule
-    public final TemporaryFolder folder = new TemporaryFolder();
-    @Rule
-    public RestartableJenkinsRule story = new RestartableJenkinsRule();
+    private static final String SYS_PROP_FOR_LOGS_PATH = "hudson.triggers.SafeTimerTask.logsTargetDir";
+    @TempDir
+    private File folder;
 
-    @BeforeClass
-    @AfterClass
-    public static void cleanProperty() throws IOException {
-        System.clearProperty(SYSPROP_FOR_LOGS_PATH);
+    @BeforeAll
+    @AfterAll
+    static void cleanProperty() {
+        System.clearProperty(SYS_PROP_FOR_LOGS_PATH);
     }
 
-
     @Issue("JENKINS-50291")
     @Test
-    public void logsDirectory() {
+    void logsDirectory(JenkinsRule j) throws Throwable {
+        assumeTrue(Jenkins.getVersion().isNewerThan(new VersionNumber("2.113"))); // JENKINS-50291 introduced in 2.114
 
-        story.then(j -> {
-            Assume.assumeTrue(Jenkins.getVersion().isNewerThan(new VersionNumber("2.113"))); // JENKINS-50291 introduced in 2.114
+        assertTrue(Metrics.HealthChecker.getLogFile(j.jenkins).getAbsolutePath().startsWith(j.getInstance().getRootDir().getAbsolutePath()));
+        System.setProperty("hudson.triggers.SafeTimerTask.logsTargetDir", newFolder(folder, "junit").getAbsolutePath());
 
-            assertTrue(Metrics.HealthChecker.getLogFile(j.jenkins).getAbsolutePath().startsWith(j.getInstance().getRootDir().getAbsolutePath()));
-            System.setProperty("hudson.triggers.SafeTimerTask.logsTargetDir", folder.newFolder().getAbsolutePath());
-        });
+        j.restart();
 
-        story.then(j -> assertFalse(Metrics.HealthChecker.getLogFile(j.jenkins).getAbsolutePath().startsWith(j.getInstance().getRootDir().getAbsolutePath())));
+        assertFalse(Metrics.HealthChecker.getLogFile(j.jenkins).getAbsolutePath().startsWith(j.getInstance().getRootDir().getAbsolutePath()));
     }
 
     @Test
-    public void jmxDomain() {
-        story.then(r -> {
-            assertTrue(ArrayUtils.contains(ManagementFactory.getPlatformMBeanServer().getDomains(), "io.jenkins"));
-        });
+    void jmxDomain(JenkinsRule j) {
+        assertTrue(ArrayUtils.contains(ManagementFactory.getPlatformMBeanServer().getDomains(), "io.jenkins"));
     }
 
     @Test
-    public void jmxMetricsExcluded() {
-        story.then(r -> {
-            MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Gc,*"), null), is(empty()));
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Vm,*"), null), is(empty()));
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:*,name=History"), null), is(empty()));
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:*,name=5m"), null), is(empty()));
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:*,name=1h"), null), is(empty()));
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Project,*"), null), is(not(empty())));
-            assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Executor,*"), null), is(not(empty())));
-        });
+    void jmxMetricsExcluded(JenkinsRule j) throws Exception {
+        MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Gc,*"), null), is(empty()));
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Vm,*"), null), is(empty()));
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:*,name=History"), null), is(empty()));
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:*,name=5m"), null), is(empty()));
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:*,name=1h"), null), is(empty()));
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Project,*"), null), is(not(empty())));
+        assertThat(mBeanServer.queryNames(new ObjectName("io.jenkins:type=Executor,*"), null), is(not(empty())));
+    }
+
+    private static File newFolder(File root, String... subDirs) throws IOException {
+        String subFolder = String.join("/", subDirs);
+        File result = new File(root, subFolder);
+        if (!result.mkdirs()) {
+            throw new IOException("Couldn't create folders " + root);
+        }
+        return result;
     }
 }

src/test/java/jenkins/metrics/impl/JenkinsMetricProviderImplTest.java

@@ -34,18 +34,15 @@
 import org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition;
 import org.jenkinsci.plugins.workflow.job.WorkflowJob;
 import org.jenkinsci.plugins.workflow.job.WorkflowRun;
-import org.junit.ClassRule;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.jvnet.hudson.test.BuildWatcher;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 import org.jvnet.hudson.test.Issue;
 import org.jvnet.hudson.test.JenkinsRule;
 import org.jvnet.hudson.test.SleepBuilder;
 import org.jvnet.hudson.test.TestExtension;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
@@ -59,15 +56,11 @@
 import static org.hamcrest.Matchers.lessThan;
 import static org.hamcrest.Matchers.notNullValue;
 
-public class JenkinsMetricProviderImplTest {
-    @Rule
-    public JenkinsRule j = new JenkinsRule();
-
-    @ClassRule
-    public static BuildWatcher w = new BuildWatcher();
+@WithJenkins
+class JenkinsMetricProviderImplTest {
 
     @Test
-    public void given__a_job_which_is_cancelled() throws Exception {
+    void given__a_job_which_is_cancelled(JenkinsRule j) throws Exception {
         MyListener listener = ExtensionList.lookup(QueueItemMetricsListener.class).get(MyListener.class);
         assertThat(listener, notNullValue());
 
@@ -76,24 +69,23 @@
         QueueTaskFuture<FreeStyleBuild> taskFuture = job.scheduleBuild2(10);
         taskFuture.cancel(true);
 
-        try{
+        try {
             j.waitForCompletion(taskFuture.waitForStart());
-        }catch (Throwable t){
+        } catch (Throwable t) {
             //CancellationException expected
         }
 
         //wait for completion
-        while (!listener.state.toString().contains("C")){
+        while (!listener.state.toString().contains("C")) {
             Thread.sleep(10);
         }
 
         assertThat(listener.state.toString(), is("QC"));
-
     }
 
-    @Ignore("TODO allOf(greaterThan(2500L), lessThan(3800L)) flaky: 3999 observed")
+    @Disabled("TODO allOf(greaterThan(2500L), lessThan(3800L)) flaky: 3999 observed")
     @Test
-    public void given__a_job__when__built__then__events_and_metrics_include_build() throws Exception {
+    void given__a_job__when__built__then__events_and_metrics_include_build(JenkinsRule j) throws Exception {
         j.jenkins.setQuietPeriod(0);
         MyListener listener = ExtensionList.lookup(QueueItemMetricsListener.class).get(MyListener.class);
         assertThat(listener, notNullValue());
@@ -106,18 +98,18 @@
         j.assertBuildStatusSuccess(p.scheduleBuild2(2));
 
         //wait for completion
-        while (!listener.state.toString().contains("F")){
+        while (!listener.state.toString().contains("F")) {
             Thread.sleep(10);
         }
         assertThat(listener.state.toString(), is("QSF"));
 
         assertThat(Metrics.metricRegistry().getTimers().get("jenkins.job.building.duration").getCount(), is(1L));
         assertThat(Metrics.metricRegistry().getTimers().get("jenkins.job.building.duration").getSnapshot().getMean(),
-                allOf(greaterThan(TimeUnit.MILLISECONDS.toNanos(2500)*1.0),
+                allOf(greaterThan(TimeUnit.MILLISECONDS.toNanos(2500) * 1.0),
                         lessThan(TimeUnit.MILLISECONDS.toNanos(3800) * 1.0)));
         List<QueueItemMetricsEvent> events = listener.getEvents();
         assertThat(events.size(), is(3));
-        Collections.sort(events, QueueItemMetricsEvent::compareEventSequence);
+        events.sort(QueueItemMetricsEvent::compareEventSequence);
         events.forEach(System.err::println);
 
         assertThat(events.get(0).getState(), is(QueueItemMetricsEvent.State.QUEUED));
@@ -145,10 +137,10 @@
 
     @Test
     @Issue("JENKINS-69817")
-    public void given__a_job_with_subtasks__when__built__then__build_include_subtasks_metrics() throws Exception {
+    void given__a_job_with_subtasks__when__built__then__build_include_subtasks_metrics(JenkinsRule j) throws Exception {
         WorkflowJob p = j.createProject(WorkflowJob.class);
         p.setDefinition(new CpsFlowDefinition("node { echo 'subtask1' }" +
-            "\nnode { echo 'subtask2' }", true));
+                "\nnode { echo 'subtask2' }", true));
         WorkflowRun workflowRun = j.buildAndAssertSuccess(p);
 
         List<TimeInQueueAction> timeInQueueActions = workflowRun.getActions(TimeInQueueAction.class);
@@ -163,7 +155,7 @@
     @TestExtension
     public static class MyListener extends QueueItemMetricsListener {
         private final List<QueueItemMetricsEvent> events = new ArrayList<>();
-        public StringBuilder state = new StringBuilder();
+        public final StringBuilder state = new StringBuilder();
 
         @Override
         public void onQueued(QueueItemMetricsEvent event) {