def test_close_expired_task_attempts(self):
"""
The close_expired_task_attempts routine should close all
attempts for tasks that are no longer available,
set them as requiring notification,
and return the number that were closed.
"""
task_no_expire = TaskFactory.create()
task = TaskFactory.create(end_date=timezone.now() + timedelta(days=1))
future_date = timezone.now() + timedelta(days=2)
user1, user2, user3 = UserFactory.create_batch(3)
TaskAttemptFactory.create(
user=user1,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(
user=user2,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(
user=user3,
state=TaskAttempt.STARTED,
task=task_no_expire)
eq_(task.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 2)
eq_(task_no_expire.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 1)
with patch('oneanddone.tasks.models.timezone.now') as now:
now.return_value = future_date
eq_(TaskAttempt.close_expired_task_attempts(), 2)
eq_(TaskAttempt.objects.filter(task=task,
state=TaskAttempt.STARTED).count(), 0)
eq_(TaskAttempt.objects.filter(task=task,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
eq_(TaskAttempt.objects.filter(task=task_no_expire,
state=TaskAttempt.STARTED).count(), 1)
def test_num_fresh_bugs_with_small_stale_query(self):
"""
Given a query that returns n < max_batch_size results, the
number of fresh bugs in the form's cleaned data is equal to 0,
if the query has been submitted before
"""
max_batch_size = 20
query_params = 'foo'
bug1, bug2 = BugzillaBugFactory.create_batch(2)
batch1 = TaskImportBatchFactory.create()
TaskFactory.create_batch(1, batch=batch1, imported_item=bug1,
is_invalid=False)
TaskFactory.create_batch(1, batch=batch1, imported_item=bug2,
is_invalid=False)
with patch('oneanddone.tasks.forms.BugzillaUtils.request_bugs') as request_bugs:
# two bugs previously imported in batch1
request_bugs.return_value = [{u'id': bug1.bugzilla_id,
u'summary': bug1.summary},
{u'id': bug2.bugzilla_id,
u'summary': bug2.summary}]
bugs = TaskImportBatchForm._get_fresh_bugs(batch1.query,
query_params,
len(request_bugs()),
max_batch_size)
eq_(len(bugs), 0)
def setUp(self):
user = UserFactory.create()
self.task_not_repeatable_no_attempts = TaskFactory.create(repeatable=False)
self.task_not_repeatable_abandoned_attempt = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.ABANDONED,
task=self.task_not_repeatable_abandoned_attempt)
self.task_not_repeatable_started_attempt = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.STARTED,
task=self.task_not_repeatable_started_attempt)
self.task_not_repeatable_finished_attempt = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.FINISHED,
task=self.task_not_repeatable_finished_attempt)
self.task_draft = TaskFactory.create(is_draft=True)
self.task_invalid = TaskFactory.create(is_invalid=True)
self.task_no_draft = TaskFactory.create(is_draft=False)
self.task_start_jan = TaskFactory.create(
is_draft=False, start_date=aware_datetime(2014, 1, 1))
self.task_end_jan = TaskFactory.create(is_draft=False, end_date=aware_datetime(2014, 1, 1))
self.task_range_jan_feb = TaskFactory.create(
is_draft=False, start_date=aware_datetime(2014, 1, 1),
end_date=aware_datetime(2014, 2, 1))
def setUp(self):
user = UserFactory.create()
self.task_not_repeatable_no_attempts = TaskFactory.create(
repeatable=False)
self.task_not_repeatable_abandoned_attempt = TaskFactory.create(
repeatable=False)
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.ABANDONED,
task=self.task_not_repeatable_abandoned_attempt)
self.task_not_repeatable_started_attempt = TaskFactory.create(
repeatable=False)
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.STARTED,
task=self.task_not_repeatable_started_attempt)
self.task_not_repeatable_finished_attempt = TaskFactory.create(
repeatable=False)
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.FINISHED,
task=self.task_not_repeatable_finished_attempt)
self.task_draft = TaskFactory.create(is_draft=True)
self.task_invalid = TaskFactory.create(is_invalid=True)
self.task_no_draft = TaskFactory.create(is_draft=False)
self.task_start_jan = TaskFactory.create(is_draft=False,
start_date=aware_datetime(
2014, 1, 1))
self.task_end_jan = TaskFactory.create(is_draft=False,
end_date=aware_datetime(
2014, 1, 1))
self.task_range_jan_feb = TaskFactory.create(
is_draft=False,
start_date=aware_datetime(2014, 1, 1),
end_date=aware_datetime(2014, 2, 1))
def test_num_fresh_bugs_with_small_stale_query(self):
"""
Given a query that returns n < max_batch_size results, the
number of fresh bugs in the form's cleaned data is equal to 0,
if the query has been submitted before
"""
max_batch_size = 20
query_params = 'foo'
bug1, bug2 = BugzillaBugFactory.create_batch(2)
batch1 = TaskImportBatchFactory.create()
TaskFactory.create_batch(1,
batch=batch1,
imported_item=bug1,
is_invalid=False)
TaskFactory.create_batch(1,
batch=batch1,
imported_item=bug2,
is_invalid=False)
with patch('oneanddone.tasks.forms.BugzillaUtils.request_bugs'
) as request_bugs:
# two bugs previously imported in batch1
request_bugs.return_value = [{
u'id': bug1.bugzilla_id,
u'summary': bug1.summary
}, {
u'id': bug2.bugzilla_id,
u'summary': bug2.summary
}]
bugs = TaskImportBatchForm._get_fresh_bugs(batch1.query,
query_params,
len(request_bugs()),
max_batch_size)
eq_(len(bugs), 0)
def test_num_fresh_bugs_with_big_stale_query(self):
"""
Given a query that returns max_batch_size + n results, where
n < max_batch_size, the number of fresh bugs in the form's
cleaned data is equal to n the second time the query is submitted
(Next n bugs are accepted.)
"""
max_batch_size = 3
n = 2
query_params = 'foo'
db_bugs = BugzillaBugFactory.create_batch(max_batch_size)
batch1 = TaskImportBatchFactory.create()
for bug in db_bugs:
TaskFactory.create_batch(1, batch=batch1, imported_item=bug,
is_invalid=False)
with patch('oneanddone.tasks.forms.BugzillaUtils.request_bugs') as request_bugs:
stale_bugs = [{u'id': bug.bugzilla_id, u'summary': bug.summary}
for bug in db_bugs]
new_bugs = [{u'id': 50 + i, u'summary': u'a'} for i in range(n)]
all_bugs = stale_bugs + new_bugs
def fake_request(request_params, fields=['id', 'summary'],
offset=0, limit=99):
return all_bugs[offset:offset + limit]
request_bugs.side_effect = fake_request
bugs = TaskImportBatchForm._get_fresh_bugs(batch1.query,
query_params,
len(all_bugs),
max_batch_size)
eq_(bugs, all_bugs[max_batch_size:])
def test_close_expired_task_attempts(self):
"""
The close_expired_task_attempts routine should close all
attempts for tasks that are no longer available,
set them as requiring notification,
and return the number that were closed.
"""
task_no_expire = TaskFactory.create()
task = TaskFactory.create(end_date=timezone.now() + timedelta(days=1))
future_date = timezone.now() + timedelta(days=2)
user1, user2, user3 = UserFactory.create_batch(3)
TaskAttemptFactory.create(
user=user1,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(
user=user2,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(
user=user3,
state=TaskAttempt.STARTED,
task=task_no_expire)
eq_(task.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 2)
eq_(task_no_expire.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 1)
with patch('oneanddone.tasks.models.timezone.now') as now:
now.return_value = future_date
eq_(TaskAttempt.close_expired_task_attempts(), 2)
eq_(TaskAttempt.objects.filter(task=task,
state=TaskAttempt.STARTED).count(), 0)
eq_(TaskAttempt.objects.filter(task=task,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
eq_(TaskAttempt.objects.filter(task=task_no_expire,
state=TaskAttempt.STARTED).count(), 1)
def setUp(self):
self.task_draft = TaskFactory.create(is_draft=True)
self.task_no_draft = TaskFactory.create(is_draft=False)
self.task_start_jan = TaskFactory.create(
is_draft=False, start_date=aware_datetime(2014, 1, 1))
self.task_end_jan = TaskFactory.create(is_draft=False, end_date=aware_datetime(2014, 1, 1))
self.task_range_jan_feb = TaskFactory.create(
is_draft=False, start_date=aware_datetime(2014, 1, 1),
end_date=aware_datetime(2014, 2, 1))
def setUp(self):
self.task_draft = TaskFactory.create(is_draft=True)
self.task_no_draft = TaskFactory.create(is_draft=False)
self.task_start_jan = TaskFactory.create(is_draft=False,
start_date=aware_datetime(
2014, 1, 1))
self.task_end_jan = TaskFactory.create(is_draft=False,
end_date=aware_datetime(
2014, 1, 1))
self.task_range_jan_feb = TaskFactory.create(
is_draft=False,
start_date=aware_datetime(2014, 1, 1),
end_date=aware_datetime(2014, 2, 1))
def test_next_task(self):
attempt = self.attempt
task2 = TaskFactory.create()
eq_(attempt.next_task, None)
attempt.task.next_task = task2
attempt.task.save()
eq_(attempt.next_task, task2)
def test_close_stale_onetime_attempts(self):
"""
The close_stale_onetime_attempts routine should close all
expired one-time attempts, set them as requiring notification,
and return the number that were closed.
"""
task = TaskFactory.create(repeatable=False)
user = UserFactory.create()
recent_attempt, expired_attempt_1, expired_attempt_2 = TaskAttemptFactory.create_batch(
3, user=user, state=TaskAttempt.STARTED, task=task)
recent_attempt.created = aware_datetime(2014, 1, 29)
recent_attempt.save()
expired_attempt_1.created = aware_datetime(2014, 1, 1)
expired_attempt_1.save()
expired_attempt_2.created = aware_datetime(2014, 1, 1)
expired_attempt_2.save()
eq_(task.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 3)
with patch('oneanddone.tasks.models.timezone.now') as now:
now.return_value = aware_datetime(2014, 1, 31)
eq_(TaskAttempt.close_stale_onetime_attempts(), 2)
eq_(
TaskAttempt.objects.filter(task=task,
state=TaskAttempt.STARTED).count(), 1)
eq_(
TaskAttempt.objects.filter(task=task,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
def test_next_task(self):
attempt = self.attempt
task2 = TaskFactory.create()
eq_(attempt.next_task, None)
attempt.task.next_task = task2
attempt.task.save()
eq_(attempt.next_task, task2)
def test_invalidate_tasks_not_equals_criterion(self):
"""
The invalidate_tasks routine should invalidate tasks which match the
invalidation criteria.
This tests a not equals criterion.
"""
bug_to_become_invalid, bug_to_stay_valid = BugzillaBugFactory.create_batch(
2)
batch = TaskImportBatchFactory.create()
criterion = TaskInvalidationCriterionFactory.create(
field_name='name',
relation=TaskInvalidationCriterion.NOT_EQUAL,
field_value='value')
criterion.batches.add(batch)
criterion.save()
task1, task2 = TaskFactory.create_batch(
2,
batch=batch,
imported_item=bug_to_become_invalid,
is_invalid=False)
task2.imported_item = bug_to_stay_valid
task2.save()
with patch('oneanddone.tasks.models.BugzillaUtils.request_bug'
) as request_bug:
request_bug.side_effect = lambda x: {
bug_to_become_invalid.bugzilla_id: {
'name': 'value'
},
bug_to_stay_valid.bugzilla_id: {
'name': 'not value'
}
}[x]
eq_(Task.invalidate_tasks(), 1)
eq_(Task.objects.get(pk=task1.pk).is_invalid, False)
eq_(Task.objects.get(pk=task2.pk).is_invalid, True)
def test_invalidation_criteria_exists(self):
batch = TaskImportBatchFactory.create()
criterion = TaskInvalidationCriterionFactory.create()
criterion.batches.add(batch)
criterion.save()
task = TaskFactory.create(batch=batch)
eq_(criterion, task.invalidation_criteria[0])
def test_bugzilla_bug_exists(self):
bug = BugzillaBugFactory.create()
task = TaskFactory.create(imported_item=bug)
with patch('oneanddone.tasks.models.BugzillaUtils.request_bug') as request_bug:
request_bug.return_value = bug
eq_(bug, task.bugzilla_bug)
request_bug.assert_called_with(bug.bugzilla_id)
def test_users_with_valid_completed_attempt_counts(self):
"""
users_with_valid_completed_attempt_counts should return counts of all attempts completed
within the time threshold, sorted by highest number of attempts
"""
task = TaskFactory.create()
user1 = UserFactory.create()
user2 = UserFactory.create()
# Invalid attempt
TaskAttemptFactory.create(user=user1,
state=TaskAttempt.FINISHED,
task=task)
# Valid attempts
ValidTaskAttemptFactory.create_batch(2,
user=user1,
state=TaskAttempt.FINISHED,
task=task)
ValidTaskAttemptFactory.create(user=user2,
state=TaskAttempt.FINISHED,
task=task)
ValidTaskAttemptFactory.create(user=user1,
state=TaskAttempt.STARTED,
task=task)
eq_(user1.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 1)
eq_(user1.taskattempt_set.filter(state=TaskAttempt.FINISHED).count(), 3)
eq_(user2.taskattempt_set.filter(state=TaskAttempt.FINISHED).count(), 1)
qs = User.users_with_valid_completed_attempt_counts()
eq_(len(qs), 2)
eq_(qs[0], user1)
eq_(qs[0].valid_completed_attempts_count, 2)
eq_(qs[1], user2)
eq_(qs[1].valid_completed_attempts_count, 1)
def test_default_sort_order(self):
"""
The sort order of tasks should default to `priority`, `difficulty`
"""
Task.objects.all().delete()
t3, t1, t4, t2, t6, t5 = TaskFactory.create_batch(6)
t1.priority = 1
t1.difficulty = 1
t1.save()
t2.priority = 1
t2.difficulty = 2
t2.save()
t3.priority = 1
t3.difficulty = 3
t3.save()
t4.priority = 2
t4.difficulty = 1
t4.save()
t5.priority = 2
t5.difficulty = 3
t5.save()
t6.priority = 3
t6.difficulty = 1
t6.save()
tasks = Task.objects.all()
eq_(tasks[0], t1)
eq_(tasks[1], t2)
eq_(tasks[2], t3)
eq_(tasks[3], t4)
eq_(tasks[4], t5)
eq_(tasks[5], t6)
def create_task(self, creator):
team = TaskTeamFactory.create()
project = TaskProjectFactory.create()
type = TaskTypeFactory.create()
return TaskFactory.create(team=team, project=project, type=type,
creator=creator, owner=creator)
def test_close_stale_onetime_attempts(self):
"""
The close_stale_onetime_attempts routine should close all
expired one-time attempts, set them as requiring notification,
and return the number that were closed.
"""
task = TaskFactory.create(repeatable=False)
user = UserFactory.create()
recent_attempt, expired_attempt_1, expired_attempt_2 = TaskAttemptFactory.create_batch(
3,
user=user,
state=TaskAttempt.STARTED,
task=task)
recent_attempt.created = aware_datetime(2014, 1, 29)
recent_attempt.save()
expired_attempt_1.created = aware_datetime(2014, 1, 1)
expired_attempt_1.save()
expired_attempt_2.created = aware_datetime(2014, 1, 1)
expired_attempt_2.save()
eq_(task.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 3)
with patch('oneanddone.tasks.models.timezone.now') as now:
now.return_value = aware_datetime(2014, 1, 31)
eq_(TaskAttempt.close_stale_onetime_attempts(), 2)
eq_(TaskAttempt.objects.filter(task=task,
state=TaskAttempt.STARTED).count(), 1)
eq_(TaskAttempt.objects.filter(task=task,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
def test_default_sort_order(self):
"""
The sort order of tasks should default to `priority`, `difficulty`
"""
Task.objects.all().delete()
t3, t1, t4, t2, t6, t5 = TaskFactory.create_batch(6)
t1.priority = 1
t1.difficulty = 1
t1.save()
t2.priority = 1
t2.difficulty = 2
t2.save()
t3.priority = 1
t3.difficulty = 3
t3.save()
t4.priority = 2
t4.difficulty = 1
t4.save()
t5.priority = 2
t5.difficulty = 3
t5.save()
t6.priority = 3
t6.difficulty = 1
t6.save()
tasks = Task.objects.all()
eq_(tasks[0], t1)
eq_(tasks[1], t2)
eq_(tasks[2], t3)
eq_(tasks[3], t4)
eq_(tasks[4], t5)
eq_(tasks[5], t6)
def test_initial_contains_empty_list_of_keywords_for_new_task(self):
"""
Initial should contain an empty list of keywords for a new task.
"""
task = TaskFactory.create()
form = TaskForm(instance=task)
eq_(form.initial['keywords'], '')
def test_save_processes_keywords_correctly(self):
"""
Saving the form should update the keywords correctly.
- Removed keywords should be removed
- New keywords should be added
- Remaining keywords should remain
"""
user = UserFactory.create()
task = TaskFactory.create()
TaskKeywordFactory.create_batch(3, task=task)
form = get_filled_taskform(task, keywords='test3, new_keyword')
form.save(user)
removed_keyword = TaskKeyword.objects.filter(task=task, name='test1')
eq_(len(removed_keyword), 0)
added_keyword = TaskKeyword.objects.filter(task=task,
name='new_keyword')
eq_(len(added_keyword), 1)
kept_keyword = TaskKeyword.objects.filter(task=task, name='test3')
eq_(len(kept_keyword), 1)
# double-check on the keywords_list property
eq_(task.keywords_list, 'test3, new_keyword')
def test_initial_contains_empty_list_of_keywords_for_new_task(self):
"""
Initial should contain an empty list of keywords for a new task.
"""
task = TaskFactory.create()
form = TaskForm(instance=task)
eq_(form.initial['keywords'], '')
def test_save_processes_keywords_correctly(self):
"""
Saving the form should update the keywords correctly.
- Removed keywords should be removed
- New keywords should be added
- Remaining keywords should remain
"""
user = UserFactory.create()
task = TaskFactory.create()
TaskKeywordFactory.create_batch(3, task=task)
data = {
'keywords': 'test3, new_keyword',
'team': task.team.id,
}
for field in ('name', 'short_description', 'execution_time', 'difficulty',
'repeatable', 'instructions', 'is_draft'):
data[field] = getattr(task, field)
form = TaskForm(instance=task, data=data)
form.save(user)
removed_keyword = TaskKeyword.objects.filter(task=task, name='test1')
eq_(len(removed_keyword), 0)
added_keyword = TaskKeyword.objects.filter(task=task, name='new_keyword')
eq_(len(added_keyword), 1)
kept_keyword = TaskKeyword.objects.filter(task=task, name='test3')
eq_(len(kept_keyword), 1)
# double-check on the keywords_list property
eq_(task.keywords_list, 'test3, new_keyword')
def test_has_completed_task_false(self):
"""
has_completed_task should return false if the user has not completed the task.
"""
user = UserFactory.create()
task = TaskFactory.create()
ok_(not user.has_completed_task(task))
def test_invalidation_criteria_exists(self):
batch = TaskImportBatchFactory.create()
criterion = TaskInvalidationCriterionFactory.create()
criterion.batches.add(batch)
criterion.save()
task = TaskFactory.create(batch=batch)
eq_(criterion, task.invalidation_criteria[0])
def test_invalidate_tasks_not_equals_criterion(self):
"""
The invalidate_tasks routine should invalidate tasks which match the
invalidation criteria.
This tests a not equals criterion.
"""
bug_to_become_invalid, bug_to_stay_valid = BugzillaBugFactory.create_batch(2)
batch = TaskImportBatchFactory.create()
criterion = TaskInvalidationCriterionFactory.create(
field_name='name',
relation=TaskInvalidationCriterion.NOT_EQUAL,
field_value='value')
criterion.batches.add(batch)
criterion.save()
task1, task2 = TaskFactory.create_batch(2,
batch=batch,
imported_item=bug_to_become_invalid,
is_invalid=False)
task2.imported_item = bug_to_stay_valid
task2.save()
with patch('oneanddone.tasks.models.BugzillaUtils.request_bug') as request_bug:
request_bug.side_effect = lambda x: {
bug_to_become_invalid.bugzilla_id: {'name': 'value'},
bug_to_stay_valid.bugzilla_id: {'name': 'not value'}}[x]
eq_(Task.invalidate_tasks(), 1)
eq_(Task.objects.get(pk=task1.pk).is_invalid, False)
eq_(Task.objects.get(pk=task2.pk).is_invalid, True)
def test_has_completed_task_false(self):
"""
has_completed_task should return false if the user has not completed the task.
"""
user = UserFactory.create()
task = TaskFactory.create()
ok_(not user.has_completed_task(task))
def test_bugzilla_bug_exists(self):
bug = BugzillaBugFactory.create()
task = TaskFactory.create(imported_item=bug)
with patch('oneanddone.tasks.models.BugzillaUtils.request_bug') as request_bug:
request_bug.return_value = bug
eq_(bug, task.bugzilla_bug)
request_bug.assert_called_with(bug.bugzilla_id)
def test_first_previous_task(self):
task1, task2, task3 = TaskFactory.create_batch(3)
eq_(task2.first_previous_task, None)
task1.next_task = task2
task1.save()
task3.next_task = task2
task3.save()
eq_(task1, task2.first_previous_task)
def test_first_previous_task(self):
task1, task2, task3 = TaskFactory.create_batch(3)
eq_(task2.first_previous_task, None)
task1.next_task = task2
task1.save()
task3.next_task = task2
task3.save()
eq_(task1, task2.first_previous_task)
def test_initial_contains_list_of_keywords_for_existing_task(self):
"""
Initial should contain the list of keywords from the task instance.
"""
task = TaskFactory.create()
TaskKeywordFactory.create_batch(3, task=task)
form = TaskForm(instance=task)
eq_(form.initial['keywords'], 'test1, test2, test3')
def test_has_completed_task_false_task_started(self):
"""
has_completed_task should return false if the user has just started the task.
"""
user = UserFactory.create()
task = TaskFactory.create()
TaskAttemptFactory.create(user=user, task=task, state=TaskAttempt.STARTED)
ok_(not user.has_completed_task(task))
def test_has_completed_task_true(self):
"""
has_completed_task should return true if the user has completed the task.
"""
user = UserFactory.create()
task = TaskFactory.create()
TaskAttemptFactory.create(user=user, task=task, state=TaskAttempt.FINISHED)
ok_(user.has_completed_task(task))
def test_initial_contains_list_of_keywords_for_existing_task(self):
"""
Initial should contain the list of keywords from the task instance.
"""
task = TaskFactory.create()
TaskKeywordFactory.create_batch(3, task=task)
form = TaskForm(instance=task)
eq_(sorted(form.initial['keywords']), sorted('test1, test2, test3'))
def test_area_filter_empty_children(self):
"""
If a TaskArea has available tasks but its children don't, the
children should not be included in the area filter.
"""
# root -> child1 -> grandchild1
# \-> child2
root = TaskAreaFactory.create()
child1, child2 = TaskAreaFactory.create_batch(2, parent=root)
grandchild1 = TaskAreaFactory.create(parent=child1)
# Only child1 has available tasks.
TaskFactory.create(area=child1, is_draft=False)
# Area should include child1, but not grandchild1.
filter_set = AvailableTasksFilterSet()
areas = filter_set.filters["area"].extra["queryset"]
eq_(set(areas), set([root, child1]))
def test_is_available_to_user_user_attempt(self):
"""
If there is an attempt by the current user,
the task should be available.
"""
user = UserFactory.create()
task = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(user=user, state=TaskAttempt.STARTED, task=task)
eq_(task.is_available_to_user(user), True)
def test_area_filter_only_with_available_tasks(self):
"""
Only TaskAreas with available tasks and their parents should be
included in the area filter.
"""
# root -> child1 -> grandchild1
# \-> child2
root = TaskAreaFactory.create()
child1, child2 = TaskAreaFactory.create_batch(2, parent=root)
grandchild1 = TaskAreaFactory.create(parent=child1)
# Only grandchild1 has available tasks.
TaskFactory.create(area=grandchild1, is_draft=False)
# Area should include grandlchild1 and its parents.
filter_set = AvailableTasksFilterSet()
areas = filter_set.filters['area'].extra['queryset']
eq_(set(areas), set([root, child1, grandchild1]))
def test_is_available_to_user_user_attempt(self):
"""
If there is an attempt by the current user,
the task should be available.
"""
user = UserFactory.create()
task = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(user=user, state=TaskAttempt.STARTED, task=task)
eq_(task.is_available_to_user(user), True)
def test_area_filter_empty_children(self):
"""
If a TaskArea has available tasks but its children don't, the
children should not be included in the area filter.
"""
# root -> child1 -> grandchild1
# \-> child2
root = TaskAreaFactory.create()
child1, child2 = TaskAreaFactory.create_batch(2, parent=root)
grandchild1 = TaskAreaFactory.create(parent=child1)
# Only child1 has available tasks.
TaskFactory.create(area=child1, is_draft=False)
# Area should include child1, but not grandchild1.
filter_set = AvailableTasksFilterSet()
areas = filter_set.filters['area'].extra['queryset']
eq_(set(areas), set([root, child1]))
def test_area_filter_only_with_available_tasks(self):
"""
Only TaskAreas with available tasks and their parents should be
included in the area filter.
"""
# root -> child1 -> grandchild1
# \-> child2
root = TaskAreaFactory.create()
child1, child2 = TaskAreaFactory.create_batch(2, parent=root)
grandchild1 = TaskAreaFactory.create(parent=child1)
# Only grandchild1 has available tasks.
TaskFactory.create(area=grandchild1, is_draft=False)
# Area should include grandlchild1 and its parents.
filter_set = AvailableTasksFilterSet()
areas = filter_set.filters["area"].extra["queryset"]
eq_(set(areas), set([root, child1, grandchild1]))
def test_validation_same_start_date_as_end_date(self):
"""
The form is not valid if start date is same as end date.
"""
form = get_filled_taskform(TaskFactory.create(),
start_date='2013-08-15',
end_date='2013-08-15')
self.assertFalse(form.is_valid())
eq_(form.non_field_errors(), ["'End date' must be after 'Start date'"])
def test_isnt_available_to_user_other_user_non_abandoned_attempt(self):
"""
If there is a non-abandoned attempt by a different user,
the task should not be available.
"""
user = UserFactory.create()
other_user = UserFactory.create()
task = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(user=other_user, state=TaskAttempt.STARTED, task=task)
eq_(task.is_available_to_user(user), False)
def test_validation_start_date_before_end_date(self):
"""
The form is valid if start date is before end date and all other
field requirements are respected.
"""
form = get_filled_taskform(TaskFactory.create(),
start_date='2013-07-01',
end_date='2013-08-15')
self.assertTrue(form.is_valid())
def test_isnt_available_to_user_other_user_non_abandoned_attempt(self):
"""
If there is a non-abandoned attempt by a different user,
the task should not be available.
"""
user = UserFactory.create()
other_user = UserFactory.create()
task = TaskFactory.create(repeatable=False)
TaskAttemptFactory.create(user=other_user, state=TaskAttempt.STARTED, task=task)
eq_(task.is_available_to_user(user), False)
def test_validation_start_date_before_end_date(self):
"""
The form is valid if start date is before end date and all other
field requirements are respected.
"""
form = get_filled_taskform(TaskFactory.create(),
start_date='2013-07-01',
end_date='2013-08-15')
self.assertTrue(form.is_valid())
def test_validation_start_date_after_end_date(self):
"""
The form is not valid if start date is after end date.
"""
form = get_filled_taskform(TaskFactory.create(),
start_date='2014-07-01',
end_date='2013-08-15')
self.assertFalse(form.is_valid())
eq_(form.non_field_errors(), ["'End date' must be after 'Start date'"])
def test_save_does_not_add_a_blank_keyword(self):
"""
Saving the form should not add a blank keyword when
keywords are empty.
"""
user = UserFactory.create()
task = TaskFactory.create()
form = get_filled_taskform(task, keywords=' ')
form.save(user)
eq_(task.keyword_set.count(), 0)
def assigned_task(base_url, is_local):
if is_local:
from oneanddone.tasks.tests import TaskFactory, TaskAttemptFactory
from oneanddone.users.tests import UserFactory
from oneanddone.tasks.models import TaskAttempt
task = TaskFactory.create(repeatable=False)
user = UserFactory.create()
TaskAttemptFactory.create(
user=user,
state=TaskAttempt.STARTED,
task=task)
return task
def test_save_does_not_add_a_blank_keyword(self):
"""
Saving the form should not add a blank keyword when
keywords are empty.
"""
user = UserFactory.create()
task = TaskFactory.create()
form = get_filled_taskform(task, keywords=' ')
form.save(user)
eq_(task.keyword_set.count(), 0)
def test_num_fresh_bugs_with_big_stale_query(self):
"""
Given a query that returns max_batch_size + n results, where
n < max_batch_size, the number of fresh bugs in the form's
cleaned data is equal to n the second time the query is submitted
(Next n bugs are accepted.)
"""
max_batch_size = 3
n = 2
query_params = 'foo'
db_bugs = BugzillaBugFactory.create_batch(max_batch_size)
batch1 = TaskImportBatchFactory.create()
for bug in db_bugs:
TaskFactory.create_batch(1,
batch=batch1,
imported_item=bug,
is_invalid=False)
with patch('oneanddone.tasks.forms.BugzillaUtils.request_bugs'
) as request_bugs:
stale_bugs = [{
u'id': bug.bugzilla_id,
u'summary': bug.summary
} for bug in db_bugs]
new_bugs = [{u'id': 50 + i, u'summary': u'a'} for i in range(n)]
all_bugs = stale_bugs + new_bugs
def fake_request(request_params,
fields=['id', 'summary'],
offset=0,
limit=99):
return all_bugs[offset:offset + limit]
request_bugs.side_effect = fake_request
bugs = TaskImportBatchForm._get_fresh_bugs(batch1.query,
query_params,
len(all_bugs),
max_batch_size)
eq_(bugs, all_bugs[max_batch_size:])
def test_save_does_not_add_a_blank_keyword(self):
"""
Saving the form should not add a blank keyword when
keywords are empty.
"""
user = UserFactory.create()
task = TaskFactory.create()
data = {
'keywords': ' ',
'team': task.team.id,
}
for field in ('name', 'short_description', 'execution_time', 'difficulty',
'repeatable', 'instructions', 'is_draft'):
data[field] = getattr(task, field)
form = TaskForm(instance=task, data=data)
form.save(user)
eq_(task.keyword_set.count(), 0)
def test_get_form_kwargs_populates_form_with_data_to_be_cloned(self):
"""
When accessed via the tasks.clone url, the view displays a form
whose initial data is that of the task being cloned, except for
the 'name' field, which should be prefixed with 'Copy of '
"""
user = UserFactory.create()
original_task = TaskFactory.create()
TaskKeywordFactory.create_batch(3, task=original_task)
original_data = get_filled_taskform(original_task).data
self.view.kwargs = {'clone': original_task.pk}
self.view.request = Mock(user=user)
with patch('oneanddone.tasks.views.generic.CreateView.get_form_kwargs') as get_form_kwargs:
get_form_kwargs.return_value = {'initial': {}}
initial = self.view.get_form_kwargs()['initial']
eq_(initial['keywords'], original_task.keywords_list)
eq_(initial['name'], ' '.join(['Copy of', original_task.name]))
del original_data['name']
assert_dict_contains_subset(original_data, initial)
def test_get_form_kwargs_populates_form_with_data_to_be_cloned(self):
"""
When accessed via the tasks.clone url, the view displays a form
whose initial data is that of the task being cloned, except for
the 'name' field, which should be prefixed with 'Copy of '
"""
user = UserFactory.create()
original_task = TaskFactory.create()
TaskKeywordFactory.create_batch(3, task=original_task)
original_data = get_filled_taskform(original_task).data
self.view.kwargs = {'clone': original_task.pk}
self.view.request = Mock(user=user)
with patch('oneanddone.tasks.views.generic.CreateView.get_form_kwargs'
) as get_form_kwargs:
get_form_kwargs.return_value = {'initial': {}}
initial = self.view.get_form_kwargs()['initial']
eq_(initial['keywords'], original_task.keywords_list)
eq_(initial['name'], ' '.join(['Copy of', original_task.name]))
del original_data['name']
assert_dict_contains_subset(original_data, initial)
def setUp(self):
self.user1, self.user2 = UserFactory.create_batch(2)
self.task1, self.task2 = TaskFactory.create_batch(2)
TaskAttemptFactory.create_batch(2,
user=self.user1,
task=self.task1,
state=TaskAttempt.FINISHED)
ValidTaskAttemptFactory.create_batch(2,
user=self.user1,
task=self.task1,
state=TaskAttempt.FINISHED)
ValidTaskAttemptFactory.create(user=self.user1,
task=self.task2,
state=TaskAttempt.FINISHED)
ValidTaskAttemptFactory.create(user=self.user2,
task=self.task1,
state=TaskAttempt.FINISHED)
ValidTaskAttemptFactory.create_batch(2,
user=self.user1,
task=self.task1,
state=TaskAttempt.ABANDONED)
ValidTaskAttemptFactory.create(user=self.user2,
task=self.task1,
state=TaskAttempt.ABANDONED)
ValidTaskAttemptFactory.create(user=self.user1,
task=self.task2,
state=TaskAttempt.ABANDONED)
ValidTaskAttemptFactory.create_batch(2,
user=self.user1,
task=self.task1,
state=TaskAttempt.CLOSED)
ValidTaskAttemptFactory.create(user=self.user2,
task=self.task1,
state=TaskAttempt.CLOSED)
ValidTaskAttemptFactory.create(user=self.user1,
task=self.task2,
state=TaskAttempt.CLOSED)
def test_recent_users(self):
"""
recent_users should return users sorted by most recent task activity
"""
task = TaskFactory.create()
user1 = UserProfileFactory.create().user
user2 = UserProfileFactory.create().user
user3 = UserProfileFactory.create().user
user4 = UserFactory.create()
TaskAttemptFactory.create(user=user4,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(user=user3,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(user=user2,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(user=user2,
state=TaskAttempt.FINISHED,
task=task)
TaskAttemptFactory.create(user=user1,
state=TaskAttempt.STARTED,
task=task)
TaskAttemptFactory.create(user=user3,
state=TaskAttempt.ABANDONED,
task=task)
eq_(user1.taskattempt_set.all().count(), 1)
eq_(user2.taskattempt_set.all().count(), 2)
eq_(user3.taskattempt_set.all().count(), 2)
eq_(user4.taskattempt_set.all().count(), 1)
qs = User.recent_users()
eq_(len(qs), 3)
eq_(qs[0], user1)
eq_(qs[1], user2)
eq_(qs[2], user3)
def test_users_with_valid_completed_attempt_counts(self):
"""
users_with_valid_completed_attempt_counts should return counts of all attempts completed
within the time threshold, sorted by highest number of attempts
"""
task = TaskFactory.create()
user1 = UserFactory.create()
user2 = UserFactory.create()
# Invalid attempt
TaskAttemptFactory.create(user=user1,
state=TaskAttempt.FINISHED,
task=task)
# Valid attempts
ValidTaskAttemptFactory.create_batch(2,
user=user1,
state=TaskAttempt.FINISHED,
task=task)
ValidTaskAttemptFactory.create(user=user2,
state=TaskAttempt.FINISHED,
task=task)
ValidTaskAttemptFactory.create(user=user1,
state=TaskAttempt.STARTED,
task=task)
eq_(user1.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 1)
eq_(
user1.taskattempt_set.filter(state=TaskAttempt.FINISHED).count(),
3)
eq_(
user2.taskattempt_set.filter(state=TaskAttempt.FINISHED).count(),
1)
qs = User.users_with_valid_completed_attempt_counts()
eq_(len(qs), 2)
eq_(qs[0], user1)
eq_(qs[0].valid_completed_attempts_count, 2)
eq_(qs[1], user2)
eq_(qs[1].valid_completed_attempts_count, 1)