Add input support to ShellTestClient for interactive command testing

Signed-off-by: David Pilar <david@czpilar.net>

Author: czpilar

spring-shell-test/src/main/java/org/springframework/shell/test/ShellInputProvider.java

@@ -0,0 +1,48 @@
+package org.springframework.shell.test;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Represents a provider for inputs and passwords used in shell interactions. This class
+ * uses two {@link Deque} instances to manage the queue of user inputs and passwords. It
+ * serves as a utility for simulating user input during testing or automated shell
+ * interactions.
+ *
+ * @param inputs Queue containing user input strings.
+ * @param passwords Queue containing user password strings.
+ */
+public record ShellInputProvider(Deque<String> inputs, Deque<String> passwords) {
+
+	static Builder builder() {
+		return Builder.builder();
+	}
+
+	final static class Builder {
+
+		private final List<String> inputs = new ArrayList<>();
+
+		private final List<String> passwords = new ArrayList<>();
+
+		static Builder builder() {
+			return new Builder();
+		}
+
+		public Builder input(String... input) {
+			inputs.addAll(List.of(input));
+			return this;
+		}
+
+		public Builder password(String... password) {
+			passwords.addAll(List.of(password));
+			return this;
+		}
+
+		public ShellInputProvider build() {
+			return new ShellInputProvider(new LinkedList<>(inputs), new LinkedList<>(passwords));
+		}
+
+	}
+}

spring-shell-test/src/main/java/org/springframework/shell/test/ShellTestClient.java

@@ -15,23 +15,20 @@
  */
 package org.springframework.shell.test;
 
+import org.springframework.shell.core.InputReader;
+import org.springframework.shell.core.command.*;
+
 import java.io.PrintWriter;
 import java.io.StringWriter;
 
-import org.springframework.shell.core.InputReader;
-import org.springframework.shell.core.command.CommandContext;
-import org.springframework.shell.core.command.CommandExecutor;
-import org.springframework.shell.core.command.CommandParser;
-import org.springframework.shell.core.command.CommandRegistry;
-import org.springframework.shell.core.command.ParsedInput;
-
 /**
  * Client for shell session which can be used as a programmatic way to interact with a
  * shell application. In a typical test, it is required to send a command to the shell as
  * if a user typed it and then verify the shell output.
  *
  * @author Janne Valkealahti
  * @author Mahmoud Ben Hassine
+ * @author David Pilar
  */
 public class ShellTestClient {
 
@@ -60,10 +57,36 @@ public ShellTestClient(CommandParser commandParser, CommandRegistry commandRegis
 	 * @throws Exception if an error occurred during command execution
 	 */
 	public ShellScreen sendCommand(String input) throws Exception {
+		return sendCommand(input, ShellInputProvider.builder().build());
+	}
+
+	/**
+	 * Sends a command to the shell, processes user inputs or passwords as needed, and
+	 * returns the resulting shell screen output.
+	 * @param input the raw command string to be sent to the shell
+	 * @param inputProvider a provider containing simulated user inputs and passwords
+	 * @return a {@code ShellScreen} object containing the output of the shell after
+	 * command execution
+	 * @throws Exception if an error occurs during the command execution
+	 */
+	public ShellScreen sendCommand(String input, ShellInputProvider inputProvider) throws Exception {
 		StringWriter stringWriter = new StringWriter();
 		ParsedInput parsedInput = this.commandParser.parse(input);
 		PrintWriter outputWriter = new PrintWriter(stringWriter);
 		InputReader inputReader = new InputReader() {
+			@Override
+			public String readInput(String prompt) {
+				outputWriter.print(prompt);
+				String in = inputProvider.inputs().pollFirst();
+				return in == null ? "" : in;
+			}
+
+			@Override
+			public char[] readPassword(String prompt) {
+				outputWriter.print(prompt);
+				String pwd = inputProvider.passwords().pollFirst();
+				return pwd == null ? new char[] {} : pwd.toCharArray();
+			}
 		};
 		CommandContext commandContext = new CommandContext(parsedInput, this.commandRegistry, outputWriter,
 				inputReader);

spring-shell-test/src/test/java/org/springframework/shell/test/ShellTestClientTests.java

@@ -17,6 +17,8 @@
 import org.springframework.shell.core.command.ExitStatus;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
+import java.io.PrintWriter;
+
 @ExtendWith(SpringExtension.class)
 class ShellTestClientTests {
 
@@ -36,6 +38,42 @@ void testUnknownCommandExecution(@Autowired ShellTestClient shellTestClient) {
 			.isInstanceOf(CommandNotFoundException.class);
 	}
 
+	@Test
+	void testCommandExecutionWithReadingInput(@Autowired ShellTestClient client) throws Exception {
+		// when
+		ShellScreen screen = client.sendCommand("hello", ShellInputProvider.builder().input("hi").build());
+
+		// then
+		ShellAssertions.assertThat(screen).containsText("You said: hi");
+	}
+
+	@Test
+	void testCommandExecutionWithReadingPassword(@Autowired ShellTestClient client) throws Exception {
+		// when
+		ShellScreen screen = client.sendCommand("password", ShellInputProvider.builder().password("secret123").build());
+
+		// then
+		ShellAssertions.assertThat(screen).containsText("Your password is: secret123");
+	}
+
+	@Test
+	void testCommandExecutionWithComplexInputs(@Autowired ShellTestClient client) throws Exception {
+		// given
+		ShellInputProvider inputProvider = ShellInputProvider.builder()
+			.input("One", "Two")
+			.password("secret1", "secret2")
+			.build();
+
+		// when
+		ShellScreen screen = client.sendCommand("complex", inputProvider);
+
+		// then
+		ShellAssertions.assertThat(screen).containsText("First input is: One");
+		ShellAssertions.assertThat(screen).containsText("First password is: secret1");
+		ShellAssertions.assertThat(screen).containsText("Second input is: Two");
+		ShellAssertions.assertThat(screen).containsText("Second password is: secret2");
+	}
+
 	@Configuration
 	static class TestCommands {
 
@@ -50,6 +88,52 @@ public ExitStatus doExecute(CommandContext commandContext) {
 			};
 		}
 
+		@Bean
+		public Command hello() {
+			return new AbstractCommand("hello", "A hello command") {
+				@Override
+				public ExitStatus doExecute(CommandContext commandContext) throws Exception {
+					String message = commandContext.inputReader().readInput();
+					commandContext.outputWriter().println("You said: " + message);
+					return ExitStatus.OK;
+				}
+			};
+		}
+
+		@Bean
+		public Command password() {
+			return new AbstractCommand("password", "A password command") {
+				@Override
+				public ExitStatus doExecute(CommandContext commandContext) throws Exception {
+					char[] chars = commandContext.inputReader().readPassword();
+					commandContext.outputWriter().println("Your password is: " + new String(chars));
+					return ExitStatus.OK;
+				}
+			};
+		}
+
+		@Bean
+		public Command complexCommand() {
+			return new AbstractCommand("complex", "A complex command") {
+				@Override
+				public ExitStatus doExecute(CommandContext commandContext) throws Exception {
+					String message = commandContext.inputReader().readInput();
+					commandContext.outputWriter().println("First input is: " + message);
+
+					char[] chars = commandContext.inputReader().readPassword();
+					commandContext.outputWriter().println("First password is: " + new String(chars));
+
+					message = commandContext.inputReader().readInput();
+					commandContext.outputWriter().println("Second input is: " + message);
+
+					chars = commandContext.inputReader().readPassword();
+					commandContext.outputWriter().println("Second password is: " + new String(chars));
+
+					return ExitStatus.OK;
+				}
+			};
+		}
+
 		@Bean
 		public CommandRegistry commandRegistry() {
 			return new CommandRegistry();