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)