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_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_attempts_finished_count(self):
"""
attempts_finished_count should return the number of attempts
the user has finished.
"""
user = UserFactory.create()
TaskAttemptFactory.create_batch(4, user=user, state=TaskAttempt.FINISHED)
TaskAttemptFactory.create(user=user, state=TaskAttempt.STARTED)
eq_(user.attempts_finished_count, 4)
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_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 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_attempts_in_progress(self):
"""
attempts_in_progress should return the number of attempts in progress.
"""
user = UserFactory.create()
tasks = TaskAttemptFactory.create_batch(4, user=user, state=TaskAttempt.STARTED)
eq_(set(user.attempts_in_progress), set(tasks))
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_get_task_details(self):
"""
Test GET details of a task with particular id for authenticated user
"""
self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)
user = UserFactory.create()
test_task = self.create_task(user)
task_attempt = TaskAttemptFactory.create(user=user, task=test_task)
task_uri = self.uri + str(test_task.id) + '/'
task_data = {"id": test_task.id, "name": test_task.name, "short_description": test_task.short_description,
"instructions": test_task.instructions, "prerequisites": test_task.prerequisites,
"execution_time": test_task.execution_time, "is_draft": test_task.is_draft,
"is_invalid": test_task.is_invalid, "project": test_task.project.name,
"team": test_task.team.name, "type": test_task.type.name, "repeatable": test_task.repeatable,
"start_date": test_task.start_date, "end_date": test_task.end_date, "difficulty": test_task.difficulty,
"why_this_matters": test_task.why_this_matters,
"keyword_set": [{"name": keyword.name} for keyword in test_task.keyword_set.all()],
"taskattempt_set": [{"user": user.email, "state": task_attempt.state}],
"owner": user.email}
response = self.client.get(task_uri)
self.assert_response_status(response, status.HTTP_200_OK)
response_data = json.loads(response.content)
eq_(response_data, task_data)
def test_get_task_list(self):
"""
Test GET task list for authenticated user
"""
header = {'HTTP_AUTHORIZATION': 'Token {}'.format(self.token)}
user = UserFactory.create()
test_task = self.create_task(user)
task_attempt = TaskAttemptFactory.create(user=user, task=test_task)
task_data = {"id": test_task.id,
"name": test_task.name,
"short_description": test_task.short_description,
"instructions": test_task.instructions,
"prerequisites": test_task.prerequisites,
"execution_time": test_task.execution_time,
"is_draft": test_task.is_draft,
"is_invalid": test_task.is_invalid,
"project": test_task.project.name,
"team": test_task.team.name,
"type": test_task.type.name,
"repeatable": test_task.repeatable,
"start_date": test_task.start_date,
"end_date": test_task.end_date,
"difficulty": test_task.difficulty,
"why_this_matters": test_task.why_this_matters,
"keyword_set": [
{"name": keyword.name} for keyword in test_task.keyword_set.all()],
"taskattempt_set": [{"user": user.email, "state": task_attempt.state}],
"owner": user.email}
response = self.client.get(reverse('api-task'), {}, **header)
self.assert_response_status(response, status.HTTP_200_OK)
response_data = json.loads(response.content)
assert_true(task_data in response_data)
def test_not_your_attempt_raises_404(self):
"""
If the current user doesn't match the user for the requested
task attempt, return a 404.
"""
attempt = TaskAttemptFactory.create()
request = Mock(user=UserFactory.create())
with self.assertRaises(Http404):
self.view.dispatch(request, pk=attempt.pk)
def test_found_attempt_stores_attempt(self):
"""
If the current user has a matching attempt, it should
be stored in the view.
"""
user = UserFactory.create()
attempt = TaskAttemptFactory.create(user=user, state=TaskAttempt.FINISHED)
request = Mock(user=user)
self.view.dispatch(request, pk=attempt.pk)
eq_(self.view.attempt, attempt)
def test_attempt_with_feedback_raises_404(self):
"""
If the current user has an attempt but feedback has already been
provided, return a 404.
"""
user = UserFactory.create()
attempt = TaskAttemptFactory.create(user=user, state=TaskAttempt.FINISHED)
FeedbackFactory.create(attempt=attempt)
request = Mock(user=UserFactory.create())
with self.assertRaises(Http404):
self.view.dispatch(request, pk=attempt.pk)
def test_post_existing_attempts(self):
"""
If the user has an existing task attempt, redirect them to the
profile detail page.
"""
attempt = TaskAttemptFactory.create()
self.view.request = Mock(user=attempt.user)
with patch('oneanddone.tasks.views.redirect') as redirect:
eq_(self.view.post(), redirect.return_value)
redirect.assert_called_with('base.home')
ok_(not TaskAttempt.objects.filter(user=attempt.user, task=self.task).exists())
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_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_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.
"""
user1, user2, user3 = UserFactory.create_batch(3)
TaskAttemptFactory.create(user=user1,
state=TaskAttempt.STARTED,
task=self.task_end_jan)
TaskAttemptFactory.create(user=user2,
state=TaskAttempt.STARTED,
task=self.task_end_jan)
TaskAttemptFactory.create(user=user3,
state=TaskAttempt.STARTED,
task=self.task_no_draft)
eq_(
self.task_end_jan.taskattempt_set.filter(
state=TaskAttempt.STARTED).count(), 2)
eq_(
self.task_no_draft.taskattempt_set.filter(
state=TaskAttempt.STARTED).count(), 1)
eq_(TaskAttempt.close_expired_task_attempts(), 2)
eq_(
TaskAttempt.objects.filter(task=self.task_end_jan,
state=TaskAttempt.STARTED).count(), 0)
eq_(
TaskAttempt.objects.filter(task=self.task_end_jan,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
eq_(
TaskAttempt.objects.filter(task=self.task_no_draft,
state=TaskAttempt.STARTED).count(), 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_post_existing_attempts(self):
"""
If the user has an existing task attempt, redirect them to the
profile detail page.
"""
attempt = TaskAttemptFactory.create()
self.view.request = Mock(user=attempt.user)
with patch('oneanddone.tasks.views.redirect') as redirect:
eq_(self.view.post(), redirect.return_value)
redirect.assert_called_with('base.home')
ok_(not TaskAttempt.objects.filter(user=attempt.user,
task=self.task).exists())
def test_attempt_with_feedback_raises_404(self):
"""
If the current user has an attempt but feedback has already been
provided, return a 404.
"""
user = UserFactory.create()
attempt = TaskAttemptFactory.create(user=user,
state=TaskAttempt.FINISHED)
FeedbackFactory.create(attempt=attempt)
request = Mock(user=UserFactory.create())
with self.assertRaises(Http404):
self.view.dispatch(request, pk=attempt.pk)
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 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_save_closes_task_attempts(self):
"""
When a saved task is unavailable,
close any open attempts, and set the attempts
to require a notification.
"""
user1 = UserFactory.create()
user2 = UserFactory.create()
TaskAttemptFactory.create(
user=user1,
state=TaskAttempt.STARTED,
task=self.task_no_draft)
TaskAttemptFactory.create(
user=user2,
state=TaskAttempt.STARTED,
task=self.task_no_draft)
eq_(self.task_no_draft.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 2)
self.task_no_draft.is_draft = True
self.task_no_draft.save()
eq_(TaskAttempt.objects.filter(task=self.task_no_draft,
state=TaskAttempt.STARTED).count(), 0)
eq_(TaskAttempt.objects.filter(task=self.task_no_draft,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
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_save_closes_task_attempts(self):
"""
When a saved task is unavailable,
close any open attempts, and set the attempts
to require a notification.
"""
user1 = UserFactory.create()
user2 = UserFactory.create()
TaskAttemptFactory.create(
user=user1,
state=TaskAttempt.STARTED,
task=self.task_no_draft)
TaskAttemptFactory.create(
user=user2,
state=TaskAttempt.STARTED,
task=self.task_no_draft)
eq_(self.task_no_draft.taskattempt_set.filter(state=TaskAttempt.STARTED).count(), 2)
self.task_no_draft.is_draft = True
self.task_no_draft.save()
eq_(TaskAttempt.objects.filter(task=self.task_no_draft,
state=TaskAttempt.STARTED).count(), 0)
eq_(TaskAttempt.objects.filter(task=self.task_no_draft,
state=TaskAttempt.CLOSED,
requires_notification=True).count(), 2)
def test_get_task_list(self):
"""
Test GET task list for authenticated user
"""
header = {'HTTP_AUTHORIZATION': 'Token {}'.format(self.token)}
test_task = self.create_task(self.client_user)
task_attempt = TaskAttemptFactory.create(user=self.client_user, task=test_task)
task_data = {"id": test_task.id, "name": test_task.name, "short_description": test_task.short_description,
"instructions": test_task.instructions, "prerequisites":test_task.prerequisites,
"execution_time": test_task.execution_time, "is_draft": test_task.is_draft, "project": test_task.project.name,
"team": test_task.team.name, "type": test_task.type.name, "repeatable": test_task.repeatable,
"start_date": test_task.start_date, "end_date": test_task.end_date, "difficulty": test_task.difficulty,
"why_this_matters": test_task.why_this_matters,
"keyword_set": [{"name": keyword.name} for keyword in test_task.keyword_set.all()],
"taskattempt_set": [{"user":self.client_user.email, "state":task_attempt.state}]}
response = self.client.get(reverse('api-task'), {}, **header)
self.assert_response_status(response, status.HTTP_200_OK)
response_data = json.loads(response.content)
assert_true(task_data in response_data)
def test_get_task_details(self):
"""
Test GET details of a task with particular id for authenticated user
"""
self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)
test_task = self.create_task(self.client_user)
task_attempt = TaskAttemptFactory.create(user=self.client_user, task=test_task)
task_uri = self.uri + str(test_task.id) + '/'
task_data = {"id": test_task.id, "name": test_task.name, "short_description": test_task.short_description,
"instructions": test_task.instructions, "prerequisites":test_task.prerequisites,
"execution_time": test_task.execution_time, "is_draft": test_task.is_draft, "project": test_task.project.name,
"team": test_task.team.name, "type": test_task.type.name, "repeatable": test_task.repeatable,
"start_date": test_task.start_date, "end_date": test_task.end_date, "difficulty": test_task.difficulty,
"why_this_matters": test_task.why_this_matters,
"keyword_set": [{"name": keyword.name} for keyword in test_task.keyword_set.all()],
"taskattempt_set": [{"user":self.client_user.email, "state":task_attempt.state}]}
response = self.client.get(task_uri)
self.assert_response_status(response, status.HTTP_200_OK)
response_data = json.loads(response.content)
eq_(response_data, task_data)
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):
user = UserFactory.create()
task = TaskFactory.create()
self.attempt = TaskAttemptFactory.create(user=user, task=task)
def setUp(self):
TaskAttempt.objects.all().delete()
user = UserFactory.create()
task = TaskFactory.create()
self.attempt = TaskAttemptFactory.create(user=user, task=task)
def setUp(self):
user = UserFactory.create()
task = TaskFactory.create()
self.attempt = TaskAttemptFactory.create(user=user, task=task)
def setUp(self):
TaskAttempt.objects.all().delete()
user = UserFactory.create()
task = TaskFactory.create()
self.attempt = TaskAttemptFactory.create(user=user, task=task)
def test_attempts_in_progress(self):
user = UserFactory.create()
tasks = TaskAttemptFactory.create_batch(4,
user=user,
state=TaskAttempt.STARTED)
eq_(set(user.attempts_in_progress), set(tasks))
def test_attempts_finished_count(self):
user = UserFactory.create()
TaskAttemptFactory.create_batch(4, user=user, state=TaskAttempt.FINISHED)
TaskAttemptFactory.create(user=user, state=TaskAttempt.STARTED)
eq_(user.attempts_finished_count, 4)
def test_attempts_in_progress(self):
user = UserFactory.create()
tasks = TaskAttemptFactory.create_batch(4, user=user, state=TaskAttempt.STARTED)
eq_(set(user.attempts_in_progress), set(tasks))
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)
