def may_specify_config_class(self):
klass = object()
eq_(Program(config_class=klass).config_class, klass) # noqa
def executor_class_defaults_to_Executor(self):
ok_(Program().executor_class is Executor)
def may_specify_executor_class(self):
klass = object()
eq_(Program(executor_class=klass).executor_class, klass) # noqa
def honors_program_binary(self):
expect('-c decorator -h biz',
out="Usage: notinvoke",
test=assert_contains,
program=Program(binary='notinvoke'))
def loader_class_defaults_to_FilesystemLoader(self):
ok_(Program().loader_class is FilesystemLoader)
def may_specify_version(self):
eq_(Program(version='1.2.3').version, '1.2.3')
def may_specify_namespace(self):
foo = load('foo')
ok_(Program(namespace=foo).namespace is foo)
from invoke import Collection, Program from witch import VERSION from .tasks import dev, prod, utils, db, aws namespace = Collection() namespace.add_collection(prod) namespace.add_collection(dev) namespace.add_collection(db) namespace.add_collection(utils) namespace.add_collection(aws) namespace.add_task(prod.deploy) namespace.add_task(prod.exec) program = Program(namespace=namespace, version=VERSION)
def uses_a_list_unaltered(self):
p = Program()
p.print_version = Mock()
p.run(['inv', '--version'], exit=False)
p.print_version.assert_called()
from invoke.config import Config # , merge_dicts
from rscli import tasks
__VERSION__ = '0.2.0'
class RSConfig(Config):
prefix = 'rscli'
'''
@staticmethod
def global_defaults():
their_defaults = Config.global_defaults()
my_defaults = {
'debug': True,
'run': {
'echo': True,
},
}
return merge_dicts(their_defaults, my_defaults)
'''
program = Program(
version=__VERSION__,
config_class=RSConfig,
namespace=Collection.from_module(tasks)
)
from invoke import Collection, Program from minv import tasks program = Program(namespace=Collection.from_module(tasks), version='0.1.0')
def interactive():
Program.initial_context = always_add_task_args_initial_context
return Program(name="OKCupyd", version=__version__,
namespace=tasks.ns).run()
def env_prefix_can_be_overridden(self):
eq_(Program(env_prefix='FOO_').env_prefix, 'FOO_')
def env_prefix_defaults_to_INVOKE_(self):
eq_(Program().env_prefix, 'INVOKE_')
def does_not_seek_tasks_module_if_namespace_was_given(self):
expect('foo',
err="No idea what 'foo' is!\n",
program=Program(namespace=Collection('blank')))
def splits_a_string(self):
p = Program()
p.print_version = Mock()
p.run("inv --version", exit=False)
p.print_version.assert_called()
def turns_KeyboardInterrupt_into_exit_code_1(self, mock_exit):
p = Program()
p.execute = Mock(side_effect=KeyboardInterrupt)
p.run("myapp -c foo mytask")
mock_exit.assert_called_with(1)
def uses_overridden_value_when_given(self):
p = Program(name='NotInvoke')
expect("--version", out="NotInvoke unknown\n", program=p)
def default_version_is_unknown(self):
eq_(Program().version, 'unknown')
def uses_overridden_value_when_given(self):
expect("myapp --help",
out="nope [--core-opts]",
program=Program(binary='nope'),
invoke=False,
test=assert_contains)
def may_specify_name(self):
eq_(Program(name='Myapp').name, 'Myapp')
def use_binary_basename_when_invoked_absolutely(self):
Program().run("/usr/local/bin/myapp --help", exit=False)
stdout = sys.stdout.getvalue()
assert_contains(stdout, "myapp [--core-opts]")
assert_not_contains(stdout, "/usr/local/bin")
def may_specify_binary(self):
eq_(Program(binary='myapp').binary, 'myapp')
def displays_name_and_version(self):
expect("--version",
program=Program(name="MyProgram", version='0.1.0'),
out="MyProgram 0.1.0\n")
def may_specify_loader_class(self):
klass = object()
eq_(Program(loader_class=klass).loader_class, klass)
def uses_loader_class_given(self):
klass = Mock(side_effect=FilesystemLoader)
Program(loader_class=klass).run("myapp --help foo", exit=False)
klass.assert_called_with(start=ANY)
def _test_flag(self, flag, key, value=True):
p = Program()
p.execute = Mock() # neuter
p.run('inv {0} foo'.format(flag))
eq_(p.config.run[key], value)
def uses_executor_class_given(self):
klass = Mock()
Program(executor_class=klass).run("myapp foo", exit=False)
klass.assert_called_with(ANY, ANY, ANY)
klass.return_value.execute.assert_called_with(ANY)
def config_class_init_kwarg_is_honored(self):
klass = Mock()
Program(config_class=klass).run("myapp foo", exit=False)
eq_(len(klass.call_args_list), 1) # don't care about actual args
def config_class_defaults_to_Config(self):
ok_(Program().config_class is Config)
