add unit tests for password parameter support

src/main/java/org/jenkinsci/plugins/buildwithparameters/BuildParameter.java

@@ -6,9 +6,9 @@
 import hudson.model.StringParameterValue;
 
 public class BuildParameter {
-    private static final String JOB_DEFAULT_PASSWORD_PLACEHOLDER = "job_default_password";
-	private String name, description, value;
+    static final String JOB_DEFAULT_PASSWORD_PLACEHOLDER = "job_default_password";
     private boolean isPasswordParam;
+    private String name, description, value;
 
     public BuildParameter(String name, String description) {
         this.name = name;
@@ -17,11 +17,11 @@ public BuildParameter(String name, String description) {
 
     public static boolean isDefaultPasswordPlaceholder(String candidate) {
     	if(candidate == null) {
-    		return false;
+    	    return false;
     	}
     	return JOB_DEFAULT_PASSWORD_PLACEHOLDER.equals(candidate);
     }
-    
+
     public String getName() {
         return name;
     }
@@ -45,11 +45,10 @@ public void setValue(ParameterValue parameterValue) {
     }
 
     public void setPasswordParam(boolean isPasswordParam) {
-		this.isPasswordParam = isPasswordParam;
+        this.isPasswordParam = isPasswordParam;
 	}
 
     public boolean isPasswordParam() {
-		return isPasswordParam;
+        return isPasswordParam;
 	}
-
 }

src/main/java/org/jenkinsci/plugins/buildwithparameters/BuildWithParametersAction.java

@@ -49,7 +49,7 @@ public List<BuildParameter> getAvailableParameters() {
             buildParameter.setPasswordParam(parameterDefinition.getClass().isAssignableFrom(PasswordParameterDefinition.class));
 
             try {
-                buildParameter.setValue(parameterDefinition.createValue(Stapler.getCurrentRequest()));
+                buildParameter.setValue(getParameterDefinitionValue(parameterDefinition));
             } catch (IllegalArgumentException ignored) {
                 // If a value was provided that does not match available options, leave the value blank.
             }
@@ -60,6 +60,10 @@ public List<BuildParameter> getAvailableParameters() {
         return buildParameters;
     }
 
+    ParameterValue getParameterDefinitionValue(ParameterDefinition parameterDefinition) {
+        return parameterDefinition.createValue(Stapler.getCurrentRequest());
+    }
+
     public String getIconFileName() {
         return "clock.png";
     }
@@ -89,14 +93,7 @@ public void doConfigSubmit(StaplerRequest req, StaplerResponse rsp) throws IOExc
             for (ParameterDefinition parameterDefinition : getParameterDefinitions()) {
                 ParameterValue parameterValue = parameterDefinition.createValue(req);
                 if(parameterValue.getClass().isAssignableFrom(PasswordParameterValue.class)) {
-                    Secret secret = ((PasswordParameterValue) parameterValue).getValue();
-                    String jobPassword = Secret.toString(secret);
-                    if(BuildParameter.isDefaultPasswordPlaceholder(jobPassword)) {
-                    	secret = ((PasswordParameterValue) parameterDefinition.getDefaultParameterValue()).getValue();
-                    	String jobDefaultPassword = Secret.toString(secret);
-                    	ParameterValue passwordParameterValue = new PasswordParameterValue(parameterValue.getName(), jobDefaultPassword);
-                    	parameterValue = passwordParameterValue;
-                    }
+                    parameterValue = applyDefaultPassword(parameterDefinition, parameterValue);
                 }
                 // This will throw an exception if the provided value is not a valid option for the parameter.
                 // This is the desired behavior, as we want to ensure valid submissions.
@@ -109,6 +106,24 @@ public void doConfigSubmit(StaplerRequest req, StaplerResponse rsp) throws IOExc
     }
 
 
+    ParameterValue applyDefaultPassword(ParameterDefinition parameterDefinition,
+            ParameterValue parameterValue) {
+        String jobPassword = getPasswordValue((PasswordParameterValue)parameterValue);
+        if(!BuildParameter.isDefaultPasswordPlaceholder(jobPassword)) {
+            return parameterValue;
+        }
+        String jobDefaultPassword = getPasswordValue(((PasswordParameterValue) parameterDefinition.getDefaultParameterValue()));
+        ParameterValue passwordParameterValue = new PasswordParameterValue(parameterValue.getName(), jobDefaultPassword);
+        return passwordParameterValue;
+    }
+
+
+    static String getPasswordValue(PasswordParameterValue parameterValue) {
+        Secret secret = parameterValue.getValue();
+        return Secret.toString(secret);
+    }
+
+
     //////////////////
     //              //
     //   HELPERS    //

src/test/java/org/jenkinsci/plugins/buildwithparameters/BuildParameterTest.java

@@ -0,0 +1,30 @@
+package org.jenkinsci.plugins.buildwithparameters;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import hudson.model.PasswordParameterValue;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+public class BuildParameterTest {
+    @Rule public JenkinsRule j = new JenkinsRule();
+
+    @Test
+    public void setValue_passwordParam() {
+        BuildParameter bp = new BuildParameter("n","v");
+        bp.setValue(new PasswordParameterValue("asdf", "fdfd"));
+        assertEquals(BuildParameter.JOB_DEFAULT_PASSWORD_PLACEHOLDER, bp.getValue());
+    }
+
+    @Test
+    public void isDefaultPasswordPlaceholder() {
+        String expected = BuildParameter.JOB_DEFAULT_PASSWORD_PLACEHOLDER;
+        assertFalse(BuildParameter.isDefaultPasswordPlaceholder(null));
+        assertFalse(BuildParameter.isDefaultPasswordPlaceholder(""));
+        assertFalse(BuildParameter.isDefaultPasswordPlaceholder(expected + "-"));
+        assertTrue(BuildParameter.isDefaultPasswordPlaceholder(expected));
+    }
+}

src/test/java/org/jenkinsci/plugins/buildwithparameters/BuildWithParametersActionTest.java

@@ -0,0 +1,72 @@
+package org.jenkinsci.plugins.buildwithparameters;
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import hudson.model.ParameterValue;
+import hudson.model.FreeStyleProject;
+import hudson.model.ParameterDefinition;
+import hudson.model.ParametersDefinitionProperty;
+import hudson.model.PasswordParameterDefinition;
+import hudson.model.PasswordParameterValue;
+
+import java.io.IOException;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+public class BuildWithParametersActionTest {
+    @Rule public JenkinsRule j = new JenkinsRule();
+
+    @Test
+    public void getAvailableParameters_passwordParam() throws IOException {
+        ParameterDefinition pwParamDef = new PasswordParameterDefinition("n", BuildParameter.JOB_DEFAULT_PASSWORD_PLACEHOLDER, "d");
+        BuildWithParametersAction bwpa = testableProject(pwParamDef);
+
+        BuildParameter pwParameter = bwpa.getAvailableParameters().get(0);
+        assertTrue(pwParameter.isPasswordParam());
+    }
+
+    private BuildWithParametersAction testableProject(
+            ParameterDefinition pwParamDef) throws IOException {
+        FreeStyleProject project = j.createFreeStyleProject();
+        ParametersDefinitionProperty paramsDef = new ParametersDefinitionProperty(pwParamDef);
+        project.addProperty(paramsDef);
+        BuildWithParametersAction bwpa = new BuildWithParametersAction(project) {
+            @Override
+            ParameterValue getParameterDefinitionValue(
+                    ParameterDefinition parameterDefinition) {
+                return null;
+            }
+        };
+        return bwpa;
+    }
+
+    @Test
+    public void applyDefaultPassword() throws IOException {
+        String jobDefaultPassword = "defaultPassword";
+        String passwordFromRequest = BuildParameter.JOB_DEFAULT_PASSWORD_PLACEHOLDER;
+        String adjustedPassword = applyDefaultPasswordHelper(jobDefaultPassword, passwordFromRequest);
+
+        assertEquals(jobDefaultPassword, adjustedPassword);
+    }
+
+    @Test
+    public void applyDefaultPassword_nonDefault() throws IOException {
+        String jobDefaultPassword = "defaultPassword";
+        String passwordFromRequest = "userSuppliedPassword";
+        String adjustedPassword = applyDefaultPasswordHelper(jobDefaultPassword, passwordFromRequest);
+
+        assertEquals(passwordFromRequest, adjustedPassword);
+    }
+
+    private String applyDefaultPasswordHelper(String jobDefaultPassword, String passwordFromRequest) throws IOException {
+        ParameterDefinition pwParamDef = new PasswordParameterDefinition("n", jobDefaultPassword, "d");
+        BuildWithParametersAction bwpa = testableProject(pwParamDef);
+
+        ParameterValue parameterValue = new PasswordParameterValue("n", passwordFromRequest);
+
+        ParameterValue adjustedParamValue = bwpa.applyDefaultPassword(pwParamDef, parameterValue);
+        return BuildWithParametersAction.getPasswordValue((PasswordParameterValue)adjustedParamValue);
+    }
+}