def test_custom_reject(self):
self.inp.send_text("w")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=False,
qmark="?",
output=DummyOutput(),
input=self.inp,
reject_letter="w",
)
result = confirm_prompt.execute()
self.assertEqual(result, False)
self.assertEqual(confirm_prompt.status["answered"], True)
self.assertEqual(confirm_prompt.status["result"], False)
self.inp.send_text("W")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
reject_letter="w",
)
result = confirm_prompt.execute()
self.assertEqual(result, False)
def test_input_n(self):
self.inp.send_text("n")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
)
result = confirm_prompt.execute()
self.assertEqual(result, False)
self.assertEqual(confirm_prompt.status["answered"], True)
self.assertEqual(confirm_prompt.status["result"], False)
self.inp.send_text("N")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
)
result = confirm_prompt.execute()
self.assertEqual(result, False)
def test_input_y_async(self):
self.inp.send_text("y")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
)
result = asyncio.run(confirm_prompt._run_async())
self.assertEqual(result, True)
self.assertEqual(confirm_prompt.status["answered"], True)
self.assertEqual(confirm_prompt.status["result"], True)
self.inp.send_text("Y")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
)
result = asyncio.run(confirm_prompt.execute_async())
self.assertEqual(result, True)
def test_custom_confirm(self):
self.inp.send_text("s")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
confirm_letter="s",
)
result = confirm_prompt._session.prompt()
self.assertEqual(result, True)
self.assertEqual(confirm_prompt.status["answered"], True)
self.assertEqual(confirm_prompt.status["result"], True)
self.inp.send_text("S")
confirm_prompt = ConfirmPrompt(
message="hello",
style=None,
default=True,
qmark="?",
output=DummyOutput(),
input=self.inp,
confirm_letter="s",
)
result = confirm_prompt.execute()
self.assertEqual(result, True)
def example_form(inp):
return form(q1=questionary.confirm("Hello?",
input=inp,
output=DummyOutput()),
q2=questionary.select("World?",
choices=["foo", "bar"],
input=inp,
output=DummyOutput()))
def mock_prompt_input():
# TODO: remove if prompt-toolkit min version gets bumped
if PIPE_INPUT_CONTEXT_MANAGER:
with create_pipe_input() as pipe_input:
with create_app_session(input=pipe_input, output=DummyOutput()):
yield pipe_input
else:
pipe_input = create_pipe_input()
try:
with create_app_session(input=pipe_input, output=DummyOutput()):
yield pipe_input
finally:
pipe_input.close()
def test_cli_argument():
arguments = ['ws-ui']
with patch.object(sys, 'argv', arguments):
with create_app_session(input=create_pipe_input(),
output=DummyOutput()):
app = Application()
asyncio.run(app.main())
def feed_app_with_input(type, message, text, **kwargs):
"""
Create an application, feed it with the given user input and return
the CLI object.
This returns a (result, CLI) tuple.
note: this only works if you import your prompt and then this function!!
"""
# If the given text doesn't end with a newline, the interface won't finish.
assert text.endswith('\r')
inp = PosixPipeInput(text)
try:
with create_app_session(input=inp, output=DummyOutput()) as session:
application = getattr(prompts, type).question(message, **kwargs)
#print(application.input)
#breakpoint()
if isinstance(application, Application):
result = application.run()
elif isinstance(application, PromptSession):
result = application.prompt()
return result
finally:
inp.close()
def test_print(monkeypatch):
mock = Mock(return_value=None)
monkeypatch.setattr(DummyOutput, "write", mock)
print_formatted_text("Hello World", output=DummyOutput())
mock.assert_has_calls([call("Hello World"), call("\r\n")])
def test_prompt_completion(self):
input_prompt = InputPrompt(
message="yes",
style=None,
default="",
qmark="!",
vi_mode=False,
input=self.inp,
output=DummyOutput(),
multiline=True,
completer={
"hello": None,
"hey": None,
"what": None
},
)
completer = input_prompt._completer
doc_text = "he"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = [
completion.text for completion in list(
completer.get_completions(doc, event)) # type: ignore
]
self.assertEqual(sorted(completions), ["hello", "hey"])
def test_prompt_filter(self):
self.inp.send_text("hello\n")
input_prompt = InputPrompt(
message="yes",
style=None,
default="world",
qmark="!",
vi_mode=False,
input=self.inp,
output=DummyOutput(),
filter=lambda x: x * 2,
transformer=lambda _: "what",
)
result = input_prompt.execute()
self.assertEqual(result, "worldhelloworldhello")
self.assertEqual(input_prompt.status["answered"], True)
self.assertEqual(input_prompt.status["result"], "worldhello")
self.assertEqual(
input_prompt._get_prompt_message(),
[
("class:answermark", "?"),
("class:answered_question", " yes"),
("class:answer", " what"),
],
)
def _feed_cli_with_input(text,
editing_mode=EditingMode.EMACS,
clipboard=None,
history=None,
multiline=False,
check_line_ending=True,
key_bindings=None):
"""
Create a Prompt, feed it with the given user input and return the CLI
object.
This returns a (result, Application) tuple.
"""
# If the given text doesn't end with a newline, the interface won't finish.
if check_line_ending:
assert text.endswith('\r')
inp = create_pipe_input()
try:
inp.send_text(text)
session = PromptSession(input=inp,
output=DummyOutput(),
editing_mode=editing_mode,
history=history,
multiline=multiline,
clipboard=clipboard,
key_bindings=key_bindings)
result = session.prompt()
return session.default_buffer.document, session.app
finally:
inp.close()
def feed_app_with_input(type, message, text, **kwargs):
"""
Create a CommandLineInterface, feed it with the given user input and return
the CLI object.
This returns a (result, CLI) tuple.
note: this only works if you import your prompt and then this function!!
"""
# If the given text doesn't end with a newline, the interface won't finish.
assert text.endswith('\n')
application = getattr(prompts, type).question(message, **kwargs)
loop = PosixEventLoop()
try:
inp = PipeInput()
inp.send_text(text)
cli = CommandLineInterface(
application=application,
eventloop=loop,
input=inp,
output=DummyOutput())
result = cli.run()
return result, cli
finally:
loop.close()
inp.close()
def ask_with_patched_input(q, text):
inp = create_pipe_input()
try:
inp.send_text(text)
return q(input=inp, output=DummyOutput())
finally:
inp.close()
def _feed_cli_with_input(text,
editing_mode=EditingMode.EMACS,
clipboard=None,
history=None):
"""
Create a CommandLineInterface, feed it with the given user input and return
the CLI object.
This returns a (result, CLI) tuple.
"""
# If the given text doesn't end with a newline, the interface won't finish.
assert text.endswith('\n')
from prompt_toolkit.eventloop.posix import PosixEventLoop as EventLoop
loop = EventLoop()
try:
inp = PipeInput()
inp.send_text(text)
cli = CommandLineInterface(application=Application(
buffer=Buffer(accept_action=AcceptAction.RETURN_DOCUMENT,
history=history),
editing_mode=editing_mode,
clipboard=clipboard or InMemoryClipboard(),
key_bindings_registry=KeyBindingManager.for_prompt().registry,
),
eventloop=loop,
input=inp,
output=DummyOutput())
result = cli.run()
return result, cli
finally:
loop.close()
inp.close()
def setUp(self):
self.input = PipeInput()
output = DummyOutput()
self.aws_shell = AWSShell(None,
mock.Mock(),
mock.Mock(),
input=self.input,
output=output)
self.processor = self.aws_shell.cli.input_processor
def app():
pipe_input = create_pipe_input()
try:
with create_app_session(input=pipe_input, output=DummyOutput()):
config = Config()
app = App(config=config)
yield app
finally:
pipe_input.close()
def test_skipping_of_questions():
inp = create_pipe_input()
try:
question = text("Hello?", input=inp, output=DummyOutput()).skip_if(
condition=True, default=42
)
response = question.ask()
assert response == 42
finally:
inp.close()
def mock_input():
pipe_input = create_pipe_input()
try:
with create_app_session(
input=pipe_input,
output=DummyOutput(),
):
yield pipe_input
finally:
pipe_input.close()
def mock_app(mocker):
app = Application(
input=create_pipe_input(),
output=DummyOutput(),
)
mocker.patch('upsies.uis.tui.tui.TUI._make_app', Mock(return_value=app))
mocker.patch('upsies.uis.tui.tui.TUI._jobs_container',
Mock(children=[]),
create=True)
mocker.patch('upsies.uis.tui.tui.TUI._layout', Mock(), create=True)
def set_dummy_app():
"""
Return a context manager that makes sure that this dummy application is
active. This is important, because we need an `Application` with
`is_done=False` flag, otherwise no keys will be processed.
"""
app = Application(layout=Layout(Window()),
output=DummyOutput(),
input=create_pipe_input())
return set_app(app)
def test_layout(self):
input = create_pipe_input()
with create_app_session(input=input, output=DummyOutput()):
tui = TerminalUI()
layout = tui.app.layout
assert len(list(layout.find_all_windows())) > 1
children = layout.container.get_children()
assert len(children) == 2
assert len(children[0].get_children()) == 2
def prompt(monkeypatch):
monkeypatch.setattr('getpass.getpass', lambda _: 'mock_password')
pipe = create_pipe_input()
try:
session = PromptSession(
input=pipe,
output=DummyOutput(),
)
yield Prompt(session, pipe)
finally:
pipe.close()
def test_async_ask_question():
loop = asyncio.new_event_loop()
inp = create_pipe_input()
try:
inp.send_text("World" + KeyInputs.ENTER + "\r")
question = text("Hello?", input=inp, output=DummyOutput())
response = loop.run_until_complete(question.ask_async())
assert response == "World"
finally:
inp.close()
def patched_prompt(questions, text, **kwargs):
"""Create a prompt where the input and output are predefined."""
inp = create_pipe_input()
try:
inp.send_text(text)
result = prompt(questions, input=inp, output=DummyOutput(), **kwargs)
return result
finally:
inp.close()
def ptk_shell(xonsh_execer):
from prompt_toolkit.input import create_pipe_input
from prompt_toolkit.output import DummyOutput
from xonsh.ptk_shell.shell import PromptToolkitShell
inp = create_pipe_input()
out = DummyOutput()
shell = PromptToolkitShell(
execer=xonsh_execer, ctx={}, ptk_args={"input": inp, "output": out}
)
yield inp, out, shell
inp.close()
def test_input(self):
self.inp.send_text("./file1\n")
filepath_prompt = FilePathPrompt(
message="hello",
style=InquirerPyStyle({"qmark": "bold"}),
input=self.inp,
output=DummyOutput(),
)
result = filepath_prompt.execute()
self.assertEqual(result, "./file1")
self.assertEqual(filepath_prompt.status["answered"], True)
self.assertEqual(filepath_prompt.status["result"], "./file1")
def test_ask_should_catch_keyboard_exception():
inp = create_pipe_input()
try:
inp.send_text(KeyInputs.CONTROLC)
application = text("Hello?", input=inp, output=DummyOutput())
result = application.ask()
assert result is None
except KeyboardInterrupt:
fail("Keyboard Interrupt should be caught by `ask()`")
finally:
inp.close()
def test_multiline_text():
inp = create_pipe_input()
try:
inp.send_text(
f"Hello{KeyInputs.ENTER}world{KeyInputs.ESCAPE}{KeyInputs.ENTER}")
question = text("Hello?",
input=inp,
output=DummyOutput(),
multiline=True)
response = question.ask()
assert response == "Hello\nworld"
finally:
inp.close()
def test_accept_default():
"""
Test `prompt(accept_default=True)`.
"""
with create_pipe_input() as inp:
session = PromptSession(input=inp, output=DummyOutput())
result = session.prompt(default="hello", accept_default=True)
assert result == "hello"
# Test calling prompt() for a second time. (We had an issue where the
# prompt reset between calls happened at the wrong time, breaking this.)
result = session.prompt(default="world", accept_default=True)
assert result == "world"
