def _call_objs(self, contextualized):
# Setup
pre_body, post_body = Mock(), Mock()
t1 = Task(pre_body, contextualized=contextualized)
t2 = Task(post_body, contextualized=contextualized)
t3 = Task(
Mock(),
pre=[call(t1, 5, foo='bar')],
post=[call(t2, 7, biz='baz')],
)
c = Collection(t1=t1, t2=t2, t3=t3)
e = Executor(collection=c)
e.execute('t3')
# Pre-task asserts
args, kwargs = pre_body.call_args
eq_(kwargs, {'foo': 'bar'})
if contextualized:
assert isinstance(args[0], Context)
eq_(args[1], 5)
else:
eq_(args, (5, ))
# Post-task asserts
args, kwargs = post_body.call_args
eq_(kwargs, {'biz': 'baz'})
if contextualized:
assert isinstance(args[0], Context)
eq_(args[1], 7)
else:
eq_(args, (7, ))
def calls_default_to_empty_args_always(self):
pre_body, post_body = Mock(), Mock()
t1 = Task(pre_body)
t2 = Task(post_body)
t3 = Task(Mock(), pre=[t1], post=[t2])
e = Executor(collection=Collection(t1=t1, t2=t2, t3=t3))
e.execute(('t3', {'something': 'meh'}))
for body in (pre_body, post_body):
eq_(body.call_args, tuple())
def setup(self):
self.task1 = Task(Mock(return_value=7))
self.task2 = Task(Mock(return_value=10), pre=['task1'])
self.task3 = Task(Mock(), pre=['task1'])
coll = Collection()
coll.add_task(self.task1, name='task1')
coll.add_task(self.task2, name='task2')
coll.add_task(self.task3, name='task3')
self.executor = Executor(collection=coll, context=Context())
def deduping_treats_different_calls_to_same_task_differently(self):
body = Mock()
t1 = Task(body)
pre = [call(t1, 5), call(t1, 7), call(t1, 5)]
t2 = Task(Mock(), pre=pre)
c = Collection(t1=t1, t2=t2)
e = Executor(collection=c)
e.execute('t2')
# Does not call the second t1(5)
body.assert_has_calls([mock_call(5), mock_call(7)])
def raises_ValueError_on_multiple_defaults(self):
t1 = Task(_func, default=True)
t2 = Task(_func, default=True)
self.c.add_task(t1, "foo")
with raises(
ValueError,
match=
r"'bar' cannot be the default because 'foo' already is!",
):
self.c.add_task(t2, "bar")
def setup(self):
s = super(Executor_, self)
s.setup()
self.task1 = Task(Mock(return_value=7))
self.task2 = Task(Mock(return_value=10), pre=[self.task1])
self.task3 = Task(Mock(), pre=[self.task1])
self.task4 = Task(Mock(return_value=15), post=[self.task1])
coll = Collection()
coll.add_task(self.task1, name='task1')
coll.add_task(self.task2, name='task2')
coll.add_task(self.task3, name='task3')
coll.add_task(self.task4, name='task4')
self.executor = Executor(collection=coll)
def modifications_on_clone_do_not_alter_original(self):
# Setup
orig = Call(self.task,
called_as='foo',
args=[1, 2, 3],
kwargs={'key': 'val'})
context = Context()
context['setting'] = 'value'
orig.context = context
# Clone & tweak
clone = orig.clone()
newtask = Task(Mock(__name__='meh'))
clone.task = newtask
clone.called_as = 'notfoo'
clone.args[0] = 7
clone.kwargs['key'] = 'notval'
clone.context['setting'] = 'notvalue'
# Compare
ok_(clone.task is not orig.task)
eq_(orig.called_as, 'foo')
eq_(clone.called_as, 'notfoo')
eq_(orig.args, [1, 2, 3])
eq_(clone.args, [7, 2, 3])
eq_(orig.kwargs['key'], 'val')
eq_(clone.kwargs['key'], 'notval')
eq_(orig.context['setting'], 'value')
eq_(clone.context['setting'], 'notvalue')
def raises_ValueError_if_no_name_found(self):
# Can't use a lambda here as they are technically real functions.
class Callable(object):
def __call__(self):
pass
self.c.add_task(Task(Callable()))
def sibling_subcollections_ignored(self):
inner = Collection('inner', self.task)
inner.configure({'foo': 'hi there'})
inner2 = Collection('inner2', Task(_func, name='task2'))
inner2.configure({'foo': 'nope'})
root = Collection(inner, inner2)
eq_(root.configuration('inner.task')['foo'], 'hi there')
eq_(root.configuration('inner2.task2')['foo'], 'nope')
def sibling_subcollections_ignored(self):
inner = Collection("inner", self.task)
inner.configure({"foo": "hi there"})
inner2 = Collection("inner2", Task(_func, name="task2"))
inner2.configure({"foo": "nope"})
root = Collection(inner, inner2)
assert root.configuration("inner.task")["foo"] == "hi there"
assert root.configuration("inner2.task2")["foo"] == "nope"
def default_tasks_called_when_no_tasks_specified(self):
# NOTE: when no tasks AND no default, Program will print global
# help. We just won't do anything at all, which is fine for now.
task = Task(Mock('default-task'))
coll = Collection()
coll.add_task(task, name='mytask', default=True)
executor = Executor(collection=coll)
executor.execute()
task.body.assert_called_with()
def name_defaults_to_body_name(self):
eq_(Task(_func).name, '_func')
def has_default_flag(self):
eq_(Task(_func).is_default, False)
def equality_testing(self):
t1 = Task(_func, name='foo')
t2 = Task(_func, name='foo')
eq_(t1, t2)
t3 = Task(_func, name='bar')
assert t1 != t3
def has_useful_repr(self):
i = repr(Task(_func))
assert '_func' in i, "'func' not found in {0!r}".format(i)
e = repr(Task(_func, name='funky'))
assert 'funky' in e, "'funky' not found in {0!r}".format(e)
assert '_func' not in e, "'_func' unexpectedly seen in {0!r}".format(e)
def prefers_name_kwarg_over_task_name_attr(self):
self.c.add_task(Task(_func, name="notfunc"), name="yesfunc")
assert "yesfunc" in self.c
assert "notfunc" not in self.c
def prefers_task_name_attr_over_function_name(self):
self.c.add_task(Task(_func, name="notfunc"))
assert "notfunc" in self.c
assert "_func" not in self.c
def honors_aliases_in_own_tasks(self):
task = Task(_func, aliases=["bar"])
self.c.add_task(task, "foo")
assert self.c["bar"] is task
def has_contextualized_flag(self):
eq_(Task(_func).contextualized, False)
def honors_aliases_in_own_tasks(self):
t = Task(_func, aliases=['bar'])
self.c.add_task(t, 'foo')
eq_(self.c['bar'], t)
def honors_own_default_task_with_no_args(self):
task = Task(_func, default=True)
self.c.add_task(task)
assert self.c[""] is task
def prefers_task_name_attr_over_function_name(self):
self.c.add_task(Task(_func, name='notfunc'))
assert 'notfunc' in self.c
assert '_func' not in self.c
def prefers_name_kwarg_over_task_name_attr(self):
self.c.add_task(Task(_func, name='notfunc'), name='yesfunc')
assert 'yesfunc' in self.c
assert 'notfunc' not in self.c
def can_override_name(self):
eq_(Task(_func, name='foo').name, 'foo')
def setup(self):
self.task = Task(Mock(__name__='mytask'))
def honors_own_default_subcollection(self):
task = Task(_func, default=True)
sub = Collection("sub")
sub.add_task(task, default=True)
self.c.add_collection(sub, default=True)
assert self.c[""] is task
def raises_ValueError_on_multiple_defaults(self):
t1 = Task(_func, default=True)
t2 = Task(_func, default=True)
self.c.add_task(t1, 'foo')
self.c.add_task(t2, 'bar')
def setup(self):
self.root = Collection()
self.task = Task(_func, name='task')
def honors_own_default_task_with_no_args(self):
t = Task(_func, default=True)
self.c.add_task(t)
eq_(self.c[''], t)
def raises_ValueError_on_multiple_defaults(self):
t1 = Task(_func, default=True)
t2 = Task(_func, default=True)
self.c.add_task(t1, "foo")
with raises(ValueError):
self.c.add_task(t2, "bar")