def test_task_5(self):
from pybossa import data_access
owner = UserFactory.create(id=500)
user = UserFactory.create(id=501, info=dict(data_access=["L1"]))
patch_data_access_levels = dict(
valid_access_levels=["L1", "L2", "L3", "L4"],
valid_user_levels_for_project_level=dict(L1=[], L2=["L1"]),
valid_project_levels_for_user_level=dict(L1=["L2", "L3", "L4"],
L2=["L3", "L4"]),
)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner,
info=dict(project_users=[owner.id]))
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(3,
project=project,
n_answers=2,
info=dict(data_access=["L1"]))
tasks[0].info['data_access'] = ["L1"]
task_repo.save(tasks[0])
tasks[1].info['data_access'] = ["L1"]
task_repo.save(tasks[1])
tasks[2].info['data_access'] = ["L2"]
task_repo.save(tasks[2])
with patch.object(data_access, 'data_access_levels',
patch_data_access_levels):
assert n_available_tasks_for_user(project, 501) == 3
def test_n_available_tasks_for_user_no_tasks(self):
"""Test n_available_tasks_for_user returns 0 if the project has no tasks"""
project = ProjectFactory.create()
n_available_tasks = helpers.n_available_tasks_for_user(project,
user_id=1)
assert n_available_tasks == 0, n_available_tasks
def test_task_2(self):
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de', 'en']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'zh']}
task_repo.save(task)
assert n_available_tasks_for_user(project, 500) == 1
def test_n_available_tasks_for_user_completed_tasks(self):
"""Test n_available_tasks_for_user returns 0 for user if all the
tasks are completed"""
project = ProjectFactory.create()
task = TaskFactory.create(project=project, state='completed')
n_available_tasks = helpers.n_available_tasks_for_user(project,
user_id=1)
assert n_available_tasks == 0, n_available_tasks
def test_n_available_tasks_for_user_no_taskruns_tasks(self):
"""Test n_available_tasks_for_user returns 1 for user
if there are no taskruns"""
project = ProjectFactory.create()
task = TaskFactory.create(project=project)
n_available_tasks = helpers.n_available_tasks_for_user(project,
user_id=1)
assert n_available_tasks == 1, n_available_tasks
def test_n_available_tasks_some_task_answered_by_another_user(self):
"""Test n_available_tasks_for_user returns 1 for a user if another
user has submitted taskruns for the task but he hasn't"""
project = ProjectFactory.create()
task = TaskFactory.create(project=project)
user = UserFactory.create()
taskrun = TaskRunFactory.create(task=task)
n_available_tasks = helpers.n_available_tasks_for_user(project,
user_id=user.id)
assert n_available_tasks == 1, n_available_tasks
def test_n_available_tasks_for_user_some_tasks_answered_by_user(self):
"""Test n_available_tasks_for_user returns 1 for user if he has
submitted taskruns for one of the tasks but there is still another task"""
project = ProjectFactory.create()
answered_task = TaskFactory.create(project=project)
available_task = TaskFactory.create(project=project)
user = UserFactory.create()
taskrun = TaskRunFactory.create(task=answered_task, user=user)
n_available_tasks = helpers.n_available_tasks_for_user(project,
user_id=user.id)
assert n_available_tasks == 1, n_available_tasks
def user_progress(project_id=None, short_name=None):
"""API endpoint for user progress.
Return a JSON object with four fields regarding the tasks for the user:
{ 'done': 10,
'total: 100,
'remaining': 90,
'remaining_for_user': 45
}
This will mean that the user has done 10% of the available tasks for the
project, 90 tasks are yet to be submitted and the user can access 45 of
them based on user preferences.
"""
if current_user.is_anonymous:
return abort(401)
if project_id or short_name:
if short_name:
project = project_repo.get_by_shortname(short_name)
elif project_id:
project = project_repo.get(project_id)
if project:
# For now, keep this version, but wait until redis cache is
# used here for task_runs too
query_attrs = dict(project_id=project.id, user_id=current_user.id)
guidelines_updated = _guidelines_updated(project.id,
current_user.id)
taskrun_count = task_repo.count_task_runs_with(**query_attrs)
num_available_tasks = n_available_tasks(project.id,
include_gold_task=True)
num_available_tasks_for_user = n_available_tasks_for_user(
project, current_user.id)
response = dict(done=taskrun_count,
total=n_tasks(project.id),
completed=n_completed_tasks(project.id),
remaining=num_available_tasks,
locked=len({
task["task_id"]
for task in get_locked_tasks(project)
}),
remaining_for_user=num_available_tasks_for_user,
quiz=current_user.get_quiz_for_project(project),
guidelines_updated=guidelines_updated)
if current_user.admin or (current_user.subadmin and current_user.id
in project.owners_ids):
num_gold_tasks = n_unexpired_gold_tasks(project.id)
response['available_gold_tasks'] = num_gold_tasks
return Response(json.dumps(response), mimetype="application/json")
else:
return abort(404)
else: # pragma: no cover
return abort(404)
def test_task_1(self):
'''
Default user scheduler doesn't check user preference
'''
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.locked
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {'languages': ['en', 'zh']}
task_repo.save(task)
assert n_available_tasks_for_user(project, 500) == 1
def test_n_available_tasks_for_user_answered_by_you_tasks(self):
"""Test n_available_tasks_for_user returns 0 for user if he has
submitted taskruns for all the tasks"""
project = ProjectFactory.create()
task = TaskFactory.create(project=project, n_answers=2)
user = UserFactory.create()
taskrun = TaskRunFactory.create(task=task, user=user)
n_available_tasks = helpers.n_available_tasks_for_user(project,
user_id=user.id)
assert task.state != 'completed', task.state
assert n_available_tasks == 0, n_available_tasks
def test_task_routing_3(self):
'''
User has empty profile set, only tasks that have empty filter can be assigned to user
'''
user_info = dict(metadata={"profile": json.dumps({})})
owner = UserFactory.create(id=500, info=user_info)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
tasks[0].worker_filter = {'finance': [0.8, '>=']}
task_repo.save(tasks[0])
tasks[1].worker_filter = {'geography': [0.5, '>=']}
task_repo.save(tasks[1])
assert n_available_tasks_for_user(project, 500) == 1
def test_task_4(self):
'''
Tasks match user profile
'''
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de', 'en']}
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(2, project=project, n_answers=10)
tasks[0].user_pref = {'languages': ['en', 'zh']}
task_repo.save(tasks[0])
tasks[1].user_pref = {'languages': ['de']}
task_repo.save(tasks[1])
assert n_available_tasks_for_user(project, 500) == 2
def test_task_6(self):
'''
Task is assigned to a user whose profile doesn't match task preference
'''
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de', 'en']}
owner.email_addr = '*****@*****.**'
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
task.user_pref = {
'languages': ['ch', 'zh'],
'assign_user': ['*****@*****.**']
}
task_repo.save(task)
assert n_available_tasks_for_user(project, 500) == 0
def user_progress(project_id=None, short_name=None):
"""API endpoint for user progress.
Return a JSON object with four fields regarding the tasks for the user:
{ 'done': 10,
'total: 100,
'remaining': 90,
'remaining_for_user': 45
}
This will mean that the user has done 10% of the available tasks for the
project, 90 tasks are yet to be submitted and the user can access 45 of
them based on user preferences.
"""
if current_user.is_anonymous:
return abort(401)
if project_id or short_name:
if short_name:
project = project_repo.get_by_shortname(short_name)
elif project_id:
project = project_repo.get(project_id)
if project:
# For now, keep this version, but wait until redis cache is
# used here for task_runs too
query_attrs = dict(project_id=project.id)
query_attrs['user_id'] = current_user.id
taskrun_count = task_repo.count_task_runs_with(**query_attrs)
num_available_tasks = n_available_tasks(project.id,
current_user.id)
num_available_tasks_for_user = n_available_tasks_for_user(
project, current_user.id)
response = dict(done=taskrun_count,
total=n_tasks(project.id),
remaining=num_available_tasks,
remaining_for_user=num_available_tasks_for_user,
quiz=current_user.get_quiz_for_project(project))
return Response(json.dumps(response), mimetype="application/json")
else:
return abort(404)
else: # pragma: no cover
return abort(404)
def test_task_7(self):
'''
task[0]: doesn't have any language/country preference, should be able to
assign to the user.
task[1]: both preference and email match, should be able to assign to the user
'''
owner = UserFactory.create(id=500)
owner.user_pref = {'languages': ['de', 'en']}
owner.email_addr = '*****@*****.**'
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
tasks[0].user_pref = {'assign_user': ['*****@*****.**']}
task_repo.save(tasks[0])
tasks[1].user_pref = {
'languages': ['de'],
'assign_user': ['*****@*****.**']
}
task_repo.save(tasks[1])
assert n_available_tasks_for_user(project, 500) == 2
def test_task_routing_2(self):
'''
task[0]: needs finance skill at least 0.8, should not be able to assign to the user
task[1]: needs geography skill at least 0.5, should not be able to assign to the user
task[3]: doesnt have filters, should be able to assign to the user
'''
user_info = dict(
metadata={
"profile": json.dumps({
"finance": 0.6,
"marketing": 0.4
})
})
owner = UserFactory.create(id=500, info=user_info)
user_repo.save(owner)
project = ProjectFactory.create(owner=owner)
project.info['sched'] = Schedulers.user_pref
tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
tasks[0].worker_filter = {'finance': [0.8, '>=']}
task_repo.save(tasks[0])
tasks[1].worker_filter = {'geography': [0.5, '>=']}
task_repo.save(tasks[1])
assert n_available_tasks_for_user(project, 500) == 1
