def test_subcommand():
app = Application('foo', 'tests.test_subcommand:Foo.quickstart')
with Given(app):
assert stdout == EXPECTED_HELP
assert status == 0
when(['-h'])
assert status == 0
assert stderr == ''
assert stdout == EXPECTED_HELP
when(['bar'])
assert stderr == ''
assert stdout == 'Bar done: False\n'
assert status == 0
when(['ba'])
assert stderr == ''
assert stdout == 'Bar done: False\n'
assert status == 0
when(['b'])
assert stderr == ''
assert stdout == 'Bar done: False\n'
assert status == 0
when(['bar', '--baz'])
assert stderr == ''
assert stdout == 'Bar done: True\n'
assert status == 1
def test_basic_pipeline():
app = Application('foo', 'tests.test_pipeline:foo')
with Given(app):
assert status == 0
assert stdout == ''
assert stderr == ''
when(stdin='bar')
assert status == 0
assert stdout == f'input: bar\n'
when(stdin='bad')
assert status == 1
assert stderr == f'error: bad\n'
def test_simple():
app = Application('foo', 'tests.test_simple:Foo.quickstart')
with Given(app):
assert stderr == ''
assert stdout == 'foo done\n'
assert status == 0
when(['-h'])
assert status == 0
assert stderr == ''
assert stdout == EXPECTED_HELP
when(['--invalid'])
assert status == 2
assert stderr == EXPECTED_USAGE
assert stdout == ''
def test_bash_autocompletion_virtualenv():
app = Application('foo', 'tests.test_completion:Foo.quickstart')
with tempfile.TemporaryDirectory() as venvdir:
os.mkdir(path.join(venvdir, 'bin'))
with Given(app, ['completion'], environ={'VIRTUAL_ENV': venvdir}):
assert stdout == EXPECTED_HELP
assert status == 0
when(given + ['install', '-s'])
assert stderr == 'The -s/--system-wide flag can not be used ' \
'within virtualenv\n'
assert status == 1
when(['completion', 'install'])
when(given + ['uninstall', '-s'])
assert stderr == 'The -s/--system-wide flag can not be used ' \
'within virtualenv\n'
assert status == 1
when(['completion', 'uninstall'])
def test_mutex():
app = Application('foo', 'tests.test_mutex:Foo.quickstart')
with Given(app):
assert stderr == ''
assert stdout == 'foo done\n'
assert status == 0
when(['--bar'])
assert status == 0
assert stderr == ''
assert stdout == 'foo done\n'
when(['--baz'])
assert status == 0
assert stderr == ''
assert stdout == 'foo done\n'
when(['--bar --baz'])
assert status == 2
assert stderr == EXPECTED_USAGE
assert stdout == ''
__mapper_args__ = {'polymorphic_identity': 'worker_task'}
def do_(self, context):
_task_done.set()
class FooApplication(RestfulpyApplication):
__configuration__ = f'''
db:
url: {DBURL}
'''
foo = FooApplication(name='Foo')
app = Application('foo', 'tests.test_appcli_worker:foo.cli_main')
def test_appcli_worker_cleanup(db):
with Given(app, 'worker cleanup'):
assert stderr == ''
assert status == 0
def test_appcli_worker_start(db):
session = db()
task = WorkerTask()
session.add(task)
session.commit()
with Given(app, 'worker start', nowait=True):
"""Test CArgs.
http home.light set <body>
http home.light set foo=1 bar="bar baz" qux=@path/to/file.ext
http home.light set ?foo=bar ?baz=qux
http home.light set -c json -- {foo: "bar"}
"""
import sys
from bddcli import Given, when, stdout, status, stderr, Application, given
app = Application('cargs', 'cargs:CArgs.quickstart')
def test_contenttypes():
with Given(app, 'example.com'):
assert status == 0
assert stdout == 'example.com'
when(given + '-cplain')
assert status == 0
assert stdout == '-H"Content-Type: text/plain" example.com'
when(given + '-cjson')
assert status == 0
assert stdout == '-H"Content-Type: application/json" example.com'
when(given + '-cmultipart')
assert status == 0
import sys
import pytest
from bddcli import Given, given, when, stdout, status, stderr, Application
def foo(): # pragma: no cover
print(' '.join(sys.argv))
app = Application('foo', 'tests.test_proxy:foo')
def test_proxy():
with Given(app, ['bar']):
assert stdout == 'foo bar\n'
assert len(stdout) == 8
import os
import sys
import pytest
from bddcli import Given, when, stdout, Application, given, stderr
def baz(): # pragma: no cover
e = os.environ.copy()
print(' '.join(f'{k}: {v}' for k, v in e.items()
if k not in ['LC_CTYPE', 'PWD']))
print(' '.join(sys.argv), file=sys.stderr)
app = Application('foo', 'tests.test_manipulators:baz')
def test_dict_manipulators():
with Given(app, environ={'bar': 'baz'}):
assert stdout == 'bar: baz\n'
with pytest.raises(ValueError):
when(environ=given + {'bar': 'qux'})
def test_list_manipulators():
with Given(app, ['bar']):
assert stderr == 'foo bar\n'
with pytest.raises(ValueError):
import base64
import json
from bddcli import Given, given, when, stdout, stderr, Application, status
from restfulpy import Application as RestfulpyApplication
foo = RestfulpyApplication(name='jwt')
def foo_main():
return foo.cli_main()
app = Application('foo', 'tests.test_appcli_jwt:foo_main')
def test_jwt():
with Given(app, 'jwt create'):
assert stderr == ''
assert status == 0
assert len(stdout) > 10
when(given + '\'{"foo": 1}\'')
assert stderr == ''
assert status == 0
header, payload, signature = stdout.encode().split(b'.')
payload = base64.urlsafe_b64decode(payload)
assert json.loads(payload) == {'foo': 1}
def test_object_attribute():
app = Application('foo', 'tests.test_pipeline:Foo.main')
with Given(app):
assert status == 0
assert stdout == 'Foo.main\n'
assert stderr == ''
import time
from bddcli import Given, stderr, Application, status, when, story, \
given, stdout
import restfulpy
from restfulpy import Application as RestfulpyApplication
from restfulpy.taskqueue import RestfulpyTask
app = Application('restfulpy', 'restfulpy.cli:main')
def test_restfulpy_cli(db):
with Given(app):
assert stdout.startswith('usage')
assert status == 0
when(given + '--version')
assert stdout == f'{restfulpy.__version__}\n'
assert status == 0
if __name__ == '__main__': # pragma: no cover
foo.cli_main(['migrate', '--help'])
from bddcli import Given, stdout, Application
from textbot import __version__
app = Application('textbot', 'textbot.cli:TextBot.quickstart')
def test_version():
with Given(app, '--version'):
assert stdout.startswith(__version__)
def terminate(s, f):
nonlocal done
done = s
print('Signal received:', s, flush=True)
signal.signal(signal.SIGTERM, terminate)
signal.signal(signal.SIGINT, terminate)
while done is None:
time.sleep(.6)
return done
app = Application('foo', 'tests.test_signal:foo')
def test_signal():
with Given(app, nowait=True) as s:
# Wait some moments
time.sleep(1)
s.kill()
s.wait()
assert stdout == 'Signal received: 15\n'
assert status == -15
when()
time.sleep(1)
s.kill(signal.SIGINT)
s.wait()
def test_binary_pipeline():
app = Application('foo', 'tests.test_pipeline_binary:foo')
with Given(app, stdin=b'bar'):
assert stderr == b''
assert stdout == b'bar'
assert status == 0
from bddcli import Given, stderr, Application, status
from restfulpy import Application as RestfulpyApplication
foo = RestfulpyApplication(name='migration')
app = Application('foo', 'tests.test_appcli_migrate:foo.cli_main')
def test_migrate():
with Given(app, 'migrate'):
assert stderr.startswith('usage: foo')
assert status == 2
if __name__ == '__main__': # pragma: no cover
foo.cli_main(['migrate', '--help'])
import os
from bddcli import Given, stdout, Application, when, given
def foos(): # pragma: no cover
e = os.environ.copy()
print(' '.join(f'{k}: {v}' for k, v in e.items()
if k not in ['LC_CTYPE', 'PWD']))
app = Application('foo', 'tests.test_environ:foos')
def test_environ():
with Given(app, environ={'bar': 'baz'}):
assert stdout == 'bar: baz\n'
when(environ=given - 'bar')
assert stdout == '\n'
when(environ=given + {'qux': 'quux'})
assert stdout == 'bar: baz qux: quux\n'
when(environ=given | {'bar': 'quux'})
assert stdout == 'bar: quux\n'
import os
from bddcli import Given, stdout, Application, when
def foo(): # pragma: no cover
print(os.getcwd())
app = Application('foo', 'tests.test_workingdirectory:foo')
def test_working_directory():
with Given(app):
assert f'{os.getcwd()}\n' == stdout
when(working_directory='/tmp')
assert stdout == '/tmp\n'
from bddcli import Given, given, when, stdout, stderr, Application
from itsdangerous import TimedJSONWebSignatureSerializer
from itsdangerous.exc import SignatureExpired
from nanohttp import settings
from restfulpy import Application as RestfulpyApplication
foo = RestfulpyApplication(name='jwt')
foo.__configuration__ = ''
def foo_main():
return foo.cli_main()
app = Application('foo', 'restfulpy.tests.test_jwt_cli:foo_main')
def test_jwt():
foo.configure(force=True)
pirincipal = TimedJSONWebSignatureSerializer(
settings.jwt.secret, algorithm_name=settings.jwt.algorithm)
with Given(app, ['jwt', 'create']):
assert stderr == ''
token = f'{stdout}'[:-1]
assert pirincipal.loads(token) == {}
# Create a jwt token with a payload
payload = dict(a=1)
when(given + f'\'{json.dumps(payload)}\'')
__configuration__ = f'''
db:
url: {DBURL}
'''
def insert_basedata(self, *args):
DBSession.add(FooModel(title='FooBase'))
DBSession.commit()
def insert_mockup(self, *args):
DBSession.add(FooModel(title='FooMock'))
DBSession.commit()
foo = FooApplication(name='Foo')
app = Application('foo', 'tests.test_appcli_db:foo.cli_main')
class TestDatabaseAdministrationCommandLine:
db = None
@classmethod
def setup_class(cls):
foo.configure(force=True)
cls.db = DBManager(DBURL)
cls.db.__enter__()
@classmethod
def teardown_class(cls):
cls.db.__exit__(None, None, None)
import tempfile
from os import path
from bddcli import Given, stderr, Application, status, stdout, when, given
from restfulpy import Application as RestfulpyApplication
foo = RestfulpyApplication(name='Foo')
app = Application('foo', 'tests.test_appcli_configuration:foo.cli_main')
def test_configuration_dump():
with Given(app, 'configuration dump'):
assert stderr == ''
assert status == 0
assert len(stdout.proxied_object) > 100
filename = tempfile.mktemp()
when(given + filename)
assert stderr == ''
assert status == 0
assert path.exists(filename)
from bddcli import Given, when, stdout, status, stderr, Application
app = Application('bddrest', 'bddrest.cli:main')
def test_document_cli():
with Given(app, ['document']):
when(stdin=yamlstory)
assert stderr == ''
assert status == 0
assert stdout == expected_markdown
def test_help():
with Given(app):
assert stdout == expected_help
yamlstory = '''
base_call:
as_: visitor
description: As a member I have to POST a book to the library.
form:
name: BDD Book
query:
a: b
response:
headers:
- 'Content-Type: application/json;charset=utf-8'
json:
foo: bar
import sys
import time
from bddcli import Given, stdout, status, Application, when
def foo(): # pragma: no cover
print(sys.stdin.read(), flush=True)
app = Application('foo', 'tests.test_interactive:foo')
def test_signal():
with Given(app, nowait=True) as s:
# Wait some moments
time.sleep(1)
s.wait('bar')
assert stdout == 'bar\n'
assert status == 0
when(stdin='baz')
s.wait()
assert stdout == 'baz\n'
assert status == 0
import sys
import pytest
from bddcli import Given, given, when, stdout, status, stderr, Application
def foo(): # pragma: no cover
print(' '.join(sys.argv))
app = Application('foo', 'tests.test_arguments:foo')
def test_arguments():
with Given(app, ['bar']):
assert stdout == 'foo bar\n'
assert status == 0
when(given - 'bar')
assert stdout == 'foo\n'
when(given + 'baz')
assert stdout == 'foo bar baz\n'
with Given(app, 'bar'):
assert stdout == 'foo bar\n'
when('baz')
assert stdout == 'foo baz\n'
