is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf $(BUILDDIR)/*
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Classy.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Classy.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/Classy"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Classy"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \
"run these through (pdf)latex."
latexpdf: latex
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
make -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
click-6.6/docs/setuptools.rst 0000644 0001750 0000144 00000010114 12564341220 017536 0 ustar untitaker users 0000000 0000000 .. _setuptools-integration:
Setuptools Integration
======================
When writing command line utilities, it's recommended to write them as
modules that are distributed with setuptools instead of using Unix
shebangs.
Why would you want to do that? There are a bunch of reasons:
1. One of the problems with the traditional approach is that the first
module the Python interpreter loads has an incorrect name. This might
sound like a small issue but it has quite significant implications.
The first module is not called by its actual name, but the
interpreter renames it to ``__main__``. While that is a perfectly
valid name it means that if another piece of code wants to import from
that module it will trigger the import a second time under its real
name and all of a sudden your code is imported twice.
2. Not on all platforms are things that easy to execute. On Linux and OS
X you can add a comment to the beginning of the file (``#!/usr/bin/env
python``) and your script works like an executable (assuming it has
the executable bit set). This however does not work on Windows.
While on Windows you can associate interpreters with file extensions
(like having everything ending in ``.py`` execute through the Python
interpreter) you will then run into issues if you want to use the
script in a virtualenv.
In fact running a script in a virtualenv is an issue with OS X and
Linux as well. With the traditional approach you need to have the
whole virtualenv activated so that the correct Python interpreter is
used. Not very user friendly.
3. The main trick only works if the script is a Python module. If your
application grows too large and you want to start using a package you
will run into issues.
Introduction
------------
To bundle your script with setuptools, all you need is the script in a
Python package and a ``setup.py`` file.
Imagine this directory structure::
yourscript.py
setup.py
Contents of ``yourscript.py``:
.. click:example::
import click
@click.command()
def cli():
"""Example script."""
click.echo('Hello World!')
Contents of ``setup.py``::
from setuptools import setup
setup(
name='yourscript',
version='0.1',
py_modules=['yourscript'],
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
yourscript=yourscript:cli
''',
)
The magic is in the ``entry_points`` parameter. Below
``console_scripts``, each line identifies one console script. The first
part before the equals sign (``=``) is the name of the script that should
be generated, the second part is the import path followed by a colon
(``:``) with the Click command.
That's it.
Testing The Script
------------------
To test the script, you can make a new virtualenv and then install your
package::
$ virtualenv venv
$ . venv/bin/activate
$ pip install --editable .
Afterwards, your command should be available:
.. click:run::
invoke(cli, prog_name='yourscript')
Scripts in Packages
-------------------
If your script is growing and you want to switch over to your script being
contained in a Python package the changes necessary are minimal. Let's
assume your directory structure changed to this::
yourpackage/
__init__.py
main.py
utils.py
scripts/
__init__.py
yourscript.py
In this case instead of using ``py_modules`` in your ``setup.py`` file you
can use ``packages`` and the automatic package finding support of
setuptools. In addition to that it's also recommended to include other
package data.
These would be the modified contents of ``setup.py``::
from setuptools import setup, find_packages
setup(
name='yourpackage',
version='0.1',
packages=find_packages(),
include_package_data=True,
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
yourscript=yourpackage.scripts.yourscript:cli
''',
)
click-6.6/docs/_templates/ 0000755 0001750 0000144 00000000000 12700515625 016727 5 ustar untitaker users 0000000 0000000 click-6.6/docs/_templates/sidebarlogo.html 0000644 0001750 0000144 00000000251 12372132670 022105 0 ustar untitaker users 0000000 0000000
 }})
click-6.6/docs/_templates/sidebarintro.html 0000644 0001750 0000144 00000001043 12700515275 022301 0 ustar untitaker users 0000000 0000000 About
Click is a Python package for creating beautiful command line interfaces in a
composable way with as little amount of code as necessary. It’s the “Command
Line Interface Creation Kitâ€.
Useful Links
click-6.6/LICENSE 0000644 0001750 0000144 00000003374 12372132670 014656 0 ustar untitaker users 0000000 0000000 Copyright (c) 2014 by Armin Ronacher.
Click uses parts of optparse written by Gregory P. Ward and maintained by the
Python software foundation. This is limited to code in the parser.py
module:
Copyright (c) 2001-2006 Gregory P. Ward. All rights reserved.
Copyright (c) 2002-2006 Python Software Foundation. All rights reserved.
Some rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* The names of the contributors may not be used to endorse or
promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
click-6.6/setup.cfg 0000644 0001750 0000144 00000000122 12700515625 015456 0 ustar untitaker users 0000000 0000000 [wheel]
universal = 1
[egg_info]
tag_build =
tag_date = 0
tag_svn_revision = 0
click-6.6/tests/ 0000755 0001750 0000144 00000000000 12700515625 015004 5 ustar untitaker users 0000000 0000000 click-6.6/tests/test_bashcomplete.py 0000644 0001750 0000144 00000001043 12700512754 021061 0 ustar untitaker users 0000000 0000000 # -*- coding: utf-8 -*-
import click
from click._bashcomplete import get_choices
def test_basic():
@click.group()
@click.option('--global-opt')
def cli(global_opt):
pass
@cli.command()
@click.option('--local-opt')
def sub(local_opt):
pass
assert list(get_choices(cli, 'lol', [], '')) == ['sub']
assert list(get_choices(cli, 'lol', [], '-')) == ['--global-opt']
assert list(get_choices(cli, 'lol', ['sub'], '')) == []
assert list(get_choices(cli, 'lol', ['sub'], '-')) == ['--local-opt']
click-6.6/tests/test_compat.py 0000644 0001750 0000144 00000001400 12541617543 017700 0 ustar untitaker users 0000000 0000000 import click
if click.__version__ >= '3.0':
def test_legacy_callbacks(runner):
def legacy_callback(ctx, value):
return value.upper()
@click.command()
@click.option('--foo', callback=legacy_callback)
def cli(foo):
click.echo(foo)
result = runner.invoke(cli, ['--foo', 'wat'])
assert result.exit_code == 0
assert 'WAT' in result.output
assert 'Invoked legacy parameter callback' in result.output
def test_bash_func_name():
from click._bashcomplete import get_completion_script
script = get_completion_script('foo-bar baz_blah', '_COMPLETE_VAR').strip()
assert script.startswith('_foo_barbaz_blah_completion()')
assert '_COMPLETE_VAR=complete $1' in script
click-6.6/tests/test_imports.py 0000644 0001750 0000144 00000002613 12626624145 020121 0 ustar untitaker users 0000000 0000000 import sys
import json
import subprocess
from click._compat import WIN
IMPORT_TEST = b'''\
try:
import __builtin__ as builtins
except ImportError:
import builtins
found_imports = set()
real_import = builtins.__import__
import sys
def tracking_import(module, locals=None, globals=None, fromlist=None,
level=0):
rv = real_import(module, locals, globals, fromlist, level)
if globals and globals['__name__'].startswith('click') and level == 0:
found_imports.add(module)
return rv
builtins.__import__ = tracking_import
import click
rv = list(found_imports)
import json
click.echo(json.dumps(rv))
'''
ALLOWED_IMPORTS = set([
'weakref', 'os', 'struct', 'collections', 'sys', 'contextlib',
'functools', 'stat', 're', 'codecs', 'inspect', 'itertools', 'io',
'threading', 'colorama'
])
if WIN:
ALLOWED_IMPORTS.update(['ctypes', 'ctypes.wintypes', 'msvcrt', 'time',
'zlib'])
def test_light_imports():
c = subprocess.Popen([sys.executable, '-'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
rv = c.communicate(IMPORT_TEST)[0]
if sys.version_info[0] != 2:
rv = rv.decode('utf-8')
imported = json.loads(rv)
print(imported)
for module in imported:
if module == 'click' or module.startswith('click.'):
continue
assert module in ALLOWED_IMPORTS
click-6.6/tests/test_commands.py 0000644 0001750 0000144 00000015712 12564341220 020220 0 ustar untitaker users 0000000 0000000 # -*- coding: utf-8 -*-
import re
import click
def test_other_command_invoke(runner):
@click.command()
@click.pass_context
def cli(ctx):
return ctx.invoke(other_cmd, arg=42)
@click.command()
@click.argument('arg', type=click.INT)
def other_cmd(arg):
click.echo(arg)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '42\n'
def test_other_command_forward(runner):
cli = click.Group()
@cli.command()
@click.option('--count', default=1)
def test(count):
click.echo('Count: %d' % count)
@cli.command()
@click.option('--count', default=1)
@click.pass_context
def dist(ctx, count):
ctx.forward(test)
ctx.invoke(test, count=42)
result = runner.invoke(cli, ['dist'])
assert not result.exception
assert result.output == 'Count: 1\nCount: 42\n'
def test_auto_shorthelp(runner):
@click.group()
def cli():
pass
@cli.command()
def short():
"""This is a short text."""
@cli.command()
def special_chars():
"""Login and store the token in ~/.netrc."""
@cli.command()
def long():
"""This is a long text that is too long to show as short help
and will be truncated instead."""
result = runner.invoke(cli, ['--help'])
assert re.search(
r'Commands:\n\s+'
r'long\s+This is a long text that is too long to show\.\.\.\n\s+'
r'short\s+This is a short text\.\n\s+'
r'special_chars\s+Login and store the token in ~/.netrc\.\s*',
result.output) is not None
def test_default_maps(runner):
@click.group()
def cli():
pass
@cli.command()
@click.option('--name', default='normal')
def foo(name):
click.echo(name)
result = runner.invoke(cli, ['foo'], default_map={
'foo': {'name': 'changed'}
})
assert not result.exception
assert result.output == 'changed\n'
def test_group_with_args(runner):
@click.group()
@click.argument('obj')
def cli(obj):
click.echo('obj=%s' % obj)
@cli.command()
def move():
click.echo('move')
result = runner.invoke(cli, [])
assert result.exit_code == 0
assert 'Show this message and exit.' in result.output
result = runner.invoke(cli, ['obj1'])
assert result.exit_code == 2
assert 'Error: Missing command.' in result.output
result = runner.invoke(cli, ['obj1', '--help'])
assert result.exit_code == 0
assert 'Show this message and exit.' in result.output
result = runner.invoke(cli, ['obj1', 'move'])
assert result.exit_code == 0
assert result.output == 'obj=obj1\nmove\n'
def test_base_command(runner):
import optparse
@click.group()
def cli():
pass
class OptParseCommand(click.BaseCommand):
def __init__(self, name, parser, callback):
click.BaseCommand.__init__(self, name)
self.parser = parser
self.callback = callback
def parse_args(self, ctx, args):
try:
opts, args = parser.parse_args(args)
except Exception as e:
ctx.fail(str(e))
ctx.args = args
ctx.params = vars(opts)
def get_usage(self, ctx):
return self.parser.get_usage()
def get_help(self, ctx):
return self.parser.format_help()
def invoke(self, ctx):
ctx.invoke(self.callback, ctx.args, **ctx.params)
parser = optparse.OptionParser(usage='Usage: foo test [OPTIONS]')
parser.add_option("-f", "--file", dest="filename",
help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")
def test_callback(args, filename, verbose):
click.echo(' '.join(args))
click.echo(filename)
click.echo(verbose)
cli.add_command(OptParseCommand('test', parser, test_callback))
result = runner.invoke(cli, ['test', '-f', 'test.txt', '-q',
'whatever.txt', 'whateverelse.txt'])
assert not result.exception
assert result.output.splitlines() == [
'whatever.txt whateverelse.txt',
'test.txt',
'False',
]
result = runner.invoke(cli, ['test', '--help'])
assert not result.exception
assert result.output.splitlines() == [
'Usage: foo test [OPTIONS]',
'',
'Options:',
' -h, --help show this help message and exit',
' -f FILE, --file=FILE write report to FILE',
' -q, --quiet don\'t print status messages to stdout',
]
def test_object_propagation(runner):
for chain in False, True:
@click.group(chain=chain)
@click.option('--debug/--no-debug', default=False)
@click.pass_context
def cli(ctx, debug):
if ctx.obj is None:
ctx.obj = {}
ctx.obj['DEBUG'] = debug
@cli.command()
@click.pass_context
def sync(ctx):
click.echo('Debug is %s' % (ctx.obj['DEBUG'] and 'on' or 'off'))
result = runner.invoke(cli, ['sync'])
assert result.exception is None
assert result.output == 'Debug is off\n'
def test_other_command_invoke_with_defaults(runner):
@click.command()
@click.pass_context
def cli(ctx):
return ctx.invoke(other_cmd)
@click.command()
@click.option('--foo', type=click.INT, default=42)
@click.pass_context
def other_cmd(ctx, foo):
assert ctx.info_name == 'other_cmd'
click.echo(foo)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == '42\n'
def test_invoked_subcommand(runner):
@click.group(invoke_without_command=True)
@click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
click.echo('no subcommand, use default')
ctx.invoke(sync)
else:
click.echo('invoke subcommand')
@cli.command()
def sync():
click.echo('in subcommand')
result = runner.invoke(cli, ['sync'])
assert not result.exception
assert result.output == 'invoke subcommand\nin subcommand\n'
result = runner.invoke(cli)
assert not result.exception
assert result.output == 'no subcommand, use default\nin subcommand\n'
def test_unprocessed_options(runner):
@click.command(context_settings=dict(
ignore_unknown_options=True
))
@click.argument('args', nargs=-1, type=click.UNPROCESSED)
@click.option('--verbose', '-v', count=True)
def cli(verbose, args):
click.echo('Verbosity: %s' % verbose)
click.echo('Args: %s' % '|'.join(args))
result = runner.invoke(cli, ['-foo', '-vvvvx', '--muhaha', 'x', 'y', '-x'])
assert not result.exception
assert result.output.splitlines() == [
'Verbosity: 4',
'Args: -foo|-x|--muhaha|x|y|-x',
]
click-6.6/tests/test_formatting.py 0000644 0001750 0000144 00000006736 12564341220 020577 0 ustar untitaker users 0000000 0000000 # -*- coding: utf-8 -*-
import click
def test_basic_functionality(runner):
@click.command()
def cli():
"""First paragraph.
This is a very long second
paragraph and not correctly
wrapped but it will be rewrapped.
\b
This is
a paragraph
without rewrapping.
\b
1
2
3
And this is a paragraph
that will be rewrapped again.
"""
result = runner.invoke(cli, ['--help'], terminal_width=60)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' First paragraph.',
'',
' This is a very long second paragraph and not correctly',
' wrapped but it will be rewrapped.',
'',
' This is',
' a paragraph',
' without rewrapping.',
'',
' 1',
' 2',
' 3',
'',
' And this is a paragraph that will be rewrapped again.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_wrapping_long_options_strings(runner):
@click.group()
def cli():
"""Top level command
"""
@cli.group()
def a_very_long():
"""Second level
"""
@a_very_long.command()
@click.argument('first')
@click.argument('second')
@click.argument('third')
@click.argument('fourth')
@click.argument('fifth')
@click.argument('sixth')
def command():
"""A command.
"""
# 54 is chosen as a length where the second line is one character
# longer than the maximum length.
result = runner.invoke(cli, ['a_very_long', 'command', '--help'],
terminal_width=54)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli a_very_long command [OPTIONS] FIRST SECOND',
' THIRD FOURTH FIFTH',
' SIXTH',
'',
' A command.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_wrapping_long_command_name(runner):
@click.group()
def cli():
"""Top level command
"""
@cli.group()
def a_very_very_very_long():
"""Second level
"""
@a_very_very_very_long.command()
@click.argument('first')
@click.argument('second')
@click.argument('third')
@click.argument('fourth')
@click.argument('fifth')
@click.argument('sixth')
def command():
"""A command.
"""
result = runner.invoke(cli, ['a_very_very_very_long', 'command', '--help'],
terminal_width=54)
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli a_very_very_very_long command ',
' [OPTIONS] FIRST SECOND THIRD FOURTH FIFTH',
' SIXTH',
'',
' A command.',
'',
'Options:',
' --help Show this message and exit.',
]
def test_formatting_empty_help_lines(runner):
@click.command()
def cli():
"""Top level command
"""
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert result.output.splitlines() == [
'Usage: cli [OPTIONS]',
'',
' Top level command',
'',
'',
'',
'Options:',
' --help Show this message and exit.',
]
click-6.6/tests/test_utils.py 0000644 0001750 0000144 00000021347 12626624145 017571 0 ustar untitaker users 0000000 0000000 import os
import sys
import pytest
import click
import click.utils
import click._termui_impl
from click._compat import WIN, PY2
def test_echo(runner):
with runner.isolation() as out:
click.echo(u'\N{SNOWMAN}')
click.echo(b'\x44\x44')
click.echo(42, nl=False)
click.echo(b'a', nl=False)
click.echo('\x1b[31mx\x1b[39m', nl=False)
bytes = out.getvalue().replace(b'\r\n', b'\n')
assert bytes == b'\xe2\x98\x83\nDD\n42ax'
# If we are in Python 2, we expect that writing bytes into a string io
# does not do anything crazy. In Python 3
if sys.version_info[0] == 2:
import StringIO
sys.stdout = x = StringIO.StringIO()
try:
click.echo('\xf6')
finally:
sys.stdout = sys.__stdout__
assert x.getvalue() == '\xf6\n'
# And in any case, if wrapped, we expect bytes to survive.
@click.command()
def cli():
click.echo(b'\xf6')
result = runner.invoke(cli, [])
assert result.output_bytes == b'\xf6\n'
# Ensure we do not strip for bytes.
with runner.isolation() as out:
click.echo(bytearray(b'\x1b[31mx\x1b[39m'), nl=False)
assert out.getvalue() == b'\x1b[31mx\x1b[39m'
def test_echo_custom_file():
import io
f = io.StringIO()
click.echo(u'hello', file=f)
assert f.getvalue() == u'hello\n'
def test_styling():
examples = [
('x', dict(fg='black'), '\x1b[30mx\x1b[0m'),
('x', dict(fg='red'), '\x1b[31mx\x1b[0m'),
('x', dict(fg='green'), '\x1b[32mx\x1b[0m'),
('x', dict(fg='yellow'), '\x1b[33mx\x1b[0m'),
('x', dict(fg='blue'), '\x1b[34mx\x1b[0m'),
('x', dict(fg='magenta'), '\x1b[35mx\x1b[0m'),
('x', dict(fg='cyan'), '\x1b[36mx\x1b[0m'),
('x', dict(fg='white'), '\x1b[37mx\x1b[0m'),
('x', dict(bg='black'), '\x1b[40mx\x1b[0m'),
('x', dict(bg='red'), '\x1b[41mx\x1b[0m'),
('x', dict(bg='green'), '\x1b[42mx\x1b[0m'),
('x', dict(bg='yellow'), '\x1b[43mx\x1b[0m'),
('x', dict(bg='blue'), '\x1b[44mx\x1b[0m'),
('x', dict(bg='magenta'), '\x1b[45mx\x1b[0m'),
('x', dict(bg='cyan'), '\x1b[46mx\x1b[0m'),
('x', dict(bg='white'), '\x1b[47mx\x1b[0m'),
('foo bar', dict(blink=True), '\x1b[5mfoo bar\x1b[0m'),
('foo bar', dict(underline=True), '\x1b[4mfoo bar\x1b[0m'),
('foo bar', dict(bold=True), '\x1b[1mfoo bar\x1b[0m'),
('foo bar', dict(dim=True), '\x1b[2mfoo bar\x1b[0m'),
]
for text, styles, ref in examples:
assert click.style(text, **styles) == ref
assert click.unstyle(ref) == text
def test_filename_formatting():
assert click.format_filename(b'foo.txt') == 'foo.txt'
assert click.format_filename(b'/x/foo.txt') == '/x/foo.txt'
assert click.format_filename(u'/x/foo.txt') == '/x/foo.txt'
assert click.format_filename(u'/x/foo.txt', shorten=True) == 'foo.txt'
# filesystem encoding on windows permits this.
if not WIN:
assert click.format_filename(b'/x/foo\xff.txt', shorten=True) \
== u'foo\ufffd.txt'
def test_prompts(runner):
@click.command()
def test():
if click.confirm('Foo'):
click.echo('yes!')
else:
click.echo('no :(')
result = runner.invoke(test, input='y\n')
assert not result.exception
assert result.output == 'Foo [y/N]: y\nyes!\n'
result = runner.invoke(test, input='\n')
assert not result.exception
assert result.output == 'Foo [y/N]: \nno :(\n'
result = runner.invoke(test, input='n\n')
assert not result.exception
assert result.output == 'Foo [y/N]: n\nno :(\n'
@click.command()
def test_no():
if click.confirm('Foo', default=True):
click.echo('yes!')
else:
click.echo('no :(')
result = runner.invoke(test_no, input='y\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: y\nyes!\n'
result = runner.invoke(test_no, input='\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: \nyes!\n'
result = runner.invoke(test_no, input='n\n')
assert not result.exception
assert result.output == 'Foo [Y/n]: n\nno :(\n'
@pytest.mark.skipif(WIN, reason='Different behavior on windows.')
def test_prompts_abort(monkeypatch, capsys):
def f(_):
raise KeyboardInterrupt()
monkeypatch.setattr('click.termui.hidden_prompt_func', f)
try:
click.prompt('Password', hide_input=True)
except click.Abort:
click.echo('Screw you.')
out, err = capsys.readouterr()
assert out == 'Password: \nScrew you.\n'
@pytest.mark.skipif(WIN, reason='Different behavior on windows.')
@pytest.mark.parametrize('cat', ['cat', 'cat ', 'cat '])
def test_echo_via_pager(monkeypatch, capfd, cat):
monkeypatch.setitem(os.environ, 'PAGER', cat)
monkeypatch.setattr(click._termui_impl, 'isatty', lambda x: True)
click.echo_via_pager('haha')
out, err = capfd.readouterr()
assert out == 'haha\n'
@pytest.mark.skipif(WIN, reason='Test does not make sense on Windows.')
def test_echo_color_flag(monkeypatch, capfd):
isatty = True
monkeypatch.setattr(click._compat, 'isatty', lambda x: isatty)
text = 'foo'
styled_text = click.style(text, fg='red')
assert styled_text == '\x1b[31mfoo\x1b[0m'
click.echo(styled_text, color=False)
out, err = capfd.readouterr()
assert out == text + '\n'
click.echo(styled_text, color=True)
out, err = capfd.readouterr()
assert out == styled_text + '\n'
isatty = True
click.echo(styled_text)
out, err = capfd.readouterr()
assert out == styled_text + '\n'
isatty = False
click.echo(styled_text)
out, err = capfd.readouterr()
assert out == text + '\n'
@pytest.mark.skipif(WIN, reason='Test too complex to make work windows.')
def test_echo_writing_to_standard_error(capfd, monkeypatch):
def emulate_input(text):
"""Emulate keyboard input."""
if sys.version_info[0] == 2:
from StringIO import StringIO
else:
from io import StringIO
monkeypatch.setattr(sys, 'stdin', StringIO(text))
click.echo('Echo to standard output')
out, err = capfd.readouterr()
assert out == 'Echo to standard output\n'
assert err == ''
click.echo('Echo to standard error', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Echo to standard error\n'
emulate_input('asdlkj\n')
click.prompt('Prompt to stdin')
out, err = capfd.readouterr()
assert out == 'Prompt to stdin: '
assert err == ''
emulate_input('asdlkj\n')
click.prompt('Prompt to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Prompt to stderr: '
emulate_input('y\n')
click.confirm('Prompt to stdin')
out, err = capfd.readouterr()
assert out == 'Prompt to stdin [y/N]: '
assert err == ''
emulate_input('y\n')
click.confirm('Prompt to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Prompt to stderr [y/N]: '
monkeypatch.setattr(click.termui, 'isatty', lambda x: True)
monkeypatch.setattr(click.termui, 'getchar', lambda: ' ')
click.pause('Pause to stdout')
out, err = capfd.readouterr()
assert out == 'Pause to stdout\n'
assert err == ''
click.pause('Pause to stderr', err=True)
out, err = capfd.readouterr()
assert out == ''
assert err == 'Pause to stderr\n'
def test_open_file(runner):
with runner.isolated_filesystem():
with open('hello.txt', 'w') as f:
f.write('Cool stuff')
@click.command()
@click.argument('filename')
def cli(filename):
with click.open_file(filename) as f:
click.echo(f.read())
click.echo('meep')
result = runner.invoke(cli, ['hello.txt'])
assert result.exception is None
assert result.output == 'Cool stuff\nmeep\n'
result = runner.invoke(cli, ['-'], input='foobar')
assert result.exception is None
assert result.output == 'foobar\nmeep\n'
@pytest.mark.xfail(WIN and not PY2, reason='God knows ...')
def test_iter_keepopenfile(tmpdir):
expected = list(map(str, range(10)))
p = tmpdir.mkdir('testdir').join('testfile')
p.write(os.linesep.join(expected))
f = p.open()
for e_line, a_line in zip(expected, click.utils.KeepOpenFile(f)):
assert e_line == a_line.strip()
@pytest.mark.xfail(WIN and not PY2, reason='God knows ...')
def test_iter_lazyfile(tmpdir):
expected = list(map(str, range(10)))
p = tmpdir.mkdir('testdir').join('testfile')
p.write(os.linesep.join(expected))
f = p.open()
for e_line, a_line in zip(expected, click.utils.LazyFile(f.name)):
assert e_line == a_line.strip()
click-6.6/tests/test_defaults.py 0000644 0001750 0000144 00000002175 12372132670 020231 0 ustar untitaker users 0000000 0000000 import click
def test_basic_defaults(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
def test_multiple_defaults(runner):
@click.command()
@click.option('--foo', default=[23, 42], type=click.FLOAT,
multiple=True)
def cli(foo):
for item in foo:
assert type(item) is float
click.echo(item)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output.splitlines() == [
'23.0',
'42.0',
]
def test_nargs_plus_multiple(runner):
@click.command()
@click.option('--arg', default=((1, 2), (3, 4)),
nargs=2, multiple=True, type=click.INT)
def cli(arg):
for item in arg:
click.echo('<%d|%d>' % item)
result = runner.invoke(cli, [])
assert not result.exception
assert result.output.splitlines() == [
'<1|2>',
'<3|4>',
]
click-6.6/tests/test_testing.py 0000644 0001750 0000144 00000011071 12626624145 020077 0 ustar untitaker users 0000000 0000000 import sys
import pytest
import click
from click.testing import CliRunner
from click._compat import PY2, WIN
# Use the most reasonable io that users would use for the python version.
if PY2:
from cStringIO import StringIO as ReasonableBytesIO
else:
from io import BytesIO as ReasonableBytesIO
def test_runner():
@click.command()
def test():
i = click.get_binary_stream('stdin')
o = click.get_binary_stream('stdout')
while 1:
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'
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_runner_with_stream():
@click.command()
def test():
i = click.get_binary_stream('stdin')
o = click.get_binary_stream('stdout')
while 1:
chunk = i.read(4096)
if not chunk:
break
o.write(chunk)
o.flush()
runner = CliRunner()
result = runner.invoke(test, input=ReasonableBytesIO(b'Hello World!\n'))
assert not result.exception
assert result.output == 'Hello World!\n'
runner = CliRunner(echo_stdin=True)
result = runner.invoke(test, input=ReasonableBytesIO(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('foo=%s' % 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('foo=%s' % 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'
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 == 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()
def cli_int():
click.echo('hello world')
sys.exit(1)
@click.command()
def cli_float():
click.echo('hello world')
sys.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_int)
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_no_error)
assert result.exit_code == 0
assert result.output == 'hello world\n'
click-6.6/tests/test_basic.py 0000644 0001750 0000144 00000027320 12700515275 017503 0 ustar untitaker users 0000000 0000000 # -*- 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_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_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, 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',
]
click-6.6/tests/test_arguments.py 0000644 0001750 0000144 00000016721 12700514455 020431 0 ustar untitaker users 0000000 0000000 # -*- coding: utf-8 -*-
import click
from click._compat import PY2
def test_nargs_star(runner):
@click.command()
@click.argument('src', nargs=-1)
@click.argument('dst')
def copy(src, dst):
click.echo('src=%s' % '|'.join(src))
click.echo('dst=%s' % dst)
result = runner.invoke(copy, ['foo.txt', 'bar.txt', 'dir'])
assert not result.exception
assert result.output.splitlines() == [
'src=foo.txt|bar.txt',
'dst=dir',
]
def test_nargs_default(runner):
try:
@click.command()
@click.argument('src', nargs=-1, default=42)
def copy(src):
pass
except TypeError as e:
assert 'nargs=-1' in str(e)
else:
assert False
def test_nargs_tup(runner):
@click.command()
@click.argument('name', nargs=1)
@click.argument('point', nargs=2, type=click.INT)
def copy(name, point):
click.echo('name=%s' % name)
click.echo('point=%d/%d' % point)
result = runner.invoke(copy, ['peter', '1', '2'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter',
'point=1/2',
]
def test_nargs_tup_composite(runner):
variations = [
dict(type=(str, int)),
dict(type=click.Tuple([str, int])),
dict(nargs=2, type=click.Tuple([str, int])),
dict(nargs=2, type=(str, int)),
]
for opts in variations:
@click.command()
@click.argument('item', **opts)
def copy(item):
click.echo('name=%s id=%d' % item)
result = runner.invoke(copy, ['peter', '1'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter id=1',
]
def test_nargs_err(runner):
@click.command()
@click.argument('x')
def copy(x):
click.echo(x)
result = runner.invoke(copy, ['foo'])
assert not result.exception
assert result.output == 'foo\n'
result = runner.invoke(copy, ['foo', 'bar'])
assert result.exit_code == 2
assert 'Got unexpected extra argument (bar)' in result.output
def test_file_args(runner):
@click.command()
@click.argument('input', type=click.File('rb'))
@click.argument('output', type=click.File('wb'))
def inout(input, output):
while True:
chunk = input.read(1024)
if not chunk:
break
output.write(chunk)
with runner.isolated_filesystem():
result = runner.invoke(inout, ['-', 'hello.txt'], input='Hey!')
assert result.output == ''
assert result.exit_code == 0
with open('hello.txt', 'rb') as f:
assert f.read() == b'Hey!'
result = runner.invoke(inout, ['hello.txt', '-'])
assert result.output == 'Hey!'
assert result.exit_code == 0
def test_path_args(runner):
@click.command()
@click.argument('input', type=click.Path(dir_okay=False, allow_dash=True))
def foo(input):
click.echo(input)
result = runner.invoke(foo, ['-'])
assert result.output == '-\n'
assert result.exit_code == 0
def test_file_atomics(runner):
@click.command()
@click.argument('output', type=click.File('wb', atomic=True))
def inout(output):
output.write(b'Foo bar baz\n')
output.flush()
with open(output.name, 'rb') as f:
old_content = f.read()
assert old_content == b'OLD\n'
with runner.isolated_filesystem():
with open('foo.txt', 'wb') as f:
f.write(b'OLD\n')
result = runner.invoke(inout, ['foo.txt'], input='Hey!',
catch_exceptions=False)
assert result.output == ''
assert result.exit_code == 0
with open('foo.txt', 'rb') as f:
assert f.read() == b'Foo bar baz\n'
def test_stdout_default(runner):
@click.command()
@click.argument('output', type=click.File('w'), default='-')
def inout(output):
output.write('Foo bar baz\n')
output.flush()
result = runner.invoke(inout, [])
assert not result.exception
assert result.output == 'Foo bar baz\n'
def test_nargs_envvar(runner):
@click.command()
@click.option('--arg', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
@click.command()
@click.option('--arg', envvar='X', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], env={'X': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
def test_empty_nargs(runner):
@click.command()
@click.argument('arg', nargs=-1)
def cmd(arg):
click.echo('arg:' + '|'.join(arg))
result = runner.invoke(cmd, [])
assert result.exit_code == 0
assert result.output == 'arg:\n'
@click.command()
@click.argument('arg', nargs=-1, required=True)
def cmd2(arg):
click.echo('arg:' + '|'.join(arg))
result = runner.invoke(cmd2, [])
assert result.exit_code == 2
assert 'Missing argument "arg"' in result.output
def test_missing_arg(runner):
@click.command()
@click.argument('arg')
def cmd(arg):
click.echo('arg:' + arg)
result = runner.invoke(cmd, [])
assert result.exit_code == 2
assert 'Missing argument "arg".' in result.output
def test_implicit_non_required(runner):
@click.command()
@click.argument('f', default='test')
def cli(f):
click.echo(f)
result = runner.invoke(cli, [])
assert result.exit_code == 0
assert result.output == 'test\n'
def test_eat_options(runner):
@click.command()
@click.option('-f')
@click.argument('files', nargs=-1)
def cmd(f, files):
for filename in files:
click.echo(filename)
click.echo(f)
result = runner.invoke(cmd, ['--', '-foo', 'bar'])
assert result.output.splitlines() == [
'-foo',
'bar',
'',
]
result = runner.invoke(cmd, ['-f', '-x', '--', '-foo', 'bar'])
assert result.output.splitlines() == [
'-foo',
'bar',
'-x',
]
def test_nargs_star_ordering(runner):
@click.command()
@click.argument('a', nargs=-1)
@click.argument('b')
@click.argument('c')
def cmd(a, b, c):
for arg in (a, b, c):
click.echo(arg)
result = runner.invoke(cmd, ['a', 'b', 'c'])
assert result.output.splitlines() == [
PY2 and "(u'a',)" or "('a',)",
'b',
'c',
]
def test_nargs_specified_plus_star_ordering(runner):
@click.command()
@click.argument('a', nargs=-1)
@click.argument('b')
@click.argument('c', nargs=2)
def cmd(a, b, c):
for arg in (a, b, c):
click.echo(arg)
result = runner.invoke(cmd, ['a', 'b', 'c', 'd', 'e', 'f'])
assert result.output.splitlines() == [
PY2 and "(u'a', u'b', u'c')" or "('a', 'b', 'c')",
'd',
PY2 and "(u'e', u'f')" or "('e', 'f')",
]
def test_defaults_for_nargs(runner):
@click.command()
@click.argument('a', nargs=2, type=int, default=(1, 2))
def cmd(a):
x, y = a
click.echo(x + y)
result = runner.invoke(cmd, [])
assert result.output.strip() == '3'
result = runner.invoke(cmd, ['3', '4'])
assert result.output.strip() == '7'
result = runner.invoke(cmd, ['3'])
assert result.exception is not None
assert 'argument a takes 2 values' in result.output
click-6.6/tests/test_options.py 0000644 0001750 0000144 00000023711 12626624145 020121 0 ustar untitaker users 0000000 0000000 # -*- coding: utf-8 -*-
import re
import os
import click
import pytest
from click._compat import text_type
def test_prefixes(runner):
@click.command()
@click.option('++foo', is_flag=True, help='das foo')
@click.option('--bar', is_flag=True, help='das bar')
def cli(foo, bar):
click.echo('foo=%s bar=%s' % (foo, bar))
result = runner.invoke(cli, ['++foo', '--bar'])
assert not result.exception
assert result.output == 'foo=True bar=True\n'
result = runner.invoke(cli, ['--help'])
assert re.search(r'\+\+foo\s+das foo', result.output) is not None
assert re.search(r'--bar\s+das bar', result.output) is not None
def test_invalid_option(runner):
try:
@click.command()
@click.option('foo')
def cli(foo):
pass
except TypeError as e:
assert 'No options defined but a name was passed (foo).' \
in str(e)
else:
assert False, 'Expected a type error because of an invalid option.'
def test_invalid_nargs(runner):
try:
@click.command()
@click.option('--foo', nargs=-1)
def cli(foo):
pass
except TypeError as e:
assert 'Options cannot have nargs < 0' in str(e)
else:
assert False, 'Expected a type error because of an invalid option.'
def test_nargs_tup_composite_mult(runner):
@click.command()
@click.option('--item', type=(str, int), multiple=True)
def copy(item):
for item in item:
click.echo('name=%s id=%d' % item)
result = runner.invoke(copy, ['--item', 'peter', '1', '--item', 'max', '2'])
assert not result.exception
assert result.output.splitlines() == [
'name=peter id=1',
'name=max id=2',
]
def test_counting(runner):
@click.command()
@click.option('-v', count=True, help='Verbosity',
type=click.IntRange(0, 3))
def cli(v):
click.echo('verbosity=%d' % v)
result = runner.invoke(cli, ['-vvv'])
assert not result.exception
assert result.output == 'verbosity=3\n'
result = runner.invoke(cli, ['-vvvv'])
assert result.exception
assert 'Invalid value for "-v": 4 is not in the valid range of 0 to 3.' \
in result.output
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == 'verbosity=0\n'
result = runner.invoke(cli, ['--help'])
assert re.search('-v\s+Verbosity', result.output) is not None
@pytest.mark.parametrize('unknown_flag', ['--foo', '-f'])
def test_unknown_options(runner, unknown_flag):
@click.command()
def cli():
pass
result = runner.invoke(cli, [unknown_flag])
assert result.exception
assert 'no such option: {0}'.format(unknown_flag) in result.output
def test_multiple_required(runner):
@click.command()
@click.option('-m', '--message', multiple=True, required=True)
def cli(message):
click.echo('\n'.join(message))
result = runner.invoke(cli, ['-m', 'foo', '-mbar'])
assert not result.exception
assert result.output == 'foo\nbar\n'
result = runner.invoke(cli, [])
assert result.exception
assert 'Error: Missing option "-m" / "--message".' in result.output
def test_multiple_envvar(runner):
@click.command()
@click.option('--arg', multiple=True)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar baz'})
assert not result.exception
assert result.output == 'foo|bar|baz\n'
@click.command()
@click.option('--arg', multiple=True, envvar='X')
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], env={'X': 'foo bar baz'})
assert not result.exception
assert result.output == 'foo|bar|baz\n'
@click.command()
@click.option('--arg', multiple=True, type=click.Path())
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo%sbar' % os.path.pathsep})
assert not result.exception
assert result.output == 'foo|bar\n'
def test_multiple_default_help(runner):
@click.command()
@click.option('--arg1', multiple=True, default=('foo', 'bar'),
show_default=True)
@click.option('--arg2', multiple=True, default=(1, 2), type=int,
show_default=True)
def cmd(arg, arg2):
pass
result = runner.invoke(cmd, ['--help'])
assert not result.exception
assert 'foo, bar' in result.output
assert '1, 2' in result.output
def test_multiple_default_type(runner):
@click.command()
@click.option('--arg1', multiple=True, default=('foo', 'bar'))
@click.option('--arg2', multiple=True, default=(1, 'a'))
def cmd(arg1, arg2):
assert all(isinstance(e[0], text_type) for e in arg1)
assert all(isinstance(e[1], text_type) for e in arg1)
assert all(isinstance(e[0], int) for e in arg2)
assert all(isinstance(e[1], text_type) for e in arg2)
result = runner.invoke(cmd, '--arg1 a b --arg1 test 1 --arg2 2 '
'two --arg2 4 four'.split())
assert not result.exception
def test_nargs_envvar(runner):
@click.command()
@click.option('--arg', nargs=2)
def cmd(arg):
click.echo('|'.join(arg))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'foo bar'})
assert not result.exception
assert result.output == 'foo|bar\n'
@click.command()
@click.option('--arg', nargs=2, multiple=True)
def cmd(arg):
for item in arg:
click.echo('|'.join(item))
result = runner.invoke(cmd, [], auto_envvar_prefix='TEST',
env={'TEST_ARG': 'x 1 y 2'})
assert not result.exception
assert result.output == 'x|1\ny|2\n'
def test_custom_validation(runner):
def validate_pos_int(ctx, value):
if value < 0:
raise click.BadParameter('Value needs to be positive')
return value
@click.command()
@click.option('--foo', callback=validate_pos_int, default=1)
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--foo', '-1'])
assert 'Invalid value for "--foo": Value needs to be positive' \
in result.output
result = runner.invoke(cmd, ['--foo', '42'])
assert result.output == '42\n'
def test_winstyle_options(runner):
@click.command()
@click.option('/debug;/no-debug', help='Enables or disables debug mode.')
def cmd(debug):
click.echo(debug)
result = runner.invoke(cmd, ['/debug'], help_option_names=['/?'])
assert result.output == 'True\n'
result = runner.invoke(cmd, ['/no-debug'], help_option_names=['/?'])
assert result.output == 'False\n'
result = runner.invoke(cmd, [], help_option_names=['/?'])
assert result.output == 'False\n'
result = runner.invoke(cmd, ['/?'], help_option_names=['/?'])
assert '/debug; /no-debug Enables or disables debug mode.' in result.output
assert '/? Show this message and exit.' in result.output
def test_legacy_options(runner):
@click.command()
@click.option('-whatever')
def cmd(whatever):
click.echo(whatever)
result = runner.invoke(cmd, ['-whatever', '42'])
assert result.output == '42\n'
result = runner.invoke(cmd, ['-whatever=23'])
assert result.output == '23\n'
def test_missing_choice(runner):
@click.command()
@click.option('--foo', type=click.Choice(['foo', 'bar']),
required=True)
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd)
assert result.exit_code == 2
assert 'Error: Missing option "--foo". Choose from foo, bar.' \
in result.output
def test_multiline_help(runner):
@click.command()
@click.option('--foo', help="""
hello
i am
multiline
""")
def cmd(foo):
click.echo(foo)
result = runner.invoke(cmd, ['--help'])
assert result.exit_code == 0
out = result.output.splitlines()
assert ' --foo TEXT hello' in out
assert ' i am' in out
assert ' multiline' in out
def test_argument_custom_class(runner):
class CustomArgument(click.Argument):
def get_default(self, ctx):
'''a dumb override of a default value for testing'''
return 'I am a default'
@click.command()
@click.argument('testarg', cls=CustomArgument, default='you wont see me')
def cmd(testarg):
click.echo(testarg)
result = runner.invoke(cmd)
assert 'I am a default' in result.output
assert 'you wont see me' not in result.output
def test_option_custom_class(runner):
class CustomOption(click.Option):
def get_help_record(self, ctx):
'''a dumb override of a help text for testing'''
return ('--help', 'I am a help text')
@click.command()
@click.option('--testoption', cls=CustomOption, help='you wont see me')
def cmd(testoption):
click.echo(testoption)
result = runner.invoke(cmd, ['--help'])
assert 'I am a help text' in result.output
assert 'you wont see me' not in result.output
def test_aliases_for_flags(runner):
@click.command()
@click.option('--warnings/--no-warnings', ' /-W', default=True)
def cli(warnings):
click.echo(warnings)
result = runner.invoke(cli, ['--warnings'])
assert result.output == 'True\n'
result = runner.invoke(cli, ['--no-warnings'])
assert result.output == 'False\n'
result = runner.invoke(cli, ['-W'])
assert result.output == 'False\n'
@click.command()
@click.option('--warnings/--no-warnings', '-w', default=True)
def cli_alt(warnings):
click.echo(warnings)
result = runner.invoke(cli_alt, ['--warnings'])
assert result.output == 'True\n'
result = runner.invoke(cli_alt, ['--no-warnings'])
assert result.output == 'False\n'
result = runner.invoke(cli_alt, ['-w'])
assert result.output == 'True\n'
click-6.6/tests/test_termui.py 0000644 0001750 0000144 00000000612 12700515275 017722 0 ustar untitaker users 0000000 0000000 import click
def test_progressbar_strip_regression(runner, monkeypatch):
label = ' padded line'
@click.command()
def cli():
with click.progressbar(tuple(range(10)), label=label) as progress:
for thing in progress:
pass
monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
assert label in runner.invoke(cli, []).output
click-6.6/tests/test_chain.py 0000644 0001750 0000144 00000013112 12642023505 017471 0 ustar untitaker users 0000000 0000000 import sys
import click
import pytest
def debug():
click.echo('%s=%s' % (
sys._getframe(1).f_code.co_name,
'|'.join(click.get_current_context().args),
))
def test_basic_chaining(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
def sdist():
click.echo('sdist called')
@cli.command('bdist')
def bdist():
click.echo('bdist called')
result = runner.invoke(cli, ['bdist', 'sdist', 'bdist'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called',
'sdist called',
'bdist called',
]
def test_chaining_help(runner):
@click.group(chain=True)
def cli():
"""ROOT HELP"""
pass
@cli.command('sdist')
def sdist():
"""SDIST HELP"""
click.echo('sdist called')
@cli.command('bdist')
def bdist():
"""BDIST HELP"""
click.echo('bdist called')
result = runner.invoke(cli, ['--help'])
assert not result.exception
assert 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...' in result.output
assert 'ROOT HELP' in result.output
result = runner.invoke(cli, ['sdist', '--help'])
assert not result.exception
assert 'SDIST HELP' in result.output
result = runner.invoke(cli, ['bdist', '--help'])
assert not result.exception
assert 'BDIST HELP' in result.output
result = runner.invoke(cli, ['bdist', 'sdist', '--help'])
assert not result.exception
assert 'SDIST HELP' in result.output
def test_chaining_with_options(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
@click.option('--format')
def sdist(format):
click.echo('sdist called %s' % format)
@cli.command('bdist')
@click.option('--format')
def bdist(format):
click.echo('bdist called %s' % format)
result = runner.invoke(cli, ['bdist', '--format=1', 'sdist', '--format=2'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called 1',
'sdist called 2',
]
def test_chaining_with_arguments(runner):
@click.group(chain=True)
def cli():
pass
@cli.command('sdist')
@click.argument('format')
def sdist(format):
click.echo('sdist called %s' % format)
@cli.command('bdist')
@click.argument('format')
def bdist(format):
click.echo('bdist called %s' % format)
result = runner.invoke(cli, ['bdist', '1', 'sdist', '2'])
assert not result.exception
assert result.output.splitlines() == [
'bdist called 1',
'sdist called 2',
]
def test_pipeline(runner):
@click.group(chain=True, invoke_without_command=True)
@click.option('-i', '--input', type=click.File('r'))
def cli(input):
pass
@cli.resultcallback()
def process_pipeline(processors, input):
iterator = (x.rstrip('\r\n') for x in input)
for processor in processors:
iterator = processor(iterator)
for item in iterator:
click.echo(item)
@cli.command('uppercase')
def make_uppercase():
def processor(iterator):
for line in iterator:
yield line.upper()
return processor
@cli.command('strip')
def make_strip():
def processor(iterator):
for line in iterator:
yield line.strip()
return processor
result = runner.invoke(cli, ['-i', '-'], input='foo\nbar')
assert not result.exception
assert result.output.splitlines() == [
'foo',
'bar',
]
result = runner.invoke(cli, ['-i', '-', 'strip'], input='foo \n bar')
assert not result.exception
assert result.output.splitlines() == [
'foo',
'bar',
]
result = runner.invoke(cli, ['-i', '-', 'strip', 'uppercase'],
input='foo \n bar')
assert not result.exception
assert result.output.splitlines() == [
'FOO',
'BAR',
]
def test_args_and_chain(runner):
@click.group(chain=True)
def cli():
debug()
@cli.command()
def a():
debug()
@cli.command()
def b():
debug()
@cli.command()
def c():
debug()
result = runner.invoke(cli, ['a', 'b', 'c'])
assert not result.exception
assert result.output.splitlines() == [
'cli=',
'a=',
'b=',
'c=',
]
def test_multicommand_arg_behavior(runner):
with pytest.raises(RuntimeError):
@click.group(chain=True)
@click.argument('forbidden', required=False)
def bad_cli():
pass
with pytest.raises(RuntimeError):
@click.group(chain=True)
@click.argument('forbidden', nargs=-1)
def bad_cli2():
pass
@click.group(chain=True)
@click.argument('arg')
def cli(arg):
click.echo('cli:%s' % arg)
@cli.command()
def a():
click.echo('a')
result = runner.invoke(cli, ['foo', 'a'])
assert not result.exception
assert result.output.splitlines() == [
'cli:foo',
'a',
]
@pytest.mark.xfail
def test_multicommand_chaining(runner):
@click.group(chain=True)
def cli():
debug()
@cli.group()
def l1a():
debug()
@l1a.command()
def l2a():
debug()
@l1a.command()
def l2b():
debug()
@cli.command()
def l1b():
debug()
result = runner.invoke(cli, ['l1a', 'l2a', 'l1b'])
assert not result.exception
assert result.output.splitlines() == [
'cli=',
'l1a=',
'l2a=',
'l1b=',
]
click-6.6/tests/conftest.py 0000644 0001750 0000144 00000000203 12372132670 017176 0 ustar untitaker users 0000000 0000000 from click.testing import CliRunner
import pytest
@pytest.fixture(scope='function')
def runner(request):
return CliRunner()
click-6.6/tests/test_context.py 0000644 0001750 0000144 00000010530 12626624145 020105 0 ustar untitaker users 0000000 0000000 # -*- coding: utf-8 -*-
import click
def test_ensure_context_objects(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo, ensure=True)
@click.group()
@pass_foo
def cli(foo):
pass
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'default\n'
def test_get_context_objects(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo, ensure=True)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
ctx.obj.title = 'test'
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_get_context_objects_no_ensuring(runner):
class Foo(object):
def __init__(self):
self.title = 'default'
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = Foo()
ctx.obj.title = 'test'
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_get_context_objects_missing(runner):
class Foo(object):
pass
pass_foo = click.make_pass_decorator(Foo)
@click.group()
@click.pass_context
def cli(ctx):
pass
@cli.command()
@pass_foo
def test(foo):
click.echo(foo.title)
result = runner.invoke(cli, ['test'])
assert result.exception is not None
assert isinstance(result.exception, RuntimeError)
assert "Managed to invoke callback without a context object " \
"of type 'Foo' existing" in str(result.exception)
def test_multi_enter(runner):
called = []
@click.command()
@click.pass_context
def cli(ctx):
def callback():
called.append(True)
ctx.call_on_close(callback)
with ctx:
pass
assert not called
result = runner.invoke(cli, [])
assert result.exception is None
assert called == [True]
def test_global_context_object(runner):
@click.command()
@click.pass_context
def cli(ctx):
assert click.get_current_context() is ctx
ctx.obj = 'FOOBAR'
assert click.get_current_context().obj == 'FOOBAR'
assert click.get_current_context(silent=True) is None
runner.invoke(cli, [], catch_exceptions=False)
assert click.get_current_context(silent=True) is None
def test_context_meta(runner):
LANG_KEY = __name__ + '.lang'
def set_language(value):
click.get_current_context().meta[LANG_KEY] = value
def get_language():
return click.get_current_context().meta.get(LANG_KEY, 'en_US')
@click.command()
@click.pass_context
def cli(ctx):
assert get_language() == 'en_US'
set_language('de_DE')
assert get_language() == 'de_DE'
runner.invoke(cli, [], catch_exceptions=False)
def test_context_pushing():
rv = []
@click.command()
def cli():
pass
ctx = click.Context(cli)
@ctx.call_on_close
def test_callback():
rv.append(42)
with ctx.scope(cleanup=False):
# Internal
assert ctx._depth == 2
assert rv == []
with ctx.scope():
# Internal
assert ctx._depth == 1
assert rv == [42]
def test_pass_obj(runner):
@click.group()
@click.pass_context
def cli(ctx):
ctx.obj = 'test'
@cli.command()
@click.pass_obj
def test(obj):
click.echo(obj)
result = runner.invoke(cli, ['test'])
assert not result.exception
assert result.output == 'test\n'
def test_close_before_pop(runner):
called = []
@click.command()
@click.pass_context
def cli(ctx):
ctx.obj = 'test'
@ctx.call_on_close
def foo():
assert click.get_current_context().obj == 'test'
called.append(True)
click.echo('aha!')
result = runner.invoke(cli, [])
assert not result.exception
assert result.output == 'aha!\n'
assert called == [True]
click-6.6/tests/test_normalization.py 0000644 0001750 0000144 00000001673 12372132670 021312 0 ustar untitaker users 0000000 0000000 import click
CONTEXT_SETTINGS = dict(token_normalize_func=lambda x: x.lower())
def test_option_normalization(runner):
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--foo')
@click.option('-x')
def cli(foo, x):
click.echo(foo)
click.echo(x)
result = runner.invoke(cli, ['--FOO', '42', '-X', 23])
assert result.output == '42\n23\n'
def test_choice_normalization(runner):
@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('--choice', type=click.Choice(['Foo', 'Bar']))
def cli(choice):
click.echo('Foo')
result = runner.invoke(cli, ['--CHOICE', 'FOO'])
assert result.output == 'Foo\n'
def test_command_normalization(runner):
@click.group(context_settings=CONTEXT_SETTINGS)
def cli():
pass
@cli.command()
def foo():
click.echo('here!')
result = runner.invoke(cli, ['FOO'])
assert result.output == 'here!\n'
click-6.6/Makefile 0000644 0001750 0000144 00000000374 12626624145 015313 0 ustar untitaker users 0000000 0000000 test:
@cd tests; PYTHONPATH=.. py.test --tb=short
upload-docs:
$(MAKE) -C docs dirhtml
rsync -a docs/_build/dirhtml/* flow.srv.pocoo.org:/srv/websites/click.pocoo.org/static/
release:
python setup.py sdist bdist_wheel upload
.PHONY: upload-docs