entry : variables.entrySet()) {
59 | context.env(entry.getKey(), entry.getValue());
60 | }
61 | }
62 |
63 | /**
64 | * Retrieve user cause that triggered this build and populate variables accordingly
65 | *
66 | * TODO: The whole hierarchy and way of applying could be refactored.
67 | */
68 | @Restricted(NoExternalUse.class)
69 | static void makeUserBuildVariables(@NonNull Run build, @NonNull Map variables) {
70 |
71 | /* Try to use UserIdCause to get & set jenkins user build variables */
72 | UserIdCause userIdCause = build.getCause(UserIdCause.class);
73 | if (new UserIdCauseDeterminant().setJenkinsUserBuildVars(userIdCause, variables)) {
74 | return;
75 | }
76 |
77 | // Try to use deprecated UserCause to get & set jenkins user build variables
78 | @SuppressWarnings("deprecation")
79 | UserCause userCause = build.getCause(UserCause.class);
80 | if (new UserCauseDeterminant().setJenkinsUserBuildVars(userCause, variables)) {
81 | return;
82 | }
83 |
84 | // If build has been triggered form an upstream build, get UserCause from there to set user build variables
85 | UpstreamCause upstreamCause = build.getCause(UpstreamCause.class);
86 | if (upstreamCause != null) {
87 | Job job = Jenkins.get().getItemByFullName(upstreamCause.getUpstreamProject(), Job.class);
88 | if (job != null) {
89 | Run upstream = job.getBuildByNumber(upstreamCause.getUpstreamBuild());
90 | if (upstream != null) {
91 | makeUserBuildVariables(upstream, variables);
92 | return;
93 | }
94 | }
95 | }
96 |
97 | // Other causes should be checked after as build can be triggered automatically and later rerun manually by a human.
98 | // In that case there will be multiple causes and the direct manually one is preferred to set in a variable.
99 | handleOtherCausesOrLogWarningIfUnhandled(build, variables);
100 | }
101 |
102 | private static void handleOtherCausesOrLogWarningIfUnhandled(@NonNull Run build, @NonNull Map variables) {
103 | // set BUILD_USER_NAME and ID to fixed value if the build was triggered by a change in the scm, timer or remotely with token
104 | SCMTriggerCause scmTriggerCause = build.getCause(SCMTriggerCause.class);
105 | if (new SCMTriggerCauseDeterminant().setJenkinsUserBuildVars(scmTriggerCause, variables)) {
106 | return;
107 | }
108 |
109 | TimerTriggerCause timerTriggerCause = build.getCause(TimerTriggerCause.class);
110 | if (new TimerTriggerCauseDeterminant().setJenkinsUserBuildVars(timerTriggerCause, variables)) {
111 | return;
112 | }
113 |
114 | RemoteCause remoteTriggerCause = build.getCause(RemoteCause.class);
115 | if (new RemoteCauseDeterminant().setJenkinsUserBuildVars(remoteTriggerCause, variables)) {
116 | return;
117 | }
118 |
119 | try {
120 | BranchIndexingCause branchIndexingCause = build.getCause(BranchIndexingCause.class);
121 | if (new BranchIndexingTriggerDeterminant().setJenkinsUserBuildVars(branchIndexingCause, variables)) {
122 | return;
123 | }
124 |
125 | BranchEventCause branchEventCause = build.getCause(BranchEventCause.class);
126 | if (branchEventCause != null) {
127 | // branch event cause does not have to be logged.
128 | return;
129 | }
130 | } catch (NoClassDefFoundError e) {
131 | log.fine("It seems the branch-api plugin is not installed, skipping.");
132 | }
133 |
134 | log.warning(() -> "Unsupported cause type(s): " + Arrays.toString(build.getCauses().toArray()));
135 | }
136 |
137 | @Extension
138 | @Symbol("withBuildUser")
139 | public static class DescriptorImpl extends BuildWrapperDescriptor {
140 | @Override
141 | public boolean isApplicable(AbstractProject item) {
142 | return true;
143 | }
144 |
145 | @NonNull
146 | @Override
147 | public String getDisplayName() {
148 | return EXTENSION_DISPLAY_NAME;
149 | }
150 | }
151 | }
152 |
153 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/BuildUserVarsConfig.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser;
2 |
3 | import hudson.Extension;
4 | import hudson.ExtensionList;
5 |
6 | import jenkins.model.GlobalConfiguration;
7 |
8 | import org.jenkinsci.Symbol;
9 | import org.kohsuke.stapler.DataBoundSetter;
10 |
11 | @Extension
12 | @Symbol("buildUserVars")
13 | public class BuildUserVarsConfig extends GlobalConfiguration {
14 |
15 | /** @return the singleton instance */
16 | public static BuildUserVarsConfig get() {
17 | return ExtensionList.lookupSingleton(BuildUserVarsConfig.class);
18 | }
19 |
20 | /** Whether to activate {@link BuildUserVarsEnvironmentContributor}. */
21 | private boolean allBuilds;
22 |
23 | public BuildUserVarsConfig() {
24 | // When Jenkins is restarted, load any saved configuration from disk.
25 | load();
26 | }
27 |
28 | public boolean isAllBuilds() {
29 | return allBuilds;
30 | }
31 |
32 | @DataBoundSetter
33 | public void setAllBuilds(boolean allBuilds) {
34 | this.allBuilds = allBuilds;
35 | save();
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/BuildUserVarsEnvironmentContributor.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser;
2 |
3 | import edu.umd.cs.findbugs.annotations.NonNull;
4 |
5 | import hudson.EnvVars;
6 | import hudson.Extension;
7 | import hudson.model.EnvironmentContributor;
8 | import hudson.model.Run;
9 | import hudson.model.TaskListener;
10 |
11 | @Extension
12 | public class BuildUserVarsEnvironmentContributor extends EnvironmentContributor {
13 |
14 | @Override
15 | public void buildEnvironmentFor(
16 | @NonNull Run r, @NonNull EnvVars envs, @NonNull TaskListener listener) {
17 | if (BuildUserVarsConfig.get().isAllBuilds()) {
18 | BuildUser.makeUserBuildVariables(r, envs);
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/utils/BuildUserVariable.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.utils;
2 |
3 | public class BuildUserVariable {
4 | public static final String USERNAME = "BUILD_USER";
5 | public static final String GROUPS = "BUILD_USER_GROUPS";
6 | public static final String FIRST_NAME = "BUILD_USER_FIRST_NAME";
7 | public static final String LAST_NAME = "BUILD_USER_LAST_NAME";
8 | public static final String EMAIL = "BUILD_USER_EMAIL";
9 | public static final String ID = "BUILD_USER_ID";
10 | public static final String UNDEFINED = "UNDEFINED";
11 |
12 | private BuildUserVariable() {
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/utils/UsernameUtils.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.utils;
2 |
3 | import java.util.Map;
4 |
5 | /**
6 | * Utility class for manipulating and extracting parts from a full username.
7 | * This class provides methods to split a full username into first and last names.
8 | *
9 | * @author GKonovalenko
10 | */
11 | public final class UsernameUtils {
12 |
13 | private UsernameUtils() {
14 | }
15 |
16 | /**
17 | * Splits a full username string into first and last names and sets the appropriate build variables.
18 | *
19 | * @param username The full username string, usually in the format "First Last"
20 | * @param variables A map to store the extracted variables, where to put build variables.
21 | */
22 | public static void setUsernameVars(String username, Map variables) {
23 | variables.put(BuildUserVariable.USERNAME, username);
24 | variables.put(BuildUserVariable.FIRST_NAME, getFirstName(username));
25 | variables.put(BuildUserVariable.LAST_NAME, getLastName(username));
26 | }
27 |
28 | /**
29 | * Extracts the first name from a full name.
30 | *
31 | * @param fullName The full name string, e.g., "First Last"
32 | * @return The first name ("First")
33 | */
34 | public static String getFirstName(String fullName) {
35 | if (fullName == null || fullName.trim().isEmpty()) {
36 | return "";
37 | }
38 | String[] parts = splitName(fullName);
39 | return parts[0];
40 | }
41 |
42 | /**
43 | * Extracts the last name from a full name.
44 | *
45 | * @param fullName The full name string, e.g., "First Last"
46 | * @return The last name ("Last")
47 | */
48 | public static String getLastName(String fullName) {
49 | if (fullName == null || fullName.trim().isEmpty()) {
50 | return "";
51 | }
52 | String[] parts = splitName(fullName);
53 | return parts.length >= 2 ? parts[1] : "";
54 | }
55 |
56 | /**
57 | * Splits a full name into its constituent parts.
58 | *
59 | * @param fullName The full name string, e.g., "First Last"
60 | * @return An array containing the first and last name
61 | */
62 | private static String[] splitName(String fullName) {
63 | return fullName.trim().split("\\s+");
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/IUsernameSettable.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter;
2 |
3 | import hudson.model.Cause;
4 |
5 | import java.util.Map;
6 |
7 | /**
8 | * Interface declaring method for setting jenkins user build variables parametrized by
9 | * {@link Cause} subclasses.
10 | *
11 | * User based {@link Cause} instance is the source of username data.
12 | *
13 | *
14 | * - BUILD_USER -- full name of user started build,
15 | * - BUILD_USER_FIRST_NAME -- first name of user started build,
16 | * - BUILD_USER_LAST_NAME -- last name of user started build,
17 | * - BUILD_USER_ID -- id of user started build.
18 | *
19 | *
20 | * @author GKonovalenko
21 | */
22 | public interface IUsernameSettable {
23 | /**
24 | * Adds username build variables extracted from build cause to map of build variables.
25 | *
26 | * @param cause cause where to get username from.
27 | * @param variables ap of build variables, where to add username variables.
28 | * @return
29 | * true if username was determined and added to the passed map,
30 | * false otherwise.
31 | */
32 | boolean setJenkinsUserBuildVars(T cause, Map variables);
33 |
34 | /**
35 | * Returns {@link Cause} subclass used to determine username.
36 | * @return class used to determine username.
37 | */
38 | Class getUsedCauseClass();
39 | }
40 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/impl/BranchIndexingTriggerDeterminant.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import jenkins.branch.BranchIndexingCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
6 | import org.jenkinsci.plugins.builduser.varsetter.IUsernameSettable;
7 |
8 | import java.util.Map;
9 |
10 | public class BranchIndexingTriggerDeterminant implements IUsernameSettable {
11 |
12 | @Override
13 | public boolean setJenkinsUserBuildVars(BranchIndexingCause cause, Map variables) {
14 | if (cause == null) {
15 | return false;
16 | }
17 |
18 | UsernameUtils.setUsernameVars("Branch Indexing", variables);
19 | variables.put(BuildUserVariable.ID, "branchIndexing");
20 | return true;
21 | }
22 |
23 | @Override
24 | public Class getUsedCauseClass() {
25 | return BranchIndexingCause.class;
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/impl/RemoteCauseDeterminant.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.RemoteCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
6 | import org.jenkinsci.plugins.builduser.varsetter.IUsernameSettable;
7 |
8 | import java.util.Map;
9 |
10 | public class RemoteCauseDeterminant implements IUsernameSettable {
11 |
12 | @Override
13 | public boolean setJenkinsUserBuildVars(RemoteCause cause, Map variables) {
14 | if (cause == null) {
15 | return false;
16 | }
17 |
18 | //As of Jenkins 2.51 remote cause is set the build was triggered using token and real user is not set
19 | UsernameUtils.setUsernameVars(String.format("%s %s", cause.getAddr(), cause.getNote()), variables);
20 | variables.put(BuildUserVariable.ID, "remoteRequest");
21 | return true;
22 | }
23 |
24 | @Override
25 | public Class getUsedCauseClass() {
26 | return RemoteCause.class;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/impl/SCMTriggerCauseDeterminant.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.triggers.SCMTrigger.SCMTriggerCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
6 | import org.jenkinsci.plugins.builduser.varsetter.IUsernameSettable;
7 |
8 | import java.util.Map;
9 |
10 | public class SCMTriggerCauseDeterminant implements IUsernameSettable {
11 |
12 | public boolean setJenkinsUserBuildVars(SCMTriggerCause cause, Map variables) {
13 | if (cause == null) {
14 | return false;
15 | }
16 |
17 | UsernameUtils.setUsernameVars("SCM Change", variables);
18 | variables.put(BuildUserVariable.ID, "scmChange");
19 |
20 | return true;
21 | }
22 |
23 | public Class getUsedCauseClass() {
24 | return SCMTriggerCause.class;
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/impl/TimerTriggerCauseDeterminant.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.triggers.TimerTrigger.TimerTriggerCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
6 | import org.jenkinsci.plugins.builduser.varsetter.IUsernameSettable;
7 |
8 | import java.util.Map;
9 |
10 | public class TimerTriggerCauseDeterminant implements IUsernameSettable {
11 |
12 | protected static final String TIMER_TRIGGER_DUMMY_USER_NAME = "Timer Trigger";
13 | protected static final String TIMER_TRIGGER_DUMMY_USER_ID = "timer";
14 |
15 | @Override
16 | public boolean setJenkinsUserBuildVars(TimerTriggerCause cause, Map variables) {
17 | if (cause == null) {
18 | return false;
19 | }
20 |
21 | UsernameUtils.setUsernameVars(TIMER_TRIGGER_DUMMY_USER_NAME, variables);
22 | variables.put(BuildUserVariable.ID, TIMER_TRIGGER_DUMMY_USER_ID);
23 | return true;
24 | }
25 |
26 | @Override
27 | public Class getUsedCauseClass() {
28 | return TimerTriggerCause.class;
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/impl/UserCauseDeterminant.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.UserCause;
4 | import hudson.model.Cause.UserIdCause;
5 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
6 | import org.jenkinsci.plugins.builduser.varsetter.IUsernameSettable;
7 |
8 | import java.util.Map;
9 |
10 | /**
11 | * This implementation is used to determine build username variables from {@link UserCause}.
12 | * This could be used with legacy version of jenkins, where {@link UserCause} is used instead of {@link UserIdCause}.
13 | *
14 | * @author GKonovalenko
15 | */
16 | @SuppressWarnings("deprecation")
17 | public class UserCauseDeterminant implements IUsernameSettable {
18 |
19 | /**
20 | * {@inheritDoc}
21 | *
22 | * {@link UserCause} based implementation.
23 | */
24 | public boolean setJenkinsUserBuildVars(UserCause cause, Map variables) {
25 | if (cause == null) {
26 | return false;
27 | }
28 |
29 | String username = cause.getUserName();
30 | UsernameUtils.setUsernameVars(username, variables);
31 |
32 | return true;
33 | }
34 |
35 | /**
36 | * {@inheritDoc}
37 | */
38 | public Class getUsedCauseClass() {
39 | return UserCause.class;
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/main/java/org/jenkinsci/plugins/builduser/varsetter/impl/UserIdCauseDeterminant.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.UserIdCause;
4 | import hudson.model.User;
5 | import hudson.security.ACL;
6 | import hudson.security.SecurityRealm;
7 | import hudson.tasks.MailAddressResolver;
8 | import jenkins.model.Jenkins;
9 | import org.apache.commons.lang.StringUtils;
10 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
11 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
12 | import org.jenkinsci.plugins.builduser.varsetter.IUsernameSettable;
13 | import org.jenkinsci.plugins.saml.SamlSecurityRealm;
14 | import org.springframework.security.core.GrantedAuthority;
15 |
16 | import java.util.Map;
17 | import java.util.Optional;
18 | import java.util.logging.Logger;
19 | import java.util.stream.Collectors;
20 |
21 | /**
22 | * This implementation is used to determine build username variables from {@link UserIdCause}.
23 | *
24 | * @author GKonovalenko
25 | */
26 | public class UserIdCauseDeterminant implements IUsernameSettable {
27 |
28 | private static final Logger log = Logger.getLogger(UserIdCauseDeterminant.class.getName());
29 |
30 | /**
31 | * {@inheritDoc}
32 | *
33 | * {@link UserIdCause} based implementation.
34 | */
35 | public boolean setJenkinsUserBuildVars(UserIdCause cause, Map variables) {
36 | if (cause == null) {
37 | return false;
38 | }
39 |
40 | String username = cause.getUserName();
41 | UsernameUtils.setUsernameVars(username, variables);
42 |
43 | String trimmedUserId = StringUtils.trimToEmpty(cause.getUserId());
44 | String originalUserId = trimmedUserId.isEmpty() ? ACL.ANONYMOUS_USERNAME : trimmedUserId;
45 | String userid = mapUserId(originalUserId);
46 |
47 | variables.put(BuildUserVariable.ID, userid);
48 |
49 | setUserGroups(originalUserId, variables);
50 | setUserEmail(originalUserId, variables);
51 |
52 | return true;
53 | }
54 |
55 | private String mapUserId(String userId) {
56 | try {
57 | SecurityRealm realm = Jenkins.get().getSecurityRealm();
58 | if (realm instanceof SamlSecurityRealm samlSecurityRealm) {
59 | String conversion = samlSecurityRealm.getUsernameCaseConversion();
60 | return switch (conversion) {
61 | case "lowercase" -> userId.toLowerCase();
62 | case "uppercase" -> userId.toUpperCase();
63 | default -> userId;
64 | };
65 | }
66 | } catch (NoClassDefFoundError e) {
67 | log.fine("It seems the saml plugin is not installed, skipping saml user name mapping.");
68 | }
69 | return userId;
70 | }
71 |
72 | private void setUserGroups(String userId, Map variables) {
73 | try {
74 | Optional.ofNullable(User.getById(userId, false))
75 | .map(User::impersonate2)
76 | .map(authentication -> authentication.getAuthorities().stream()
77 | .map(GrantedAuthority::getAuthority)
78 | .filter(authority -> authority != null && !authority.isEmpty())
79 | .collect(Collectors.joining(","))
80 | ).ifPresentOrElse(groups ->
81 | variables.put(BuildUserVariable.GROUPS, groups)
82 | , () ->
83 | variables.put(BuildUserVariable.GROUPS, "")
84 | );
85 | } catch (Exception err) {
86 | log.warning(String.format("Failed to get groups for user: %s error: %s ", userId, err));
87 | }
88 | }
89 |
90 | private void setUserEmail(String userId, Map variables) {
91 | Optional.ofNullable(User.getById(userId, false))
92 | .map(MailAddressResolver::resolve)
93 | .ifPresent(email -> variables.put(BuildUserVariable.EMAIL, email));
94 | }
95 |
96 | /**
97 | * {@inheritDoc}
98 | */
99 | public Class getUsedCauseClass() {
100 | return UserIdCause.class;
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/resources/index.jelly:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 | This plugin is used to set user build variables: jenkins user name and id.
9 |
--------------------------------------------------------------------------------
/src/main/resources/org/jenkinsci/plugins/builduser/BuildUser/config.jelly:
--------------------------------------------------------------------------------
1 |
2 |
3 |
8 |
9 |
--------------------------------------------------------------------------------
/src/main/resources/org/jenkinsci/plugins/builduser/BuildUser/global.jelly:
--------------------------------------------------------------------------------
1 |
2 |
3 |
15 |
17 |
18 |
--------------------------------------------------------------------------------
/src/main/resources/org/jenkinsci/plugins/builduser/BuildUser/help.html:
--------------------------------------------------------------------------------
1 |
2 | This plugin is used to set user build variables:
3 |
4 | - BUILD_USER -- full name of user started build,
5 | - BUILD_USER_FIRST_NAME -- first name of user started build,
6 | - BUILD_USER_LAST_NAME -- last name of user started build,
7 | - BUILD_USER_ID -- id of user started build.
8 | - BUILD_USER_EMAIL -- email of user started build.
9 |
10 |
2 | When checked, build user variables will be added to the environment for all builds.
3 | There is no need to use the Set Jenkins user build variables wrapper.
4 |
5 |
--------------------------------------------------------------------------------
/src/main/webapp/help.html:
--------------------------------------------------------------------------------
1 |
2 | This plugin is used to set user build variables:
3 |
4 | - BUILD_USER -- full name of user started build,
5 | - BUILD_USER_FIRST_NAME -- first name of user started build,
6 | - BUILD_USER_LAST_NAME -- last name of user started build,
7 | - BUILD_USER_ID -- id of user started build.
8 | - BUILD_USER_EMAIL -- email of user started build.
9 |
10 |
20 | * - missing {@code load}
21 | *
- missing {@code save}
22 | *
- misnamed or absent getter/setter
23 | *
- misnamed {@code textbox}
24 | *
25 | */
26 | @Test
27 | void uiAndStorage(JenkinsRule r) throws Throwable {
28 | assertFalse(BuildUserVarsConfig.get().isAllBuilds(), "not set initially");
29 | HtmlForm config = r.createWebClient().goTo("configure").getFormByName("config");
30 | HtmlCheckBoxInput checkbox = config.getInputByName("_.allBuilds");
31 | checkbox.setChecked(true);
32 | r.submit(config);
33 | assertTrue(
34 | BuildUserVarsConfig.get().isAllBuilds(),
35 | "global config page let us edit it");
36 |
37 | r.restart();
38 |
39 | assertTrue(
40 | BuildUserVarsConfig.get().isAllBuilds(),
41 | "still there after restart of Jenkins");
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/BuildUserVarsIntegrationTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser;
2 |
3 | import hudson.EnvVars;
4 | import hudson.model.Cause;
5 | import hudson.model.CauseAction;
6 | import hudson.model.FreeStyleProject;
7 | import hudson.model.User;
8 | import hudson.tasks.Mailer;
9 | import org.junit.jupiter.api.Test;
10 | import org.jvnet.hudson.test.CaptureEnvironmentBuilder;
11 | import org.jvnet.hudson.test.JenkinsRule;
12 | import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
13 |
14 | import static org.junit.jupiter.api.Assertions.assertEquals;
15 |
16 | @WithJenkins
17 | class BuildUserVarsIntegrationTest {
18 | private static final String TEST_USER_NAME = "Bob Smith";
19 | private static final String TEST_USER_EMAIL = "bob@example.com";
20 |
21 | @Test
22 | void smokes(JenkinsRule r) throws Exception {
23 | User user = User.getById("bob", true);
24 | user.setFullName(TEST_USER_NAME);
25 | user.addProperty(new Mailer.UserProperty(TEST_USER_EMAIL));
26 | r.jenkins.setSecurityRealm(r.createDummySecurityRealm());
27 |
28 | FreeStyleProject p = r.createFreeStyleProject();
29 | p.getBuildWrappersList().add(new BuildUser());
30 | CaptureEnvironmentBuilder captureEnvironment = new CaptureEnvironmentBuilder();
31 | p.getBuildersList().add(captureEnvironment);
32 | r.assertBuildStatusSuccess(
33 | p.scheduleBuild2(0, new CauseAction(new Cause.UserIdCause(user.getId()))));
34 |
35 | EnvVars envVars = captureEnvironment.getEnvVars();
36 | assertEquals(TEST_USER_NAME, envVars.get("BUILD_USER"));
37 | assertEquals("authenticated", envVars.get("BUILD_USER_GROUPS"));
38 | assertEquals("Bob", envVars.get("BUILD_USER_FIRST_NAME"));
39 | assertEquals("Smith", envVars.get("BUILD_USER_LAST_NAME"));
40 | assertEquals(TEST_USER_EMAIL, envVars.get("BUILD_USER_EMAIL"));
41 | assertEquals("bob", envVars.get("BUILD_USER_ID"));
42 | }
43 |
44 | @Test
45 | void allBuilds(JenkinsRule r) throws Exception {
46 | BuildUserVarsConfig config = BuildUserVarsConfig.get();
47 | config.setAllBuilds(true);
48 | config.save();
49 |
50 | User user = User.getById("bob", true);
51 | user.setFullName(TEST_USER_NAME);
52 | user.addProperty(new Mailer.UserProperty(TEST_USER_EMAIL));
53 | r.jenkins.setSecurityRealm(r.createDummySecurityRealm());
54 |
55 | FreeStyleProject p = r.createFreeStyleProject();
56 | CaptureEnvironmentBuilder captureEnvironment = new CaptureEnvironmentBuilder();
57 | p.getBuildersList().add(captureEnvironment);
58 | r.assertBuildStatusSuccess(
59 | p.scheduleBuild2(0, new CauseAction(new Cause.UserIdCause(user.getId()))));
60 |
61 | EnvVars envVars = captureEnvironment.getEnvVars();
62 | assertEquals(TEST_USER_NAME, envVars.get("BUILD_USER"));
63 | assertEquals("authenticated", envVars.get("BUILD_USER_GROUPS"));
64 | assertEquals("Bob", envVars.get("BUILD_USER_FIRST_NAME"));
65 | assertEquals("Smith", envVars.get("BUILD_USER_LAST_NAME"));
66 | assertEquals(TEST_USER_EMAIL, envVars.get("BUILD_USER_EMAIL"));
67 | assertEquals("bob", envVars.get("BUILD_USER_ID"));
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/utils/UsernameUtilsTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.utils;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import java.util.HashMap;
6 | import java.util.Map;
7 |
8 | import static org.junit.jupiter.api.Assertions.assertEquals;
9 |
10 | /**
11 | *
12 | * @author GKonovalenko
13 | */
14 | class UsernameUtilsTest {
15 |
16 | @Test
17 | void testGetFirstName() {
18 | assertEquals("First", UsernameUtils.getFirstName("First Second"));
19 | assertEquals("First", UsernameUtils.getFirstName("First Second"));
20 | assertEquals("First", UsernameUtils.getFirstName("First\tSecond"));
21 | assertEquals("First", UsernameUtils.getFirstName("First\t\tSecond"));
22 | assertEquals("First", UsernameUtils.getFirstName(" First Second "));
23 | assertEquals("First", UsernameUtils.getFirstName("\t \tFirst\t \tSecond \t "));
24 | assertEquals("", UsernameUtils.getFirstName(""));
25 | assertEquals("First", UsernameUtils.getFirstName(" First "));
26 | assertEquals("", UsernameUtils.getFirstName(null));
27 | }
28 |
29 | @Test
30 | void testGetLastName() {
31 | assertEquals("Second", UsernameUtils.getLastName("First Second"));
32 | assertEquals("Second", UsernameUtils.getLastName("First Second"));
33 | assertEquals("Second", UsernameUtils.getLastName("First\tSecond"));
34 | assertEquals("Second", UsernameUtils.getLastName("First\t\tSecond"));
35 | assertEquals("Second", UsernameUtils.getLastName(" First Second "));
36 | assertEquals("Second", UsernameUtils.getLastName("\t \tFirst\t \tSecond \t "));
37 | assertEquals("", UsernameUtils.getLastName(""));
38 | assertEquals("", UsernameUtils.getLastName(" First "));
39 | assertEquals("", UsernameUtils.getLastName(null));
40 | }
41 |
42 | @Test
43 | void testSetUsernameVars() {
44 | Map variables = new HashMap<>();
45 | UsernameUtils.setUsernameVars("John Doe", variables);
46 | assertEquals("John Doe", variables.get(BuildUserVariable.USERNAME));
47 | assertEquals("John", variables.get(BuildUserVariable.FIRST_NAME));
48 | assertEquals("Doe", variables.get(BuildUserVariable.LAST_NAME));
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/BranchIndexingTriggerDeterminantTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import jenkins.branch.BranchIndexingCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.junit.jupiter.api.Test;
6 |
7 | import java.lang.reflect.Constructor;
8 | import java.util.Collections;
9 | import java.util.HashMap;
10 | import java.util.Map;
11 |
12 | import static org.hamcrest.MatcherAssert.assertThat;
13 | import static org.hamcrest.Matchers.*;
14 | import static org.junit.jupiter.api.Assertions.assertFalse;
15 | import static org.junit.jupiter.api.Assertions.assertTrue;
16 |
17 | class BranchIndexingTriggerDeterminantTest {
18 |
19 | @Test
20 | void usedCauseClassIsBranchIndexingCause() {
21 | assertThat(new BranchIndexingTriggerDeterminant().getUsedCauseClass(), equalTo(BranchIndexingCause.class));
22 | }
23 |
24 | @Test
25 | void setVarsReturnsFalseWithoutBuildUserVarsOnNullCause() {
26 | Map variables = new HashMap<>();
27 | assertFalse(new BranchIndexingTriggerDeterminant().setJenkinsUserBuildVars(null, variables));
28 | assertThat(variables, equalTo(Collections.emptyMap()));
29 | }
30 |
31 | @Test
32 | void setVarsReturnsTrueWithBuildUsersVarsOnValidCause() throws Exception {
33 | Map variables = new HashMap<>();
34 | assertTrue(new BranchIndexingTriggerDeterminant().setJenkinsUserBuildVars(mockCause(), variables));
35 | assertThat(variables, allOf(hasEntry(BuildUserVariable.USERNAME, "Branch Indexing"),
36 | hasEntry(BuildUserVariable.FIRST_NAME, "Branch"),
37 | hasEntry(BuildUserVariable.LAST_NAME, "Indexing"),
38 | hasEntry(BuildUserVariable.ID, "branchIndexing")
39 | ));
40 | }
41 |
42 | private static BranchIndexingCause mockCause() throws Exception {
43 | Constructor ctor = BranchIndexingCause.class.getDeclaredConstructor();
44 | ctor.setAccessible(true);
45 | return ctor.newInstance();
46 | }
47 |
48 | }
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/RemoteCauseDeterminantTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.RemoteCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.junit.jupiter.api.Test;
6 |
7 | import java.lang.reflect.Constructor;
8 | import java.util.Collections;
9 | import java.util.HashMap;
10 | import java.util.Map;
11 |
12 | import static org.hamcrest.MatcherAssert.assertThat;
13 | import static org.hamcrest.Matchers.*;
14 | import static org.junit.jupiter.api.Assertions.assertFalse;
15 | import static org.junit.jupiter.api.Assertions.assertTrue;
16 |
17 | class RemoteCauseDeterminantTest {
18 |
19 | @Test
20 | void usedCauseClassIsRemoteCause() {
21 | assertThat(new RemoteCauseDeterminant().getUsedCauseClass(), equalTo(RemoteCause.class));
22 | }
23 |
24 | @Test
25 | void setVarsReturnsFalseWithoutBuildUserVarsOnNullCause() {
26 | Map variables = new HashMap<>();
27 | assertFalse(new RemoteCauseDeterminant().setJenkinsUserBuildVars(null, variables));
28 | assertThat(variables, equalTo(Collections.emptyMap()));
29 | }
30 |
31 | @Test
32 | void setVarsReturnsTrueWithBuildUsersVarsOnValidCause() throws Exception {
33 | Map variables = new HashMap<>();
34 | assertTrue(new RemoteCauseDeterminant().setJenkinsUserBuildVars(mockCause(), variables));
35 | assertThat(variables, allOf(hasEntry(BuildUserVariable.USERNAME, "host note"),
36 | hasEntry(BuildUserVariable.FIRST_NAME, "host"),
37 | hasEntry(BuildUserVariable.LAST_NAME, "note"),
38 | hasEntry(BuildUserVariable.ID, "remoteRequest")
39 | ));
40 | }
41 |
42 | private static RemoteCause mockCause() throws Exception {
43 | Constructor ctor = RemoteCause.class.getDeclaredConstructor(String.class, String.class);
44 | ctor.setAccessible(true);
45 | return ctor.newInstance("host", "note");
46 | }
47 |
48 | }
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/SCMTriggerCauseDeterminantTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.triggers.SCMTrigger.SCMTriggerCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.junit.jupiter.api.Test;
6 |
7 | import java.lang.reflect.Constructor;
8 | import java.util.Collections;
9 | import java.util.HashMap;
10 | import java.util.Map;
11 |
12 | import static org.hamcrest.MatcherAssert.assertThat;
13 | import static org.hamcrest.Matchers.*;
14 | import static org.junit.jupiter.api.Assertions.assertFalse;
15 | import static org.junit.jupiter.api.Assertions.assertTrue;
16 |
17 | class SCMTriggerCauseDeterminantTest {
18 |
19 | @Test
20 | void usedCauseClassIsSCMTriggerCause() {
21 | assertThat(new SCMTriggerCauseDeterminant().getUsedCauseClass(), equalTo(SCMTriggerCause.class));
22 | }
23 |
24 | @Test
25 | void setVarsReturnsFalseWithoutBuildUserVarsOnNullCause() {
26 | Map variables = new HashMap<>();
27 | assertFalse(new SCMTriggerCauseDeterminant().setJenkinsUserBuildVars(null, variables));
28 | assertThat(variables, equalTo(Collections.emptyMap()));
29 | }
30 |
31 | @Test
32 | void setVarsReturnsTrueWithBuildUsersVarsOnValidCause() throws Exception {
33 | Map variables = new HashMap<>();
34 | assertTrue(new SCMTriggerCauseDeterminant().setJenkinsUserBuildVars(mockCause(), variables));
35 | assertThat(variables, allOf(hasEntry(BuildUserVariable.USERNAME, "SCM Change"),
36 | hasEntry(BuildUserVariable.FIRST_NAME, "SCM"),
37 | hasEntry(BuildUserVariable.LAST_NAME, "Change"),
38 | hasEntry(BuildUserVariable.ID, "scmChange")
39 | ));
40 | }
41 |
42 | private static SCMTriggerCause mockCause() throws Exception {
43 | Constructor ctor = SCMTriggerCause.class.getDeclaredConstructor();
44 | ctor.setAccessible(true);
45 | return ctor.newInstance();
46 | }
47 |
48 | }
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/TimerTriggerCauseDeterminantTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.triggers.TimerTrigger.TimerTriggerCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.jenkinsci.plugins.builduser.utils.UsernameUtils;
6 | import org.junit.jupiter.api.Test;
7 |
8 | import java.lang.reflect.Constructor;
9 | import java.util.Collections;
10 | import java.util.HashMap;
11 | import java.util.Map;
12 |
13 | import static org.hamcrest.MatcherAssert.assertThat;
14 | import static org.hamcrest.Matchers.*;
15 | import static org.junit.jupiter.api.Assertions.assertFalse;
16 | import static org.junit.jupiter.api.Assertions.assertTrue;
17 |
18 | class TimerTriggerCauseDeterminantTest {
19 |
20 | @Test
21 | void usedCauseClassIsSCMTriggerCause() {
22 | assertThat(new TimerTriggerCauseDeterminant().getUsedCauseClass(), equalTo(TimerTriggerCause.class));
23 | }
24 |
25 | @Test
26 | void setVarsReturnsFalseWithoutBuildUserVarsOnNullCause() {
27 | Map variables = new HashMap<>();
28 | assertFalse(new TimerTriggerCauseDeterminant().setJenkinsUserBuildVars(null, variables));
29 | assertThat(variables, equalTo(Collections.emptyMap()));
30 | }
31 |
32 | @Test
33 | void setVarsReturnsTrueWithBuildUsersVarsOnValidCause() throws Exception {
34 | Map variables = new HashMap<>();
35 | assertTrue(new TimerTriggerCauseDeterminant().setJenkinsUserBuildVars(mockCause(), variables));
36 | assertThat(variables, allOf(hasEntry(BuildUserVariable.USERNAME, TimerTriggerCauseDeterminant.TIMER_TRIGGER_DUMMY_USER_NAME),
37 | hasEntry(BuildUserVariable.FIRST_NAME, UsernameUtils.getFirstName(TimerTriggerCauseDeterminant.TIMER_TRIGGER_DUMMY_USER_NAME)),
38 | hasEntry(BuildUserVariable.LAST_NAME, UsernameUtils.getLastName(TimerTriggerCauseDeterminant.TIMER_TRIGGER_DUMMY_USER_NAME)),
39 | hasEntry(BuildUserVariable.ID, TimerTriggerCauseDeterminant.TIMER_TRIGGER_DUMMY_USER_ID)
40 | ));
41 | }
42 |
43 | private static TimerTriggerCause mockCause() throws Exception {
44 | Constructor ctor = TimerTriggerCause.class.getDeclaredConstructor();
45 | ctor.setAccessible(true);
46 | return ctor.newInstance();
47 | }
48 |
49 | }
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/UserCauseDeterminantTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.UserCause;
4 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
5 | import org.junit.jupiter.api.Test;
6 |
7 | import java.util.Collections;
8 | import java.util.HashMap;
9 | import java.util.Map;
10 |
11 | import static org.hamcrest.MatcherAssert.assertThat;
12 | import static org.hamcrest.Matchers.*;
13 | import static org.junit.jupiter.api.Assertions.assertFalse;
14 | import static org.junit.jupiter.api.Assertions.assertTrue;
15 |
16 | class UserCauseDeterminantTest {
17 |
18 | @Test
19 | void usedCauseClassIsUserCause() {
20 | assertThat(new UserCauseDeterminant().getUsedCauseClass(), equalTo(UserCause.class));
21 | }
22 |
23 | @Test
24 | void setVarsReturnsFalseWithoutBuildUserVarsOnNullCause() {
25 | Map variables = new HashMap<>();
26 | assertFalse(new UserCauseDeterminant().setJenkinsUserBuildVars(null, variables));
27 | assertThat(variables, equalTo(Collections.emptyMap()));
28 | }
29 |
30 | @Test
31 | void setVarsReturnsTrueWithBuildUsersVarsOnValidCause() {
32 | Map variables = new HashMap<>();
33 | assertTrue(new UserCauseDeterminant().setJenkinsUserBuildVars(mockCause(), variables));
34 | assertThat(variables, allOf(hasEntry(BuildUserVariable.USERNAME, "John Doe"),
35 | hasEntry(BuildUserVariable.FIRST_NAME, "John"),
36 | hasEntry(BuildUserVariable.LAST_NAME, "Doe")
37 | ));
38 | }
39 |
40 | private static UserCause mockCause() {
41 | return new UserCause() {
42 | @Override
43 | public String getUserName() {
44 | return "John Doe";
45 | }
46 | };
47 | }
48 |
49 | }
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/UserIdCauseDeterminantEmailTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.UserIdCause;
4 | import hudson.model.User;
5 | import hudson.tasks.MailAddressResolver;
6 | import hudson.tasks.Mailer.UserProperty;
7 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
8 | import org.junit.Rule;
9 | import org.junit.Test;
10 | import org.jvnet.hudson.test.JenkinsRule;
11 | import org.jvnet.hudson.test.TestExtension;
12 |
13 | import java.io.IOException;
14 | import java.util.HashMap;
15 | import java.util.Map;
16 |
17 | import static org.hamcrest.CoreMatchers.equalTo;
18 | import static org.hamcrest.CoreMatchers.is;
19 | import static org.hamcrest.MatcherAssert.assertThat;
20 |
21 | public class UserIdCauseDeterminantEmailTest {
22 | public static final String TEST_USER = "test_user";
23 |
24 | @Rule
25 | public JenkinsRule r = new JenkinsRule();
26 |
27 | @Test
28 | public void testSetJenkinsUserBuildVarsEmailWithResolver() throws IOException {
29 | User user = User.getById(TEST_USER, true);
30 | assert user != null;
31 | user.addProperty(new UserProperty(null));
32 |
33 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
34 | r.jenkins.setSecurityRealm(realm);
35 |
36 | Map outputVars = new HashMap<>();
37 | UserIdCause cause = new UserIdCause(TEST_USER);
38 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
39 | determinant.setJenkinsUserBuildVars(cause, outputVars);
40 |
41 | assertThat(outputVars.get(BuildUserVariable.EMAIL), is(equalTo("resolveduser@example.com")));
42 | }
43 |
44 | @TestExtension
45 | public static class TestMailAddressResolver extends MailAddressResolver {
46 | @Override
47 | public String findMailAddressFor(User user) {
48 | return "resolveduser@example.com";
49 | }
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/UserIdCauseDeterminantSamlTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.UserIdCause;
4 | import hudson.security.ChainedServletFilter2;
5 | import hudson.security.SecurityRealm;
6 | import jenkins.model.IdStrategy;
7 | import org.easymock.EasyMock;
8 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
9 | import org.jenkinsci.plugins.saml.SamlSecurityRealm;
10 | import org.junit.jupiter.api.Test;
11 | import org.jvnet.hudson.test.JenkinsRule;
12 | import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
13 | import org.springframework.security.core.GrantedAuthority;
14 | import org.springframework.security.core.userdetails.User;
15 |
16 | import jakarta.servlet.FilterConfig;
17 | import java.util.ArrayList;
18 | import java.util.HashMap;
19 | import java.util.Map;
20 |
21 | import static org.easymock.EasyMock.anyObject;
22 | import static org.hamcrest.CoreMatchers.equalTo;
23 | import static org.hamcrest.CoreMatchers.is;
24 | import static org.hamcrest.MatcherAssert.assertThat;
25 |
26 | @WithJenkins
27 | class UserIdCauseDeterminantSamlTest {
28 | private static final String TEST_USER = "Testuser";
29 |
30 | private static Map runSamlSecurityRealmTest(JenkinsRule r, String userid, String caseConversion) {
31 | ArrayList grantedAuthorities = new ArrayList<>();
32 | User user = new User(userid, "password123", true, true, true, true, grantedAuthorities);
33 | SamlSecurityRealm realm = EasyMock.mock(SamlSecurityRealm.class);
34 |
35 | IdStrategy strategy = new IdStrategy.CaseSensitive();
36 | EasyMock.expect(realm.getUserIdStrategy()).andReturn(strategy).anyTimes();
37 | EasyMock.expect(realm.getSecurityComponents()).andReturn(new SecurityRealm.SecurityComponents());
38 | EasyMock.expect(realm.createFilter(anyObject(FilterConfig.class))).andReturn(new ChainedServletFilter2());
39 | EasyMock.expect(realm.getUsernameCaseConversion()).andReturn(caseConversion);
40 | EasyMock.expect(realm.loadUserByUsername2(userid)).andReturn(user).anyTimes();
41 |
42 | EasyMock.replay(realm);
43 |
44 | hudson.model.User.getById(userid, true);
45 | r.jenkins.setSecurityRealm(realm);
46 | Map outputVars = new HashMap<>();
47 | UserIdCause cause = new UserIdCause(userid);
48 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
49 | determinant.setJenkinsUserBuildVars(cause, outputVars);
50 | return outputVars;
51 | }
52 |
53 | @Test
54 | void testSetJenkinsUserBuildVarsSamlUpperCase(JenkinsRule r) {
55 | Map outputVars = runSamlSecurityRealmTest(r, TEST_USER, "uppercase");
56 | assertThat(outputVars.get(BuildUserVariable.ID), is(equalTo("TESTUSER")));
57 | }
58 |
59 | @Test
60 | void testSetJenkinsUserBuildVarsSamlLowerCase(JenkinsRule r) {
61 | Map outputVars = runSamlSecurityRealmTest(r, TEST_USER, "lowercase");
62 | assertThat(outputVars.get(BuildUserVariable.ID), is(equalTo("testuser")));
63 | }
64 |
65 | @Test
66 | void testSetJenkinsUserBuildVarsSamlNoCase(JenkinsRule r) {
67 | Map outputVars = runSamlSecurityRealmTest(r, TEST_USER, "none");
68 | assertThat(outputVars.get(BuildUserVariable.ID), is(equalTo(TEST_USER)));
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/src/test/java/org/jenkinsci/plugins/builduser/varsetter/impl/UserIdCauseDeterminantTest.java:
--------------------------------------------------------------------------------
1 | package org.jenkinsci.plugins.builduser.varsetter.impl;
2 |
3 | import hudson.model.Cause.UserIdCause;
4 | import hudson.model.User;
5 | import hudson.tasks.Mailer.UserProperty;
6 | import org.jenkinsci.plugins.builduser.utils.BuildUserVariable;
7 | import org.junit.jupiter.api.Test;
8 | import org.jvnet.hudson.test.JenkinsRule;
9 | import org.jvnet.hudson.test.junit.jupiter.WithJenkins;
10 |
11 | import java.io.IOException;
12 | import java.util.HashMap;
13 | import java.util.Map;
14 |
15 | import static org.hamcrest.CoreMatchers.equalTo;
16 | import static org.hamcrest.CoreMatchers.is;
17 | import static org.hamcrest.MatcherAssert.assertThat;
18 |
19 | @WithJenkins
20 | class UserIdCauseDeterminantTest {
21 | private static final String TEST_USER = "test_user";
22 |
23 | @Test
24 | void testSetJenkinsUserBuildVars(JenkinsRule r) {
25 | User.getById(TEST_USER, true);
26 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
27 | r.jenkins.setSecurityRealm(realm);
28 | realm.addGroups(TEST_USER, "group1", "group2");
29 | Map outputVars = new HashMap<>();
30 | UserIdCause cause = new UserIdCause(TEST_USER);
31 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
32 | determinant.setJenkinsUserBuildVars(cause, outputVars);
33 | assertThat(outputVars.get(BuildUserVariable.GROUPS), is(equalTo("authenticated,group1,group2")));
34 | }
35 |
36 | @Test
37 | void testSetJenkinsUserBuildVarsInvalidUser(JenkinsRule r) {
38 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
39 | r.jenkins.setSecurityRealm(realm);
40 | Map outputVars = new HashMap<>();
41 | UserIdCause cause = new UserIdCause(TEST_USER);
42 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
43 | determinant.setJenkinsUserBuildVars(cause, outputVars);
44 | assertThat(outputVars.get(BuildUserVariable.GROUPS), is(equalTo("")));
45 | }
46 |
47 | @Test
48 | void testSetJenkinsUserBuildVarsNoGroups(JenkinsRule r) {
49 | User.getById(TEST_USER, true);
50 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
51 | r.jenkins.setSecurityRealm(realm);
52 | Map outputVars = new HashMap<>();
53 | UserIdCause cause = new UserIdCause(TEST_USER);
54 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
55 | determinant.setJenkinsUserBuildVars(cause, outputVars);
56 | assertThat(outputVars.get(BuildUserVariable.GROUPS), is(equalTo("authenticated")));
57 | }
58 |
59 | @Test
60 | void testSetJenkinsUserBuildVarsNoSecurityRealm(JenkinsRule r) {
61 | User.getById(TEST_USER, true);
62 | Map outputVars = new HashMap<>();
63 | UserIdCause cause = new UserIdCause(TEST_USER);
64 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
65 | determinant.setJenkinsUserBuildVars(cause, outputVars);
66 | assertThat(outputVars.get(BuildUserVariable.GROUPS), is(equalTo(null)));
67 | }
68 |
69 | @Test
70 | void testSetJenkinsUserBuildVarsEmail(JenkinsRule r) throws IOException {
71 | User user = User.getById(TEST_USER, true);
72 | user.addProperty(new UserProperty("testuser@example.com"));
73 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
74 | r.jenkins.setSecurityRealm(realm);
75 | Map outputVars = new HashMap<>();
76 | UserIdCause cause = new UserIdCause(TEST_USER);
77 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
78 | determinant.setJenkinsUserBuildVars(cause, outputVars);
79 | assertThat(outputVars.get(BuildUserVariable.EMAIL), is(equalTo("testuser@example.com")));
80 | }
81 |
82 | @Test
83 | void testSetJenkinsUserBuildVarsId(JenkinsRule r) {
84 | User.getById(TEST_USER, true);
85 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
86 | r.jenkins.setSecurityRealm(realm);
87 | Map outputVars = new HashMap<>();
88 | UserIdCause cause = new UserIdCause(TEST_USER);
89 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
90 | determinant.setJenkinsUserBuildVars(cause, outputVars);
91 | assertThat(outputVars.get(BuildUserVariable.ID), is(equalTo(TEST_USER)));
92 | }
93 |
94 | @Test
95 | void testSetJenkinsUserBuildVarsKeepsExistingVariables(JenkinsRule r) {
96 | User.getById(TEST_USER, true);
97 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
98 | r.jenkins.setSecurityRealm(realm);
99 |
100 | Map outputVars = new HashMap<>();
101 | outputVars.put("EXISTING_VAR", "existing_value");
102 |
103 | UserIdCause cause = new UserIdCause(TEST_USER);
104 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
105 |
106 | determinant.setJenkinsUserBuildVars(cause, outputVars);
107 |
108 | assertThat(outputVars.get("EXISTING_VAR"), is(equalTo("existing_value")));
109 | }
110 |
111 | @Test
112 | void testSetJenkinsUserBuildVarsNoEmail(JenkinsRule r) throws IOException {
113 | User user = User.getById(TEST_USER, true);
114 | user.addProperty(new UserProperty(null));
115 | JenkinsRule.DummySecurityRealm realm = r.createDummySecurityRealm();
116 | r.jenkins.setSecurityRealm(realm);
117 |
118 | Map outputVars = new HashMap<>();
119 | UserIdCause cause = new UserIdCause(TEST_USER);
120 | UserIdCauseDeterminant determinant = new UserIdCauseDeterminant();
121 |
122 | determinant.setJenkinsUserBuildVars(cause, outputVars);
123 |
124 | assertThat(outputVars.get(BuildUserVariable.EMAIL), is(equalTo(null)));
125 | }
126 | }
127 |
--------------------------------------------------------------------------------