Add JIRA_ISSUES_SIZE to the JiraEnvironmentVariableBuilder (#707)

* Add configurable JIRA_ISSUES_SIZE to the JiraEnvironmentVariableBuilder

---------
Co-authored-by: Pawel Kozikowski <pawel.kozikowski@atos.net>

Author: rantoniuk

src/main/java/hudson/plugins/jira/JiraEnvironmentContributingAction.java

@@ -6,35 +6,44 @@
 import hudson.model.InvisibleAction;
 
 /*
- * JiraEnvironmentVariableBuilder adds an instance of this class to the build to
- * provide the environment variables
+ * JiraEnvironmentVariableBuilder adds an instance of this class to the build to provide the environment variables
+ *
  */
 public class JiraEnvironmentContributingAction extends InvisibleAction implements EnvironmentContributingAction {
 
     public static final String ISSUES_VARIABLE_NAME = "JIRA_ISSUES";
     public static final String JIRA_URL_VARIABLE_NAME = "JIRA_URL";
+    public static final String ISSUES_SIZE_VARIABLE_NAME = "JIRA_ISSUES_SIZE";
 
     private final String issuesList;
 
+    private final Integer issuesSize;
+
     private final String jiraUrl;
 
     public String getIssuesList() {
         return issuesList;
     }
 
+    public Integer getNumberOfIssues() {
+        return issuesSize;
+    }
+
     public String getJiraUrl() {
         return jiraUrl;
     }
 
-    public JiraEnvironmentContributingAction(String issuesList, String jiraUrl) {
+    public JiraEnvironmentContributingAction(String issuesList, Integer issuesSize, String jiraUrl) {
         this.issuesList = issuesList;
+        this.issuesSize = issuesSize;
         this.jiraUrl = jiraUrl;
     }
 
     @Override
     public void buildEnvVars(AbstractBuild<?, ?> ab, EnvVars ev) {
         if (ev != null) {
-            ev.put(ISSUES_VARIABLE_NAME, issuesList);
+            ev.put(ISSUES_VARIABLE_NAME, getIssuesList());
+            ev.put(ISSUES_SIZE_VARIABLE_NAME, getNumberOfIssues().toString());
             ev.put(JIRA_URL_VARIABLE_NAME, getJiraUrl());
         }
     }

src/main/java/hudson/plugins/jira/JiraEnvironmentVariableBuilder.java

@@ -1,6 +1,5 @@
 package hudson.plugins.jira;
 
-import hudson.AbortException;
 import hudson.Extension;
 import hudson.Launcher;
 import hudson.model.AbstractBuild;
@@ -12,6 +11,7 @@
 import hudson.tasks.Builder;
 import java.io.IOException;
 import java.util.Set;
+import jenkins.model.Jenkins;
 import org.apache.commons.lang.StringUtils;
 import org.kohsuke.stapler.DataBoundConstructor;
 
@@ -46,18 +46,23 @@ public boolean perform(AbstractBuild<?, ?> build, Launcher launcher, BuildListen
         JiraSite site = getSiteForProject(build.getProject());
 
         if (site == null) {
-            throw new AbortException(Messages.JiraEnvironmentVariableBuilder_NoJiraSite());
+            listener.getLogger().println(Messages.JiraEnvironmentVariableBuilder_NoJiraSite());
+            return false;
         }
 
         Set<String> ids = getIssueSelector().findIssueIds(build, site, listener);
 
         String idList = StringUtils.join(ids, ",");
+        Integer idListSize = ids.size();
 
         listener.getLogger()
                 .println(Messages.JiraEnvironmentVariableBuilder_Updating(
                         JiraEnvironmentContributingAction.ISSUES_VARIABLE_NAME, idList));
+        listener.getLogger()
+                .println(Messages.JiraEnvironmentVariableBuilder_Updating(
+                        JiraEnvironmentContributingAction.ISSUES_SIZE_VARIABLE_NAME, idListSize));
 
-        build.addAction(new JiraEnvironmentContributingAction(idList, site.getName()));
+        build.addAction(new JiraEnvironmentContributingAction(idList, idListSize, site.getName()));
 
         return true;
     }
@@ -77,5 +82,9 @@ public boolean isApplicable(Class<? extends AbstractProject> klass) {
         public String getDisplayName() {
             return Messages.JiraEnvironmentVariableBuilder_DisplayName();
         }
+
+        public boolean hasIssueSelectors() {
+            return Jenkins.get().getDescriptorList(AbstractIssueSelector.class).size() > 0;
+        }
     }
 }

src/main/java/hudson/plugins/jira/versionparameter/JiraVersionParameterDefinition.java

@@ -37,7 +37,8 @@ public JiraVersionParameterDefinition(
             String jiraShowReleased,
             String jiraShowArchived,
             String jiraShowUnreleased) {
-        super(name, description);
+        super(name);
+        setDescription(description);
         setJiraProjectKey(jiraProjectKey);
         setJiraReleasePattern(jiraReleasePattern);
         setJiraShowReleased(jiraShowReleased);

src/main/resources/hudson/plugins/jira/JiraEnvironmentVariableBuilder/help.html

@@ -3,6 +3,7 @@
   <div>Available variables:</div>
   <ul>
       <li>JIRA_ISSUES - A comma separated list of issues which are referenced in the version control system changelog</li>
+      <li>JIRA_ISSUES_SIZE - Size of the list described above</li>
       <li>JIRA_URL - Primary URL for the Jira server </li>
   </ul>
   <p>

src/test/java/hudson/plugins/jira/JiraEnvironmentContributingActionTest.java

@@ -13,35 +13,39 @@
 
 class JiraEnvironmentContributingActionTest {
     private static final String JIRA_URL = "http://example.com";
-    private static final String JIRA_URL_PROPERTY_NAME = "JIRA_URL";
-    private static final String ISSUES_PROPERTY_NAME = "JIRA_ISSUES";
     private static final String ISSUES_LIST = "ISS-1,ISS-2";
+    private static final Integer ISSUES_SIZE = 2;
 
     @Test
-    void buildEnvVarsEnvIsNull() {
-        JiraEnvironmentContributingAction action = new JiraEnvironmentContributingAction(ISSUES_LIST, JIRA_URL);
+    public void buildEnvVarsEnvIsNull() {
+        JiraEnvironmentContributingAction action =
+                new JiraEnvironmentContributingAction(ISSUES_LIST, ISSUES_SIZE, JIRA_URL);
         AbstractBuild build = mock(AbstractBuild.class);
 
         action.buildEnvVars(build, null);
         // just expecting no exception
     }
 
     @Test
-    void buildEnvVarsAddVariables() {
-        JiraEnvironmentContributingAction action = new JiraEnvironmentContributingAction(ISSUES_LIST, JIRA_URL);
-        AbstractBuild build = mock(AbstractBuild.class);
+    public void buildEnvVarsAddVariables() {
+        JiraEnvironmentContributingAction action =
+                new JiraEnvironmentContributingAction(ISSUES_LIST, ISSUES_SIZE, JIRA_URL);
+        AbstractBuild<?, ?> build = mock(AbstractBuild.class);
         EnvVars envVars = mock(EnvVars.class);
 
         action.buildEnvVars(build, envVars);
 
         ArgumentCaptor<String> keys = ArgumentCaptor.forClass(String.class);
         ArgumentCaptor<String> values = ArgumentCaptor.forClass(String.class);
-        verify(envVars, times(2)).put(keys.capture(), values.capture());
+        verify(envVars, times(3)).put(keys.capture(), values.capture());
 
-        assertThat(keys.getAllValues().get(0), is(ISSUES_PROPERTY_NAME));
+        assertThat(keys.getAllValues().get(0), is(JiraEnvironmentContributingAction.ISSUES_VARIABLE_NAME));
         assertThat(values.getAllValues().get(0), is(ISSUES_LIST));
 
-        assertThat(keys.getAllValues().get(1), is(JIRA_URL_PROPERTY_NAME));
-        assertThat(values.getAllValues().get(1), is(JIRA_URL));
+        assertThat(keys.getAllValues().get(1), is(JiraEnvironmentContributingAction.ISSUES_SIZE_VARIABLE_NAME));
+        assertThat(values.getAllValues().get(1), is(ISSUES_SIZE.toString()));
+
+        assertThat(keys.getAllValues().get(2), is(JiraEnvironmentContributingAction.JIRA_URL_VARIABLE_NAME));
+        assertThat(values.getAllValues().get(2), is(JIRA_URL));
     }
 }

src/test/java/hudson/plugins/jira/JiraEnvironmentVariableBuilderTest.java

@@ -4,14 +4,15 @@
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import hudson.AbortException;
 import hudson.EnvVars;
 import hudson.Launcher;
 import hudson.model.AbstractBuild;
@@ -21,20 +22,23 @@
 import hudson.model.Node;
 import hudson.plugins.jira.selector.AbstractIssueSelector;
 import hudson.plugins.jira.selector.DefaultIssueSelector;
+import hudson.plugins.jira.selector.ExplicitIssueSelector;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.Arrays;
 import java.util.LinkedHashSet;
+import org.junit.Rule;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.WithoutJenkins;
+import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
 
+@WithJenkins
 class JiraEnvironmentVariableBuilderTest {
 
     private static final String JIRA_URL = "http://example.com";
-    private static final String JIRA_URL_PROPERTY_NAME = "JIRA_URL";
-    private static final String ISSUES_PROPERTY_NAME = "JIRA_ISSUES";
     private static final String ISSUE_ID_1 = "ISS-1";
     private static final String ISSUE_ID_2 = "ISS-2";
 
@@ -47,12 +51,15 @@ class JiraEnvironmentVariableBuilderTest {
     Launcher launcher;
     BuildListener listener;
     EnvVars env;
-    AbstractProject project;
+    AbstractProject<?, ?> project;
     JiraSite site;
     AbstractIssueSelector issueSelector;
     PrintStream logger;
     Node node;
 
+    @Rule
+    JenkinsRule jenkinsRule = new JenkinsRule();
+
     @BeforeEach
     void createMocks() throws IOException, InterruptedException {
         build = mock(AbstractBuild.class);
@@ -76,29 +83,33 @@ void createMocks() throws IOException, InterruptedException {
     }
 
     @Test
-    void issueSelectorDefaultsToDefault() {
+    @WithoutJenkins
+    public void testIssueSelectorDefaultsToDefault() {
         final JiraEnvironmentVariableBuilder builder = new JiraEnvironmentVariableBuilder(null);
         assertThat(builder.getIssueSelector(), instanceOf(DefaultIssueSelector.class));
     }
 
     @Test
-    void setIssueSelectorPersists() {
+    @WithoutJenkins
+    public void testSetIssueSelectorPersists() {
         final JiraEnvironmentVariableBuilder builder = new JiraEnvironmentVariableBuilder(issueSelector);
         assertThat(builder.getIssueSelector(), is(issueSelector));
     }
 
     @Test
-    void performWithNoSiteFailsBuild() {
+    @WithoutJenkins
+    public void testPerformWithNoSiteFailsBuild() throws InterruptedException, IOException {
         JiraEnvironmentVariableBuilder builder = spy(new JiraEnvironmentVariableBuilder(issueSelector));
-        doReturn(null).when(builder).getSiteForProject(Mockito.any());
-        assertThrows(AbortException.class, () -> builder.perform(build, launcher, listener));
+        doReturn(null).when(builder).getSiteForProject(project);
+        assertThat(builder.perform(build, launcher, listener), is(false));
+        verify(logger, times(1)).println(Messages.JiraEnvironmentVariableBuilder_NoJiraSite());
     }
 
     @Test
-    void performAddsAction() throws InterruptedException, IOException {
+    @WithoutJenkins
+    public void testPerformAddsAction() throws InterruptedException, IOException {
         JiraEnvironmentVariableBuilder builder = spy(new JiraEnvironmentVariableBuilder(issueSelector));
-        doReturn(site).when(builder).getSiteForProject(Mockito.any());
-
+        doReturn(site).when(builder).getSiteForProject(project);
         boolean result = builder.perform(build, launcher, listener);
 
         assertThat(result, is(true));
@@ -112,5 +123,25 @@ void performAddsAction() throws InterruptedException, IOException {
 
         assertThat(action.getJiraUrl(), is(JIRA_URL));
         assertThat(action.getIssuesList(), anyOf(is(EXPECTED_JIRA_ISSUES_1), is(EXPECTED_JIRA_ISSUES_2)));
+        assertThat(action.getNumberOfIssues(), is(2));
+    }
+
+    @Test
+    public void testHasIssueSelectors_HasDefaultSelector(JenkinsRule r) {
+        JiraEnvironmentVariableBuilder builder = new JiraEnvironmentVariableBuilder(null);
+        assertThat(builder.getIssueSelector(), instanceOf(DefaultIssueSelector.class));
+        JiraEnvironmentVariableBuilder.DescriptorImpl descriptor =
+                (JiraEnvironmentVariableBuilder.DescriptorImpl) r.jenkins.getDescriptor(builder.getClass());
+        assertTrue(descriptor.hasIssueSelectors());
+    }
+
+    @Test
+    public void testHasIssueSelectors(JenkinsRule r) {
+        ExplicitIssueSelector explicitIssueSelector = new ExplicitIssueSelector();
+        JiraEnvironmentVariableBuilder builder = new JiraEnvironmentVariableBuilder(explicitIssueSelector);
+        assertEquals(explicitIssueSelector, builder.getIssueSelector());
+        JiraEnvironmentVariableBuilder.DescriptorImpl descriptor =
+                (JiraEnvironmentVariableBuilder.DescriptorImpl) r.jenkins.getDescriptor(builder.getClass());
+        assertTrue(descriptor.hasIssueSelectors());
     }
 }

src/test/java/hudson/plugins/jira/versionparameter/JiraVersionParameterDefinitionTest.java

@@ -6,7 +6,6 @@
 
 import hudson.cli.CLICommand;
 import hudson.model.Job;
-import hudson.model.ParameterDefinition;
 import hudson.model.ParameterValue;
 import hudson.plugins.jira.JiraSession;
 import hudson.plugins.jira.JiraSite;
@@ -54,12 +53,20 @@ void createMocksAndVersions() {
 
     @Test
     void parameterValueMethodOverrides() throws Exception {
-        ParameterDefinition definition =
-                new JiraVersionParameterDefinition("pname", "pdesc", "JIRAKEY", null, "false", "false", "false");
+        JiraVersionParameterDefinition definition =
+                new JiraVersionParameterDefinition("pname", "pdesc", "JIRAKEY", null, "false", "true", "true");
+
+        assertEquals("JIRAKEY", definition.getJiraProjectKey());
+        assertEquals("false", definition.getJiraShowReleased());
+        assertEquals("true", definition.getJiraShowArchived());
+        assertEquals("true", definition.getJiraShowUnreleased());
+
+        assertEquals("pdesc", definition.getDescription());
+
         CLICommand cliCommand = mock(CLICommand.class);
 
         ParameterValue value = definition.createValue(cliCommand, "Jira Version 1.2.3");
-        assertEquals("pname", value.getName());
+        assertEquals(definition.getName(), value.getName());
         assertEquals("Jira Version 1.2.3", value.getValue());
     }