def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
data = {'subject': 'Test email subject',
'body': 'Test email body',
'functional_area': self.functional_area.id}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 1)
address = lambda u: '%s %s <%s>' % (u.first_name, u.last_name, u.email)
recipients = map(address, reps)
eq_(set(mail.outbox[0].to), set(recipients))
eq_(mail.outbox[0].subject, data['subject'])
eq_(mail.outbox[0].body, data['body'])
fake_messages.assert_called_with(ANY, 'Email sent successfully.')
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='Council')
User.objects.filter(groups__name='Council').delete()
UserFactory.create_batch(9, groups=['Council'])
automated_poll = PollFactoryNoSignals.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)
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
fake_messages.expects('success')
data = {
'subject': 'Test email subject',
'body': 'Test email body',
'functional_area': self.functional_area.id
}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 1)
address = lambda u: '%s %s <%s>' % (u.first_name, u.last_name, u.email)
recipients = map(address, reps)
eq_(set(mail.outbox[0].to), set(recipients))
eq_(mail.outbox[0].subject, data['subject'])
eq_(mail.outbox[0].body, data['body'])
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())
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())
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
data = {'subject': 'Test email subject',
'body': 'Test email body',
'functional_area': self.functional_area.id}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 20)
def format_name(user):
return '%s %s <%s>' % (user.first_name, user.last_name, user.email)
recipients = map(format_name, reps)
receivers = []
for i in range(0, len(mail.outbox)):
eq_(mail.outbox[i].subject, data['subject'])
eq_(mail.outbox[i].body, data['body'])
receivers.append(mail.outbox[i].to[0])
eq_(set(receivers), set(recipients))
fake_messages.assert_called_with(ANY, 'Email sent successfully.')
def test_send_mail(self, fake_messages):
"""Test EmailRepsForm email sending functionality."""
data = {"subject": "Test email subject", "body": "Test email body", "functional_area": self.functional_area.id}
form = EmailRepsForm(data=data)
ok_(form.is_valid())
area = self.functional_area
UserFactory.create_batch(20, userprofile__functional_areas=[area])
factory = RequestFactory()
request = factory.request()
request.user = UserFactory.create()
reps = User.objects.filter(userprofile__functional_areas__name=area)
form.send_email(request, reps)
eq_(len(mail.outbox), 20)
address = lambda u: "%s %s <%s>" % (u.first_name, u.last_name, u.email)
recipients = map(address, reps)
receivers = []
for i in range(0, len(mail.outbox)):
eq_(mail.outbox[i].subject, data["subject"])
eq_(mail.outbox[i].body, data["body"])
receivers.append(mail.outbox[i].to[0])
eq_(set(receivers), set(recipients))
fake_messages.assert_called_with(ANY, "Email sent successfully.")
def test_invalid_date(self, mocked_date):
model = ContentType.objects.get_for_model(UserProfile)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
UserFactory.create_batch(2, groups=['Mentor'])
mocked_date.return_value = datetime(now().year, now().month, 2)
send_rotm_nomination_reminder()
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
def test_invalid_date(self, mocked_date):
model = ContentType.objects.get_for_model(UserProfile)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
UserFactory.create_batch(2, groups=['Mentor'])
mocked_date.return_value = datetime(now().year, now().month, 2)
send_rotm_nomination_reminder()
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
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 = PollFactoryNoSignals.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)
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 = PollFactoryNoSignals.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)
def test_comment_multiple_users(self, mocked_mail):
"""Test sending email when a new comment is added on a NGReport
and the users have the option enabled in their settings.
"""
commenter = UserFactory.create()
reporter = UserFactory.create(
userprofile__receive_email_on_add_comment=True)
report = NGReportFactory.create(user=reporter)
users_with_comments = UserFactory.create_batch(
2, userprofile__receive_email_on_add_comment=True)
# disconnect the signals in order to add two users in NGReportComment
with mute_signals(post_save):
for user_obj in users_with_comments:
NGReportCommentFactory.create(user=user_obj,
report=report,
comment='This is a comment')
NGReportCommentFactory.create(user=commenter,
report=report,
comment='This is a comment')
ok_(mocked_mail.called)
eq_(mocked_mail.call_count, 3)
msg = '[Report] User {0} commented on {1}'.format(
commenter.get_full_name(), report)
mocked_data = mocked_mail.call_args_list[0][1]
eq_(mocked_data['subject'], msg)
def test_comment_multiple_users(self):
"""Test sending email when a new comment is added on a NGReport
and the users have the option enabled in their settings.
"""
commenter = UserFactory.create()
reporter = UserFactory.create(
userprofile__receive_email_on_add_comment=True)
report = NGReportFactory.create(user=reporter)
users_with_comments = UserFactory.create_batch(
2, userprofile__receive_email_on_add_comment=True)
# disconnect the signals in order to add two users in NGReportComment
for user_obj in users_with_comments:
NGReportCommentFactoryNoSignals.create(
user=user_obj, report=report, comment='This is a comment')
NGReportCommentFactory.create(user=commenter, report=report,
comment='This is a comment')
eq_(len(mail.outbox), 3)
recipients = ['%s <%s>' % (reporter.get_full_name(), reporter.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 = ('[Report] User {0} commented on {1}'
.format(commenter.get_full_name(), report))
eq_(mail.outbox[0].subject, msg)
def test_send_email_on_report_comment_settings_True_multiple_users(self):
"""Test sending email when a new comment is added on a NGReport
and the users have the option enabled in their settings.
"""
commenter = UserFactory.create()
reporter = UserFactory.create(
userprofile__receive_email_on_add_comment=True)
report = NGReportFactory.create(user=reporter)
users_with_comments = UserFactory.create_batch(
2, userprofile__receive_email_on_add_comment=True)
# disconnect the signals in order to add two users in NGReportComment
for user_obj in users_with_comments:
NGReportCommentFactoryNoSignals.create(user=user_obj,
report=report,
comment='This is a comment')
NGReportCommentFactory.create(user=commenter,
report=report,
comment='This is a comment')
eq_(len(mail.outbox), 3)
recipients = [
reporter.email, users_with_comments[0].email,
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 = ('[Report] User {0} commented on {1}'.format(
commenter.get_full_name(), report))
eq_(mail.outbox[0].subject, msg)
def test_overview(self):
UserFactory.create_batch(10, groups=['Rep'])
NGReportFactory.create_batch(12)
# Past events
EventFactory.create_batch(5)
# Current and future events
EventFactory.create_batch(10, start=now() + timedelta(days=3),
end=now() + timedelta(days=4))
response = self.get(reverse('stats_dashboard'))
eq_(response.status_code, 200)
self.assertTemplateUsed(response, 'stats_dashboard.html')
eq_(response.context['reps'], 10)
eq_(response.context['past_events'], 5)
eq_(response.context['future_events'], 10)
eq_(response.context['activities'], 27)
def test_overview(self):
UserFactory.create_batch(10, groups=['Rep'])
NGReportFactory.create_batch(12)
# Past events
EventFactory.create_batch(5)
# Current and future events
EventFactory.create_batch(10, start=now() + timedelta(days=3),
end=now() + timedelta(days=4))
response = self.get(reverse('stats_dashboard'))
eq_(response.status_code, 200)
self.assertTemplateUsed(response, 'stats_dashboard.html')
eq_(response.context['reps'], 10)
eq_(response.context['past_events'], 5)
eq_(response.context['future_events'], 10)
eq_(response.context['activities'], 27)
def test_inactive(self):
reps = UserFactory.create_batch(12, groups=['Rep'])
active = timedelta(days=5)
inactive_low = timedelta(weeks=5)
inactive_high = timedelta(weeks=9)
active_reps = reps[:5]
inactive_low_reps = reps[5:9]
inactive_high_reps = reps[9:]
for user in active_reps:
# Activities in future and past 4 weeks
NGReportFactory.create(user=user,
report_date=now().date() - active)
NGReportFactory.create(user=user,
report_date=now().date() + active)
# Activities in future and past 4+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_low)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_low)
# Activities in future and past 8+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_high)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_high)
for user in inactive_low_reps:
# Activities in future and past 4+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_low)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_low)
# Activities in future and past 8+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_high)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_high)
for user in inactive_high_reps:
# Activities in future and past 8+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_high)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_high)
response = self.get(reverse('stats_dashboard'))
eq_(response.status_code, 200)
self.assertTemplateUsed(response, 'stats_dashboard.html')
eq_(response.context['active_users'], 5)
eq_(response.context['inactive_low_users'], 4)
eq_(response.context['inactive_high_users'], 3)
def test_inactive(self):
reps = UserFactory.create_batch(12, groups=['Rep'])
active = timedelta(days=5)
inactive_low = timedelta(weeks=5)
inactive_high = timedelta(weeks=9)
active_reps = reps[:5]
inactive_low_reps = reps[5:9]
inactive_high_reps = reps[9:]
for user in active_reps:
# Activities in future and past 4 weeks
NGReportFactory.create(user=user,
report_date=now().date() - active)
NGReportFactory.create(user=user,
report_date=now().date() + active)
# Activities in future and past 4+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_low)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_low)
# Activities in future and past 8+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_high)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_high)
for user in inactive_low_reps:
# Activities in future and past 4+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_low)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_low)
# Activities in future and past 8+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_high)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_high)
for user in inactive_high_reps:
# Activities in future and past 8+ weeks
NGReportFactory.create(user=user,
report_date=now().date() - inactive_high)
NGReportFactory.create(user=user,
report_date=now().date() + inactive_high)
response = self.get(reverse('stats_dashboard'))
eq_(response.status_code, 200)
self.assertTemplateUsed(response, 'stats_dashboard.html')
eq_(response.context['active_users'], 5)
eq_(response.context['inactive_low_users'], 4)
eq_(response.context['inactive_high_users'], 3)
def test_overview(self):
UserFactory.create_batch(10, groups=['Rep'])
NGReportFactory.create_batch(12)
# Past events
EventFactory.create_batch(5)
# Current and future events
EventFactory.create_batch(10,
start=now() + timedelta(days=3),
end=now() + timedelta(days=4))
response = Client().get(reverse('kpi'))
eq_(response.status_code, 200)
self.assertJinja2TemplateUsed(response, 'kpi.jinja')
eq_(response.context['reps_count'], 10)
eq_(response.context['past_events'], 5)
eq_(response.context['future_events'], 10)
eq_(response.context['activities'], 27)
def test_base(self, mocked_date):
model = ContentType.objects.get_for_model(UserProfile)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
mentors = UserFactory.create_batch(2, groups=['Mentor'])
mocked_date.return_value = datetime(now().year, now().month, 1)
send_rotm_nomination_reminder()
items = ActionItem.objects.filter(content_type=model)
eq_(items.count(), 2)
eq_(set([mentor.id for mentor in mentors]),
set(items.values_list('object_id', flat=True)))
def test_base(self, mocked_date):
model = ContentType.objects.get_for_model(UserProfile)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
mentors = UserFactory.create_batch(2, groups=['Mentor'])
mocked_date.return_value = datetime(now().year, now().month, 1)
send_rotm_nomination_reminder()
items = ActionItem.objects.filter(content_type=model)
eq_(items.count(), 2)
eq_(set([mentor.id for mentor in mentors]),
set(items.values_list('object_id', flat=True)))
def test_extend_voting_period_no_majority(self):
bug = BugFactory.create()
start = now().replace(microsecond=0)
end = get_date(days=1)
new_end = get_date(days=2)
user = UserFactory.create(groups=['Admin'])
group = Group.objects.get(name='Council')
User.objects.filter(groups__name='Council').delete()
council = UserFactory.create_batch(9, groups=['Council'])
automated_poll = PollFactoryNoSignals.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=council[0], poll=automated_poll)
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)
reminders = map(lambda x: x.subject, mail.outbox)
msg = '[Urgent] Voting extended for poll'
# Test that those who voted don't receive notification
eq_(reminders.count(msg), 8)
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)
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='Council')
User.objects.filter(groups__name='Council').delete()
council = UserFactory.create_batch(9, groups=['Council'])
automated_poll = PollFactoryNoSignals.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=council[0], poll=automated_poll)
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)
reminders = map(lambda x: x.subject, mail.outbox)
msg = '[Urgent] Voting extended for poll'
# Test that those who voted don't receive notification
eq_(reminders.count(msg), 8)
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)
def test_comment_multiple_users(self, mocked_mail):
"""Test sending email when a new comment is added on a NGReport
and the users have the option enabled in their settings.
"""
commenter = UserFactory.create()
reporter = UserFactory.create(userprofile__receive_email_on_add_comment=True)
report = NGReportFactory.create(user=reporter)
users_with_comments = UserFactory.create_batch(
2, userprofile__receive_email_on_add_comment=True)
# disconnect the signals in order to add two users in NGReportComment
with mute_signals(post_save):
for user_obj in users_with_comments:
NGReportCommentFactory.create(user=user_obj, report=report,
comment='This is a comment')
NGReportCommentFactory.create(user=commenter, report=report,
comment='This is a comment')
ok_(mocked_mail.called)
eq_(mocked_mail.call_count, 3)
msg = '[Report] User {0} commented on {1}'.format(commenter.get_full_name(), report)
mocked_data = mocked_mail.call_args_list[0][1]
eq_(mocked_data['subject'], msg)
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))
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)
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'10',
'end_form_0_month': u'2',
'end_form_0_year': u'{0}'.format(now().year + 2),
'end_form_1_hour': u'12',
'end_form_1_minute': u'00',
'name': u'Form data.',
'start_form_0_day': u'10',
'start_form_0_month': u'2',
'start_form_0_year': u'{0}'.format(now().year + 1),
'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,
exclude=('votes',),
can_delete=True)
RadioPollFormset = inlineformset_factory(Poll,
RadioPoll,
formset=forms.BaseRadioPollInlineFormSet,
extra=1,
can_delete=True,
exclude=('votes',))
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)
