def test_including_and_excluding(self):
class MyTaskSet(TaskSet):
@task
def not_included_or_excluded(self):
pass
@tag('included')
@task
def included(self):
pass
@tag('excluded')
@task
def excluded(self):
pass
@tag('included', 'excluded')
@task
def included_and_excluded(self):
pass
filter_tasks_by_tags(MyTaskSet,
tags=set(['included']),
exclude_tags=set(['excluded']))
self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.included])
def test_tagged_tasks_shared_across_tasksets(self):
@tag('tagged')
def shared_task():
pass
def untagged_shared_task():
pass
@tag('tagged')
class SharedTaskSet(TaskSet):
@task
def inner_task(self):
pass
class IncludeTaskSet(TaskSet):
tasks = [shared_task, untagged_shared_task, SharedTaskSet]
class ExcludeTaskSet(TaskSet):
tasks = [shared_task, untagged_shared_task, SharedTaskSet]
filter_tasks_by_tags(IncludeTaskSet, tags=set(['tagged']))
self.assertListEqual(IncludeTaskSet.tasks,
[shared_task, SharedTaskSet])
self.assertListEqual(IncludeTaskSet.tasks[1].tasks,
[SharedTaskSet.inner_task])
filter_tasks_by_tags(ExcludeTaskSet, exclude_tags=set(['tagged']))
self.assertListEqual(ExcludeTaskSet.tasks, [untagged_shared_task])
def test_including_tasksets(self):
class MyTaskSet(TaskSet):
@task
class MixedNestedTaskSet(TaskSet):
@tag('included')
@task
def included(self):
pass
@task
def not_included(self):
pass
@tag('included')
@task
class TaggedNestedTaskSet(TaskSet):
@task
def included(self):
pass
@task
class NormalNestedTaskSet(TaskSet):
@task
def not_included(self):
pass
filter_tasks_by_tags(MyTaskSet, tags=set(['included']))
self.assertListEqual(
MyTaskSet.tasks,
[MyTaskSet.MixedNestedTaskSet, MyTaskSet.TaggedNestedTaskSet])
self.assertListEqual(MyTaskSet.MixedNestedTaskSet.tasks,
[MyTaskSet.MixedNestedTaskSet.included])
def test_including_tags(self):
class MyTaskSet(TaskSet):
@tag("include this", "other tag")
@task
def included(self):
pass
@tag("dont include this", "other tag")
@task
def not_included(self):
pass
@task
def dont_include_this_either(self):
pass
self.assertListEqual(
MyTaskSet.tasks,
[
MyTaskSet.included,
MyTaskSet.not_included,
MyTaskSet.dont_include_this_either,
],
)
filter_tasks_by_tags(MyTaskSet, tags=set(["include this"]))
self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.included])
def test_excluding_tags(self):
class MyTaskSet(TaskSet):
@tag('exclude this', 'other tag')
@task
def excluded(self):
pass
@tag('dont exclude this', 'other tag')
@task
def not_excluded(self):
pass
@task
def dont_exclude_this_either(self):
pass
self.assertListEqual(MyTaskSet.tasks, [
MyTaskSet.excluded, MyTaskSet.not_excluded,
MyTaskSet.dont_exclude_this_either
])
filter_tasks_by_tags(MyTaskSet, exclude_tags=set(['exclude this']))
self.assertListEqual(
MyTaskSet.tasks,
[MyTaskSet.not_excluded, MyTaskSet.dont_exclude_this_either])
def test_including_and_excluding(self):
class MyTaskSet(TaskSet):
@task
def not_included_or_excluded(self):
pass
@tag("included")
@task
def included(self):
pass
@tag("excluded")
@task
def excluded(self):
pass
@tag("included", "excluded")
@task
def included_and_excluded(self):
pass
filter_tasks_by_tags(MyTaskSet,
tags={"included"},
exclude_tags={"excluded"})
self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.included])
def test_excluding_tags(self):
class MyTaskSet(TaskSet):
@tag("exclude this", "other tag")
@task
def excluded(self):
pass
@tag("dont exclude this", "other tag")
@task
def not_excluded(self):
pass
@task
def dont_exclude_this_either(self):
pass
self.assertListEqual(MyTaskSet.tasks, [
MyTaskSet.excluded, MyTaskSet.not_excluded,
MyTaskSet.dont_exclude_this_either
])
filter_tasks_by_tags(MyTaskSet, exclude_tags={"exclude this"})
self.assertListEqual(
MyTaskSet.tasks,
[MyTaskSet.not_excluded, MyTaskSet.dont_exclude_this_either])
def test_excluding_tags_with_weights(self):
class MyTaskSet(TaskSet):
@tag("dont exclude this")
@task(2)
def dont_exclude_twice(self):
pass
@task(3)
def dont_exclude_3_times(self):
pass
@tag("excluded")
@task(4)
def exclude_4_times(self):
pass
@tag("excluded")
@task(5)
def exclude_5_times(self):
pass
self.assertListEqual(
MyTaskSet.tasks,
[
MyTaskSet.dont_exclude_twice,
MyTaskSet.dont_exclude_twice,
MyTaskSet.dont_exclude_3_times,
MyTaskSet.dont_exclude_3_times,
MyTaskSet.dont_exclude_3_times,
MyTaskSet.exclude_4_times,
MyTaskSet.exclude_4_times,
MyTaskSet.exclude_4_times,
MyTaskSet.exclude_4_times,
MyTaskSet.exclude_5_times,
MyTaskSet.exclude_5_times,
MyTaskSet.exclude_5_times,
MyTaskSet.exclude_5_times,
MyTaskSet.exclude_5_times,
],
)
filter_tasks_by_tags(MyTaskSet, exclude_tags=set(["excluded"]))
self.assertListEqual(
MyTaskSet.tasks,
[
MyTaskSet.dont_exclude_twice,
MyTaskSet.dont_exclude_twice,
MyTaskSet.dont_exclude_3_times,
MyTaskSet.dont_exclude_3_times,
MyTaskSet.dont_exclude_3_times,
],
)
def _filter_tasks_by_tags(self):
"""
Filter the tasks on all the user_classes recursively, according to the tags and
exclude_tags attributes
"""
if self.tags is not None:
self.tags = set(self.tags)
if self.exclude_tags is not None:
self.exclude_tags = set(self.exclude_tags)
for user_class in self.user_classes:
filter_tasks_by_tags(user_class, self.tags, self.exclude_tags)
def test_include_tags_under_user(self):
class MyUser(User):
@tag('include this')
@task
def included(self):
pass
@tag('dont include this')
@task
def not_included(self):
pass
@task
def dont_include_this_either(self):
pass
filter_tasks_by_tags(MyUser, tags=set(['include this']))
self.assertListEqual(MyUser.tasks, [MyUser.included])
def test_excluding_tasksets(self):
class MyTaskSet(TaskSet):
@task
class MixedNestedTaskSet(TaskSet):
@tag("excluded")
@task
def excluded(self):
pass
@task
def not_excluded(self):
pass
@task
class ExcludedNestedTaskSet(TaskSet):
@tag("excluded")
@task
def excluded(self):
pass
@tag("excluded")
@task
class TaggedNestedTaskSet(TaskSet):
@task
def excluded(self):
pass
@task
class NormalNestedTaskSet(TaskSet):
@task
def not_excluded(self):
pass
filter_tasks_by_tags(MyTaskSet, exclude_tags=set(["excluded"]))
self.assertListEqual(
MyTaskSet.tasks,
[MyTaskSet.MixedNestedTaskSet, MyTaskSet.NormalNestedTaskSet],
)
self.assertListEqual(
MyTaskSet.MixedNestedTaskSet.tasks,
[MyTaskSet.MixedNestedTaskSet.not_excluded],
)
def test_exclude_tags_under_user(self):
class MyUser(User):
@tag('exclude this')
@task
def excluded(self):
pass
@tag('dont exclude this')
@task
def not_excluded(self):
pass
@task
def dont_exclude_this_either(self):
pass
filter_tasks_by_tags(MyUser, exclude_tags=set(['exclude this']))
self.assertListEqual(
MyUser.tasks,
[MyUser.not_excluded, MyUser.dont_exclude_this_either])
def test_including_tags_with_weights(self):
class MyTaskSet(TaskSet):
@tag('included')
@task(2)
def include_twice(self):
pass
@tag('included')
@task(3)
def include_3_times(self):
pass
@tag('dont include this')
@task(4)
def dont_include_4_times(self):
pass
@task(5)
def dont_include_5_times(self):
pass
self.assertListEqual(MyTaskSet.tasks, [
MyTaskSet.include_twice, MyTaskSet.include_twice,
MyTaskSet.include_3_times, MyTaskSet.include_3_times,
MyTaskSet.include_3_times, MyTaskSet.dont_include_4_times,
MyTaskSet.dont_include_4_times, MyTaskSet.dont_include_4_times,
MyTaskSet.dont_include_4_times, MyTaskSet.dont_include_5_times,
MyTaskSet.dont_include_5_times, MyTaskSet.dont_include_5_times,
MyTaskSet.dont_include_5_times, MyTaskSet.dont_include_5_times
])
filter_tasks_by_tags(MyTaskSet, tags=set(['included']))
self.assertListEqual(MyTaskSet.tasks, [
MyTaskSet.include_twice, MyTaskSet.include_twice,
MyTaskSet.include_3_times, MyTaskSet.include_3_times,
MyTaskSet.include_3_times
])
