Python tests.UserFactory类代码示例

 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_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_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_forbidden_client(self):
        """
        Test user deletion by an authenticated but forbidden client
        """
        forbidden_user = UserFactory.create()
        forbidden_token = Token.objects.create(user=forbidden_user)

        self.client.credentials(HTTP_AUTHORIZATION='Token ' + forbidden_token.key)

        test_user = UserFactory.create()
        user_uri = self.uri + test_user.email + '/'

        #Make a DELETE request
        delete_response = self.client.delete(user_uri)
        self.assert_response_status(delete_response, status.HTTP_403_FORBIDDEN)

    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_missing_attempt_raises_404(self):
     """
     If there is no task attempt with the given ID, return a 404.
     """
     request = Mock(user=UserFactory.create())
     with self.assertRaises(Http404):
         self.view.dispatch(request, pk=9999)

 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_success_url_no_profile(self):
     """
     If the user has no profile, return the url to create user profile.
     """
     user = UserFactory.create()
     self.view.user = user
     eq_(self.view.success_url, reverse_lazy('users.profile.create'))

 def test_is_available_to_user_no_attempts(self):
     """
     If there are no attempts,
     the task should be available.
     """
     user = UserFactory.create()
     eq_(self.task_not_repeatable_no_attempts.is_available_to_user(user), True)

 def test_not_staff(self):
     """
     If the user is not staff, raise a PermissionDenied exception.
     """
     request = Mock()
     request.user = UserFactory.create(is_staff=False)
     self.view.dispatch(request)

    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_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_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_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_display_email_without_profile(self):
     """
     The display_email attribute should return 'Email consent denied'
     if they have no profile.
     """
     user = UserFactory.build(email='[email protected]')
     eq_(user.display_email, 'Email consent denied')