class TestTaskRepositorySaveDeleteUpdate(Test):
def setUp(self):
super(TestTaskRepositorySaveDeleteUpdate, self).setUp()
self.task_repo = TaskRepository(db)
def test_save_saves_tasks(self):
"""Test save persists Task instances"""
task = TaskFactory.build()
assert self.task_repo.get_task(task.id) is None
self.task_repo.save(task)
assert self.task_repo.get_task(task.id) == task, "Task not saved"
def test_save_saves_taskruns(self):
"""Test save persists TaskRun instances"""
taskrun = TaskRunFactory.build()
assert self.task_repo.get_task_run(taskrun.id) is None
self.task_repo.save(taskrun)
assert self.task_repo.get_task_run(
taskrun.id) == taskrun, "TaskRun not saved"
def test_save_fails_if_integrity_error(self):
"""Test save raises a DBIntegrityError if the instance to be saved lacks
a required value"""
task = TaskFactory.build(project_id=None, project=None)
assert_raises(DBIntegrityError, self.task_repo.save, task)
def test_save_only_saves_tasks_and_taskruns(self):
"""Test save raises a WrongObjectError when an object which is neither
a Task nor a Taskrun instance is saved"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.save, bad_object)
def test_update_task(self):
"""Test update persists the changes made to Task instances"""
task = TaskFactory.create(state='ongoing')
task.state = 'done'
self.task_repo.update(task)
updated_task = self.task_repo.get_task(task.id)
assert updated_task.state == 'done', updated_task
def test_update_taskrun(self):
"""Test update persists the changes made to TaskRun instances"""
taskrun = TaskRunFactory.create(info='info')
taskrun.info = 'updated info!'
self.task_repo.update(taskrun)
updated_taskrun = self.task_repo.get_task_run(taskrun.id)
assert updated_taskrun.info == 'updated info!', updated_taskrun
def test_update_fails_if_integrity_error(self):
"""Test update raises a DBIntegrityError if the instance to be updated
lacks a required value"""
task = TaskFactory.create()
task.project_id = None
assert_raises(DBIntegrityError, self.task_repo.update, task)
def test_update_only_updates_tasks_and_taskruns(self):
"""Test update raises a WrongObjectError when an object which is neither
a Task nor a TaskRun instance is updated"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.update, bad_object)
def test_delete_task(self):
"""Test delete removes the Task instance"""
task = TaskFactory.create()
self.task_repo.delete(task)
deleted = self.task_repo.get_task(task.id)
assert deleted is None, deleted
def test_delete_task_deletes_dependent_taskruns(self):
"""Test delete removes the dependent TaskRun instances"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete(task)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_taskrun(self):
"""Test delete removes the TaskRun instance"""
taskrun = TaskRunFactory.create()
self.task_repo.delete(taskrun)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_only_deletes_tasks(self):
"""Test delete raises a WrongObjectError if is requested to delete other
than a task"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.delete, bad_object)
def test_delete_all_deletes_many_tasks(self):
"""Test delete_all deletes many tasks at once"""
tasks = TaskFactory.create_batch(2)
self.task_repo.delete_all(tasks)
for task in tasks:
assert self.task_repo.get_task(task.id) is None, task
def test_delete_all_deletes_dependent(self):
"""Test delete_all deletes dependent taskruns too"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete_all([task])
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_all_deletes_many_taskruns(self):
"""Test delete_all deletes many taskruns at once"""
taskruns = TaskRunFactory.create_batch(2)
self.task_repo.delete_all(taskruns)
for taskrun in taskruns:
assert self.task_repo.get_task_run(taskrun.id) is None, taskrun
def test_delete_all_raises_error_if_no_task(self):
"""Test delete_all raises a WrongObjectError if is requested to delete
any other object than a task"""
bad_objects = [dict(), 'string']
assert_raises(WrongObjectError, self.task_repo.delete_all, bad_objects)
def test_update_tasks_redundancy_changes_all_project_tasks_redundancy(
self):
"""Test update_tasks_redundancy updates the n_answers value for every
task in the project"""
project = ProjectFactory.create()
TaskFactory.create_batch(2, project=project, n_answers=1)
self.task_repo.update_tasks_redundancy(project, 2)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.n_answers == 2, task.n_answers
def test_update_tasks_redundancy_updates_state_when_incrementing(self):
"""Test update_tasks_redundancy changes 'completed' tasks to 'ongoing'
if n_answers is incremented enough"""
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, project=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 3)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.state == 'ongoing', task.state
def test_update_tasks_redundancy_updates_state_when_decrementing(self):
"""Test update_tasks_redundancy changes 'ongoing' tasks to 'completed'
if n_answers is decremented enough"""
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, project=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
TaskRunFactory.create(task=tasks[1])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 1)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.state == 'completed', task.state
class TestTaskRepositorySaveDeleteUpdate(Test):
def setUp(self):
super(TestTaskRepositorySaveDeleteUpdate, self).setUp()
self.task_repo = TaskRepository(db)
@with_context
def test_save_saves_tasks(self):
"""Test save persists Task instances"""
task = TaskFactory.build()
assert self.task_repo.get_task(task.id) is None
self.task_repo.save(task)
assert self.task_repo.get_task(task.id) == task, "Task not saved"
@with_context
def test_save_saves_taskruns(self):
"""Test save persists TaskRun instances"""
taskrun = TaskRunFactory.build()
assert self.task_repo.get_task_run(taskrun.id) is None
self.task_repo.save(taskrun)
assert self.task_repo.get_task_run(taskrun.id) == taskrun, "TaskRun not saved"
@with_context
def test_save_fails_if_integrity_error(self):
"""Test save raises a DBIntegrityError if the instance to be saved lacks
a required value"""
task = TaskFactory.build(project_id=None, project=None)
assert_raises(DBIntegrityError, self.task_repo.save, task)
@with_context
def test_save_only_saves_tasks_and_taskruns(self):
"""Test save raises a WrongObjectError when an object which is neither
a Task nor a Taskrun instance is saved"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.save, bad_object)
@with_context
def test_update_task(self):
"""Test update persists the changes made to Task instances"""
task = TaskFactory.create(state='ongoing')
task.state = 'done'
self.task_repo.update(task)
updated_task = self.task_repo.get_task(task.id)
assert updated_task.state == 'done', updated_task
@with_context
def test_update_taskrun(self):
"""Test update persists the changes made to TaskRun instances"""
taskrun = TaskRunFactory.create(info='info')
taskrun.info = 'updated info!'
self.task_repo.update(taskrun)
updated_taskrun = self.task_repo.get_task_run(taskrun.id)
assert updated_taskrun.info == 'updated info!', updated_taskrun
@with_context
def test_update_fails_if_integrity_error(self):
"""Test update raises a DBIntegrityError if the instance to be updated
lacks a required value"""
task = TaskFactory.create()
task.project_id = None
assert_raises(DBIntegrityError, self.task_repo.update, task)
@with_context
def test_update_only_updates_tasks_and_taskruns(self):
"""Test update raises a WrongObjectError when an object which is neither
a Task nor a TaskRun instance is updated"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.update, bad_object)
@with_context
def test_delete_task(self):
"""Test delete removes the Task instance"""
task = TaskFactory.create()
self.task_repo.delete(task)
deleted = self.task_repo.get_task(task.id)
assert deleted is None, deleted
@with_context
def test_delete_task_deletes_dependent_taskruns(self):
"""Test delete removes the dependent TaskRun instances"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete(task)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
@with_context
def test_delete_taskrun(self):
"""Test delete removes the TaskRun instance"""
taskrun = TaskRunFactory.create()
self.task_repo.delete(taskrun)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
@with_context
def test_delete_only_deletes_tasks(self):
"""Test delete raises a WrongObjectError if is requested to delete other
than a task"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.delete, bad_object)
@with_context
def test_delete_valid_from_project_deletes_many_tasks(self):
"""Test delete_valid_from_project deletes many tasks at once"""
tasks = TaskFactory.create_batch(2)
project = project_repo.get(tasks[0].project_id)
self.task_repo.delete_valid_from_project(project)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
assert len(tasks) == 0, len(tasks)
@with_context
def test_delete_valid_from_project_deletes_dependent(self):
"""Test delete_valid_from_project deletes dependent taskruns too"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
task_run_id = taskrun.id
project = project_repo.get(task.project_id)
self.task_repo.delete_valid_from_project(project)
deleted = self.task_repo.get_task_run(id=task_run_id)
assert deleted is None, deleted
@with_context
def test_delete_valid_from_project_deletes_dependent_without_result(self):
"""Test delete_valid_from_project deletes dependent taskruns without result"""
task = TaskFactory.create(n_answers=1)
project = project_repo.get(task.project_id)
taskrun = TaskRunFactory.create(task=task)
task2 = TaskFactory.create(project=project)
TaskRunFactory.create(task=task2)
self.task_repo.delete_valid_from_project(project)
non_deleted = self.task_repo.filter_tasks_by(project_id=project.id)
err_msg = "There should be one task, as it belongs to a result"
assert len(non_deleted) == 1, err_msg
assert non_deleted[0].id == task.id, err_msg
non_deleted = self.task_repo.filter_task_runs_by(project_id=project.id)
err_msg = "There should be one task_run, as it belongs to a result"
assert len(non_deleted) == 1, err_msg
assert non_deleted[0].id == taskrun.id, err_msg
@with_context
def test_delete_taskruns_from_project_deletes_taskruns(self):
task = TaskFactory.create()
project = project_repo.get(task.project_id)
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete_taskruns_from_project(project)
taskruns = self.task_repo.filter_task_runs_by(project_id=project.id)
assert taskruns == [], taskruns
@with_context
def test_update_tasks_redundancy_changes_all_project_tasks_redundancy(self):
"""Test update_tasks_redundancy updates the n_answers value for every
task in the project"""
project = ProjectFactory.create()
TaskFactory.create_batch(2, project=project, n_answers=1)
self.task_repo.update_tasks_redundancy(project, 2)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.n_answers == 2, task.n_answers
@with_context
def test_update_tasks_redundancy_updates_state_when_incrementing(self):
"""Test update_tasks_redundancy changes 'completed' tasks to 'ongoing'
if n_answers is incremented enough"""
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, project=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 3)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.state == 'ongoing', task.state
@with_context
def test_update_tasks_redundancy_updates_state_when_decrementing(self):
"""Test update_tasks_redundancy changes 'ongoing' tasks to 'completed'
if n_answers is decremented enough"""
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, project=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
TaskRunFactory.create(task=tasks[1])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 1)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.state == 'completed', task.state
class TestTaskRepositorySaveDeleteUpdate(Test):
def setUp(self):
super(TestTaskRepositorySaveDeleteUpdate, self).setUp()
self.task_repo = TaskRepository(db)
def test_save_saves_tasks(self):
"""Test save persists Task instances"""
task = TaskFactory.build()
assert self.task_repo.get_task(task.id) is None
self.task_repo.save(task)
assert self.task_repo.get_task(task.id) == task, "Task not saved"
def test_save_saves_taskruns(self):
"""Test save persists TaskRun instances"""
taskrun = TaskRunFactory.build()
assert self.task_repo.get_task_run(taskrun.id) is None
self.task_repo.save(taskrun)
assert self.task_repo.get_task_run(taskrun.id) == taskrun, "TaskRun not saved"
def test_save_fails_if_integrity_error(self):
"""Test save raises a DBIntegrityError if the instance to be saved lacks
a required value"""
task = TaskFactory.build(project_id=None, project=None)
assert_raises(DBIntegrityError, self.task_repo.save, task)
def test_save_only_saves_tasks_and_taskruns(self):
"""Test save raises a WrongObjectError when an object which is neither
a Task nor a Taskrun instance is saved"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.save, bad_object)
def test_update_task(self):
"""Test update persists the changes made to Task instances"""
task = TaskFactory.create(state='ongoing')
task.state = 'done'
self.task_repo.update(task)
updated_task = self.task_repo.get_task(task.id)
assert updated_task.state == 'done', updated_task
def test_update_taskrun(self):
"""Test update persists the changes made to TaskRun instances"""
taskrun = TaskRunFactory.create(info='info')
taskrun.info = 'updated info!'
self.task_repo.update(taskrun)
updated_taskrun = self.task_repo.get_task_run(taskrun.id)
assert updated_taskrun.info == 'updated info!', updated_taskrun
def test_update_fails_if_integrity_error(self):
"""Test update raises a DBIntegrityError if the instance to be updated
lacks a required value"""
task = TaskFactory.create()
task.project_id = None
assert_raises(DBIntegrityError, self.task_repo.update, task)
def test_update_only_updates_tasks_and_taskruns(self):
"""Test update raises a WrongObjectError when an object which is neither
a Task nor a TaskRun instance is updated"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.update, bad_object)
def test_delete_task(self):
"""Test delete removes the Task instance"""
task = TaskFactory.create()
self.task_repo.delete(task)
deleted = self.task_repo.get_task(task.id)
assert deleted is None, deleted
def test_delete_task_deletes_dependent_taskruns(self):
"""Test delete removes the dependent TaskRun instances"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete(task)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_taskrun(self):
"""Test delete removes the TaskRun instance"""
taskrun = TaskRunFactory.create()
self.task_repo.delete(taskrun)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_only_deletes_tasks(self):
"""Test delete raises a WrongObjectError if is requested to delete other
than a task"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.delete, bad_object)
def test_delete_valid_from_project_deletes_many_tasks(self):
"""Test delete_valid_from_project deletes many tasks at once"""
tasks = TaskFactory.create_batch(2)
project = project_repo.get(tasks[0].project_id)
self.task_repo.delete_valid_from_project(project)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
assert len(tasks) == 0, len(tasks)
def test_delete_valid_from_project_deletes_dependent(self):
"""Test delete_valid_from_project deletes dependent taskruns too"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
task_run_id = taskrun.id
project = project_repo.get(task.project_id)
self.task_repo.delete_valid_from_project(project)
deleted = self.task_repo.get_task_run(id=task_run_id)
assert deleted is None, deleted
def test_delete_valid_from_project_deletes_dependent_without_result(self):
"""Test delete_valid_from_project deletes dependent taskruns without result"""
task = TaskFactory.create(n_answers=1)
project = project_repo.get(task.project_id)
taskrun = TaskRunFactory.create(task=task)
task2 = TaskFactory.create(project=project)
TaskRunFactory.create(task=task2)
self.task_repo.delete_valid_from_project(project)
non_deleted = self.task_repo.filter_tasks_by(project_id=project.id)
err_msg = "There should be one task, as it belongs to a result"
assert len(non_deleted) == 1, err_msg
assert non_deleted[0].id == task.id, err_msg
non_deleted = self.task_repo.filter_task_runs_by(project_id=project.id)
err_msg = "There should be one task_run, as it belongs to a result"
assert len(non_deleted) == 1, err_msg
assert non_deleted[0].id == taskrun.id, err_msg
def test_delete_taskruns_from_project_deletes_taskruns(self):
task = TaskFactory.create()
project = project_repo.get(task.project_id)
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete_taskruns_from_project(project)
taskruns = self.task_repo.filter_task_runs_by(project_id=project.id)
assert taskruns == [], taskruns
def test_update_tasks_redundancy_changes_all_project_tasks_redundancy(self):
"""Test update_tasks_redundancy updates the n_answers value for every
task in the project"""
project = ProjectFactory.create()
TaskFactory.create_batch(2, project=project, n_answers=1)
self.task_repo.update_tasks_redundancy(project, 2)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.n_answers == 2, task.n_answers
def test_update_tasks_redundancy_updates_state_when_incrementing(self):
"""Test update_tasks_redundancy changes 'completed' tasks to 'ongoing'
if n_answers is incremented enough"""
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, project=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 3)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.state == 'ongoing', task.state
def test_update_tasks_redundancy_updates_state_when_decrementing(self):
"""Test update_tasks_redundancy changes 'ongoing' tasks to 'completed'
if n_answers is decremented enough"""
project = ProjectFactory.create()
tasks = TaskFactory.create_batch(2, project=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
TaskRunFactory.create(task=tasks[1])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 1)
tasks = self.task_repo.filter_tasks_by(project_id=project.id)
for task in tasks:
assert task.state == 'completed', task.state
class TestTaskRepositorySaveDeleteUpdate(Test):
def setUp(self):
super(TestTaskRepositorySaveDeleteUpdate, self).setUp()
self.task_repo = TaskRepository(db)
def test_save_saves_tasks(self):
"""Test save persists Task instances"""
task = TaskFactory.build()
assert self.task_repo.get_task(task.id) is None
self.task_repo.save(task)
assert self.task_repo.get_task(task.id) == task, "Task not saved"
def test_save_saves_taskruns(self):
"""Test save persists TaskRun instances"""
taskrun = TaskRunFactory.build()
assert self.task_repo.get_task_run(taskrun.id) is None
self.task_repo.save(taskrun)
assert self.task_repo.get_task_run(taskrun.id) == taskrun, "TaskRun not saved"
def test_save_fails_if_integrity_error(self):
"""Test save raises a DBIntegrityError if the instance to be saved lacks
a required value"""
task = TaskFactory.build(app_id=None, app=None)
assert_raises(DBIntegrityError, self.task_repo.save, task)
def test_save_only_saves_tasks_and_taskruns(self):
"""Test save raises a WrongObjectError when an object which is neither
a Task nor a Taskrun instance is saved"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.save, bad_object)
def test_update_task(self):
"""Test update persists the changes made to Task instances"""
task = TaskFactory.create(state='ongoing')
task.state = 'done'
self.task_repo.update(task)
updated_task = self.task_repo.get_task(task.id)
assert updated_task.state == 'done', updated_task
def test_update_taskrun(self):
"""Test update persists the changes made to TaskRun instances"""
taskrun = TaskRunFactory.create(info='info')
taskrun.info = 'updated info!'
self.task_repo.update(taskrun)
updated_taskrun = self.task_repo.get_task_run(taskrun.id)
assert updated_taskrun.info == 'updated info!', updated_taskrun
def test_update_fails_if_integrity_error(self):
"""Test update raises a DBIntegrityError if the instance to be updated
lacks a required value"""
task = TaskFactory.create()
task.app_id = None
assert_raises(DBIntegrityError, self.task_repo.update, task)
def test_update_only_updates_tasks_and_taskruns(self):
"""Test update raises a WrongObjectError when an object which is neither
a Task nor a TaskRun instance is updated"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.update, bad_object)
def test_delete_task(self):
"""Test delete removes the Task instance"""
task = TaskFactory.create()
self.task_repo.delete(task)
deleted = self.task_repo.get_task(task.id)
assert deleted is None, deleted
def test_delete_task_deletes_dependent_taskruns(self):
"""Test delete removes the dependent TaskRun instances"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete(task)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_taskrun(self):
"""Test delete removes the TaskRun instance"""
taskrun = TaskRunFactory.create()
self.task_repo.delete(taskrun)
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_only_deletes_tasks(self):
"""Test delete raises a WrongObjectError if is requested to delete other
than a task"""
bad_object = dict()
assert_raises(WrongObjectError, self.task_repo.delete, bad_object)
def test_delete_all_deletes_many_tasks(self):
"""Test delete_all deletes many tasks at once"""
tasks = TaskFactory.create_batch(2)
self.task_repo.delete_all(tasks)
for task in tasks:
assert self.task_repo.get_task(task.id) is None, task
def test_delete_all_deletes_dependent(self):
"""Test delete_all deletes dependent taskruns too"""
task = TaskFactory.create()
taskrun = TaskRunFactory.create(task=task)
self.task_repo.delete_all([task])
deleted = self.task_repo.get_task_run(taskrun.id)
assert deleted is None, deleted
def test_delete_all_deletes_many_taskruns(self):
"""Test delete_all deletes many taskruns at once"""
taskruns = TaskRunFactory.create_batch(2)
self.task_repo.delete_all(taskruns)
for taskrun in taskruns:
assert self.task_repo.get_task_run(taskrun.id) is None, taskrun
def test_delete_all_raises_error_if_no_task(self):
"""Test delete_all raises a WrongObjectError if is requested to delete
any other object than a task"""
bad_objects = [dict(), 'string']
assert_raises(WrongObjectError, self.task_repo.delete_all, bad_objects)
def test_update_tasks_redundancy_changes_all_project_tasks_redundancy(self):
"""Test update_tasks_redundancy updates the n_answers value for every
task in the project"""
project = AppFactory.create()
TaskFactory.create_batch(2, app=project, n_answers=1)
self.task_repo.update_tasks_redundancy(project, 2)
tasks = self.task_repo.filter_tasks_by(app_id=project.id)
for task in tasks:
assert task.n_answers == 2, task.n_answers
def test_update_tasks_redundancy_updates_state_when_incrementing(self):
"""Test update_tasks_redundancy changes 'completed' tasks to 'ongoing'
if n_answers is incremented enough"""
project = AppFactory.create()
tasks = TaskFactory.create_batch(2, app=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 3)
tasks = self.task_repo.filter_tasks_by(app_id=project.id)
for task in tasks:
assert task.state == 'ongoing', task.state
def test_update_tasks_redundancy_updates_state_when_decrementing(self):
"""Test update_tasks_redundancy changes 'ongoing' tasks to 'completed'
if n_answers is decremented enough"""
project = AppFactory.create()
tasks = TaskFactory.create_batch(2, app=project, n_answers=2)
TaskRunFactory.create_batch(2, task=tasks[0])
TaskRunFactory.create(task=tasks[1])
tasks[0].state = 'completed'
self.task_repo.update(tasks[0])
assert tasks[0].state == 'completed', tasks[0].state
assert tasks[1].state == 'ongoing', tasks[1].state
self.task_repo.update_tasks_redundancy(project, 1)
tasks = self.task_repo.filter_tasks_by(app_id=project.id)
for task in tasks:
assert task.state == 'completed', task.state