Python PollFactory.create方法代码示例

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_future_vote_action_item(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

        council = Group.objects.get(name='Council')
        start = now() + timedelta(hours=3)
        PollFactory.create(valid_groups=council, start=start)

        items = ActionItem.objects.filter(content_type=model)
        eq_(items.count(), 0)

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_view_current_voting(self, faked_message):
        """View a voting."""
        rep_group = Group.objects.get(name='Rep')
        poll_start = now() - timedelta(days=5)
        poll = PollFactory.create(valid_groups=rep_group,
                                  end=poll_start + timedelta(days=10))

        # Anonymous user.
        c = Client()
        response = c.get(poll.get_absolute_url(), follow=True)
        eq_(response.status_code, 200)
        self.assertJinja2TemplateUsed(response, 'main.jinja')

        # Logged in user.
        with self.login(self.rep) as client:
            response = client.get(poll.get_absolute_url())
        eq_(response.status_code, 200)
        self.assertJinja2TemplateUsed(response, 'vote_voting.jinja')

        # # Logged in as a mozillian user - not valid voting group.
        with self.login(self.mozillian) as client:
            response = client.get(poll.get_absolute_url(), follow=True)
        faked_message.error.assert_called_once_with(
            mock.ANY, 'You do not have the permissions to vote on this voting.')
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_view_post_a_comment(self, fake_messages):
        """Post a comment on an automated poll."""
        poll_start = now() - timedelta(days=5)
        poll_user = UserFactory.create(groups=['Council'])
        poll_group = Group.objects.get(name='Council')
        bug = BugFactory.create()
        swag_poll = PollFactory.create(name='swag poll', start=poll_start,
                                       end=poll_start + timedelta(days=15),
                                       created_by=poll_user,
                                       valid_groups=poll_group,
                                       bug=bug,
                                       automated_poll=True,
                                       description='Swag poll description.',
                                       slug='swag-poll')
        vote_url = reverse('voting_view_voting',
                           kwargs={'slug': 'swag-poll'})
        factory = RequestFactory()
        request = factory.post(vote_url, {'comment': 'This is a comment'},
                               follow=True)
        request.user = poll_user

        view_voting(request, slug=swag_poll.slug)
        poll_comment = PollComment.objects.get(poll=swag_poll)
        eq_(poll_comment.user, poll_user)
        eq_(poll_comment.comment, 'This is a comment')
        fake_messages.success.assert_called_once_with(
            mock.ANY, 'Comment saved successfully.')

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_comment_multiple_users(self):
        """Test sending email when a new comment is added on a Poll
        and the users have the option enabled in their settings.
        """
        commenter = UserFactory.create()
        creator = UserFactory.create(
            userprofile__receive_email_on_add_voting_comment=True)
        poll = PollFactory.create(created_by=creator)
        users_with_comments = UserFactory.create_batch(
            2, userprofile__receive_email_on_add_voting_comment=True)
        # disconnect the signals in order to add two users in PollComment
        for user_obj in users_with_comments:
            PollCommentFactoryNoSignals.create(
                user=user_obj, poll=poll, comment='This is a comment')
        PollCommentFactory.create(user=commenter, poll=poll,
                                  comment='This is a comment')

        eq_(len(mail.outbox), 3)
        recipients = ['%s <%s>' % (creator.get_full_name(), creator.email),
                      '%s <%s>' % (users_with_comments[0].get_full_name(),
                                   users_with_comments[0].email),
                      '%s <%s>' % (users_with_comments[1].get_full_name(),
                                   users_with_comments[1].email)]
        receivers = [mail.outbox[0].to[0], mail.outbox[1].to[0],
                     mail.outbox[2].to[0]]
        eq_(set(recipients), set(receivers))
        msg = ('[Voting] User {0} commented on {1}'
               .format(commenter.get_full_name(), poll))
        eq_(mail.outbox[0].subject, msg)

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_view_voting_results(self, faked_message):
        """View the results of a voting."""
        poll_start = now() - timedelta(days=5)
        poll = PollFactory.create(valid_groups=self.rep_group,
                                  start=poll_start,
                                  end=poll_start - timedelta(days=3),
                                  comments_allowed=False)

        # Anonymous user.
        client = Client()
        response = client.get(poll.get_absolute_url(), follow=True)
        eq_(response.status_code, 200)
        self.assertJinja2TemplateUsed(response, 'main.jinja')

        # Logged in user.
        with self.login(self.rep) as client:
            response = client.get(poll.get_absolute_url())
        eq_(response.status_code, 200)
        self.assertJinja2TemplateUsed(response, 'view_voting.jinja')

        # Logged in user, invalid voting group.
        with self.login(self.mozillian) as client:
            response = client.get(poll.get_absolute_url())
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        faked_message.error.assert_called_once_with(
            mock.ANY, 'You do not have the permissions to vote on this voting.')

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_budget_vote_action_item(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

        council = Group.objects.get(name='Council')
        user = UserFactory.create(groups=['Council'])
        bug = BugFactory.create()

        start = now() - timedelta(hours=3)
        poll = PollFactory.create(valid_groups=council, automated_poll=True,
                                  bug=bug, start=start)

        create_poll_action_items()

        items = ActionItem.objects.filter(content_type=model,
                                          object_id=poll.id)
        eq_(items.count(), 1)

        for item in items:
            eq_(item.name,
                'Cast your vote for budget request ' + poll.bug.summary)
            eq_(item.user, user)
            ok_(item.priority, ActionItem.NORMAL)
            ok_(not item.completed)

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_update_valid_groups(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

        council = Group.objects.get(name='Council')
        reps = Group.objects.get(name='Rep')
        UserFactory.create_batch(3, groups=['Council'])
        UserFactory.create_batch(4, groups=['Rep'])
        start = now() - timedelta(hours=3)
        poll = PollFactory.create(valid_groups=council, start=start)

        create_poll_action_items()

        poll.valid_groups = reps
        poll.save()

        items = ActionItem.objects.filter(content_type=model,
                                          object_id=poll.id)
        eq_(items.count(), 4)

        for user in reps.user_set.all():
            ok_(items.filter(user=user).exists())

        for user in council.user_set.all():
            ok_(not items.filter(user=user).exists())

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_view_edit_voting(self):
        """Test view edit voting."""
        poll_start = now() - timedelta(days=5)
        poll = PollFactory.create(valid_groups=self.admin_group, start=poll_start,
                                  end=poll_start + timedelta(days=10),
                                  comments_allowed=False,
                                  created_by=self.nominee1)

        # Anonymous user
        c = Client()
        response = c.get(reverse('voting_edit_voting', kwargs={'slug': poll.slug}), follow=True)
        eq_(response.status_code, 200)
        self.assertJinja2TemplateUsed(response, 'main.jinja')

        # Logged in user.
        with mock.patch('remo.base.decorators.messages.error') as faked_message:
            with self.login(self.rep) as client:
                response = client.get(reverse('voting_edit_voting', kwargs={'slug': poll.slug}),
                                      follow=True)
            self.assertJinja2TemplateUsed(response, 'main.jinja')
            ok_(faked_message.called)
            eq_(faked_message.call_args_list[0][0][1], 'Permission denied.')

        # Logged in as admin
        with self.login(self.admin) as client:
            response = client.get(reverse('voting_edit_voting', kwargs={'slug': poll.slug}))
            self.assertJinja2TemplateUsed(response, 'edit_voting.jinja')

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_view_delete_automated_poll(self):
        with mute_signals(post_save):
            poll_start = now() - timedelta(days=5)
            poll_user = UserFactory.create(groups=['Review'])
            poll_group = Group.objects.get(name='Review')
            bug = BugFactory.create()
            swag_poll = PollFactory.create(name='swag poll', start=poll_start,
                                           end=poll_start + timedelta(days=15),
                                           created_by=poll_user,
                                           valid_groups=poll_group,
                                           bug=bug,
                                           automated_poll=True,
                                           description='Swag poll description.',
                                           slug='swag-poll')

        with mock.patch('remo.voting.views.messages.success') as faked_message:
            with self.login(self.admin) as client:
                response = client.post(reverse('voting_delete_voting',
                                               kwargs={'slug': swag_poll.slug}),
                                       follow=True)
            self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
            ok_(faked_message.called)
            eq_(faked_message.call_args_list[0][0][1], 'Voting successfully deleted.')
            ok_(not Poll.objects.filter(id=swag_poll.id).exists())
            ok_(not Bug.objects.filter(id=bug.id).exists())

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_view_post_a_comment(self, fake_messages):
        """Post a comment on poll."""
        poll_start = datetime2pdt() - timedelta(days=5)
        poll_user = UserFactory.create(groups=["Council"])
        poll_group = Group.objects.get(name="Council")
        swag_poll = PollFactory.create(
            name="swag poll",
            start=poll_start,
            end=poll_start + timedelta(days=15),
            created_by=poll_user,
            valid_groups=poll_group,
            automated_poll=True,
            description="Swag poll description.",
            slug="swag-poll",
        )
        vote_url = reverse("voting_view_voting", kwargs={"slug": "swag-poll"})
        factory = RequestFactory()
        request = factory.post(vote_url, {"comment": "This is a comment"}, follow=True)
        request.user = poll_user

        response = view_voting(request, slug=swag_poll.slug)
        self.assertTemplateUsed(response, "list_votings.html")
        poll_comment = PollComment.objects.get(poll=swag_poll)
        eq_(poll_comment.user, poll_user)
        eq_(poll_comment.comment, "This is a comment")
        fake_messages.success.assert_called_once_with(mock.ANY, "Your vote has been successfully registered.")

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
 def test_clean_one_radio_one_range_poll(self):
     """Test with valid data for one radio and one range poll."""
     poll = PollFactory.create(start=datetime(now().year + 1, 2, 1, tzinfo=pytz.UTC))
     form = forms.PollAddForm(data=self.form_data,
                              instance=poll,
                              radio_poll_formset=self.radio_poll_formset,
                              range_poll_formset=self.range_poll_formset)
     ok_(form.is_valid())

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
 def test_base(self):
     poll = PollFactory.create()
     range_poll = RangePollFactory.create(poll=poll)
     RangePollChoiceFactory.create(range_poll=range_poll)
     data = {'range_poll__{0}'.format(range_poll.choices.all()[0].id): u'1'}
     vote_form = forms.RangePollChoiceVoteForm(data=data,
                                               choices=range_poll.choices.all())
     ok_(vote_form.is_valid())

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_vote_action_item(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

        council = Group.objects.get(name='Council')
        user = UserFactory.create(groups=['Council'])
        PollFactory.create(valid_groups=council)

        items = ActionItem.objects.filter(content_type=model)
        eq_(items.count(), 1)

        for item in items:
            eq_(item.name, 'Cast your vote')
            eq_(item.user, user)
            ok_(item.priority, ActionItem.NORMAL)
            ok_(not item.completed)

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
    def test_resolved_past_vote(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

        council = Group.objects.get(name='Council')
        UserFactory.create(groups=['Council'])
        PollFactory.create(valid_groups=council,
                           end=now() - timedelta(days=1))

        items = ActionItem.objects.filter(content_type=model)
        eq_(items.count(), 1)

        resolve_action_items()
        items = ActionItem.objects.filter(content_type=model)
        for item in items:
            ok_(item.resolved)
            ok_(not item.completed)

# 需要导入模块: from remo.voting.tests import PollFactory [as 别名]
# 或者: from remo.voting.tests.PollFactory import create [as 别名]
 def test_delete_as_other_rep(self):
     user = UserFactory.create(groups=['Rep'])
     group = Group.objects.get(name='Rep')
     poll = PollFactory.create(created_by=user, valid_groups=group)
     comment = PollCommentFactory.create(poll=poll, user=user,
                                         comment='This is a comment')
     other_rep = UserFactory.create(groups=['Rep'])
     self.post(user=other_rep, url=comment.get_absolute_delete_url())
     ok_(PollComment.objects.filter(pk=comment.id).exists())