Python UserFactory.create_batch方法代码示例

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
 def test_filter_emails_alternate(self):
     request = self.factory.get('/', {'email': '[email protected]'})
     user = UserFactory.create(email='[email protected]')
     UserFactory.create_batch(2)
     ExternalAccount.objects.create(user=user.userprofile, type=ExternalAccount.TYPE_EMAIL,
                                    identifier='[email protected]')
     f = UserProfileFilter(request.GET, queryset=UserProfile.objects.all())
     eq_(f.qs.count(), 1)
     eq_(f.qs[0], user.userprofile)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
 def test_filter_emails_alternate_idp(self):
     request = self.factory.get('/', {'email': '[email protected]'})
     user = UserFactory.create(email='[email protected]')
     UserFactory.create_batch(2)
     IdpProfile.objects.create(
         profile=user.userprofile,
         auth0_user_id='ad|[email protected]',
         email='[email protected]'
     )
     f = UserProfileFilter(request.GET, queryset=UserProfile.objects.all())
     eq_(f.qs.count(), 1)
     eq_(f.qs[0], user.userprofile)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_group_member_count_only_members(self):
        group = GroupFactory.create(name='foo')
        users = UserFactory.create_batch(3)
        for u in users:
            group.add_member(u.userprofile)

        eq_(Group.objects.get(name='foo').member_count, 3)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_skill_member_count(self):
        skill = SkillFactory.create(name='foo')
        users = UserFactory.create_batch(3)
        for u in users:
            skill.add_member(u.userprofile)

        eq_(Skill.objects.get(name='foo').member_count, 3)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_accept_reject_user_not_redeemer(self):
        inviter, redeemer = UserFactory.create_batch(2)
        invite = InviteFactory.create(inviter=inviter.userprofile, redeemer=redeemer.userprofile)
        user = UserFactory.create()

        with self.login(user) as client:
            url = reverse("groups:accept_reject_invitation", args=[invite.pk, "accept"])
            response = client.get(url, follow=True)
            eq_(response.status_code, 404)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_send_invitation_email_no_curator_manager(self):
        inviter, redeemer = UserFactory.create_batch(2)
        invite = InviteFactory.create(inviter=inviter.userprofile, redeemer=redeemer.userprofile)
        user = UserFactory.create()

        with self.login(user) as client:
            url = urlparams(reverse("groups:send_invitation_email", args=[invite.pk]), "invitation")
            response = client.get(url, follow=True)
            eq_(response.status_code, 404)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_reject_invitation(self):
        inviter, redeemer = UserFactory.create_batch(2)
        invite = InviteFactory.create(inviter=inviter.userprofile, redeemer=redeemer.userprofile)

        with self.login(redeemer) as client:
            url = reverse("groups:accept_reject_invitation", args=[invite.pk, "reject"])
            response = client.get(url, follow=True)
            eq_(response.status_code, 200)

        invite = Invite.objects.filter(pk=invite.pk)
        ok_(not invite.exists())

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_accept_invitation_without_terms(self):
        inviter, redeemer = UserFactory.create_batch(2)
        invite = InviteFactory.create(inviter=inviter.userprofile, redeemer=redeemer.userprofile)

        with self.login(redeemer) as client:
            url = reverse("groups:accept_reject_invitation", args=[invite.pk, "accept"])
            response = client.get(url, follow=True)
            eq_(response.status_code, 200)

        invite = Invite.objects.get(pk=invite.pk)
        ok_(invite.accepted)
        ok_(invite.group.has_member(redeemer.userprofile))

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_group_member_count_non_members(self):
        group = GroupFactory.create(name='foo')
        users = UserFactory.create_batch(10)

        for u in users[:3]:
            group.add_member(u.userprofile, status=GroupMembership.MEMBER)

        for u in users[3:7]:
            group.add_member(u.userprofile, status=GroupMembership.PENDING)

        for u in users[7:]:
            group.add_member(u.userprofile, status=GroupMembership.PENDING_TERMS)

        eq_(Group.objects.get(name='foo').member_count, 3)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_send_invitation_email_different_curator(self, mock_success, mock_notification):
        curator, inviter = UserFactory.create_batch(2)
        redeemer = UserFactory.create(userprofile={"full_name": "Foo Bar"})
        invite = InviteFactory.create(inviter=inviter.userprofile, redeemer=redeemer.userprofile)
        invite.group.curators.add(curator.userprofile)
        invite.group.curators.add(inviter.userprofile)

        with self.login(curator) as client:
            url = urlparams(reverse("groups:send_invitation_email", args=[invite.pk]), "invitation")
            response = client.get(url, follow=True)
            eq_(response.status_code, 200)

        mock_notification.delay.assert_called_once_with(invite.pk, "")
        msg = "Invitation to Foo Bar has been sent successfully."
        mock_success.assert_called_once_with(ANY, msg)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
 def test_send_invitation_invalid_email(self, mock_send_email):
     inviter, redeemer = UserFactory.create_batch(2)
     group = GroupFactory.create(name='Foo')
     template_name = 'groups/email/invite_invalid_email.txt'
     InviteFactory.create(inviter=inviter.userprofile,
                          redeemer=redeemer.userprofile,
                          group=group)
     with patch('mozillians.groups.tasks.get_template', autospec=True) as mock_get_template:
         tasks.notify_redeemer_invitation_invalid(redeemer.userprofile.pk, group.pk)
     args = [
         '[Mozillians] Invitation to group "foo" is no longer valid',
         ANY,
         '[email protected]',
         [redeemer.userprofile.email]
     ]
     ok_(mock_get_template.called)
     eq_(template_name, mock_get_template.call_args[0][0])
     mock_send_email.assert_called_once_with(*args)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_accept_invitation_with_terms(self):
        inviter, redeemer = UserFactory.create_batch(2)
        invite = InviteFactory.create(inviter=inviter.userprofile, redeemer=redeemer.userprofile)
        invite.group.terms = "Group Terms"
        invite.group.save()

        with self.login(redeemer) as client:
            url = reverse("groups:accept_reject_invitation", args=[invite.pk, "accept"])
            response = client.get(url, follow=True)
            eq_(response.status_code, 200)

        invite = Invite.objects.get(pk=invite.pk)
        ok_(invite.accepted)
        ok_(
            invite.group.groupmembership_set.filter(
                userprofile=redeemer.userprofile, status=GroupMembership.PENDING_TERMS
            ).exists()
        )

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
    def test_show_common_skills(self):
        """Show most common skills first."""
        user_1 = UserFactory.create()
        user_2 = UserFactory.create()
        user_3 = UserFactory.create()
        user_4 = UserFactory.create()

        group = GroupFactory.create()
        group.add_member(user_1.userprofile)
        group.add_member(user_2.userprofile)
        group.add_member(user_3.userprofile)
        group.add_member(user_4.userprofile)

        skill_1 = SkillFactory.create()
        skill_2 = SkillFactory.create()
        skill_3 = SkillFactory.create()
        skill_4 = SkillFactory.create()
        skill_3.members.add(user_1.userprofile)
        skill_3.members.add(user_2.userprofile)
        skill_3.members.add(user_3.userprofile)
        skill_3.members.add(user_4.userprofile)
        skill_2.members.add(user_2.userprofile)
        skill_2.members.add(user_3.userprofile)
        skill_2.members.add(user_4.userprofile)
        skill_4.members.add(user_3.userprofile)
        skill_4.members.add(user_4.userprofile)
        skill_1.members.add(user_1.userprofile)
        users = UserFactory.create_batch(5)
        for user in users:
            skill_4.members.add(user.userprofile)

        url = reverse('groups:show_group', kwargs={'url': group.url})
        with self.login(user_1) as client:
            response = client.get(url, follow=True)
        eq_(response.status_code, 200)
        skills = response.context['skills']
        eq_(skills[0], skill_3)
        eq_(skills[1], skill_2)
        eq_(skills[2], skill_4)
        ok_(skill_1 not in skills)

# 需要导入模块: from mozillians.users.tests import UserFactory [as 别名]
# 或者: from mozillians.users.tests.UserFactory import create_batch [as 别名]
 def test_only_unvouched(self):
     UserFactory.create_batch(4, vouched=False)
     UserFactory.create_batch(3, vouched=True)
     qs = UserProfile.objects.all()
     eq_(filter_vouched(qs, 'no').count(), 4)