Merge pull request #3 from rundeck/feature/builders

Refactor to use builders for trigger/run methods fixes #2

src/main/java/org/rundeck/api/DefaultRunAdhoc.java

@@ -0,0 +1,54 @@
+package org.rundeck.api;
+
+import java.util.Properties;
+
+/**
+ * Base class for adhoc requests
+ */
+class DefaultRunAdhoc implements RunAdhoc{
+    private String project;
+    private Properties nodeFilters;
+    private Integer nodeThreadcount;
+    private Boolean nodeKeepgoing;
+    private String asUser;
+
+    public String getProject() {
+        return project;
+    }
+
+    public void setProject(String project) {
+        this.project = project;
+    }
+
+    public Properties getNodeFilters() {
+        return nodeFilters;
+    }
+
+    public void setNodeFilters(Properties nodeFilters) {
+        this.nodeFilters = nodeFilters;
+    }
+
+    public Integer getNodeThreadcount() {
+        return nodeThreadcount;
+    }
+
+    public void setNodeThreadcount(Integer nodeThreadcount) {
+        this.nodeThreadcount = nodeThreadcount;
+    }
+
+    public Boolean getNodeKeepgoing() {
+        return nodeKeepgoing;
+    }
+
+    public void setNodeKeepgoing(Boolean nodeKeepgoing) {
+        this.nodeKeepgoing = nodeKeepgoing;
+    }
+
+    public String getAsUser() {
+        return asUser;
+    }
+
+    public void setAsUser(String asUser) {
+        this.asUser = asUser;
+    }
+}

src/main/java/org/rundeck/api/DefaultRunAdhocCommand.java

@@ -0,0 +1,18 @@
+package org.rundeck.api;
+
+/**
+ * Implementation of {@link RunAdhocCommand}
+ */
+class DefaultRunAdhocCommand extends DefaultRunAdhoc implements RunAdhocCommand {
+    private String command;
+
+    @Override
+    public String getCommand() {
+        return command;
+    }
+
+    public void setCommand(String command) {
+        this.command = command;
+    }
+
+}

src/main/java/org/rundeck/api/DefaultRunAdhocScript.java

@@ -0,0 +1,28 @@
+package org.rundeck.api;
+
+import java.io.InputStream;
+
+/**
+ * Bean implementing {@link RunAdhocScript}
+ */
+class DefaultRunAdhocScript extends DefaultRunAdhoc implements RunAdhocScript {
+    private InputStream script;
+    private String argString;
+
+    @Override
+    public InputStream getScript() {
+        return script;
+    }
+
+    public void setScript(InputStream script) {
+        this.script = script;
+    }
+
+    public String getArgString() {
+        return argString;
+    }
+
+    public void setArgString(String argString) {
+        this.argString = argString;
+    }
+}

src/main/java/org/rundeck/api/DefaultRunJob.java

@@ -0,0 +1,50 @@
+package org.rundeck.api;
+
+import java.util.Properties;
+
+/**
+ * impl of {@link RunJob}
+ */
+class DefaultRunJob implements RunJob {
+    private String jobId;
+    private Properties options;
+    private Properties nodeFilters;
+    private String asUser;
+
+
+    @Override
+    public String getJobId() {
+        return jobId;
+    }
+
+    @Override
+    public Properties getOptions() {
+        return options;
+    }
+
+    @Override
+    public Properties getNodeFilters() {
+        return nodeFilters;
+    }
+
+    @Override
+    public String getAsUser() {
+        return asUser;
+    }
+
+    public void setJobId(String jobId) {
+        this.jobId = jobId;
+    }
+
+    public void setOptions(Properties options) {
+        this.options = options;
+    }
+
+    public void setNodeFilters(Properties nodeFilters) {
+        this.nodeFilters = nodeFilters;
+    }
+
+    public void setAsUser(String asUser) {
+        this.asUser = asUser;
+    }
+}

src/main/java/org/rundeck/api/RunAdhoc.java

@@ -0,0 +1,38 @@
+package org.rundeck.api;
+
+import java.util.Properties;
+
+/**
+ * Super interface for adhoc executions
+ */
+public interface RunAdhoc {
+    /**
+     * Project name, required
+     * @return
+     */
+    String getProject();
+
+    /**
+     * Filters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+     * @return
+     */
+    Properties getNodeFilters();
+
+    /**
+     * Thread count to use (for parallelizing when running on multiple nodes) - optional
+     * @return
+     */
+    Integer getNodeThreadcount();
+
+    /**
+     * if true, continue executing on other nodes even if some fail - optional
+     * @return
+     */
+    Boolean getNodeKeepgoing();
+
+    /**
+     * Specify a user name to run the job as, must have 'runAs' permission
+     * @return
+     */
+    String getAsUser();
+}

src/main/java/org/rundeck/api/RunAdhocCommand.java

@@ -0,0 +1,14 @@
+package org.rundeck.api;
+
+/**
+ * A command to execute
+ */
+public interface RunAdhocCommand extends RunAdhoc {
+
+    /**
+     * Command to executed
+     * @return
+     */
+    String getCommand();
+
+}

src/main/java/org/rundeck/api/RunAdhocCommandBuilder.java

@@ -0,0 +1,55 @@
+package org.rundeck.api;
+
+import java.util.Properties;
+
+/**
+ * $INTERFACE is ... User: greg Date: 7/9/13 Time: 10:38 AM
+ */
+public class RunAdhocCommandBuilder {
+    private DefaultRunAdhocCommand command;
+
+    public RunAdhocCommandBuilder() {
+        command = new DefaultRunAdhocCommand();
+    }
+
+    public static RunAdhocCommandBuilder builder() {
+        return new RunAdhocCommandBuilder();
+    }
+
+    public RunAdhocCommandBuilder setProject(String project) {
+        command.setProject(project);
+
+        return this;
+    }
+
+    public RunAdhocCommandBuilder setCommand(String commandString) {
+        command.setCommand(commandString);
+        return this;
+    }
+
+    public RunAdhocCommandBuilder setNodeFilters(Properties nodeFilters) {
+        command.setNodeFilters(nodeFilters);
+        return this;
+    }
+
+    public RunAdhocCommandBuilder setNodeThreadcount(Integer nodeThreadcount) {
+        command.setNodeThreadcount(nodeThreadcount);
+        return this;
+    }
+
+    public RunAdhocCommandBuilder setNodeKeepgoing(Boolean nodeKeepgoing) {
+        command.setNodeKeepgoing(nodeKeepgoing);
+        return this;
+    }
+
+    public RunAdhocCommandBuilder setAsUser(String asUser) {
+        command.setAsUser(asUser);
+        return this;
+    }
+
+    public RunAdhocCommand create() {
+        DefaultRunAdhocCommand built = command;
+        command = new DefaultRunAdhocCommand();
+        return built;
+    }
+}

src/main/java/org/rundeck/api/RunAdhocScript.java

@@ -0,0 +1,22 @@
+package org.rundeck.api;
+
+import java.io.InputStream;
+
+/**
+ * An adhoc script to be executed by Rundeck
+ */
+public interface RunAdhocScript extends RunAdhoc {
+
+    /**
+     * InputStream for reading the script to be executed - mandatory
+     * @return
+     */
+    InputStream getScript();
+
+    /**
+     * Arguments to the script
+     * @return
+     */
+    String getArgString();
+
+}

src/main/java/org/rundeck/api/RunAdhocScriptBuilder.java

@@ -0,0 +1,88 @@
+package org.rundeck.api;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+/**
+ * A builder to create a {@link RunAdhocScript}, use the {@link #builder()} to create a builder, then {@link #create()}
+ * to build an RunAdhocScript
+ */
+public class RunAdhocScriptBuilder {
+    private DefaultRunAdhocScript script;
+
+    private RunAdhocScriptBuilder() {
+        script = new DefaultRunAdhocScript();
+    }
+
+    public RunAdhocScriptBuilder(final RunAdhocScript oldScript) {
+        script = new DefaultRunAdhocScript();
+        setAsUser(oldScript.getAsUser());
+        setArgString(oldScript.getArgString());
+        setProject(oldScript.getProject());
+        setScript(oldScript.getScript());
+        setNodeFilters(oldScript.getNodeFilters());
+        setNodeKeepgoing(oldScript.getNodeKeepgoing());
+        setNodeThreadcount(oldScript.getNodeThreadcount());
+    }
+
+    /**
+     * Create a new builder
+     *
+     * @return
+     */
+    public static RunAdhocScriptBuilder builder() {
+        return new RunAdhocScriptBuilder();
+    }
+
+    /**
+     * Create a builder initialized with an existing {@link RunAdhocScript}
+     *
+     * @param script
+     *
+     * @return this builder
+     */
+    public static RunAdhocScriptBuilder builder(final RunAdhocScript script) {
+        return new RunAdhocScriptBuilder(script);
+    }
+
+    public RunAdhocScriptBuilder setProject(final String project) {
+        script.setProject(project);
+        return this;
+    }
+
+    public RunAdhocScriptBuilder setScript(final InputStream stream) {
+        script.setScript(stream);
+        return this;
+    }
+
+    public RunAdhocScriptBuilder setArgString(final String argString) {
+        script.setArgString(argString);
+        return this;
+    }
+
+    public RunAdhocScriptBuilder setNodeFilters(final Properties nodeFilters) {
+        script.setNodeFilters(nodeFilters);
+        return this;
+    }
+
+    public RunAdhocScriptBuilder setNodeThreadcount(final Integer nodeThreadcount) {
+        script.setNodeThreadcount(nodeThreadcount);
+        return this;
+    }
+
+    public RunAdhocScriptBuilder setNodeKeepgoing(final Boolean nodeKeepgoing) {
+        script.setNodeKeepgoing(nodeKeepgoing);
+        return this;
+    }
+
+    public RunAdhocScriptBuilder setAsUser(final String asUser) {
+        script.setAsUser(asUser);
+        return this;
+    }
+
+    public RunAdhocScript create() {
+        final DefaultRunAdhocScript built = script;
+        script = new DefaultRunAdhocScript();
+        return built;
+    }
+}

src/main/java/org/rundeck/api/RunJob.java

@@ -0,0 +1,34 @@
+package org.rundeck.api;
+
+import java.util.Properties;
+
+/**
+ * Job run request
+ */
+public interface RunJob {
+    /**
+     * Identifier of the job - mandatory
+     * @return
+     */
+    String getJobId();
+
+    /**
+     * Options of the job - optional. See {@link OptionsBuilder}.
+     * @return
+     */
+    Properties getOptions();
+
+    /**
+     * Node filters for overriding the nodes on which the job will be executed - optional. See
+     *            {@link NodeFiltersBuilder}
+     *
+     * @return
+     */
+    Properties getNodeFilters();
+
+    /**
+     * Specify a user name to run the job as, must have 'runAs' permission
+     * @return
+     */
+    String getAsUser();
+}

src/main/java/org/rundeck/api/RunJobBuilder.java

@@ -0,0 +1,44 @@
+package org.rundeck.api;
+
+import java.util.Properties;
+
+/**
+ * Job run request builder
+ */
+public class RunJobBuilder {
+    private DefaultRunJob jobRun;
+
+    public static RunJobBuilder builder() {
+        return new RunJobBuilder();
+    }
+
+    public RunJobBuilder() {
+        jobRun = new DefaultRunJob();
+    }
+
+    public RunJobBuilder setJobId(String jobId) {
+        jobRun.setJobId(jobId);
+        return this;
+    }
+
+    public RunJobBuilder setOptions(Properties options) {
+        jobRun.setOptions(options);
+        return this;
+    }
+
+    public RunJobBuilder setNodeFilters(Properties nodeFilters) {
+        jobRun.setNodeFilters(nodeFilters);
+        return this;
+    }
+
+    public RunJobBuilder setAsUser(String asUser) {
+        jobRun.setAsUser(asUser);
+        return this;
+    }
+
+    public RunJob create() {
+        RunJob built = jobRun;
+        jobRun = new DefaultRunJob();
+        return built;
+    }
+}

src/test/java/org/rundeck/api/RundeckClientTest.java

@@ -28,10 +28,7 @@ import org.rundeck.api.query.ExecutionQuery;
 import org.rundeck.api.util.PagedResults;
 
 import java.io.ByteArrayInputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 
 
 /**
@@ -347,13 +344,13 @@ public class RundeckClientTest {
         final RundeckJobDelete delete = deleteTest.getResults().get(0);
         Assert.assertFalse(delete.isSuccessful());
         Assert.assertNotNull(delete.getError());
-        Assert.assertEquals("unauthorized",delete.getErrorCode());
+        Assert.assertEquals("unauthorized", delete.getErrorCode());
         Assert.assertNull(delete.getMessage());
         Assert.assertEquals("3a6d16be-4268-4d26-86a9-cebc1781f768", delete.getId());
     }
     @Test
     @Betamax(tape = "trigger_job_basic")
-    public void triggerJobBasic() throws Exception {
+    public void triggerJobDeprecatedBasic() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
 
         final RundeckExecution test
@@ -366,6 +363,38 @@ public class RundeckClientTest {
         Assert.assertEquals("admin", test.getStartedBy());
         Assert.assertEquals(RundeckExecution.ExecutionStatus.RUNNING, test.getStatus());
 
+    }
+    @Test
+    @Betamax(tape = "trigger_job_basic")
+    public void triggerJobBasic() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+
+        final RundeckExecution test
+            = client.triggerJob(RunJobBuilder.builder().setJobId("3170ba0e-6093-4b58-94d2-52988aefbfc9").create());
+
+        Assert.assertEquals((Long) 19L, test.getId());
+        Assert.assertEquals(null, test.getArgstring());
+        Assert.assertEquals(null, test.getAbortedBy());
+        Assert.assertEquals("echo hi there ${job.username} ; sleep 90", test.getDescription());
+        Assert.assertEquals("admin", test.getStartedBy());
+        Assert.assertEquals(RundeckExecution.ExecutionStatus.RUNNING, test.getStatus());
+
+    }
+    @Test
+    @Betamax(tape = "trigger_job_as_user")
+    public void triggerJobDeprecatedAsUser() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+
+        final RundeckExecution test
+            = client.triggerJob("3170ba0e-6093-4b58-94d2-52988aefbfc9", null, null, "api-java-client-user-test1");
+
+        Assert.assertEquals((Long) 20L, test.getId());
+        Assert.assertEquals(null, test.getArgstring());
+        Assert.assertEquals(null, test.getAbortedBy());
+        Assert.assertEquals("echo hi there ${job.username} ; sleep 90", test.getDescription());
+        Assert.assertEquals("api-java-client-user-test1", test.getStartedBy());
+        Assert.assertEquals(RundeckExecution.ExecutionStatus.RUNNING, test.getStatus());
+
     }
     @Test
     @Betamax(tape = "trigger_job_as_user")
@@ -373,7 +402,10 @@ public class RundeckClientTest {
         RundeckClient client = createClient(TEST_TOKEN_3);
 
         final RundeckExecution test
-            = client.triggerJob("3170ba0e-6093-4b58-94d2-52988aefbfc9",null,null,"api-java-client-user-test1");
+            = client.triggerJob(RunJobBuilder.builder()
+                .setJobId("3170ba0e-6093-4b58-94d2-52988aefbfc9")
+                .setAsUser("api-java-client-user-test1")
+                .create());
 
         Assert.assertEquals((Long)20L, test.getId());
         Assert.assertEquals(null, test.getArgstring());
@@ -385,7 +417,7 @@ public class RundeckClientTest {
     }
     @Test
     @Betamax(tape = "trigger_job_as_user_unauthorized")
-    public void triggerJobAsUserUnauthorized() throws Exception {
+    public void triggerJobDeprecatedAsUserUnauthorized() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
 
         final RundeckExecution test;
@@ -396,10 +428,26 @@ public class RundeckClientTest {
             Assert.assertEquals("Not authorized for action \"Run as User\" for Job ID 3170ba0e-6093-4b58-94d2-52988aefbfc9", e.getMessage());
         }
     }
+    @Test
+    @Betamax(tape = "trigger_job_as_user_unauthorized")
+    public void triggerJobAsUserUnauthorized() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+
+        final RundeckExecution test;
+        try {
+            test = client.triggerJob(RunJobBuilder.builder()
+                    .setJobId("3170ba0e-6093-4b58-94d2-52988aefbfc9")
+                    .setAsUser("api-java-client-user-test2")
+                    .create());
+            Assert.fail("should not succeed");
+        } catch (RundeckApiException e) {
+            Assert.assertEquals("Not authorized for action \"Run as User\" for Job ID 3170ba0e-6093-4b58-94d2-52988aefbfc9", e.getMessage());
+        }
+    }
 
     @Test
     @Betamax(tape = "trigger_adhoc_command")
-    public void triggerAdhocCommand() throws Exception {
+    public void triggerAdhocCommandDeprecated() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
 
         final RundeckExecution test
@@ -413,9 +461,28 @@ public class RundeckClientTest {
         Assert.assertEquals(RundeckExecution.ExecutionStatus.SUCCEEDED, test.getStatus());
     }
 
+    @Test
+    @Betamax(tape = "trigger_adhoc_command")
+    public void triggerAdhocCommand() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+
+        final RundeckExecution test
+                = client.triggerAdhocCommand(RunAdhocCommandBuilder.builder()
+                .setProject("test")
+                .setCommand("echo test trigger_adhoc_command")
+                .create());
+
+        Assert.assertEquals((Long) 23L, test.getId());
+        Assert.assertEquals(null, test.getArgstring());
+        Assert.assertEquals(null, test.getAbortedBy());
+        Assert.assertEquals("echo test trigger_adhoc_command", test.getDescription());
+        Assert.assertEquals("admin", test.getStartedBy());
+        Assert.assertEquals(RundeckExecution.ExecutionStatus.SUCCEEDED, test.getStatus());
+    }
+
     @Test
     @Betamax(tape = "trigger_adhoc_command_as_user")
-    public void triggerAdhocCommandAsUser() throws Exception {
+    public void triggerAdhocCommandDeprecatedAsUser() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
 
         final RundeckExecution test
@@ -429,8 +496,29 @@ public class RundeckClientTest {
         Assert.assertEquals(RundeckExecution.ExecutionStatus.SUCCEEDED, test.getStatus());
     }
     @Test
+    @Betamax(tape = "trigger_adhoc_command_as_user")
+    public void triggerAdhocCommandAsUser() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+
+        final RundeckExecution test
+                = client.triggerAdhocCommand(
+                RunAdhocCommandBuilder.builder()
+                        .setProject("test")
+                        .setCommand("echo test trigger_adhoc_command_as_user")
+                        .setAsUser("api-java-client-test-run-command-as-user1")
+                        .create()
+                );
+
+        Assert.assertEquals((Long) 24L, test.getId());
+        Assert.assertEquals(null, test.getArgstring());
+        Assert.assertEquals(null, test.getAbortedBy());
+        Assert.assertEquals("echo test trigger_adhoc_command_as_user", test.getDescription());
+        Assert.assertEquals("api-java-client-test-run-command-as-user1", test.getStartedBy());
+        Assert.assertEquals(RundeckExecution.ExecutionStatus.SUCCEEDED, test.getStatus());
+    }
+    @Test
     @Betamax(tape = "trigger_adhoc_command_as_user_unauthorized")
-    public void triggerAdhocCommandAsUserUnauthorized() throws Exception {
+    public void triggerAdhocCommandDeprecatedAsUserUnauthorized() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
 
         final RundeckExecution test;
@@ -441,7 +529,44 @@ public class RundeckClientTest {
             Assert.assertEquals("Not authorized for action \"Run as User\" for Run Adhoc", e.getMessage());
         }
     }
+    @Test
+    @Betamax(tape = "trigger_adhoc_command_as_user_unauthorized")
+    public void triggerAdhocCommandAsUserUnauthorized() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
 
+        final RundeckExecution test;
+        try {
+            test = client.triggerAdhocCommand(
+                    RunAdhocCommandBuilder.builder()
+                            .setProject("test")
+                            .setCommand("echo test trigger_adhoc_command_as_user")
+                            .setAsUser("api-java-client-test-run-command-as-user1")
+                            .create()
+            );
+            Assert.fail("should not succeed");
+        } catch (RundeckApiException e) {
+            Assert.assertEquals("Not authorized for action \"Run as User\" for Run Adhoc", e.getMessage());
+        }
+    }
+
+    @Test
+    @Betamax(tape = "trigger_adhoc_script")
+    public void triggerAdhocScriptDeprecated() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+        String script = "#!/bin/bash\n" +
+                "echo test trigger_adhoc_script\n";
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(script.getBytes());
+
+        final RundeckExecution test
+                = client.triggerAdhocScript("test", byteArrayInputStream,(Properties) null, null, null, null, null);
+
+        Assert.assertEquals((Long) 25L, test.getId());
+        Assert.assertEquals(null, test.getArgstring());
+        Assert.assertEquals(null, test.getAbortedBy());
+        Assert.assertEquals("#!/bin/bash\necho test trigger_adhoc_script", test.getDescription());
+        Assert.assertEquals("admin", test.getStartedBy());
+        Assert.assertEquals(RundeckExecution.ExecutionStatus.RUNNING, test.getStatus());
+    }
     @Test
     @Betamax(tape = "trigger_adhoc_script")
     public void triggerAdhocScript() throws Exception {
@@ -451,7 +576,8 @@ public class RundeckClientTest {
         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(script.getBytes());
 
         final RundeckExecution test
-                = client.triggerAdhocScript("test", byteArrayInputStream, null, null, null, null, null);
+                = client.triggerAdhocScript(RunAdhocScriptBuilder.builder().setProject("test").setScript
+                (byteArrayInputStream).create());
 
         Assert.assertEquals((Long) 25L, test.getId());
         Assert.assertEquals(null, test.getArgstring());
@@ -462,6 +588,24 @@ public class RundeckClientTest {
     }
     @Test
     @Betamax(tape = "trigger_adhoc_script_as_user")
+    public void triggerAdhocScriptDeprecatedAsUser() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+        String script = "#!/bin/bash\n" +
+                "echo test trigger_adhoc_script\n";
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(script.getBytes());
+
+        final RundeckExecution test
+                = client.triggerAdhocScript("test", byteArrayInputStream, (Properties) null, null, null, null, "api-java-client-test-adhoc-script-as-user1");
+
+        Assert.assertEquals((Long) 26L, test.getId());
+        Assert.assertEquals(null, test.getArgstring());
+        Assert.assertEquals(null, test.getAbortedBy());
+        Assert.assertEquals("#!/bin/bash\necho test trigger_adhoc_script", test.getDescription());
+        Assert.assertEquals("api-java-client-test-adhoc-script-as-user1", test.getStartedBy());
+        Assert.assertEquals(RundeckExecution.ExecutionStatus.RUNNING, test.getStatus());
+    }
+    @Test
+    @Betamax(tape = "trigger_adhoc_script_as_user")
     public void triggerAdhocScriptAsUser() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
         String script = "#!/bin/bash\n" +
@@ -469,7 +613,8 @@ public class RundeckClientTest {
         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(script.getBytes());
 
         final RundeckExecution test
-                = client.triggerAdhocScript("test", byteArrayInputStream, null, null, null, null, "api-java-client-test-adhoc-script-as-user1");
+                = client.triggerAdhocScript(RunAdhocScriptBuilder.builder().setProject("test").setScript
+                (byteArrayInputStream).setAsUser("api-java-client-test-adhoc-script-as-user1").create());
 
         Assert.assertEquals((Long) 26L, test.getId());
         Assert.assertEquals(null, test.getArgstring());
@@ -480,6 +625,23 @@ public class RundeckClientTest {
     }
     @Test
     @Betamax(tape = "trigger_adhoc_script_as_user_unauthorized")
+    public void triggerAdhocScriptDeprecatedAsUserUnauthorized() throws Exception {
+        RundeckClient client = createClient(TEST_TOKEN_3);
+        String script = "#!/bin/bash\n" +
+                "echo test trigger_adhoc_script\n";
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(script.getBytes());
+
+        try{
+        final RundeckExecution test
+                = client.triggerAdhocScript("test", byteArrayInputStream, (Properties) null, null, null, null, "api-java-client-test-adhoc-script-as-user1");
+            Assert.fail("should not succeed");
+        } catch (RundeckApiException e) {
+            Assert.assertEquals("Not authorized for action \"Run as User\" for Run Adhoc", e.getMessage());
+        }
+
+    }
+    @Test
+    @Betamax(tape = "trigger_adhoc_script_as_user_unauthorized")
     public void triggerAdhocScriptAsUserUnauthorized() throws Exception {
         RundeckClient client = createClient(TEST_TOKEN_3);
         String script = "#!/bin/bash\n" +
@@ -488,7 +650,8 @@ public class RundeckClientTest {
 
         try{
         final RundeckExecution test
-                = client.triggerAdhocScript("test", byteArrayInputStream, null, null, null, null, "api-java-client-test-adhoc-script-as-user1");
+                = client.triggerAdhocScript(RunAdhocScriptBuilder.builder().setProject("test").setScript
+                (byteArrayInputStream).setAsUser("api-java-client-test-adhoc-script-as-user1").create());
             Assert.fail("should not succeed");
         } catch (RundeckApiException e) {
             Assert.assertEquals("Not authorized for action \"Run as User\" for Run Adhoc", e.getMessage());