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 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_form_creation():
inp = create_pipe_input()
text = "Y" + KeyInputs.ENTER + "\r"
try:
inp.send_text(text)
f = example_form(inp)
result = f.unsafe_ask()
assert result == {'q1': True, 'q2': 'foo'}
finally:
inp.close()
def test_ask_should_catch_keyboard_exception():
inp = create_pipe_input()
try:
inp.send_text(KeyInputs.CONTROLC)
f = example_form(inp)
result = f.ask()
assert result == {}
except KeyboardInterrupt:
fail("Keyboard Interrupt should be caught by `ask()`")
finally:
inp.close()
def test_ask_should_catch_keyboard_exception():
inp = create_pipe_input()
try:
inp.send_text(KeyInputs.CONTROLC)
question = text("Hello?", input=inp, output=DummyOutput())
result = question.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 patched_prompt(questions, text, **kwargs):
"""Create a prompt where the input and output are predefined."""
inp = create_pipe_input()
try:
# noinspection PyUnresolvedReferences
inp.send_text(text)
result = prompt(questions, input=inp, output=DummyOutput(), **kwargs)
return result
finally:
inp.close()
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.
"""
with create_pipe_input() as pipe_input:
app = Application(
layout=Layout(Window()),
output=DummyOutput(),
input=pipe_input,
)
with set_app(app):
yield
def test_skipping_of_skipping_of_questions():
inp = create_pipe_input()
try:
inp.send_text("World" + KeyInputs.ENTER + "\r")
question = text("Hello?", input=inp, output=DummyOutput()).skip_if(
condition=False, default=42
)
response = question.ask()
assert response == "World" and not response == 42
finally:
inp.close()
def test_accept_default():
"""
Test `prompt(accept_default=True)`.
"""
inp = create_pipe_input()
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'
inp.close()
def test_accept_default():
"""
Test `prompt(accept_default=True)`.
"""
inp = create_pipe_input()
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'
inp.close()
def __init__(self,
ctx: click.Context = None,
on_finished=None,
hist_file=None,
before_start=None,
readline=None,
complete_while_typing=True,
fuzzy_completion=True,
mouse_support=False,
lexer=True,
*args,
**kwargs):
self._stdout = kwargs.get('stdout')
super(ClickCmd, self).__init__(*args, **kwargs)
# readline overrides
self.old_completer = None
self.old_delims = None
self.readline = readline
# Prompt Toolkit Settings
self.complete_while_typing = complete_while_typing
self.fuzzy_completion = fuzzy_completion
self.mouse_support = mouse_support
self.lexer = lexer
self._pipe_input = create_pipe_input() if not self.readline else None
# A callback function that will be excuted before loading up the shell.
# By default this changes the color to 0a on a Windows machine
self.before_start = before_start
# Save the click.Context and callback for when the shell completes
self.ctx = ctx
self.on_finished = on_finished
# Define the history file
hist_file = hist_file or os.path.join(os.path.expanduser('~'),
globs.HISTORY_FILENAME)
self.hist_file = os.path.abspath(hist_file)
if not os.path.isdir(os.path.dirname(self.hist_file)):
os.makedirs(os.path.dirname(self.hist_file))
self.history = FileHistory(self.hist_file)
self.history.load_history_strings()
def feed_cli_with_input(_type, message, text, **kwargs):
"""
Create a Prompt, feed it with the given user input and return the CLI
object.
This returns a (result, Application) tuple.
"""
inp = create_pipe_input()
try:
inp.send_text(text)
prompter = prompt_by_name(_type)
application = prompter(message, input=inp, output=DummyOutput(), **kwargs)
result = application.unsafe_ask()
return result, application
finally:
inp.close()
def feed_cli_with_input(_type, message, texts, sleep_time=1, **kwargs):
"""
Create a Prompt, feed it with the given user input and return the CLI
object.
You an provide multiple texts, the feeder will async sleep for `sleep_time`
This returns a (result, Application) tuple.
"""
if not isinstance(texts, list):
texts = [texts]
inp = create_pipe_input()
try:
prompter = prompt_by_name(_type)
application = prompter(message,
input=inp,
output=DummyOutput(),
**kwargs)
if is_prompt_toolkit_3():
loop = asyncio.new_event_loop()
future_result = loop.create_task(application.unsafe_ask_async())
for i, text in enumerate(texts):
# noinspection PyUnresolvedReferences
inp.send_text(text)
if i != len(texts) - 1:
loop.run_until_complete(asyncio.sleep(sleep_time))
result = loop.run_until_complete(future_result)
else:
for text in texts:
inp.send_text(text)
result = application.unsafe_ask()
return result, application
finally:
inp.close()
def test_blank_line_fix():
def get_prompt_tokens():
return [("class:question", "What is your favourite letter?")]
ic = InquirerControl(["a", "b", "c"])
inp = create_pipe_input()
try:
inp.send_text("")
layout = common.create_inquirer_layout(ic,
get_prompt_tokens,
input=inp,
output=DummyOutput())
# usually this would be 2000000000000000000000000000000
# but `common._fix_unecessary_blank_lines` makes sure
# the main window is not as greedy (avoiding blank lines)
assert (layout.container.preferred_height(
100, 200).max == 1000000000000000000000000000001)
finally:
inp.close()
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 setUp(self):
self.inp = create_pipe_input()
def setUp(self):
self.inp = create_pipe_input()
self.dirs_to_create = ["dir1", "dir2", "dir3", ".dir"]
self.files_to_create = ["file1", "file2", "file3", ".file"]
self.test_dir = Path(tempfile.mkdtemp())
self.create_temp_files()
