def setUp(self):
     User = get_user_model()
     self.student = mommy.prepare(User, is_active=True)
     self.student.set_password('123')
     self.student.save()
     self.leader = mommy.prepare(User, is_active=True)
     self.leader.set_password('123')
     self.leader.save()
     self.superuser = mommy.prepare(
         User, is_active=True, is_superuser=True, is_staff=True
     )
     self.superuser.set_password('123')
     self.superuser.save()
     self.project1 = mommy.make(Project, leader=self.leader)
     self.project2 = mommy.make(Project)
     self.announcements_project1 = mommy.make(
         Announcement, project=self.project1, fixed=False, _quantity=5
     )
     self.announcements_project2 = mommy.make(
         Announcement, project=self.project2, fixed=False, _quantity=10
     )
     self.enrollment = mommy.make(
         Enrollment, project=self.project1, user=self.student,
         blocked=True
     )
     self.client = Client()

    def test_has_module_perms(self):
        """Staff members have all Django admin perms"""
        user = prepare(User, is_staff=False)
        self.assertFalse(user.has_module_perms("foo"), user)

        user = prepare(User, is_staff=True)
        self.assertTrue(user.has_module_perms("foo"), user)

    def test_prepare_should_create_objects_respecting_quantity_parameter(self):
        people = mommy.prepare(Person, _quantity=5)
        self.assertEqual(len(people), 5)
        self.assertTrue(all(not p.id for p in people))

        people = mommy.prepare(Person, _quantity=5, name="George Washington")
        self.assertTrue(all(p.name == "George Washington" for p in people))

    def test_wipes_old_email(self):
        """Test that old emails are wiped"""
        latest_email_open = mommy.prepare(EmailOpen)
        latest_email_open.user_agent = ''
        latest_email_open.save()

        old_email_open = mommy.prepare(EmailOpen)
        old_email_open.user_agent = ''
        old_email_open.opened_at = self.month_ago
        old_email_open.save()

        # As the database will always update with the last modified at time we
        # need to do an `UPDATE` operation in the database to change the time
        # the open was created.
        EmailOpen.objects.filter(
            pk=old_email_open.pk).update(opened_at=self.month_ago)

        all_email_opens_pre = EmailOpen.objects.all()

        self.assertIn(latest_email_open, all_email_opens_pre)
        self.assertIn(old_email_open, all_email_opens_pre)

        tasks.wipe_old_email_opens()

        all_email_opens_post = EmailOpen.objects.all()
        self.assertIn(latest_email_open, all_email_opens_post)
        self.assertNotIn(old_email_open, all_email_opens_post)

    def test(self):
        class Car(models.Model):
            name = models.CharField(max_length=255)

        class CarIndex(Index):
            class Meta:
                fields = ['name']
                model = Car


        CarIndex.objects.put_mapping()
        # I don't understand why this is the *only* test that will randomly
        # blow up, unless you give ES a little time to do its thing
        time.sleep(.1)

        with suspended_updates():
            car = prepare(Car, pk=1)
            car2 = prepare(Car, pk=2)
            car3 = prepare(Car, pk=3)
            CarIndex.objects.update([car])
            CarIndex.objects.update(car2)
            CarIndex.objects.update(car3)
            # bulk saving shouldn't happen yet
            self.assertEqual([], CarIndex.objects.query("match", name=car.name).execute().hits)
            # suspended_updates should handle deletes too
            CarIndex.objects.delete(car3)

        # now saving to ES should have happen
        self.assertEqual(1, len(CarIndex.objects.query("match", name=car.name).execute().hits))
        self.assertEqual(1, len(CarIndex.objects.query("match", name=car2.name).execute().hits))
        # the third car was deleted
        self.assertEqual(0, len(CarIndex.objects.query("match", name=car3.name).execute().hits))

 def test_str(self):
     user = prepare(User, first_name="foo", last_name="bar")
     self.assertEqual(str(user), "bar, foo")
     # the str method should fall back on the email address if a part of
     # their name is blank
     user = prepare(User, first_name="", last_name="bar")
     self.assertEqual(str(user), user.email)

    def __create_distinct_comments(self, label):
        assignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
        group = mommy.make('core.AssignmentGroup', parentnode=assignment)
        feedbackset = mommy.make('devilry_group.FeedbackSet', group=group)

        examiner = mommy.make('core.Examiner',
                              assignmentgroup=group,
                              relatedexaminer__user=mommy.make(settings.AUTH_USER_MODEL))

        count = 100
        comments = []
        for x in range(count):
            comments.append(mommy.prepare(GroupComment, user=examiner.relatedexaminer.user, feedback_set=feedbackset,
                                          user_role=GroupComment.USER_ROLE_ADMIN))
            comments.append(mommy.prepare(GroupComment, user=examiner.relatedexaminer.user, feedback_set=feedbackset,
                                          user_role=GroupComment.USER_ROLE_STUDENT))
            comments.append(mommy.prepare(GroupComment, user=examiner.relatedexaminer.user, feedback_set=feedbackset,
                                          user_role=GroupComment.USER_ROLE_EXAMINER))

        with TimeExecution('{} ({})'.format(label, count)):
            for c in comments:
                c.save()

                # for c in comments:
                #    c.delete()
                #
        return group

    def test_allow_create_fkey_related_model(self):
        try:
            person = mommy.make(Person, dog_set=[mommy.prepare(Dog), mommy.prepare(Dog)])
        except TypeError:
            self.fail('type error raised')

        self.assertEqual(person.dog_set.count(), 2)

 def test_financial_aid_in_range_0_to_100(self):
     trips_year = self.init_trips_year()
     with self.assertRaises(ValidationError):
         mommy.make(IncomingStudent, trips_year=trips_year, financial_aid=-1).full_clean()
     with self.assertRaises(ValidationError):
         mommy.prepare(IncomingStudent, trips_year=trips_year, financial_aid=101).full_clean()
     mommy.prepare(IncomingStudent, trips_year=trips_year, financial_aid=100).full_clean()

    def test_can_cloak_as(self):
        """Only staffers can cloak"""
        user = prepare(User, is_staff=False)
        self.assertFalse(user.has_module_perms("foo"), user)

        user = prepare(User, is_staff=True)
        self.assertTrue(user.has_module_perms("foo"), user)

 def test_checks_if_token_has_expired(self):
     #  expired token
     yesterday = datetime.now() - timedelta(days=1)
     sso_user_token = mommy.prepare(SSOUserToken, expiration_datetime=yesterday)
     self.assertTrue(sso_user_token.has_expired)
     #  valid token
     tomorrow = datetime.now() + timedelta(days=1)
     sso_user_token = mommy.prepare(SSOUserToken, expiration_datetime=tomorrow)
     self.assertFalse(sso_user_token.has_expired)

 def test_clean_grading_points_is_none(self):
     testuser = mommy.prepare(settings.AUTH_USER_MODEL)
     testfeedbackset = mommy.prepare('devilry_group.FeedbackSet',
                                     grading_published_datetime=timezone.now(),
                                     grading_published_by=testuser,
                                     grading_points=None)
     with self.assertRaisesMessage(ValidationError,
                                   'A FeedbackSet can not be published without providing "points".'):
         testfeedbackset.clean()

    def test_password_field_only_when_user_being_created(self):
        """
        The password field should only be on the form if the user is being
        created (not edited)
        """
        form = UserForm(user=prepare(User))
        self.assertIn("password", form.fields)

        form = UserForm(instance=make(User), user=prepare(User))
        self.assertNotIn("password", form.fields)

def test_category_list_content(mocker):
    """Test the dictionary with the months and years."""
    category_mock = mocker.patch('djangopress.blog.models.Category.objects')
    uncategorized = mommy.prepare(Category, name='Uncategorized')
    uncategorized.pk = 1
    categories = mommy.prepare(Category, _quantity=3)
    categories.insert(0, uncategorized)
    category_mock.all.return_value = categories
    dictionary = {}
    dictionary['categories'] = categories
    assert category_list() == dictionary

 def test_bus_assignment_is_either_one_way_or_round_trip(self):
     msg = "Cannot have round-trip AND one-way bus assignments"
     with self.assertRaisesRegexp(ValidationError, msg):
         mommy.prepare(
             IncomingStudent, bus_assignment_round_trip=mommy.make(Stop), bus_assignment_to_hanover=mommy.make(Stop)
         ).full_clean()
     with self.assertRaisesRegexp(ValidationError, msg):
         mommy.prepare(
             IncomingStudent,
             bus_assignment_round_trip=mommy.make(Stop),
             bus_assignment_from_hanover=mommy.make(Stop),
         ).full_clean()

    def test_tag(self):
        # dog = Recipe(Dog)
        # tag_recipe = Recipe(
        #     Tag,
        #     content_object=foreign_key(dog))

        # tag = tag_recipe.prepare()
        dog = mommy.prepare(Dog)
        tag = mommy.prepare(Tag)
        tag.content_object = dog
        self.assertIsNotNone(tag.content_object)
        print "Mommy - test_tag: Dog Count", Dog.objects.all()
        print "Mommy - test_tag: Person Count", Person.objects.all()

def test_default_pagination_value(rf, mocker):
    """Test the default value when a bad pagination option is given."""
    mocker.patch('djangopress.blog.views.Option.objects.get_or_create',
                 new=option_get_or_create_stub('a')
                 )
    category_mock = mocker.patch('djangopress.blog.models.Category.objects')
    category = mommy.prepare(Category, name='Uncategorized')
    category.pk = 1
    category_mock.get_or_create.return_value = category, None
    posts_mock = mocker.patch('djangopress.blog.models.Post.objects.all')
    posts_mock.return_value = mommy.prepare(Post, _quantity=6)
    request = rf.get(reverse('djangopress:home'))
    response = PostList.as_view()(request)
    assert response.context_data['paginator'].per_page == 5

def test_post_list_custom_pagination_pag(rf, mocker):
    """Test a custom pagination value."""
    mocker.patch('djangopress.blog.views.Option.objects.get_or_create',
                 new=option_get_or_create_stub('3')
                 )
    category_mock = mocker.patch('djangopress.blog.models.Category.objects')
    category = mommy.prepare(Category, name='Uncategorized')
    category.pk = 1
    category_mock.get_or_create.return_value = category, None
    posts_mock = mocker.patch('djangopress.blog.models.Post.objects.all')
    posts_mock.return_value = mommy.prepare(Post, _quantity=4)
    request = rf.get(reverse('djangopress:home'))
    response = PostList.as_view()(request)
    assert response.context_data['is_paginated']

 def test_only_single_editable_group_for_each_period_id_none(self):
     period1 = mommy.make('core.Period')
     period2 = mommy.make('core.Period')
     permissiongroup = mommy.make('devilry_account.PermissionGroup',
                                  grouptype=PermissionGroup.GROUPTYPE_PERIODADMIN,
                                  is_custom_manageable=True)
     mommy.make('devilry_account.PeriodPermissionGroup',
                permissiongroup=permissiongroup,
                period=period1)
     with self.assertRaisesMessage(ValidationError, 'Only a single editable permission '
                                                    'group is allowed for a semester.'):
         mommy.prepare('devilry_account.PeriodPermissionGroup',
                       permissiongroup=permissiongroup,
                       period=period2).clean()

 def test_only_single_editable_group_for_each_subject_id_none(self):
     subject1 = mommy.make('core.Subject')
     subject2 = mommy.make('core.Subject')
     permissiongroup = mommy.make('devilry_account.PermissionGroup',
                                  grouptype=PermissionGroup.GROUPTYPE_SUBJECTADMIN,
                                  is_custom_manageable=True)
     mommy.make('devilry_account.SubjectPermissionGroup',
                permissiongroup=permissiongroup,
                subject=subject1)
     with self.assertRaisesMessage(ValidationError, 'Only a single editable permission '
                                                    'group is allowed for a course.'):
         mommy.prepare('devilry_account.SubjectPermissionGroup',
                       permissiongroup=permissiongroup,
                       subject=subject2).clean()