Esempio n. 1
0
    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)
Esempio n. 2
0
    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)
Esempio n. 3
0
    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())
Esempio n. 4
0
    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)
Esempio n. 5
0
    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')
Esempio n. 6
0
    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.')
Esempio n. 7
0
    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.')
Esempio n. 8
0
    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')
Esempio n. 9
0
    def test_extend_voting_period_majority(self):
        bug = BugFactory.create()
        start = now().replace(microsecond=0)
        end = datetime.combine(get_date(days=1), datetime.min.time())

        user = UserFactory.create(groups=['Admin'])
        group = Group.objects.get(name='Review')
        User.objects.filter(groups__name='Review').delete()
        UserFactory.create_batch(9, groups=['Review'])

        with mute_signals(post_save):
            automated_poll = PollFactory.create(name='poll',
                                                start=start, end=end,
                                                valid_groups=group,
                                                created_by=user,
                                                automated_poll=True,
                                                bug=bug)

        radio_poll = RadioPollFactory.create(poll=automated_poll,
                                             question='Budget Approval')
        RadioPollChoiceFactory.create(answer='Approved', votes=5,
                                      radio_poll=radio_poll)
        RadioPollChoiceFactory.create(answer='Denied', votes=3,
                                      radio_poll=radio_poll)

        extend_voting_period()

        poll = Poll.objects.get(pk=automated_poll.id)
        eq_(poll.end.year, end.year)
        eq_(poll.end.month, end.month)
        eq_(poll.end.day, end.day)
        eq_(poll.end.hour, 0)
        eq_(poll.end.minute, 0)
        eq_(poll.end.second, 0)
        ok_(not poll.is_extended)
Esempio n. 10
0
    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.")
Esempio n. 11
0
    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())
Esempio n. 12
0
    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())
Esempio n. 13
0
    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)

        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)
Esempio n. 14
0
    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)
Esempio n. 15
0
    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.')
Esempio n. 16
0
    def test_view_edit_current_voting(self):
        """Test current voting test."""
        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)

        # Logged in as a non-admin user.
        with mock.patch(
                'remo.base.decorators.messages.error') as faked_message:
            with self.login(self.rep) as client:
                response = client.post(reverse('voting_edit_voting',
                                               kwargs={'slug': poll.slug}),
                                       self.edit_current_data,
                                       follow=True)
            eq_(response.request['PATH_INFO'], '/')
            ok_(faked_message.called)
            eq_(faked_message.call_args_list[0][0][1], 'Permission denied.')

        # Logged in as administrator.
        with mock.patch('remo.voting.views.messages.success') as faked_message:
            with self.login(self.admin) as client:
                response = client.post(reverse('voting_edit_voting',
                                               kwargs={'slug': poll.slug}),
                                       self.edit_current_data,
                                       follow=True)
            eq_(response.request['PATH_INFO'],
                reverse('voting_edit_voting', kwargs={'slug': poll.slug}))
            ok_(faked_message.called)
            eq_(faked_message.call_args_list[0][0][1],
                'Voting successfully edited.')

        # Ensure voting data get saved.
        poll = Poll.objects.get(name='Test edit voting')

        # Test fields with the same name in POST data and models.
        excluded = ['valid_groups', 'created_by']
        for field in set(self.edit_current_data).difference(set(excluded)):
            if getattr(poll, field, None):
                eq_(getattr(poll, field), self.edit_current_data[field])

        # Test excluded fields.
        eq_(self.edit_current_data['created_by'], poll.created_by.id)
        eq_(self.edit_current_data['valid_groups'], poll.valid_groups.id)

        # Ensure voting end is saved.
        month = self.edit_current_data['end_form_0_month']
        day = self.edit_current_data['end_form_0_day']
        year = self.edit_current_data['end_form_0_year']
        hour = self.edit_current_data['end_form_1_hour']
        minute = self.edit_current_data['end_form_1_minute']

        end = datetime(year, month, day, hour, minute)
        eq_(make_aware(end, pytz.UTC), poll.end)

        start_year = self.edit_current_data['start_form_0_year']
        self.assertNotEqual(poll.start.year, start_year)
Esempio n. 17
0
    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)
Esempio n. 18
0
 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())
Esempio n. 19
0
 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())
Esempio n. 20
0
 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())
Esempio n. 21
0
    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)
Esempio n. 22
0
 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())
Esempio n. 23
0
    def test_send_discussion_email_to_council_edit(self):
        bug = BugFactory.create(bug_id=989812)
        automated_poll = PollFactory.build(
            name='automated_poll', automated_poll=True, bug=bug)

        with patch('remo.voting.models.send_remo_mail') as mocked_send_mail:
            automated_poll_discussion_email(None, automated_poll, False, {})

        ok_(not mocked_send_mail.called)
Esempio n. 24
0
 def test_delete_as_owner(self, redirect_mock):
     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')
     with self.login(user) as client:
         client.post(comment.get_absolute_delete_url(), user=comment.user)
     ok_(not PollComment.objects.filter(pk=comment.id).exists())
     redirect_mock.assert_called_with(poll.get_absolute_url())
Esempio n. 25
0
    def test_send_discussion_email_to_council_edit(self):
        bug = BugFactory.create(bug_id=989812)
        automated_poll = PollFactory.build(name='automated_poll',
                                           automated_poll=True,
                                           bug=bug)

        with patch('remo.voting.models.send_remo_mail') as mocked_send_mail:
            automated_poll_discussion_email(None, automated_poll, False, {})

        ok_(not mocked_send_mail.called)
Esempio n. 26
0
 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'])
     with self.login(other_rep) as client:
         client.post(comment.get_absolute_delete_url(), user=other_rep)
     ok_(PollComment.objects.filter(pk=comment.id).exists())
Esempio n. 27
0
 def test_invalid(self):
     poll = PollFactory.create()
     range_poll = RangePollFactory.create(poll=poll)
     RangePollChoiceFactory.create(range_poll=range_poll)
     field_name = 'range_poll__{0}'.format(range_poll.choices.all()[0].id)
     data = {field_name: u'0'}
     vote_form = forms.RangePollChoiceVoteForm(
         data=data, choices=range_poll.choices.all())
     ok_(not vote_form.is_valid())
     ok_(field_name in vote_form.errors)
     ok_(vote_form[field_name], 'You must vote at least one nominee')
Esempio n. 28
0
 def test_one_user_settings_False(self):
     """Test sending email when a new comment is added on a Poll
     and the user has the option disabled in his/her settings.
     """
     commenter = UserFactory.create()
     user = UserFactory.create(userprofile__receive_email_on_add_voting_comment=False)
     with mute_signals(post_save):
         poll = PollFactory.create(created_by=user)
     with patch('remo.voting.models.send_remo_mail.delay') as mail_mock:
         PollCommentFactory.create(user=commenter, poll=poll, comment='This is a comment')
     ok_(not mail_mock.called)
Esempio n. 29
0
    def test_view_future_voting(self):
        """View a voting planned to start in the future."""
        poll_start = now() + timedelta(days=5)
        poll = PollFactory.create(valid_groups=self.rep_group,
                                  start=poll_start,
                                  end=poll_start + timedelta(days=10),
                                  comments_allowed=False)

        with self.login(self.rep) as client:
            response = client.get(poll.get_absolute_url())
        self.assertJinja2TemplateUsed(response, 'vote_voting.jinja')
Esempio n. 30
0
 def test_invalid(self):
     poll = PollFactory.create()
     range_poll = RangePollFactory.create(poll=poll)
     RangePollChoiceFactory.create(range_poll=range_poll)
     field_name = 'range_poll__{0}'.format(range_poll.choices.all()[0].id)
     data = {field_name: u'0'}
     vote_form = forms.RangePollChoiceVoteForm(data=data,
                                               choices=range_poll.choices.all())
     ok_(not vote_form.is_valid())
     ok_(field_name in vote_form.errors)
     ok_(vote_form[field_name], 'You must vote at least one nominee')
Esempio n. 31
0
    def test_view_edit_current_voting(self):
        """Test current voting test."""
        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)

        # Logged in as a non-admin user.
        with mock.patch('remo.base.decorators.messages.error') as faked_message:
            with self.login(self.rep) as client:
                response = client.post(reverse('voting_edit_voting', kwargs={'slug': poll.slug}),
                                       self.edit_current_data, follow=True)
            eq_(response.request['PATH_INFO'], '/')
            ok_(faked_message.called)
            eq_(faked_message.call_args_list[0][0][1], 'Permission denied.')

        # Logged in as administrator.
        with mock.patch('remo.voting.views.messages.success') as faked_message:
            with self.login(self.admin) as client:
                response = client.post(reverse('voting_edit_voting', kwargs={'slug': poll.slug}),
                                       self.edit_current_data, follow=True)
            eq_(response.request['PATH_INFO'],
                reverse('voting_edit_voting', kwargs={'slug': poll.slug}))
            ok_(faked_message.called)
            eq_(faked_message.call_args_list[0][0][1], 'Voting successfully edited.')

        # Ensure voting data get saved.
        poll = Poll.objects.get(name='Test edit voting')

        # Test fields with the same name in POST data and models.
        excluded = ['valid_groups', 'created_by']
        for field in set(self.edit_current_data).difference(set(excluded)):
            if getattr(poll, field, None):
                eq_(getattr(poll, field), self.edit_current_data[field])

        # Test excluded fields.
        eq_(self.edit_current_data['created_by'], poll.created_by.id)
        eq_(self.edit_current_data['valid_groups'], poll.valid_groups.id)

        # Ensure voting end is saved.
        month = self.edit_current_data['end_form_0_month']
        day = self.edit_current_data['end_form_0_day']
        year = self.edit_current_data['end_form_0_year']
        hour = self.edit_current_data['end_form_1_hour']
        minute = self.edit_current_data['end_form_1_minute']

        end = datetime(year, month, day, hour, minute)
        eq_(make_aware(end, pytz.UTC), poll.end)

        start_year = self.edit_current_data['start_form_0_year']
        self.assertNotEqual(poll.start.year, start_year)
Esempio n. 32
0
 def test_post_a_comment(self, form_mock, messages_mock):
     user = UserFactory.create(groups=['Rep'])
     group = Group.objects.get(name='Rep')
     poll = PollFactory.create(created_by=user, valid_groups=group)
     form_mock.is_valid.return_value = True
     response = self.post(url=poll.get_absolute_url(),
                          user=user, data={'comment': 'This is a comment'})
     eq_(response.status_code, 200)
     messages_mock.assert_called_with(
         mock.ANY, 'Comment saved successfully.')
     ok_(form_mock().save.called)
     eq_(response.context['poll'], poll)
     self.assertTemplateUsed('vote_voting.html')
Esempio n. 33
0
 def test_one_user_settings_False(self):
     """Test sending email when a new comment is added on a Poll
     and the user has the option disabled in his/her settings.
     """
     commenter = UserFactory.create()
     user = UserFactory.create(
         userprofile__receive_email_on_add_voting_comment=False)
     with mute_signals(post_save):
         poll = PollFactory.create(created_by=user)
     with patch('remo.voting.models.send_remo_mail.delay') as mail_mock:
         PollCommentFactory.create(user=commenter,
                                   poll=poll,
                                   comment='This is a comment')
     ok_(not mail_mock.called)
Esempio n. 34
0
 def test_post_a_comment(self, form_mock, messages_mock):
     user = UserFactory.create(groups=['Rep'])
     group = Group.objects.get(name='Rep')
     poll = PollFactory.create(created_by=user, valid_groups=group)
     form_mock.is_valid.return_value = True
     response = self.post(url=poll.get_absolute_url(),
                          user=user,
                          data={'comment': 'This is a comment'})
     eq_(response.status_code, 200)
     messages_mock.assert_called_with(mock.ANY,
                                      'Comment saved successfully.')
     ok_(form_mock().save.called)
     eq_(response.context['poll'], poll)
     self.assertTemplateUsed('vote_voting.html')
Esempio n. 35
0
    def test_send_discussion_email_to_council(self):
        bug = BugFactory.create(bug_id=989812)
        automated_poll = PollFactory.build(
            name='automated_poll', automated_poll=True, bug=bug)

        with patch('remo.voting.models.send_remo_mail') as mocked_send_mail:
            automated_poll_discussion_email(None, automated_poll, True, {})

        subject = 'Discuss [Bug 989812] - Bug summary'
        data = {'bug': bug, 'BUGZILLA_URL': BUGZILLA_URL,
                'poll': automated_poll}
        mocked_send_mail.delay.assert_called_once_with(
            subject=subject,
            email_template='emails/review_budget_notify_council.txt',
            recipients_list=[settings.REPS_COUNCIL_ALIAS],
            data=data)
Esempio n. 36
0
    def test_comment_one_user(self):
        """Test sending email when a new comment is added on a Poll
        and the user has the option enabled in his/her settings.
        """
        commenter = UserFactory.create()
        creator = UserFactory.create(
            userprofile__receive_email_on_add_voting_comment=True)
        # Disable notifications related to the creation of a poll
        with mute_signals(post_save):
            poll = PollFactory.create(created_by=creator)

        with patch('remo.voting.models.send_remo_mail.delay') as mail_mock:
            PollCommentFactory.create(user=commenter, poll=poll, comment='This is a comment')

        ok_(mail_mock.called)
        eq_(mail_mock.call_count, 1)
Esempio n. 37
0
    def test_update_vote_due_date(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'])
        poll = PollFactory.create(valid_groups=council)

        poll.end = poll.end + timedelta(days=4)
        poll.save()

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

        for item in items:
            eq_(item.due_date, poll.end.date())
Esempio n. 38
0
    def test_resolve_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'])
        poll = PollFactory.create(valid_groups=council)

        VoteFactory.create(poll=poll, user=user)

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

        for item in items:
            ok_(item.completed)
            ok_(item.resolved)
Esempio n. 39
0
    def test_resolve_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'])
        start = now() - timedelta(hours=3)
        poll = PollFactory.create(valid_groups=council, start=start)
        VoteFactory.create(poll=poll, user=user)

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

        for item in items:
            ok_(item.completed)
            ok_(item.resolved)
Esempio n. 40
0
    def test_extend_voting_period_no_majority(self):
        bug = BugFactory.create()
        start = now().replace(microsecond=0)
        end = datetime.combine(get_date(days=1), datetime.min.time())
        new_end = datetime.combine(get_date(days=2), datetime.min.time())

        user = UserFactory.create(groups=['Admin'])
        group = Group.objects.get(name='Review')
        User.objects.filter(groups__name='Review').delete()
        review = UserFactory.create_batch(9, groups=['Review'])

        with mute_signals(post_save):
            automated_poll = PollFactory.create(name='poll',
                                                start=start,
                                                end=end,
                                                valid_groups=group,
                                                created_by=user,
                                                automated_poll=True,
                                                bug=bug)

        radio_poll = RadioPollFactory.create(poll=automated_poll,
                                             question='Budget Approval')
        RadioPollChoiceFactory.create(answer='Approved',
                                      votes=3,
                                      radio_poll=radio_poll)
        RadioPollChoiceFactory.create(answer='Denied',
                                      votes=4,
                                      radio_poll=radio_poll)
        VoteFactory.create(user=review[0], poll=automated_poll)

        with patch('remo.voting.tasks.send_remo_mail.delay') as mocked_mail:
            extend_voting_period()

        poll = Poll.objects.get(pk=automated_poll.id)
        eq_(poll.end.year, new_end.year)
        eq_(poll.end.month, new_end.month)
        eq_(poll.end.day, new_end.day)
        eq_(poll.end.hour, 0)
        eq_(poll.end.minute, 0)
        eq_(poll.end.second, 0)
        ok_(poll.is_extended)

        # Test that only the 1 that hasn't voted gets a notification
        ok_(mocked_mail.called)
        eq_(mocked_mail.call_count, 1)
Esempio n. 41
0
    def test_send_discussion_email_to_council(self):
        bug = BugFactory.create(bug_id=989812)
        automated_poll = PollFactory.build(name='automated_poll',
                                           automated_poll=True,
                                           bug=bug)

        with patch('remo.voting.models.send_remo_mail') as mocked_send_mail:
            automated_poll_discussion_email(None, automated_poll, True, {})

        subject = 'Discuss [Bug 989812] - Bug summary'
        data = {'bug': bug, 'BUGZILLA_URL': BUGZILLA_URL}
        headers = {'Reply-To': settings.REPS_COUNCIL_ALIAS}
        mocked_send_mail.delay.assert_called_once_with(
            subject=subject,
            email_template='emails/review_budget_notify_council.txt',
            recipients_list=[settings.REPS_COUNCIL_ALIAS],
            data=data,
            headers=headers)
Esempio n. 42
0
    def test_comment_one_user(self):
        """Test sending email when a new comment is added on a Poll
        and the user has the option enabled in his/her settings.
        """
        commenter = UserFactory.create()
        creator = UserFactory.create(
            userprofile__receive_email_on_add_voting_comment=True)
        # Disable notifications related to the creation of a poll
        with mute_signals(post_save):
            poll = PollFactory.create(created_by=creator)

        with patch('remo.voting.models.send_remo_mail.delay') as mail_mock:
            PollCommentFactory.create(user=commenter,
                                      poll=poll,
                                      comment='This is a comment')

        ok_(mail_mock.called)
        eq_(mail_mock.call_count, 1)
Esempio n. 43
0
    def test_user_has_already_voted(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

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

        start = now() - timedelta(hours=3)
        poll = PollFactory.create(valid_groups=council,
                                  end=now() - timedelta(days=1),
                                  start=start)
        VoteFactory.create(poll=poll, user=user)

        # Check that there is only one action item and it's resolved
        items = ActionItem.objects.filter(content_type=model)
        eq_(items.count(), 1)
        eq_(items[0].resolved, True)
Esempio n. 44
0
    def test_user_has_already_voted(self):
        model = ContentType.objects.get_for_model(Poll)
        items = ActionItem.objects.filter(content_type=model)
        ok_(not items.exists())

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

        start = now() - timedelta(hours=3)
        poll = PollFactory.create(valid_groups=council,
                                  end=now() - timedelta(days=1),
                                  start=start)
        VoteFactory.create(poll=poll, user=user)

        # Check that there is only one action item and it's resolved
        items = ActionItem.objects.filter(content_type=model)
        eq_(items.count(), 1)
        eq_(items[0].resolved, True)
Esempio n. 45
0
    def test_update_vote_due_date(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'])
        start = now() - timedelta(hours=3)
        poll = PollFactory.create(valid_groups=council, start=start)

        poll.end = poll.end + timedelta(days=4)
        poll.save()

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

        for item in items:
            eq_(item.due_date, poll.end.date())
Esempio n. 46
0
    def test_view_cast_a_vote(self, fake_messages):
        """Cast a vote on a voting."""
        poll_start = now() - timedelta(days=5)
        poll = PollFactory.create(valid_groups=self.rep_group,
                                  start=poll_start,
                                  end=poll_start + timedelta(days=10),
                                  comments_allowed=False)

        # Cast a vote as a valid user.
        with self.login(self.rep) as client:
            response = client.post(poll.get_absolute_url(), self.post_data)
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        fake_messages.success.assert_called_once_with(
            mock.ANY, 'Your vote has been successfully registered.')

        # Ensure that there is a vote for user 'rep'
        poll = Poll.objects.get(id=poll.id)
        eq_(poll.users_voted.filter(username=self.rep.username).count(), 1)

        # Cast a vote as a valid user for a second time.
        with self.login(self.rep) as client:
            response = client.post(poll.get_absolute_url(),
                                   self.post_data,
                                   follow=True)
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        fake_messages.warning.assert_called_once_with(
            mock.ANY, ('You have already cast your vote for this voting. '
                       'Come back to see the results on %s UTC.' %
                       poll.end.strftime('%Y %B %d, %H:%M')))
        eq_(poll.users_voted.filter(username=self.rep.username).count(), 1)

        # Cast a vote as an invalid user.
        with self.login(self.mozillian) as client:
            response = client.post(poll.get_absolute_url(),
                                   self.post_data,
                                   follow=True)
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        fake_messages.error.assert_called_once_with(
            mock.ANY, ('You do not have the permissions to vote '
                       'on this voting.'))
        eq_(
            poll.users_voted.filter(username=self.mozillian.username).count(),
            0)
Esempio n. 47
0
    def test_extend_voting_period_no_majority(self):
        bug = BugFactory.create()
        start = now().replace(microsecond=0)
        end = datetime.combine(get_date(days=1), datetime.min.time())
        new_end = datetime.combine(get_date(days=2), datetime.min.time())

        user = UserFactory.create(groups=['Admin'])
        group = Group.objects.get(name='Review')
        User.objects.filter(groups__name='Review').delete()
        review = UserFactory.create_batch(9, groups=['Review'])

        with mute_signals(post_save):
            automated_poll = PollFactory.create(name='poll',
                                                start=start, end=end,
                                                valid_groups=group,
                                                created_by=user,
                                                automated_poll=True,
                                                bug=bug)

        radio_poll = RadioPollFactory.create(poll=automated_poll,
                                             question='Budget Approval')
        RadioPollChoiceFactory.create(answer='Approved', votes=3,
                                      radio_poll=radio_poll)
        RadioPollChoiceFactory.create(answer='Denied', votes=4,
                                      radio_poll=radio_poll)
        VoteFactory.create(user=review[0], poll=automated_poll)

        with patch('remo.voting.tasks.send_remo_mail.delay') as mocked_mail:
            extend_voting_period()

        poll = Poll.objects.get(pk=automated_poll.id)
        eq_(poll.end.year, new_end.year)
        eq_(poll.end.month, new_end.month)
        eq_(poll.end.day, new_end.day)
        eq_(poll.end.hour, 0)
        eq_(poll.end.minute, 0)
        eq_(poll.end.second, 0)
        ok_(poll.is_extended)

        # Test that only the 1 that hasn't voted gets a notification
        ok_(mocked_mail.called)
        eq_(mocked_mail.call_count, 1)
Esempio n. 48
0
    def test_send_discussion_email_to_council(self):
        bug = BugFactory.create(bug_id=989812)
        automated_poll = PollFactory.build(name='automated_poll',
                                           automated_poll=True,
                                           bug=bug)

        with patch('remo.voting.models.send_remo_mail') as mocked_send_mail:
            automated_poll_discussion_email(None, automated_poll, True, {})

        subject = 'Discuss [Bug 989812] - Bug summary'
        data = {
            'bug': bug,
            'BUGZILLA_URL': get_bugzilla_url(bug),
            'poll': automated_poll
        }
        mocked_send_mail.delay.assert_called_once_with(
            subject=subject,
            email_template='emails/review_budget_notify_review_team.jinja',
            recipients_list=[settings.REPS_REVIEW_ALIAS],
            data=data)
Esempio n. 49
0
    def test_extend_voting_period_majority(self):
        bug = BugFactory.create()
        start = now().replace(microsecond=0)
        end = datetime.combine(get_date(days=1), datetime.min.time())

        user = UserFactory.create(groups=['Admin'])
        group = Group.objects.get(name='Review')
        User.objects.filter(groups__name='Review').delete()
        UserFactory.create_batch(9, groups=['Review'])

        with mute_signals(post_save):
            automated_poll = PollFactory.create(name='poll',
                                                start=start,
                                                end=end,
                                                valid_groups=group,
                                                created_by=user,
                                                automated_poll=True,
                                                bug=bug)

        radio_poll = RadioPollFactory.create(poll=automated_poll,
                                             question='Budget Approval')
        RadioPollChoiceFactory.create(answer='Approved',
                                      votes=5,
                                      radio_poll=radio_poll)
        RadioPollChoiceFactory.create(answer='Denied',
                                      votes=3,
                                      radio_poll=radio_poll)

        extend_voting_period()

        poll = Poll.objects.get(pk=automated_poll.id)
        eq_(poll.end.year, end.year)
        eq_(poll.end.month, end.month)
        eq_(poll.end.day, end.day)
        eq_(poll.end.hour, 0)
        eq_(poll.end.minute, 0)
        eq_(poll.end.second, 0)
        ok_(not poll.is_extended)
Esempio n. 50
0
    def test_view_cast_a_vote(self, fake_messages):
        """Cast a vote on a voting."""
        UserFactory.create(username='******')
        poll_start = now() - timedelta(days=5)
        poll = PollFactory.create(valid_groups=self.rep_group, start=poll_start,
                                  end=poll_start + timedelta(days=10),
                                  comments_allowed=False)

        # Cast a vote as a valid user.
        with self.login(self.rep) as client:
            response = client.post(poll.get_absolute_url(), self.post_data)
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        fake_messages.success.assert_called_once_with(
            mock.ANY, 'Your vote has been successfully registered.')

        # Ensure that there is a vote for user 'rep'
        poll = Poll.objects.get(id=poll.id)
        eq_(poll.users_voted.filter(username=self.rep.username).count(), 1)

        # Cast a vote as a valid user for a second time.
        with self.login(self.rep) as client:
            response = client.post(poll.get_absolute_url(), self.post_data, follow=True)
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        fake_messages.warning.assert_called_once_with(
            mock.ANY, ('You have already cast your vote for this voting. '
                       'Come back to see the results on %s UTC.'
                       % poll.end.strftime('%Y %B %d, %H:%M')))
        eq_(poll.users_voted.filter(username=self.rep.username).count(), 1)

        # Cast a vote as an invalid user.
        with self.login(self.mozillian) as client:
            response = client.post(poll.get_absolute_url(), self.post_data, follow=True)
        self.assertJinja2TemplateUsed(response, 'list_votings.jinja')
        fake_messages.error.assert_called_once_with(
            mock.ANY, ('You do not have the permissions to vote '
                       'on this voting.'))
        eq_(poll.users_voted.filter(username=self.mozillian.username).count(), 0)
Esempio n. 51
0
    def test_poll_already_exists(self, mocked_now_date, mocked_waffle_switch):
        mocked_waffle_switch.return_value = False
        UserFactory.create(userprofile__is_rotm_nominee=True)
        UserFactory.create(userprofile__is_rotm_nominee=True)
        UserFactory.create(username='******')
        # Nomination ends on the 10th of each month
        mocked_now_date.return_value = datetime(now().year, now().month, 10)
        poll_start = datetime(now().year, now().month, 1)
        poll_end = poll_start + timedelta(days=14)
        poll_name = ('Rep of the month for {0}'.format(
                     number2month(now().month)))

        mentor_group = Group.objects.get(name='Mentor')
        poll = PollFactory.create(start=poll_start,
                                  end=poll_end,
                                  valid_groups=mentor_group,
                                  name=poll_name)

        create_rotm_poll()

        rotm_polls = Poll.objects.filter(name=poll_name)
        ok_(rotm_polls.exists())
        eq_(rotm_polls.count(), 1)
        eq_(rotm_polls[0].pk, poll.pk)
Esempio n. 52
0
    def setUp(self):
        """Initial setup for the tests."""
        self.poll = PollFactory.create()
        self.radio_poll = RadioPollFactory.create(poll=self.poll)
        self.radio_poll_choice = (RadioPollChoiceFactory.create(
            radio_poll=self.radio_poll))
        self.range_poll = RangePollFactory.create(poll=self.poll)
        self.range_poll_choice = (RangePollChoiceFactory.create(
            range_poll=self.range_poll))
        UserFactory.create_batch(20, groups=['Rep'])
        self.user_list = (User.objects.filter(
            groups__name='Rep', userprofile__registration_complete=True))
        self.user = self.user_list[0]

        self.form_data = {
            'description': u'This is a description.',
            'end_form_0_day': u'1',
            'end_form_0_month': u'1',
            'end_form_0_year': u'2019',
            'end_form_1_hour': u'12',
            'end_form_1_minute': u'00',
            'name': u'Form data.',
            'start_form_0_day': u'1',
            'start_form_0_month': u'1',
            'start_form_0_year': u'2018',
            'start_form_1_hour': u'12',
            'start_form_1_minute': u'00',
            'valid_groups': u'1'
        }

        self.radio_formset_data = {
            'radio_polls-0-id':
            u'%d' % self.radio_poll.id,
            'radio_polls-0-question':
            u'Radio Poll Example 2 - Question 1',
            'radio_polls-TOTAL_FORMS':
            u'1',
            'radio_polls-INITIAL_FORMS':
            u'1',
            'radio_polls-MAX_NUM_FORMS':
            u'1000',
            '%d_radio_choices-TOTAL_FORMS' % self.radio_poll.id:
            u'1',
            '%d_radio_choices-INITIAL_FORMS' % self.radio_poll.id:
            u'1',
            '%d_radio_choices-MAX_NUM_FORMS' % self.radio_poll.id:
            u'1000',
            '%d_radio_choices-0-id' % self.radio_poll.id:
            (u'%d' % self.radio_poll_choice.id),
            '%d_radio_choices-0-answer' % self.radio_poll.id:
            u'Answer 1',
            '%d_radio_choices-0-DELETE' % self.radio_poll.id:
            False
        }

        self.range_formset_data = {
            'range_polls-TOTAL_FORMS':
            u'1',
            'range_polls-INITIAL_FORMS':
            u'1',
            'range_polls-MAX_NUM_FORMS':
            u'1000',
            'range_polls-0-id':
            u'%d' % self.range_poll.id,
            'range_polls-0-name':
            u'Current Range Poll 1',
            '%d_range_choices-0-id' % self.range_poll.id:
            (u'%d' % self.range_poll.id),
            '%d_range_choices-0-nominee' % self.range_poll.id:
            (u'%d' % self.user.id),
            '%d_range_choices-0-DELETE' % self.range_poll.id:
            False,
            '%d_range_choices-TOTAL_FORMS' % self.range_poll.id:
            u'1',
            '%d_range_choices-INITIAL_FORMS' % self.range_poll.id:
            u'1',
            '%d_range_choices-MAX_NUM_FORMS' % self.range_poll.id:
            u'1000'
        }

        self.empty_radio_formset = {
            'radio_polls-TOTAL_FORMS': u'0',
            'radio_polls-INITIAL_FORMS': u'0',
            'radio_polls-MAX_NUM_FORMS': u'1000'
        }

        self.empty_range_formset = {
            'range_polls-TOTAL_FORMS': u'0',
            'range_polls-INITIAL_FORMS': u'0',
            'range_polls-MAX_NUM_FORMS': u'1000'
        }

        RangePollFormset = inlineformset_factory(
            Poll,
            RangePoll,
            formset=forms.BaseRangePollInlineFormSet,
            extra=1,
            can_delete=True)
        RadioPollFormset = inlineformset_factory(
            Poll,
            RadioPoll,
            formset=forms.BaseRadioPollInlineFormSet,
            extra=1,
            can_delete=True)

        self.range_poll_formset = (RangePollFormset(self.range_formset_data,
                                                    instance=self.poll,
                                                    user_list=self.user_list))
        self.radio_poll_formset = (RadioPollFormset(self.radio_formset_data,
                                                    instance=self.poll))
        self.radio_poll_formset_empty = (RadioPollFormset(
            self.empty_radio_formset, instance=self.poll))
        self.range_poll_formset_empty = (RangePollFormset(
            self.empty_range_formset,
            instance=self.poll,
            user_list=self.user_list))
Esempio n. 53
0
    def setUp(self):
        """Initial data for the tests."""
        self.nominee1, self.nominee2, self.nominee3 = UserFactory.create_batch(3, groups=['Rep'])
        self.rep = UserFactory.create(groups=['Rep'])
        self.admin = UserFactory.create(groups=['Admin', 'Rep'])
        self.mozillian = UserFactory.create(groups=['Mozillians'])
        poll_start = now() + timedelta(days=5)
        self.admin_group = Group.objects.get(name='Admin')
        self.rep_group = Group.objects.get(name='Rep')
        self.poll = PollFactory.create(valid_groups=self.admin_group,
                                       start=poll_start,
                                       end=poll_start + timedelta(days=10),
                                       comments_allowed=False)
        self.range_poll = RangePollFactory(poll=self.poll)
        self.range_poll_choice1 = RangePollChoiceFactory(range_poll=self.range_poll,
                                                         nominee=self.nominee1)
        self.range_poll_choice2 = RangePollChoiceFactory(range_poll=self.range_poll,
                                                         nominee=self.nominee2)
        self.radio_poll = RadioPollFactory(poll=self.poll)
        self.radio_poll_choice1, self.radio_poll_choice2 = RadioPollChoiceFactory.create_batch(
            2, radio_poll=self.radio_poll)

        self.post_data = {'range_poll__1': 1,
                          'range_poll__2': 2,
                          'radio_poll__1': 2}

        self.edit_future_data = {
            'name': u'Test edit voting',
            'description': u'This is a description.',
            'created_by': self.poll.created_by.id,
            'valid_groups': self.admin_group.id,
            'start_form_0_year': now().year + 1,
            'start_form_0_month': 10,
            'start_form_0_day': 1,
            'start_form_1_hour': 7,
            'start_form_1_minute': 00,
            'end_form_0_year': now().year + 1,
            'end_form_0_month': 10,
            'end_form_0_day': 4,
            'end_form_1_hour': 7,
            'end_form_1_minute': 00,
            'range_polls-TOTAL_FORMS': u'1',
            'range_polls-INITIAL_FORMS': u'1',
            'range_polls-MAX_NUM_FORMS': u'1000',
            'range_polls-0-id': self.range_poll.id,
            'range_polls-0-name': u'Current Range Poll 1',
            '{0}_range_choices-0-id'.format(self.range_poll.id): self.range_poll_choice1.id,
            '{0}_range_choices-0-nominee'.format(self.range_poll.id): self.nominee1.id,
            '{0}_range_choices-0-DELETE'.format(self.range_poll.id): False,
            '{0}_range_choices-1-id'.format(self.range_poll.id): self.range_poll_choice2.id,
            '{0}_range_choices-1-nominee'.format(self.range_poll.id): self.nominee2.id,
            '{0}_range_choices-1-DELETE'.format(self.range_poll.id): False,
            '{0}_range_choices-2-id'.format(self.range_poll.id): u'',
            '{0}_range_choices-2-nominee'.format(self.range_poll.id): self.nominee3.id,
            '{0}_range_choices-2-DELETE'.format(self.range_poll.id): False,
            '{0}_range_choices-TOTAL_FORMS'.format(self.range_poll.id): u'3',
            '{0}_range_choices-INITIAL_FORMS'.format(self.range_poll.id): u'2',
            '{0}_range_choices-TOTAL_FORMS'.format(self.range_poll.id): u'1000',
            'radio_polls-0-id': self.radio_poll.id,
            'radio_polls-0-question': u'Radio Poll - Question 1',
            'radio_polls-TOTAL_FORMS': u'1',
            'radio_polls-INITIAL_FORMS': u'1',
            'radio_polls-MAX_NUM_FORMS': u'1000',
            '{0}_radio_choices-TOTAL_FORMS'.format(self.radio_poll.id): u'2',
            '{0}_radio_choices-INITIAL_FORMS'.format(self.radio_poll.id): u'2',
            '{0}_radio_choices-MAX_NUM_FORMS'.format(self.radio_poll.id): u'1000',
            '{0}_radio_choices-0-id'.format(self.radio_poll.id): self.radio_poll_choice1.id,
            '{0}_radio_choices-0-answer'.format(self.radio_poll.id): u'Radio Poll - Answer 1',
            '{0}_radio_choices-0-DELETE'.format(self.radio_poll.id): False,
            '{0}_radio_choices-1-id'.format(self.radio_poll.id): self.radio_poll_choice2.id,
            '{0}_radio_choices-1-answer'.format(self.radio_poll.id): u'Radio Poll - Answer 2',
            '{0}_radio_choices-1-DELETE'.format(self.radio_poll.id): False}

        self.edit_current_data = {
            'name': u'Test edit voting',
            'description': u'This is a description.',
            'created_by': self.nominee1.id,
            'valid_groups': self.admin_group.id,
            'start_form_0_year': 2011,
            'end_form_0_year': now().year,
            'end_form_0_month': 10,
            'end_form_0_day': 4,
            'end_form_1_hour': 7,
            'end_form_1_minute': 00}

        # Give permissions to admin group
        group = Group.objects.get(name='Admin')
        permissions = Permission.objects.filter(name__icontains='poll')
        for perm in permissions:
            group.permissions.add(perm)