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_view_dashboard_page(self):
"""Get dashboard page."""
c = Client()
# Get as anonymous user.
response = c.get(reverse('dashboard'), follow=True)
eq_(response.status_code, 200)
self.assertJinja2TemplateUsed(response, 'main.jinja')
# Get as logged in rep.
rep = UserFactory.create(groups=['Rep'])
with self.login(rep) as client:
response = client.get(reverse('dashboard'))
eq_(response.status_code, 200)
self.assertJinja2TemplateUsed(response, 'dashboard_reps.jinja')
# Get as logged in mentor.
mentor = UserFactory.create(groups=['Mentor'])
with self.login(mentor) as client:
response = client.get(reverse('dashboard'))
eq_(response.status_code, 200)
self.assertJinja2TemplateUsed(response, 'dashboard_reps.jinja')
# Get as logged in counselor.
councelor = UserFactory.create(groups=['Council'])
with self.login(councelor) as client:
response = client.get(reverse('dashboard'))
eq_(response.status_code, 200)
self.assertJinja2TemplateUsed(response, 'dashboard_reps.jinja')
def test_resolve_mentor_validation(self):
model = ContentType.objects.get_for_model(Bug)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
mentor = UserFactory.create(groups=['Rep', 'Mentor'])
UserFactory.create(groups=['Rep'], userprofile__mentor=mentor)
bug = BugFactory.build(pending_mentor_validation=True,
assigned_to=mentor)
bug.save()
items = ActionItem.objects.filter(content_type=model)
eq_(items.count(), 1)
eq_(items[0].name, 'Waiting mentor validation for ' + bug.summary)
eq_(items[0].user, mentor)
eq_(items[0].priority, ActionItem.BLOCKER)
bug.pending_mentor_validation = False
bug.save()
items = ActionItem.objects.filter(content_type=model, object_id=bug.id)
for item in items:
ok_(item.completed)
ok_(item.resolved)
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_base(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
event = EventFactory.create()
functional_areas = [FunctionalAreaFactory.create()]
campaign = CampaignFactory.create()
activity = ActivityFactory.create()
report = NGReportFactory.create(
functional_areas=functional_areas, mentor=mentor,
campaign=campaign, user=user, event=event, activity=activity)
url = '/api/beta/activities/%s' % report.id
request = RequestFactory().get(url)
data = ActivitiesDetailedSerializer(report,
context={'request': request}).data
eq_(data['user']['first_name'], user.first_name)
eq_(data['user']['last_name'], user.last_name)
eq_(data['user']['display_name'], user.userprofile.display_name)
ok_(data['user']['_url'])
eq_(data['activity'], activity.name)
eq_(data['initiative'], campaign.name)
eq_(data['functional_areas'][0]['name'], functional_areas[0].name)
eq_(data['activity_description'], report.activity_description)
eq_(data['location'], report.location)
eq_(data['latitude'], float(report.latitude))
eq_(data['longitude'], float(report.longitude))
eq_(data['report_date'], report.report_date.strftime('%Y-%m-%d'))
eq_(data['link'], report.link)
eq_(data['link_description'], report.link_description)
eq_(data['mentor']['first_name'], mentor.first_name)
eq_(data['mentor']['last_name'], mentor.last_name)
eq_(data['mentor']['display_name'], mentor.userprofile.display_name)
ok_(data['mentor']['_url'])
eq_(data['passive_report'], report.is_passive)
eq_(data['event']['name'], event.name)
ok_(data['event']['_url'])
def test_base(self):
mentor = UserFactory.create()
rep = UserFactory.create(userprofile__mentor=mentor)
UserStatusFactory.create(user=rep, start_date=get_date(days=-1), is_unavailable=False)
set_unavailability_flag()
status = UserStatus.objects.get(user=rep)
ok_(status.is_unavailable)
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_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_list_no_alumni(self):
"""Test page header context for rep."""
UserFactory.create(groups=['Rep'])
response = self.get(reverse('profiles_alumni'))
self.assertTemplateUsed(response, 'profiles_list_alumni.html')
eq_(response.status_code, 200)
ok_(not response.context['objects'].object_list)
def setUp(self):
"""Setup tests."""
self.admin = UserFactory.create(username='******', groups=['Admin'])
self.counselor = UserFactory.create(username='******')
self.mentor = UserFactory.create(username='******', groups=['Mentor'])
self.user = UserFactory.create(username='******', groups=['Rep'],
userprofile__mentor=self.mentor)
self.up = self.user.userprofile
self.data = {'empty': False,
'recruits': '10',
'recruits_comments': 'This is recruit comments.',
'past_items': 'This is past items.',
'next_items': 'This is next items.',
'flags': 'This is flags.',
'delete_report': False,
'reportevent_set-TOTAL_FORMS': '1',
'reportevent_set-INITIAL_FORMS': '0',
'reportevent_set-MAX_NUM_FORMS': '',
'reportevent_set-0-id': '',
'reportevent_set-0-name': 'Event name',
'reportevent_set-0-description': 'Event description',
'reportevent_set-0-link': 'http://example.com/evtlnk',
'reportevent_set-0-participation_type': '1',
'reportevent_set-0-DELETE': False,
'reportlink_set-TOTAL_FORMS': '1',
'reportlink_set-INITIAL_FORMS': '0',
'reportlink_set-MAX_NUM_FORMS': '',
'reportlink_set-0-id': '',
'reportlink_set-0-link': 'http://example.com/link',
'reportlink_set-0-description': 'This is description',
'reportlink_set-0-DELETE': False}
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_get_nominee_right_split(self):
UserFactory.create(first_name='Foo', last_name='Foo Bar',
groups=['Rep'])
user = get_nominee('Foo Foo Bar')
ok_(user)
eq_(user.first_name, 'Foo')
eq_(user.last_name, 'Foo Bar')
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_dry_run(self):
"""Test sending of first notification with debug activated."""
mentor = UserFactory.create(groups=['Mentor'])
rep = UserFactory.create(groups=['Rep'], userprofile__mentor=mentor)
ReportFactoryWithoutSignals.create(user=rep)
management.call_command('send_first_report_notification', dry_run=True)
eq_(len(mail.outbox), 0)
def test_send_notification(self):
"""Test sending of first notification to Reps to fill reports."""
mentor = UserFactory.create(groups=['Mentor'])
rep = UserFactory.create(groups=['Rep'], userprofile__mentor=mentor)
ReportFactoryWithoutSignals.create(user=rep)
management.call_command('send_first_report_notification', [], {})
eq_(len(mail.outbox), 1)
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_get_as_anonymous(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
display_name = user.userprofile.display_name
UserStatusFactory.create(user=user)
client = Client()
client.get(reverse('edit_availability',
kwargs={'display_name': display_name}))
def test_invalid_timespan(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
date = get_date(weeks=15)
data = {'expected_date': date}
form = UserStatusForm(data, instance=UserStatus(user=user))
ok_(not form.is_valid())
ok_('expected_date' in form.errors)
def test_automated_radio_poll_valid_bug(self):
"""Test the creation of an automated radio poll."""
UserFactory.create(username='******')
bug = BugFactory.create(council_vote_requested=True, component='Budget Requests')
poll = Poll.objects.get(bug=bug)
eq_(poll.bug.bug_id, bug.bug_id)
eq_(poll.description, bug.first_comment)
eq_(poll.name, bug.summary)
def test_get_as_other_rep(self):
user = UserFactory.create()
rep = UserFactory.create()
display_name = user.userprofile.display_name
UserStatusFactory.create(user=user)
url = reverse('edit_availability',
kwargs={'display_name': display_name})
self.get(url=url, user=rep)
def test_change_invalid_bugzilla_email(self):
"""Test change bugzilla email with an invalid one."""
mentor = UserFactory.create(groups=["Mentor"], userprofile__initial_council=True)
rep = UserFactory.create(groups=["Rep"], userprofile__mentor=mentor)
data = {"first_name": rep.first_name, "last_name": rep.last_name, "email": mentor.email}
form = ChangeUserForm(data=data, instance=rep)
ok_(not form.is_valid())
def test_get_remo_url(self):
mentor = UserFactory.create()
functional_areas = FunctionalAreaFactory.create_batch(2)
user = UserFactory.create(userprofile__mentor=mentor, groups=['Rep'],
userprofile__functional_areas=functional_areas)
url = '/api/beta/users/%s' % user.id
request = RequestFactory().get(url)
data = UserProfileDetailedSerializer(user.userprofile, context={'request': request}).data
ok_(user.userprofile.get_absolute_url() in data['remo_url'])
def test_get_as_owner(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
display_name = user.userprofile.display_name
UserStatusFactory.create(user=user)
url = reverse('edit_availability',
kwargs={'display_name': display_name})
self.get(url=url, user=user)
self.assertTemplateUsed('edit_availability.html')
def test_with_report_filled(self):
mentor = UserFactory.create(groups=["Mentor"])
today = now().date()
rep = UserFactory.create(groups=["Rep"], userprofile__mentor=mentor)
NGReportFactory.create(user=rep, report_date=today - timedelta(weeks=2))
with patch("remo.reports.utils.send_remo_mail") as mail_mock:
send_second_report_notification()
ok_(not mail_mock.called)
def test_uppercase_status(self):
"""Test that status and resolution are always saved in uppercase."""
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
bug = BugFactory.create(bug_id=0000, status='foo',
resolution='bar', assigned_to=user)
eq_(bug.status, 'FOO')
eq_(bug.resolution, 'BAR')
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())
def test_get_as_other_rep(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
rep = UserFactory.create()
display_name = user.userprofile.display_name
UserStatusFactory.create(user=user)
url = reverse('edit_availability',
kwargs={'display_name': display_name})
with self.login(rep) as client:
client.get(url, user=rep)
def test_get_as_owner(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
display_name = user.userprofile.display_name
UserStatusFactory.create(user=user)
url = reverse('edit_availability',
kwargs={'display_name': display_name})
with self.login(user) as client:
response = client.get(url, user=user)
self.assertJinja2TemplateUsed(response, 'edit_availability.jinja')
def test_base(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
date = get_date(days=1)
data = {"expected_date": date}
form = UserStatusForm(data, instance=UserStatus(user=user))
ok_(form.is_valid())
db_obj = form.save()
eq_(db_obj.expected_date, get_date(days=1))
eq_(db_obj.user.get_full_name(), user.get_full_name())
def test_expected_date_before_start_date(self):
mentor = UserFactory.create()
user = UserFactory.create(userprofile__mentor=mentor)
start_date = get_date(4)
expected_date = get_date(days=2)
data = {'start_date': start_date,
'expected_date': expected_date}
form = UserStatusForm(data, instance=UserStatus(user=user))
ok_(not form.is_valid())
ok_('expected_date' in form.errors)
def test_waiting_multiple_documents(self):
model = ContentType.objects.get_for_model(Bug)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
whiteboard = '[waiting receipts][waiting report][waiting photos]'
user = UserFactory.create(groups=['Rep'])
bug = BugFactory.build(whiteboard=whiteboard, assigned_to=user)
bug.save()
items = ActionItem.objects.filter(content_type=model, object_id=bug.id)
eq_(items.count(), 3)
namelist = [
'Add receipts for ' + bug.summary, 'Add report for ' + bug.summary,
'Add photos for ' + bug.summary
]
for item in items:
ok_(item.name in namelist)
eq_(item.user, user)
eq_(item.priority, ActionItem.NORMAL)
def test_create_event_report(self):
"""Test creating a passive report after creating an event."""
activity = Activity.objects.get(name=ACTIVITY_EVENT_CREATE)
event = EventFactory.build()
event.owner = UserFactory.create()
event.save()
report = NGReport.objects.get(event=event,
user=event.owner,
activity=activity)
location = '%s, %s, %s' % (event.city, event.region, event.country)
eq_(report.mentor, event.owner.userprofile.mentor)
eq_(report.activity.name, ACTIVITY_EVENT_CREATE)
eq_(report.latitude, event.lat)
eq_(report.longitude, event.lon)
eq_(report.location, location)
eq_(report.is_passive, True)
eq_(report.link, get_event_link(event))
eq_(report.activity_description, event.description)
self.assertQuerysetEqual(report.functional_areas.all(),
[e.name for e in event.categories.all()],
lambda x: x.name)
def test_owner(self):
"""Test creating a passive attendance report for event owner."""
activity = Activity.objects.get(name=ACTIVITY_EVENT_ATTEND)
user = UserFactory.create(groups=['Rep', 'Mentor'],
userprofile__initial_council=True)
event = EventFactory.create(owner=user)
report = NGReport.objects.get(event=event,
user=user,
activity=activity)
location = '%s, %s, %s' % (event.city, event.region, event.country)
eq_(report.mentor, user.userprofile.mentor)
eq_(report.activity.name, ACTIVITY_EVENT_ATTEND)
eq_(report.latitude, event.lat)
eq_(report.longitude, event.lon)
eq_(report.location, location)
eq_(report.is_passive, True)
eq_(report.link, get_event_link(event))
eq_(report.activity_description, event.description)
self.assertQuerysetEqual(report.functional_areas.all(),
[e.name for e in event.categories.all()],
lambda x: x.name)
def test_passive_report_save(self):
"""Test that a passive report is created on form save()"""
start_form = {
'start_form_0_month': 1,
'start_form_0_day': 25,
'start_form_0_year': 2013,
'start_form_1_hour': 4,
'start_form_1_minute': 1
}
end_form = {
'end_form_0_month': 1,
'end_form_0_day': 26,
'end_form_0_year': 2013,
'end_form_1_hour': 4,
'end_form_1_minute': 1
}
owner = UserFactory.create(groups=['Rep', 'Mentor'])
areas = [FunctionalAreaFactory.create()]
campaign = [CampaignFactory.create()]
event = EventFactory.create(owner=owner, categories=areas)
data = model_to_dict(event)
data['categories'] = areas[0].id
data['campaign'] = campaign[0].id
data.update(start_form)
data.update(end_form)
form = PostEventForm(data=data, editable_owner=False, instance=event)
activity = Activity.objects.get(name=ACTIVITY_POST_EVENT_METRICS)
reports = NGReport.objects.filter(user=owner, activity=activity)
ok_(not reports.exists())
ok_(form.is_valid())
form.save()
reports = NGReport.objects.filter(user=owner, activity=activity)
ok_(reports.count(), 1)
def test_base(self):
mentor = UserFactory.create(groups=['Mentor'])
report_1 = NGReportFactory.create(mentor=mentor,
report_date=date(2013, 11, 1))
report_2 = NGReportFactory.create(mentor=mentor,
report_date=date(2014, 1, 1))
NGReport.objects.update(created_on=date(2014, 1, 1))
with patch('remo.reports.tasks.now') as datetime_now:
datetime_now.return_value = datetime(2014, 1, 1)
with patch('remo.reports.tasks.render_to_string') as render_mock:
render_mock.return_value = 'rendered'
with patch('remo.reports.tasks.send_mail') as send_mail_mock:
with patch('remo.reports.tasks.DIGEST_SUBJECT', '{date}'):
send_report_digest()
call_args = render_mock.call_args[0]
eq_(call_args[1]['mentor'], mentor)
eq_(set(call_args[1]['reports']), set([report_1, report_2]))
eq_(call_args[1]['datestring'], 'Wed 01 Jan 2014')
send_mail_mock.assert_called_with('Wed 01 Jan 2014', 'rendered',
settings.FROM_EMAIL, [mentor.email])
def test_remove_assignee(self):
model = ContentType.objects.get_for_model(Bug)
items = ActionItem.objects.filter(content_type=model)
ok_(not items.exists())
user = UserFactory.create(groups=['Rep'])
bug = BugFactory.build(pending_mentor_validation=True,
assigned_to=user)
bug.save()
items = ActionItem.objects.filter(content_type=model)
eq_(items.count(), 1)
eq_(items[0].name, 'Waiting mentor validation for ' + bug.summary)
eq_(items[0].user, user)
eq_(items[0].priority, ActionItem.BLOCKER)
bug.assigned_to = None
bug.save()
items = ActionItem.objects.filter(content_type=model, object_id=bug.id)
for item in items:
ok_(item.resolved)
ok_(not item.completed)
def test_base(self):
user = UserFactory.create()
categories = [FunctionalAreaFactory.create()]
initiative = CampaignFactory.create()
event = EventFactory.create(categories=categories,
owner=user,
campaign=initiative)
url = '/api/beta/events/%s' % event.id
request = RequestFactory().get(url)
data = EventDetailedSerializer(event, context={
'request': request
}).data
serialized_start = parser.parse(data['start'])
serialized_end = parser.parse(data['end'])
eq_(data['name'], event.name)
eq_(data['description'], event.description)
eq_(serialized_start.date(), event.start.date())
eq_(serialized_start.time(), event.start.time())
eq_(serialized_end.date(), event.end.date())
eq_(serialized_end.time(), event.end.time())
eq_(data['timezone'], event.timezone)
eq_(data['city'], event.city)
eq_(data['region'], event.region)
eq_(data['country'], event.country)
eq_(data['lat'], event.lat)
eq_(data['lon'], event.lon)
eq_(data['external_link'], event.external_link)
eq_(data['estimated_attendance'], event.estimated_attendance)
eq_(data['planning_pad_url'], event.planning_pad_url)
eq_(data['hashtag'], event.hashtag)
eq_(data['owner']['first_name'], user.first_name)
eq_(data['owner']['last_name'], user.last_name)
eq_(data['owner']['display_name'], user.userprofile.display_name)
ok_(data['owner']['_url'])
eq_(data['categories'][0]['name'], categories[0].name)
eq_(data['initiative'], initiative.name)
def test_mozillian_username_missing(self, mocked_lookup):
"""Test that if a Mozillian changes his
settings in the mozillians.org, we update his username
on our portal.
"""
mozillian = UserFactory.create(
groups=['Mozillians'],
first_name='Awesome',
last_name='Mozillian',
userprofile__mozillian_username='******')
mocked_lookup.return_value = {
'is_vouched': True,
'email': mozillian.email,
'username': '******',
'full_name': {
'privacy': 'Mozillians',
'value': 'Awesome Mozillian'
}
}
check_mozillian_username.apply()
user = User.objects.get(email=mozillian.email)
eq_(user.userprofile.mozillian_username, '')
eq_(user.get_full_name(), u'Anonymous Mozillian')
def test_quarter(self, mocked_quarter):
mocked_quarter.return_value = (1, date(2015, 3, 1))
# Previous quarter
start = datetime(2014, 12, 5)
UserFactory.create(groups=['Rep'],
userprofile__date_joined_program=start)
# This quarter
start = datetime(2015, 1, 5)
UserFactory.create(groups=['Rep'],
userprofile__date_joined_program=start)
# Next quarter
start = datetime(2015, 5, 3)
UserFactory.create(groups=['Rep'],
userprofile__date_joined_program=start)
request = self.factory.get(self.url)
request.query_params = dict()
response = PeopleKPIView().get(request)
eq_(response.data['quarter_total'], 1)
eq_(response.data['quarter_growth_percentage'], 100)
def test_current_week(self, mock_api_now, mock_utils_now):
now_return_value = datetime(2015, 3, 1)
mock_api_now.return_value = now_return_value
mock_utils_now.return_value = now_return_value
# Current week
start = datetime(2015, 2, 22)
UserFactory.create(groups=['Rep'],
userprofile__date_joined_program=start)
# Previous week
start = datetime(2015, 2, 18)
UserFactory.create(groups=['Rep'],
userprofile__date_joined_program=start)
# Next week
start = datetime(2015, 3, 4)
UserFactory.create(groups=['Rep'],
userprofile__date_joined_program=start)
request = self.factory.get(self.url)
request.query_params = dict()
response = PeopleKPIView().get(request)
eq_(response.data['week_total'], 1)
eq_(response.data['week_growth_percentage'], (1 - 2) * 100 / 2.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)
def setUp(self):
"""Initial data for the tests."""
UserFactory.create(username='******', email='*****@*****.**',
first_name='ReMo', last_name='bot')
def test_council_group_has_mentor_change_permissions(self):
"""Test that council group has mentor change permissions."""
councelor = UserFactory.create(groups=['Council'])
ok_(councelor.has_perm('profiles.can_edit_profiles'))
def test_get_last_report_past(self):
report_date = now().date() - timedelta(weeks=5)
user = UserFactory.create(groups=['Rep'])
NGReportFactory.create(user=user, report_date=report_date)
eq_(get_last_report(user).report_date, report_date)
def test_get_as_admin(self):
user = UserFactory.create(groups=['Admin'])
report = NGReportFactory.create()
response = self.get(url=report.get_absolute_edit_url(), user=user)
eq_(response.context['report'], report)
self.assertTemplateUsed('edit_ng_report.html')
def test_view_delete_profile_page(self):
"""Get delete profile page."""
admin = UserFactory.create(groups=['Admin'])
self.client.login(username=admin.username, password='******')
response = self.client.get(self.user_delete_url, follow=True)
self.assertTemplateUsed(response, 'main.html')
def test_edit_profile_redirect_admin(self):
"""Test that after edit profile redirection is correct."""
admin = UserFactory.create(groups=['Admin'])
self.client.login(username=admin.username, password='******')
response = self.client.post(self.user_edit_url, self.data, follow=True)
eq_(response.request['PATH_INFO'], self.user_url)
def test_base_content_list_unauthed(self):
"""Test list base content unauthorized."""
user = UserFactory.create(groups=['Rep'])
self.get(reverse('list_activities'), user=user, follow=True)
def test_as_other_rep(self):
user = UserFactory.create()
report = NGReportFactory.create()
report_comment = NGReportCommentFactory.create(report=report)
self.post(user=user, url=report_comment.get_absolute_delete_url())
ok_(NGReportComment.objects.filter(pk=report_comment.id).exists())
def test_with_valid_data(self, mocked_request, switch_is_active_mock):
"""Test fetch_bugs valid bug data processing."""
UserFactory.create(username='******')
if ((not getattr(settings, 'REMOZILLA_USERNAME', None) or
not getattr(settings, 'REMOZILLA_PASSWORD', None))):
raise SkipTest('Skipping test due to unset REMOZILLA_USERNAME.')
switch_is_active_mock.return_value = True
previous_last_updated_time = get_last_updated_date()
mentor = UserFactory.create()
user = UserFactory.create(groups=['Rep'], email='*****@*****.**',
userprofile__mentor=mentor)
login_data = {u'token': u'bugzilla_token',
u'id': 12345}
bug_data = [{'id': 7788,
'summary': 'This is summary',
'creator': '*****@*****.**',
'creation_time': '2010-10-5T13:45:23Z',
'component': 'Budget Requests',
'whiteboard': 'This is whiteboard',
'cc': ['*****@*****.**', '*****@*****.**'],
'assigned_to': '*****@*****.**',
'status': 'resolved',
'flags': [{'status': '?',
'name': 'remo-approval'},
{'status': '?',
'name': 'needinfo',
'requestee': settings.REPS_COUNCIL_ALIAS},
{'status': '?',
'name': 'needinfo',
'requestee': '*****@*****.**'}],
'resolution': 'invalid'},
{'id': 1199,
'summary': 'New summary',
'creator': '*****@*****.**',
'creation_time': '2012-12-5T11:30:23Z',
'component': 'Budget Requests',
'whiteboard': 'Council Reviewer Assigned',
'cc': ['*****@*****.**', '*****@*****.**'],
'flags': [{'status': '?',
'name': 'remo-approval'},
{'status': '?',
'name': 'remo-review'}],
'assigned_to': '*****@*****.**',
'status': 'resolved',
'resolution': 'invalid'}]
def mocked_get(url, *args, **kwargs):
mocked_response = Mock()
if 'login' in url:
mocked_response.json.return_value = login_data
return mocked_response
elif 'comment' in url:
comments = {
'bugs': {
'7788': {
'comments': [{'text': 'foo'}, {'text': 'bar'}]
},
'1199': {
'comments': [{'text': 'bar'}, {'text': 'foo'}]
}
}
}
mocked_response.json.return_value = comments
return mocked_response
else:
mocked_response.json.return_value = {'bugs': bug_data}
url_params = parse_qs(urlparse(url).query)
offset = url_params.get('offset')
if offset and int(offset[0]) > 0:
mocked_response.json.return_value = {'bugs': []}
return mocked_response
mocked_request.side_effect = mocked_get
fetch_bugs()
eq_(Bug.objects.all().count(), 2)
eq_(Bug.objects.filter(component='Budget Requests').count(), 2)
# refresh status_obj
self.assertGreater(get_last_updated_date(), previous_last_updated_time)
bug = Bug.objects.get(bug_id=7788)
eq_(bug.cc.all().count(), 1)
eq_(bug.assigned_to.email, '*****@*****.**')
eq_(bug.resolution, 'INVALID')
eq_(bug.creator, User.objects.get(email='*****@*****.**'))
ok_(bug.council_vote_requested)
ok_(user in bug.budget_needinfo.all())
eq_(bug.first_comment, 'foo')
bug = Bug.objects.get(bug_id=1199)
eq_(bug.creator, None)
eq_(bug.cc.all().count(), 1)
ok_(not bug.council_vote_requested)
ok_(bug.pending_mentor_validation)
ok_(bug.council_member_assigned)
eq_(bug.first_comment, 'bar')
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 test_delete_as_admin(self, redirect_mock):
user = UserFactory.create(groups=['Admin'])
comment = PollCommentFactory.create()
with self.login(user) as client:
client.post(comment.get_absolute_delete_url(), user=user)
ok_(not PollComment.objects.filter(pk=comment.id).exists())
def test_edit_profile_permissions_admin(self):
"""Test admin permission to edit profile."""
admin = UserFactory.create(groups=['Admin'])
self.client.login(username=admin.username, password='******')
response = self.client.get(self.user_edit_url, follow=True)
self.assertTemplateUsed(response, 'profiles_edit.html')
def test_admin_group_has_all_permissions(self):
"""Test that admin group has all permissions."""
admin = UserFactory.create(groups=['Admin'])
for permission in self.permissions:
ok_(admin.has_perm(permission))
def test_delete_user_delete_profile_no_perms(self):
"""Test user can't delete profile without permissions."""
user = UserFactory.create(groups=['Rep'])
self.client.login(username=user.username, password='******')
self.client.post(self.user_delete_url, follow=True)
ok_(User.objects.filter(pk=self.rep.id).exists())
def test_council_group_has_no_permissions(self):
"""Test that council group has no permissions."""
councelor = UserFactory.create(groups=['Council'])
for permission in self.permissions:
ok_(not councelor.has_perm(permission))
def test_rep_group_has_no_permissions(self):
"""Test that rep group has no permissions."""
user = UserFactory.create(groups=['Rep'])
for permission in self.permissions:
ok_(not user.has_perm(permission))
def setUp(self):
self.mentor = UserFactory.create(groups=['Rep', 'Mentor'])
self.rep = UserFactory.create(groups=['Rep'],
userprofile__mentor=self.mentor)
def test_last_report_date_none(self):
user = UserFactory.create(groups=['Rep'])
ok_(not get_last_report(user))
future_date = now().date() + timedelta(weeks=2)
NGReportFactory.create(user=user, report_date=future_date)
ok_(not get_last_report(user))
def test_get_as_other_rep(self):
user = UserFactory.create()
report = NGReportFactory.create()
self.get(url=report.get_absolute_edit_url(), user=user)
