Broaden the temp offline eligibility tests

Start the Jenkins controller only once for the entire test so that it
runs faster.  This is more important on Windows than on Linux, but is not
harmful because the tests configure their needed Jenkins configuration
at the start of each test.

Use nodeName as the isEligible argument rather than label string.
Label string did not match a node so would always return false.
Remove the label declaration since it is not needed for these tests.

Confirm that the Jenkins controller is eligible when it has executors
and is not eligible when it does not have executors.

Check more details of the descriptors.

Author: MarkEWaite

src/test/java/org/jvnet/jenkins/plugins/nodelabelparameter/IgnoreTempOfflineNodeEligibilityTest.java

@@ -1,60 +1,94 @@
 package org.jvnet.jenkins.plugins.nodelabelparameter;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+import static org.hamcrest.Matchers.hasProperty;
+import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
 import hudson.DescriptorExtensionList;
 import hudson.model.Node;
-import hudson.model.labels.LabelAtom;
 import hudson.slaves.DumbSlave;
-import org.junit.Before;
-import org.junit.Rule;
+import java.util.Random;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
 import org.junit.Test;
 import org.jvnet.hudson.test.JenkinsRule;
 import org.jvnet.jenkins.plugins.nodelabelparameter.node.IgnoreTempOfflineNodeEligibility;
 import org.jvnet.jenkins.plugins.nodelabelparameter.node.NodeEligibility;
 import org.jvnet.jenkins.plugins.nodelabelparameter.node.NodeEligibility.NodeEligibilityDescriptor;
 
 public class IgnoreTempOfflineNodeEligibilityTest {
-    @Rule
-    public JenkinsRule j = new JenkinsRule();
+    @ClassRule
+    public static JenkinsRule j = new JenkinsRule();
 
-    private DumbSlave onlineNode1;
+    private static DumbSlave onlineNode1;
 
-    @Before
-    public void setUp() throws Exception {
-        onlineNode1 = j.createOnlineSlave(new LabelAtom("label"));
+    @BeforeClass
+    public static void createAgent() throws Exception {
+        onlineNode1 = j.createOnlineSlave();
     }
 
-    IgnoreTempOfflineNodeEligibility ignoreTempOfflineNodeEligibility = new IgnoreTempOfflineNodeEligibility();
+    private final IgnoreTempOfflineNodeEligibility ignoreTempOfflineNodeEligibility =
+            new IgnoreTempOfflineNodeEligibility();
+    private final Random random = new Random();
 
     @Test
     public void testGetComputer() throws Exception {
+        // Does not matter if executors on the Jenkins controller are enabled
+        j.jenkins.setNumExecutors(random.nextBoolean() ? 1 : 0);
+
+        // Null node is never eligible
         Node node = null;
-        // Node is null
         assertFalse(ignoreTempOfflineNodeEligibility.isEligible(node));
-        // Node is not null
-        assertFalse(ignoreTempOfflineNodeEligibility.isEligible(onlineNode1.getLabelString()));
-        // Node is null and nodeName is empty
+        // Non-existent node name is never eligible
+        assertFalse(ignoreTempOfflineNodeEligibility.isEligible("not-a-valid-node"));
+
+        // Online node is always eligible
+        assertTrue(ignoreTempOfflineNodeEligibility.isEligible(onlineNode1));
+        // Online node name is always eligible
+        assertTrue(ignoreTempOfflineNodeEligibility.isEligible(onlineNode1.getNodeName()));
+    }
+
+    @Test
+    public void testGetComputerWithControllerExecutor() throws Exception {
+        // Enable executors on the Jenkins controller
+        j.jenkins.setNumExecutors(1);
+
+        // Node of the Jenkins controller is eligible because it has executors
+        assertTrue(ignoreTempOfflineNodeEligibility.isEligible(j.jenkins));
+        // Empty node name is eligible because empty string matches the controller
         assertTrue(ignoreTempOfflineNodeEligibility.isEligible(""));
+        // Node name of the Jenkins controller is eligible because it has executors
+        assertTrue(ignoreTempOfflineNodeEligibility.isEligible("built-in"));
+    }
+
+    @Test
+    public void testGetComputerWithoutControllerExecutor() throws Exception {
+        // Disable executors on the Jenkins controller
+        j.jenkins.setNumExecutors(0);
+
+        // Node of the Jenkins controller is not eligible because it has no executors
+        assertFalse(ignoreTempOfflineNodeEligibility.isEligible(j.jenkins));
+        // Empty node name is not eligible because empty string matches the controller
+        assertFalse(ignoreTempOfflineNodeEligibility.isEligible(""));
+        // Node name of the Jenkins controller is not eligible because it has no executors
+        assertFalse(ignoreTempOfflineNodeEligibility.isEligible("built-in"));
     }
 
     @Test
     public void testGetDescriptor() {
         NodeEligibilityDescriptor descriptor = ignoreTempOfflineNodeEligibility.getDescriptor();
-        // Check if descriptor is not null
-        assertNotNull(descriptor);
-        // Check if descriptor is an instance of NodeEligibilityDescriptor
-        assertTrue(descriptor instanceof NodeEligibilityDescriptor);
+        assertThat(descriptor.getDisplayName(), is("Ignore Temp Offline Nodes"));
     }
 
     @Test
     public void testAll() {
         DescriptorExtensionList<NodeEligibility, NodeEligibilityDescriptor> descriptors = NodeEligibility.all();
-        // Check if descriptors is not empty
-        assertTrue(!descriptors.isEmpty());
-        // Check if descriptors is not null
-        assertNotNull(descriptors);
+        assertThat(descriptors, hasItem(hasProperty("displayName", is("All Nodes"))));
+        assertThat(descriptors, hasItem(hasProperty("displayName", is("Ignore Offline Nodes"))));
+        assertThat(descriptors, hasItem(hasProperty("displayName", is("Ignore Temp Offline Nodes"))));
+        assertThat(descriptors.size(), is(3));
     }
 }