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): 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_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 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_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)