421 lines
10 KiB
Python
421 lines
10 KiB
Python
import os
|
|
import sys
|
|
from io import BytesIO
|
|
|
|
import pytest
|
|
|
|
import click
|
|
from click._compat import WIN
|
|
from click.testing import CliRunner
|
|
|
|
|
|
def test_runner():
|
|
@click.command()
|
|
def test():
|
|
i = click.get_binary_stream("stdin")
|
|
o = click.get_binary_stream("stdout")
|
|
while True:
|
|
chunk = i.read(4096)
|
|
if not chunk:
|
|
break
|
|
o.write(chunk)
|
|
o.flush()
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, input="Hello World!\n")
|
|
assert not result.exception
|
|
assert result.output == "Hello World!\n"
|
|
|
|
|
|
def test_echo_stdin_stream():
|
|
@click.command()
|
|
def test():
|
|
i = click.get_binary_stream("stdin")
|
|
o = click.get_binary_stream("stdout")
|
|
while True:
|
|
chunk = i.read(4096)
|
|
if not chunk:
|
|
break
|
|
o.write(chunk)
|
|
o.flush()
|
|
|
|
runner = CliRunner(echo_stdin=True)
|
|
result = runner.invoke(test, input="Hello World!\n")
|
|
assert not result.exception
|
|
assert result.output == "Hello World!\nHello World!\n"
|
|
|
|
|
|
def test_echo_stdin_prompts():
|
|
@click.command()
|
|
def test_python_input():
|
|
foo = input("Foo: ")
|
|
click.echo(f"foo={foo}")
|
|
|
|
runner = CliRunner(echo_stdin=True)
|
|
result = runner.invoke(test_python_input, input="bar bar\n")
|
|
assert not result.exception
|
|
assert result.output == "Foo: bar bar\nfoo=bar bar\n"
|
|
|
|
@click.command()
|
|
@click.option("--foo", prompt=True)
|
|
def test_prompt(foo):
|
|
click.echo(f"foo={foo}")
|
|
|
|
result = runner.invoke(test_prompt, input="bar bar\n")
|
|
assert not result.exception
|
|
assert result.output == "Foo: bar bar\nfoo=bar bar\n"
|
|
|
|
@click.command()
|
|
@click.option("--foo", prompt=True, hide_input=True)
|
|
def test_hidden_prompt(foo):
|
|
click.echo(f"foo={foo}")
|
|
|
|
result = runner.invoke(test_hidden_prompt, input="bar bar\n")
|
|
assert not result.exception
|
|
assert result.output == "Foo: \nfoo=bar bar\n"
|
|
|
|
@click.command()
|
|
@click.option("--foo", prompt=True)
|
|
@click.option("--bar", prompt=True)
|
|
def test_multiple_prompts(foo, bar):
|
|
click.echo(f"foo={foo}, bar={bar}")
|
|
|
|
result = runner.invoke(test_multiple_prompts, input="one\ntwo\n")
|
|
assert not result.exception
|
|
assert result.output == "Foo: one\nBar: two\nfoo=one, bar=two\n"
|
|
|
|
|
|
def test_runner_with_stream():
|
|
@click.command()
|
|
def test():
|
|
i = click.get_binary_stream("stdin")
|
|
o = click.get_binary_stream("stdout")
|
|
while True:
|
|
chunk = i.read(4096)
|
|
if not chunk:
|
|
break
|
|
o.write(chunk)
|
|
o.flush()
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, input=BytesIO(b"Hello World!\n"))
|
|
assert not result.exception
|
|
assert result.output == "Hello World!\n"
|
|
|
|
runner = CliRunner(echo_stdin=True)
|
|
result = runner.invoke(test, input=BytesIO(b"Hello World!\n"))
|
|
assert not result.exception
|
|
assert result.output == "Hello World!\nHello World!\n"
|
|
|
|
|
|
def test_prompts():
|
|
@click.command()
|
|
@click.option("--foo", prompt=True)
|
|
def test(foo):
|
|
click.echo(f"foo={foo}")
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, input="wau wau\n")
|
|
assert not result.exception
|
|
assert result.output == "Foo: wau wau\nfoo=wau wau\n"
|
|
|
|
@click.command()
|
|
@click.option("--foo", prompt=True, hide_input=True)
|
|
def test(foo):
|
|
click.echo(f"foo={foo}")
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(test, input="wau wau\n")
|
|
assert not result.exception
|
|
assert result.output == "Foo: \nfoo=wau wau\n"
|
|
|
|
|
|
def test_getchar():
|
|
@click.command()
|
|
def continue_it():
|
|
click.echo(click.getchar())
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(continue_it, input="y")
|
|
assert not result.exception
|
|
assert result.output == "y\n"
|
|
|
|
runner = CliRunner(echo_stdin=True)
|
|
result = runner.invoke(continue_it, input="y")
|
|
assert not result.exception
|
|
assert result.output == "y\n"
|
|
|
|
@click.command()
|
|
def getchar_echo():
|
|
click.echo(click.getchar(echo=True))
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(getchar_echo, input="y")
|
|
assert not result.exception
|
|
assert result.output == "yy\n"
|
|
|
|
runner = CliRunner(echo_stdin=True)
|
|
result = runner.invoke(getchar_echo, input="y")
|
|
assert not result.exception
|
|
assert result.output == "yy\n"
|
|
|
|
|
|
def test_catch_exceptions():
|
|
class CustomError(Exception):
|
|
pass
|
|
|
|
@click.command()
|
|
def cli():
|
|
raise CustomError(1)
|
|
|
|
runner = CliRunner()
|
|
|
|
result = runner.invoke(cli)
|
|
assert isinstance(result.exception, CustomError)
|
|
assert type(result.exc_info) is tuple
|
|
assert len(result.exc_info) == 3
|
|
|
|
with pytest.raises(CustomError):
|
|
runner.invoke(cli, catch_exceptions=False)
|
|
|
|
CustomError = SystemExit
|
|
|
|
result = runner.invoke(cli)
|
|
assert result.exit_code == 1
|
|
|
|
|
|
@pytest.mark.skipif(WIN, reason="Test does not make sense on Windows.")
|
|
def test_with_color():
|
|
@click.command()
|
|
def cli():
|
|
click.secho("hello world", fg="blue")
|
|
|
|
runner = CliRunner()
|
|
|
|
result = runner.invoke(cli)
|
|
assert result.output == "hello world\n"
|
|
assert not result.exception
|
|
|
|
result = runner.invoke(cli, color=True)
|
|
assert result.output == f"{click.style('hello world', fg='blue')}\n"
|
|
assert not result.exception
|
|
|
|
|
|
def test_with_color_but_pause_not_blocking():
|
|
@click.command()
|
|
def cli():
|
|
click.pause()
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(cli, color=True)
|
|
assert not result.exception
|
|
assert result.output == ""
|
|
|
|
|
|
def test_exit_code_and_output_from_sys_exit():
|
|
# See issue #362
|
|
@click.command()
|
|
def cli_string():
|
|
click.echo("hello world")
|
|
sys.exit("error")
|
|
|
|
@click.command()
|
|
@click.pass_context
|
|
def cli_string_ctx_exit(ctx):
|
|
click.echo("hello world")
|
|
ctx.exit("error")
|
|
|
|
@click.command()
|
|
def cli_int():
|
|
click.echo("hello world")
|
|
sys.exit(1)
|
|
|
|
@click.command()
|
|
@click.pass_context
|
|
def cli_int_ctx_exit(ctx):
|
|
click.echo("hello world")
|
|
ctx.exit(1)
|
|
|
|
@click.command()
|
|
def cli_float():
|
|
click.echo("hello world")
|
|
sys.exit(1.0)
|
|
|
|
@click.command()
|
|
@click.pass_context
|
|
def cli_float_ctx_exit(ctx):
|
|
click.echo("hello world")
|
|
ctx.exit(1.0)
|
|
|
|
@click.command()
|
|
def cli_no_error():
|
|
click.echo("hello world")
|
|
|
|
runner = CliRunner()
|
|
|
|
result = runner.invoke(cli_string)
|
|
assert result.exit_code == 1
|
|
assert result.output == "hello world\nerror\n"
|
|
|
|
result = runner.invoke(cli_string_ctx_exit)
|
|
assert result.exit_code == 1
|
|
assert result.output == "hello world\nerror\n"
|
|
|
|
result = runner.invoke(cli_int)
|
|
assert result.exit_code == 1
|
|
assert result.output == "hello world\n"
|
|
|
|
result = runner.invoke(cli_int_ctx_exit)
|
|
assert result.exit_code == 1
|
|
assert result.output == "hello world\n"
|
|
|
|
result = runner.invoke(cli_float)
|
|
assert result.exit_code == 1
|
|
assert result.output == "hello world\n1.0\n"
|
|
|
|
result = runner.invoke(cli_float_ctx_exit)
|
|
assert result.exit_code == 1
|
|
assert result.output == "hello world\n1.0\n"
|
|
|
|
result = runner.invoke(cli_no_error)
|
|
assert result.exit_code == 0
|
|
assert result.output == "hello world\n"
|
|
|
|
|
|
def test_env():
|
|
@click.command()
|
|
def cli_env():
|
|
click.echo(f"ENV={os.environ['TEST_CLICK_ENV']}")
|
|
|
|
runner = CliRunner()
|
|
|
|
env_orig = dict(os.environ)
|
|
env = dict(env_orig)
|
|
assert "TEST_CLICK_ENV" not in env
|
|
env["TEST_CLICK_ENV"] = "some_value"
|
|
result = runner.invoke(cli_env, env=env)
|
|
assert result.exit_code == 0
|
|
assert result.output == "ENV=some_value\n"
|
|
|
|
assert os.environ == env_orig
|
|
|
|
|
|
def test_stderr():
|
|
@click.command()
|
|
def cli_stderr():
|
|
click.echo("stdout")
|
|
click.echo("stderr", err=True)
|
|
|
|
runner = CliRunner(mix_stderr=False)
|
|
|
|
result = runner.invoke(cli_stderr)
|
|
|
|
assert result.output == "stdout\n"
|
|
assert result.stdout == "stdout\n"
|
|
assert result.stderr == "stderr\n"
|
|
|
|
runner_mix = CliRunner(mix_stderr=True)
|
|
result_mix = runner_mix.invoke(cli_stderr)
|
|
|
|
assert result_mix.output == "stdout\nstderr\n"
|
|
assert result_mix.stdout == "stdout\nstderr\n"
|
|
|
|
with pytest.raises(ValueError):
|
|
result_mix.stderr
|
|
|
|
@click.command()
|
|
def cli_empty_stderr():
|
|
click.echo("stdout")
|
|
|
|
runner = CliRunner(mix_stderr=False)
|
|
|
|
result = runner.invoke(cli_empty_stderr)
|
|
|
|
assert result.output == "stdout\n"
|
|
assert result.stdout == "stdout\n"
|
|
assert result.stderr == ""
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"args, expected_output",
|
|
[
|
|
(None, "bar\n"),
|
|
([], "bar\n"),
|
|
("", "bar\n"),
|
|
(["--foo", "one two"], "one two\n"),
|
|
('--foo "one two"', "one two\n"),
|
|
],
|
|
)
|
|
def test_args(args, expected_output):
|
|
@click.command()
|
|
@click.option("--foo", default="bar")
|
|
def cli_args(foo):
|
|
click.echo(foo)
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(cli_args, args=args)
|
|
assert result.exit_code == 0
|
|
assert result.output == expected_output
|
|
|
|
|
|
def test_setting_prog_name_in_extra():
|
|
@click.command()
|
|
def cli():
|
|
click.echo("ok")
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(cli, prog_name="foobar")
|
|
assert not result.exception
|
|
assert result.output == "ok\n"
|
|
|
|
|
|
def test_command_standalone_mode_returns_value():
|
|
@click.command()
|
|
def cli():
|
|
click.echo("ok")
|
|
return "Hello, World!"
|
|
|
|
runner = CliRunner()
|
|
result = runner.invoke(cli, standalone_mode=False)
|
|
assert result.output == "ok\n"
|
|
assert result.return_value == "Hello, World!"
|
|
assert result.exit_code == 0
|
|
|
|
|
|
def test_file_stdin_attrs(runner):
|
|
@click.command()
|
|
@click.argument("f", type=click.File())
|
|
def cli(f):
|
|
click.echo(f.name)
|
|
click.echo(f.mode, nl=False)
|
|
|
|
result = runner.invoke(cli, ["-"])
|
|
assert result.output == "<stdin>\nr"
|
|
|
|
|
|
def test_isolated_runner(runner):
|
|
with runner.isolated_filesystem() as d:
|
|
assert os.path.exists(d)
|
|
|
|
assert not os.path.exists(d)
|
|
|
|
|
|
def test_isolated_runner_custom_tempdir(runner, tmp_path):
|
|
with runner.isolated_filesystem(temp_dir=tmp_path) as d:
|
|
assert os.path.exists(d)
|
|
|
|
assert os.path.exists(d)
|
|
os.rmdir(d)
|
|
|
|
|
|
def test_isolation_stderr_errors():
|
|
"""Writing to stderr should escape invalid characters instead of
|
|
raising a UnicodeEncodeError.
|
|
"""
|
|
runner = CliRunner(mix_stderr=False)
|
|
|
|
with runner.isolation() as (_, err):
|
|
click.echo("\udce2", err=True, nl=False)
|
|
|
|
assert err.getvalue() == b"\\udce2"
|