499 lines
14 KiB
Python
499 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
|
import os
|
|
import uuid
|
|
import click
|
|
|
|
|
|
def test_basic_functionality(runner):
|
|
@click.command()
|
|
def cli():
|
|
"""Hello World!"""
|
|
click.echo('I EXECUTED')
|
|
|
|
result = runner.invoke(cli, ['--help'])
|
|
assert not result.exception
|
|
assert 'Hello World!' in result.output
|
|
assert 'Show this message and exit.' in result.output
|
|
assert result.exit_code == 0
|
|
assert 'I EXECUTED' not in result.output
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert 'I EXECUTED' in result.output
|
|
assert result.exit_code == 0
|
|
|
|
|
|
def test_return_values():
|
|
@click.command()
|
|
def cli():
|
|
return 42
|
|
|
|
with cli.make_context('foo', []) as ctx:
|
|
rv = cli.invoke(ctx)
|
|
assert rv is 42
|
|
|
|
|
|
def test_basic_group(runner):
|
|
@click.group()
|
|
def cli():
|
|
"""This is the root."""
|
|
click.echo('ROOT EXECUTED')
|
|
|
|
@cli.command()
|
|
def subcommand():
|
|
"""This is a subcommand."""
|
|
click.echo('SUBCOMMAND EXECUTED')
|
|
|
|
result = runner.invoke(cli, ['--help'])
|
|
assert not result.exception
|
|
assert 'COMMAND [ARGS]...' in result.output
|
|
assert 'This is the root' in result.output
|
|
assert 'This is a subcommand.' in result.output
|
|
assert result.exit_code == 0
|
|
assert 'ROOT EXECUTED' not in result.output
|
|
|
|
result = runner.invoke(cli, ['subcommand'])
|
|
assert not result.exception
|
|
assert result.exit_code == 0
|
|
assert 'ROOT EXECUTED' in result.output
|
|
assert 'SUBCOMMAND EXECUTED' in result.output
|
|
|
|
|
|
def test_basic_option(runner):
|
|
@click.command()
|
|
@click.option('--foo', default='no value')
|
|
def cli(foo):
|
|
click.echo('FOO:[%s]' % foo)
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert 'FOO:[no value]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo=42'])
|
|
assert not result.exception
|
|
assert 'FOO:[42]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo'])
|
|
assert result.exception
|
|
assert '--foo option requires an argument' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo='])
|
|
assert not result.exception
|
|
assert 'FOO:[]' in result.output
|
|
|
|
result = runner.invoke(cli, [u'--foo=\N{SNOWMAN}'])
|
|
assert not result.exception
|
|
assert u'FOO:[\N{SNOWMAN}]' in result.output
|
|
|
|
|
|
def test_int_option(runner):
|
|
@click.command()
|
|
@click.option('--foo', default=42)
|
|
def cli(foo):
|
|
click.echo('FOO:[%s]' % (foo * 2))
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert 'FOO:[84]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo=23'])
|
|
assert not result.exception
|
|
assert 'FOO:[46]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo=bar'])
|
|
assert result.exception
|
|
assert 'Invalid value for "--foo": bar is not a valid integer' \
|
|
in result.output
|
|
|
|
|
|
def test_uuid_option(runner):
|
|
@click.command()
|
|
@click.option('--u', default='ba122011-349f-423b-873b-9d6a79c688ab',
|
|
type=click.UUID)
|
|
def cli(u):
|
|
assert type(u) is uuid.UUID
|
|
click.echo('U:[%s]' % u)
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert 'U:[ba122011-349f-423b-873b-9d6a79c688ab]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--u=821592c1-c50e-4971-9cd6-e89dc6832f86'])
|
|
assert not result.exception
|
|
assert 'U:[821592c1-c50e-4971-9cd6-e89dc6832f86]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--u=bar'])
|
|
assert result.exception
|
|
assert 'Invalid value for "--u": bar is not a valid UUID value' \
|
|
in result.output
|
|
|
|
|
|
def test_float_option(runner):
|
|
@click.command()
|
|
@click.option('--foo', default=42, type=click.FLOAT)
|
|
def cli(foo):
|
|
assert type(foo) is float
|
|
click.echo('FOO:[%s]' % foo)
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert 'FOO:[42.0]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo=23.5'])
|
|
assert not result.exception
|
|
assert 'FOO:[23.5]' in result.output
|
|
|
|
result = runner.invoke(cli, ['--foo=bar'])
|
|
assert result.exception
|
|
assert 'Invalid value for "--foo": bar is not a valid float' \
|
|
in result.output
|
|
|
|
|
|
def test_boolean_option(runner):
|
|
for default in True, False:
|
|
@click.command()
|
|
@click.option('--with-foo/--without-foo', default=default)
|
|
def cli(with_foo):
|
|
click.echo(with_foo)
|
|
|
|
result = runner.invoke(cli, ['--with-foo'])
|
|
assert not result.exception
|
|
assert result.output == 'True\n'
|
|
result = runner.invoke(cli, ['--without-foo'])
|
|
assert not result.exception
|
|
assert result.output == 'False\n'
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert result.output == '%s\n' % default
|
|
|
|
for default in True, False:
|
|
@click.command()
|
|
@click.option('--flag', is_flag=True, default=default)
|
|
def cli(flag):
|
|
click.echo(flag)
|
|
|
|
result = runner.invoke(cli, ['--flag'])
|
|
assert not result.exception
|
|
assert result.output == '%s\n' % (not default)
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert result.output == '%s\n' % (default)
|
|
|
|
|
|
def test_boolean_conversion(runner):
|
|
for default in True, False:
|
|
@click.command()
|
|
@click.option('--flag', default=default, type=bool)
|
|
def cli(flag):
|
|
click.echo(flag)
|
|
|
|
for value in 'true', 't', '1', 'yes', 'y':
|
|
result = runner.invoke(cli, ['--flag', value])
|
|
assert not result.exception
|
|
assert result.output == 'True\n'
|
|
|
|
for value in 'false', 'f', '0', 'no', 'n':
|
|
result = runner.invoke(cli, ['--flag', value])
|
|
assert not result.exception
|
|
assert result.output == 'False\n'
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert not result.exception
|
|
assert result.output == '%s\n' % default
|
|
|
|
|
|
def test_file_option(runner):
|
|
@click.command()
|
|
@click.option('--file', type=click.File('w'))
|
|
def input(file):
|
|
file.write('Hello World!\n')
|
|
|
|
@click.command()
|
|
@click.option('--file', type=click.File('r'))
|
|
def output(file):
|
|
click.echo(file.read())
|
|
|
|
with runner.isolated_filesystem():
|
|
result_in = runner.invoke(input, ['--file=example.txt'])
|
|
result_out = runner.invoke(output, ['--file=example.txt'])
|
|
|
|
assert not result_in.exception
|
|
assert result_in.output == ''
|
|
assert not result_out.exception
|
|
assert result_out.output == 'Hello World!\n\n'
|
|
|
|
|
|
def test_file_lazy_mode(runner):
|
|
do_io = False
|
|
|
|
@click.command()
|
|
@click.option('--file', type=click.File('w'))
|
|
def input(file):
|
|
if do_io:
|
|
file.write('Hello World!\n')
|
|
|
|
@click.command()
|
|
@click.option('--file', type=click.File('r'))
|
|
def output(file):
|
|
pass
|
|
|
|
with runner.isolated_filesystem():
|
|
os.mkdir('example.txt')
|
|
|
|
do_io = True
|
|
result_in = runner.invoke(input, ['--file=example.txt'])
|
|
assert result_in.exit_code == 1
|
|
|
|
do_io = False
|
|
result_in = runner.invoke(input, ['--file=example.txt'])
|
|
assert result_in.exit_code == 0
|
|
|
|
result_out = runner.invoke(output, ['--file=example.txt'])
|
|
assert result_out.exception
|
|
|
|
@click.command()
|
|
@click.option('--file', type=click.File('w', lazy=False))
|
|
def input_non_lazy(file):
|
|
file.write('Hello World!\n')
|
|
|
|
with runner.isolated_filesystem():
|
|
os.mkdir('example.txt')
|
|
result_in = runner.invoke(input_non_lazy, ['--file=example.txt'])
|
|
assert result_in.exit_code == 2
|
|
assert 'Invalid value for "--file": Could not open file: example.txt' \
|
|
in result_in.output
|
|
|
|
|
|
def test_path_option(runner):
|
|
@click.command()
|
|
@click.option('-O', type=click.Path(file_okay=False, exists=True,
|
|
writable=True))
|
|
def write_to_dir(o):
|
|
with open(os.path.join(o, 'foo.txt'), 'wb') as f:
|
|
f.write(b'meh\n')
|
|
|
|
with runner.isolated_filesystem():
|
|
os.mkdir('test')
|
|
|
|
result = runner.invoke(write_to_dir, ['-O', 'test'])
|
|
assert not result.exception
|
|
|
|
with open('test/foo.txt', 'rb') as f:
|
|
assert f.read() == b'meh\n'
|
|
|
|
result = runner.invoke(write_to_dir, ['-O', 'test/foo.txt'])
|
|
assert 'Invalid value for "-O": Directory "test/foo.txt" is a file.' \
|
|
in result.output
|
|
|
|
@click.command()
|
|
@click.option('-f', type=click.Path(exists=True))
|
|
def showtype(f):
|
|
click.echo('is_file=%s' % os.path.isfile(f))
|
|
click.echo('is_dir=%s' % os.path.isdir(f))
|
|
|
|
with runner.isolated_filesystem():
|
|
result = runner.invoke(showtype, ['-f', 'xxx'])
|
|
assert 'Error: Invalid value for "-f": Path "xxx" does not exist' \
|
|
in result.output
|
|
|
|
result = runner.invoke(showtype, ['-f', '.'])
|
|
assert 'is_file=False' in result.output
|
|
assert 'is_dir=True' in result.output
|
|
|
|
@click.command()
|
|
@click.option('-f', type=click.Path())
|
|
def exists(f):
|
|
click.echo('exists=%s' % os.path.exists(f))
|
|
|
|
with runner.isolated_filesystem():
|
|
result = runner.invoke(exists, ['-f', 'xxx'])
|
|
assert 'exists=False' in result.output
|
|
|
|
result = runner.invoke(exists, ['-f', '.'])
|
|
assert 'exists=True' in result.output
|
|
|
|
|
|
def test_choice_option(runner):
|
|
@click.command()
|
|
@click.option('--method', type=click.Choice(['foo', 'bar', 'baz']))
|
|
def cli(method):
|
|
click.echo(method)
|
|
|
|
result = runner.invoke(cli, ['--method=foo'])
|
|
assert not result.exception
|
|
assert result.output == 'foo\n'
|
|
|
|
result = runner.invoke(cli, ['--method=meh'])
|
|
assert result.exit_code == 2
|
|
assert 'Invalid value for "--method": invalid choice: meh. ' \
|
|
'(choose from foo, bar, baz)' in result.output
|
|
|
|
result = runner.invoke(cli, ['--help'])
|
|
assert '--method [foo|bar|baz]' in result.output
|
|
|
|
|
|
def test_int_range_option(runner):
|
|
@click.command()
|
|
@click.option('--x', type=click.IntRange(0, 5))
|
|
def cli(x):
|
|
click.echo(x)
|
|
|
|
result = runner.invoke(cli, ['--x=5'])
|
|
assert not result.exception
|
|
assert result.output == '5\n'
|
|
|
|
result = runner.invoke(cli, ['--x=6'])
|
|
assert result.exit_code == 2
|
|
assert 'Invalid value for "--x": 6 is not in the valid range of 0 to 5.\n' \
|
|
in result.output
|
|
|
|
@click.command()
|
|
@click.option('--x', type=click.IntRange(0, 5, clamp=True))
|
|
def clamp(x):
|
|
click.echo(x)
|
|
|
|
result = runner.invoke(clamp, ['--x=5'])
|
|
assert not result.exception
|
|
assert result.output == '5\n'
|
|
|
|
result = runner.invoke(clamp, ['--x=6'])
|
|
assert not result.exception
|
|
assert result.output == '5\n'
|
|
|
|
result = runner.invoke(clamp, ['--x=-1'])
|
|
assert not result.exception
|
|
assert result.output == '0\n'
|
|
|
|
|
|
def test_float_range_option(runner):
|
|
@click.command()
|
|
@click.option('--x', type=click.FloatRange(0, 5))
|
|
def cli(x):
|
|
click.echo(x)
|
|
|
|
result = runner.invoke(cli, ['--x=5.0'])
|
|
assert not result.exception
|
|
assert result.output == '5.0\n'
|
|
|
|
result = runner.invoke(cli, ['--x=6.0'])
|
|
assert result.exit_code == 2
|
|
assert 'Invalid value for "--x": 6.0 is not in the valid range of 0 to 5.\n' \
|
|
in result.output
|
|
|
|
@click.command()
|
|
@click.option('--x', type=click.FloatRange(0, 5, clamp=True))
|
|
def clamp(x):
|
|
click.echo(x)
|
|
|
|
result = runner.invoke(clamp, ['--x=5.0'])
|
|
assert not result.exception
|
|
assert result.output == '5.0\n'
|
|
|
|
result = runner.invoke(clamp, ['--x=6.0'])
|
|
assert not result.exception
|
|
assert result.output == '5\n'
|
|
|
|
result = runner.invoke(clamp, ['--x=-1.0'])
|
|
assert not result.exception
|
|
assert result.output == '0\n'
|
|
|
|
|
|
def test_required_option(runner):
|
|
@click.command()
|
|
@click.option('--foo', required=True)
|
|
def cli(foo):
|
|
click.echo(foo)
|
|
|
|
result = runner.invoke(cli, [])
|
|
assert result.exit_code == 2
|
|
assert 'Missing option "--foo"' in result.output
|
|
|
|
|
|
def test_evaluation_order(runner):
|
|
called = []
|
|
|
|
def memo(ctx, param, value):
|
|
called.append(value)
|
|
return value
|
|
|
|
@click.command()
|
|
@click.option('--missing', default='missing',
|
|
is_eager=False, callback=memo)
|
|
@click.option('--eager-flag1', flag_value='eager1',
|
|
is_eager=True, callback=memo)
|
|
@click.option('--eager-flag2', flag_value='eager2',
|
|
is_eager=True, callback=memo)
|
|
@click.option('--eager-flag3', flag_value='eager3',
|
|
is_eager=True, callback=memo)
|
|
@click.option('--normal-flag1', flag_value='normal1',
|
|
is_eager=False, callback=memo)
|
|
@click.option('--normal-flag2', flag_value='normal2',
|
|
is_eager=False, callback=memo)
|
|
@click.option('--normal-flag3', flag_value='normal3',
|
|
is_eager=False, callback=memo)
|
|
def cli(**x):
|
|
pass
|
|
|
|
result = runner.invoke(cli, ['--eager-flag2',
|
|
'--eager-flag1',
|
|
'--normal-flag2',
|
|
'--eager-flag3',
|
|
'--normal-flag3',
|
|
'--normal-flag3',
|
|
'--normal-flag1',
|
|
'--normal-flag1'])
|
|
assert not result.exception
|
|
assert called == [
|
|
'eager2',
|
|
'eager1',
|
|
'eager3',
|
|
'normal2',
|
|
'normal3',
|
|
'normal1',
|
|
'missing',
|
|
]
|
|
|
|
|
|
def test_hidden_option(runner):
|
|
@click.command()
|
|
@click.option('--nope', hidden=True)
|
|
def cli(nope):
|
|
click.echo(nope)
|
|
|
|
result = runner.invoke(cli, ['--help'])
|
|
assert result.exit_code == 0
|
|
assert '--nope' not in result.output
|
|
|
|
|
|
def test_hidden_command(runner):
|
|
@click.group()
|
|
def cli():
|
|
pass
|
|
|
|
@cli.command(hidden=True)
|
|
def nope():
|
|
pass
|
|
|
|
result = runner.invoke(cli, ['--help'])
|
|
assert result.exit_code == 0
|
|
assert 'nope' not in result.output
|
|
|
|
|
|
def test_hidden_group(runner):
|
|
@click.group()
|
|
def cli():
|
|
pass
|
|
|
|
@cli.group(hidden=True)
|
|
def subgroup():
|
|
pass
|
|
|
|
@subgroup.command()
|
|
def nope():
|
|
pass
|
|
|
|
result = runner.invoke(cli, ['--help'])
|
|
assert result.exit_code == 0
|
|
assert 'subgroup' not in result.output
|
|
assert 'nope' not in result.output
|