Migrate tests to JUnit5 (#453)

* Migrate annotations * Migrate assertions * Cleanup assertions * Minor cleanup * Remove public visibility of test classes and methods Co-authored-by: strangelookingnerd <[email protected]>
jenkinsci · Feb 6, 2025 · fca49d2 · fca49d2
1 parent 9bce724
commit fca49d2
Show file tree

Hide file tree

Showing 35 changed files with 572 additions and 748 deletions.
diff --git a/src/test/java/jenkins/advancedqueue/JCasCFivePrioritiesTest.java b/src/test/java/jenkins/advancedqueue/JCasCFivePrioritiesTest.java
@@ -25,20 +25,20 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
-import io.jenkins.plugins.casc.misc.RoundTripAbstractTest;
+import io.jenkins.plugins.casc.misc.junit.jupiter.AbstractRoundTripTest;
 import java.util.List;
 import jenkins.advancedqueue.priority.PriorityStrategy;
 import jenkins.advancedqueue.sorter.strategy.AbsoluteStrategy;
-import org.jvnet.hudson.test.RestartableJenkinsRule;
+import org.jvnet.hudson.test.JenkinsRule;
 
-public class JCasCFivePrioritiesTest extends RoundTripAbstractTest {
+public class JCasCFivePrioritiesTest extends AbstractRoundTripTest {
 
     @Override
-    protected void assertConfiguredAsExpected(RestartableJenkinsRule j, String configContent) {
+    protected void assertConfiguredAsExpected(JenkinsRule j, String configContent) {
         PrioritySorterConfiguration globalConfig = PrioritySorterConfiguration.get();
-        assertFalse("Non-admins cannot edit priority", globalConfig.getOnlyAdminsMayEditPriorityConfiguration());
+        assertFalse(globalConfig.getOnlyAdminsMayEditPriorityConfiguration(), "Non-admins cannot edit priority");
         assertThat("Wrong strategy class", globalConfig.getStrategy().getClass(), is(AbsoluteStrategy.class));
         assertThat("Wrong number of priorities", globalConfig.getStrategy().getNumberOfPriorities(), is(5));
         assertThat("Wrong default priority", globalConfig.getStrategy().getDefaultPriority(), is(3));

diff --git a/src/test/java/jenkins/advancedqueue/JCasCSimpleTest.java b/src/test/java/jenkins/advancedqueue/JCasCSimpleTest.java
@@ -25,19 +25,19 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
-import io.jenkins.plugins.casc.misc.RoundTripAbstractTest;
+import io.jenkins.plugins.casc.misc.junit.jupiter.AbstractRoundTripTest;
 import java.util.List;
 import jenkins.advancedqueue.sorter.strategy.AbsoluteStrategy;
-import org.jvnet.hudson.test.RestartableJenkinsRule;
+import org.jvnet.hudson.test.JenkinsRule;
 
-public class JCasCSimpleTest extends RoundTripAbstractTest {
+public class JCasCSimpleTest extends AbstractRoundTripTest {
 
     @Override
-    protected void assertConfiguredAsExpected(RestartableJenkinsRule j, String configContent) {
+    protected void assertConfiguredAsExpected(JenkinsRule j, String configContent) {
         PrioritySorterConfiguration globalConfig = PrioritySorterConfiguration.get();
-        assertFalse("Non-admins cannot edit priority", globalConfig.getOnlyAdminsMayEditPriorityConfiguration());
+        assertFalse(globalConfig.getOnlyAdminsMayEditPriorityConfiguration(), "Non-admins cannot edit priority");
         assertThat("Wrong strategy class", globalConfig.getStrategy().getClass(), is(AbsoluteStrategy.class));
         assertThat("Wrong number of priorities", globalConfig.getStrategy().getNumberOfPriorities(), is(5));
         assertThat("Wrong default priority", globalConfig.getStrategy().getDefaultPriority(), is(3));

diff --git a/src/test/java/jenkins/advancedqueue/PriorityCalculationsUtilTest.java b/src/test/java/jenkins/advancedqueue/PriorityCalculationsUtilTest.java
@@ -1,27 +1,28 @@
 package jenkins.advancedqueue;
 
-import org.junit.Assert;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-public class PriorityCalculationsUtilTest {
+import org.junit.jupiter.api.Test;
+
+class PriorityCalculationsUtilTest {
 
     @Test
-    public void testScale() {
-        Assert.assertEquals(10, PriorityCalculationsUtil.scale(100, 10, 100));
-        Assert.assertEquals(1, PriorityCalculationsUtil.scale(100, 10, 9));
-        Assert.assertEquals(5, PriorityCalculationsUtil.scale(100, 10, 50));
-        Assert.assertEquals(8, PriorityCalculationsUtil.scale(100, 10, 75));
+    void testScale() {
+        assertEquals(10, PriorityCalculationsUtil.scale(100, 10, 100));
+        assertEquals(1, PriorityCalculationsUtil.scale(100, 10, 9));
+        assertEquals(5, PriorityCalculationsUtil.scale(100, 10, 50));
+        assertEquals(8, PriorityCalculationsUtil.scale(100, 10, 75));
 
-        Assert.assertEquals(1, PriorityCalculationsUtil.scale(5, 10, 1));
-        Assert.assertEquals(3, PriorityCalculationsUtil.scale(5, 10, 2));
-        Assert.assertEquals(5, PriorityCalculationsUtil.scale(5, 10, 3));
-        Assert.assertEquals(8, PriorityCalculationsUtil.scale(5, 10, 4));
-        Assert.assertEquals(10, PriorityCalculationsUtil.scale(5, 10, 5));
+        assertEquals(1, PriorityCalculationsUtil.scale(5, 10, 1));
+        assertEquals(3, PriorityCalculationsUtil.scale(5, 10, 2));
+        assertEquals(5, PriorityCalculationsUtil.scale(5, 10, 3));
+        assertEquals(8, PriorityCalculationsUtil.scale(5, 10, 4));
+        assertEquals(10, PriorityCalculationsUtil.scale(5, 10, 5));
     }
 
     @Test
-    public void testScaleUseDefaultPriority() {
-        Assert.assertEquals(
+    void testScaleUseDefaultPriority() {
+        assertEquals(
                 PriorityCalculationsUtil.getUseDefaultPriorityPriority(),
                 PriorityCalculationsUtil.scale(5, 10, PriorityCalculationsUtil.getUseDefaultPriorityPriority()));
     }

diff --git a/src/test/java/jenkins/advancedqueue/PriorityConfigurationPlaceholderTaskHelperTest.java b/src/test/java/jenkins/advancedqueue/PriorityConfigurationPlaceholderTaskHelperTest.java
@@ -5,10 +5,7 @@
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.not;
 import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -23,23 +20,24 @@
 import org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition;
 import org.jenkinsci.plugins.workflow.job.WorkflowJob;
 import org.jenkinsci.plugins.workflow.support.steps.ExecutorStepExecution;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 
-public class PriorityConfigurationPlaceholderTaskHelperTest {
+@WithJenkins
+class PriorityConfigurationPlaceholderTaskHelperTest {
 
-    @ClassRule
-    public static JenkinsRule j = new JenkinsRule();
+    private static JenkinsRule j;
 
     private static Queue.Item pipelineItemInQuietPeriod;
     private static DecisionLogger decisionLogger;
     private static List<String> loggedMessages;
 
-    @BeforeClass
-    public static void startPipelineJobWithQuietPeriod() throws Exception {
+    @BeforeAll
+    static void beforeAll(JenkinsRule rule) throws Exception {
+        j = rule;
         // Start a Pipeline with a quiet period of 37 seconds before it runs
         String pipelineName = "my-pipeline-in-the-quiet-period";
         WorkflowJob pipeline = j.createProject(WorkflowJob.class, pipelineName);
@@ -53,11 +51,19 @@ public static void startPipelineJobWithQuietPeriod() throws Exception {
         pipeline.setDefinition(new CpsFlowDefinition(pipelineDefinition, true));
         pipeline.scheduleBuild(37, new Cause.UserIdCause());
         pipelineItemInQuietPeriod = findQueueItem(pipelineName);
-        assertNotNull("Pipeline in quiet period not in Queue", pipelineItemInQuietPeriod);
+        assertNotNull(pipelineItemInQuietPeriod, "Pipeline in quiet period not in Queue");
         // Check the item is blocked due to the 37 second quiet period
         assertThat(
                 pipelineItemInQuietPeriod.getCauseOfBlockage().getShortDescription(),
                 startsWith("In the quiet period."));
+
+        decisionLogger = new DecisionLogger() {
+            @Override
+            public DecisionLogger addDecisionLog(int indent, String log) {
+                loggedMessages.add(log);
+                return this;
+            }
+        };
     }
 
     private static Queue.Item findQueueItem(String name) {
@@ -71,24 +77,13 @@ private static Queue.Item findQueueItem(String name) {
         return found;
     }
 
-    @BeforeClass
-    public static void createDecisionLogger() {
-        decisionLogger = new DecisionLogger() {
-            @Override
-            public DecisionLogger addDecisionLog(int indent, String log) {
-                loggedMessages.add(log);
-                return this;
-            }
-        };
-    }
-
-    @Before
-    public void clearLoggedMessages() throws Exception {
+    @BeforeEach
+    void beforeEach() throws Exception {
         loggedMessages = new ArrayList<>();
     }
 
     @Test
-    public void testGetPriorityAssignsGlobalDefault() {
+    void testGetPriorityAssignsGlobalDefault() {
         PriorityConfiguration configuration = new PriorityConfiguration();
         PriorityConfigurationCallbackImpl callback = new PriorityConfigurationCallbackImpl();
         assertThat(callback.getPrioritySelection(), is(-1)); // Before callback is used
@@ -98,14 +93,14 @@ public void testGetPriorityAssignsGlobalDefault() {
     }
 
     @Test
-    public void testIsPlaceholderTask() {
+    void testIsPlaceholderTask() {
         PriorityConfigurationPlaceholderTaskHelper helper = new PriorityConfigurationPlaceholderTaskHelper();
         // Pipeline task is not a placeholder task
         assertFalse(helper.isPlaceholderTask(pipelineItemInQuietPeriod.getTask()));
     }
 
     @Test
-    public void testGetPriority() {
+    void testGetPriority() {
         // Could not find an easy way to generate a placeholder task
         // Use a mock object for better test coverage
         ExecutorStepExecution.PlaceholderTask task = mock(ExecutorStepExecution.PlaceholderTask.class);
@@ -123,7 +118,7 @@ public void testGetPriority() {
     }
 
     @Test
-    public void testGetPriorityNonJobTask() {
+    void testGetPriorityNonJobTask() {
         // Could not find an easy way to generate a placeholder task
         // Use a mock object for better test coverage
         ExecutorStepExecution.PlaceholderTask task = mock(ExecutorStepExecution.PlaceholderTask.class);
@@ -148,7 +143,7 @@ public void testGetPriorityNonJobTask() {
     }
 
     @Test
-    public void testIsPlaceholderTaskUsed() {
+    void testIsPlaceholderTaskUsed() {
         assertTrue(PriorityConfigurationPlaceholderTaskHelper.isPlaceholderTaskUsed());
     }
 

diff --git a/...java/jenkins/advancedqueue/jobinclusion/strategy/FolderBasedJobInclusionStrategyTest.java b/...java/jenkins/advancedqueue/jobinclusion/strategy/FolderBasedJobInclusionStrategyTest.java
@@ -3,40 +3,34 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 import com.cloudbees.hudson.plugins.folder.Folder;
 import hudson.model.FreeStyleProject;
 import hudson.util.ListBoxModel;
 import java.util.ArrayList;
 import java.util.List;
 import jenkins.advancedqueue.DecisionLogger;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 
-public class FolderBasedJobInclusionStrategyTest {
+@WithJenkins
+class FolderBasedJobInclusionStrategyTest {
 
-    @ClassRule
-    public static JenkinsRule j = new JenkinsRule();
+    private static JenkinsRule j;
 
     private static FolderBasedJobInclusionStrategy strategy;
     private static DecisionLogger decisionLogger;
     private static List<String> loggedMessages;
 
-    @BeforeClass
-    public static void createStrategy() throws Exception {
+    @BeforeAll
+    static void beforeAll(JenkinsRule rule) throws Exception {
+        j = rule;
         strategy = new FolderBasedJobInclusionStrategy("testFolder");
-    }
-
-    @BeforeClass
-    public static void createDecisionLogger() throws Exception {
         decisionLogger = new DecisionLogger() {
             @Override
             public DecisionLogger addDecisionLog(int indent, String log) {
@@ -46,65 +40,65 @@ public DecisionLogger addDecisionLog(int indent, String log) {
         };
     }
 
-    @Before
-    public void clearLoggedMessages() throws Exception {
+    @BeforeEach
+    void beforeEach() throws Exception {
         loggedMessages = new ArrayList<>();
     }
 
-    @After
-    public void checkLoggedMessages() throws Exception {
+    @AfterEach
+    void afterEach() throws Exception {
         assertThat(loggedMessages, is(empty()));
     }
 
     @Test
-    public void getDescriptor() {
+    void getDescriptor() {
         assertNotNull(strategy.getDescriptor());
-        assertTrue(
-                strategy.getDescriptor()
-                        instanceof FolderBasedJobInclusionStrategy.FolderBasedJobInclusionStrategyDescriptor);
+        assertInstanceOf(
+                FolderBasedJobInclusionStrategy.FolderBasedJobInclusionStrategyDescriptor.class,
+                strategy.getDescriptor());
     }
 
     @Test
-    public void all() {
+    void all() {
         assertFalse(FolderBasedJobInclusionStrategy.all().isEmpty());
     }
 
     @Test
-    public void getFolderName() {
+    void getFolderName() {
         assertEquals("testFolder", strategy.getFolderName());
     }
 
     @Test
-    public void contains() throws Exception {
+    void contains() throws Exception {
         FreeStyleProject project = this.j.createFreeStyleProject("testFolder_jobName");
 
         assertTrue(strategy.contains(decisionLogger, project));
     }
 
     @Test
-    public void containsReturnsFalseForJobNotInFolder() throws Exception {
+    void containsReturnsFalseForJobNotInFolder() throws Exception {
         FreeStyleProject project = j.createFreeStyleProject("otherFolder_jobName");
 
         assertFalse(strategy.contains(decisionLogger, project));
     }
 
     @Test
-    public void containsReturnsTrueForJobInSubFolder() throws Exception {
+    void containsReturnsTrueForJobInSubFolder() throws Exception {
         FreeStyleProject project = j.createFreeStyleProject("testFolder_subFolder_jobName");
 
         assertTrue(strategy.contains(decisionLogger, project));
     }
 
     @Test
-    public void getListFolderItemsReturnsNonNullListBoxModel() {
+    void getListFolderItemsReturnsNonNullListBoxModel() {
         FolderBasedJobInclusionStrategy.FolderBasedJobInclusionStrategyDescriptor descriptor =
                 new FolderBasedJobInclusionStrategy.FolderBasedJobInclusionStrategyDescriptor();
         ListBoxModel items = descriptor.getListFolderItems();
         assertNotNull(items);
     }
 
     @Test
-    public void getListFolderItemsReturnsCorrectFolderNames() throws Exception {
+    void getListFolderItemsReturnsCorrectFolderNames() throws Exception {
 
         j.jenkins.createProject(Folder.class, "folder1");
         j.jenkins.createProject(Folder.class, "folder2");