def test_edit_event(self):
"""Edit event with inactive categories."""
start_form = {
'start_form_0_month': 1,
'start_form_0_day': 25,
'start_form_0_year': 2014,
'start_form_1_hour': 4,
'start_form_1_minute': 1}
end_form = {
'end_form_0_month': 1,
'end_form_0_day': 25,
'end_form_0_year': 2015,
'end_form_1_hour': 4,
'end_form_1_minute': 1}
owner = UserFactory.create(groups=['Mentor'])
active_areas = FunctionalAreaFactory.create_batch(2)
inactive_areas = FunctionalAreaFactory.create_batch(2, active=False)
event = EventFactory.create(owner=owner, categories=inactive_areas)
data = model_to_dict(event)
data['categories'] = [x.id for x in active_areas + inactive_areas]
data.update(start_form)
data.update(end_form)
form = EventForm(data=data, editable_owner=False, instance=event)
ok_(form.is_valid())
result = form.save()
for area in active_areas + inactive_areas:
ok_(area in result.categories.all())
def test_invalid_formset(self):
"""Test unique metrics validation."""
metrics = EventMetricFactory.create_batch(2)
FunctionalAreaFactory.create_batch(3)
data = {
'eventmetricoutcome_set-0-id': '',
'eventmetricoutcome_set-0-metric': metrics[0].id,
'eventmetricoutcome_set-0-expected_outcome': 100,
'eventmetricoutcome_set-1-id': '',
'eventmetricoutcome_set-1-metric': metrics[0].id,
'eventmetricoutcome_set-1-expected_outcome': 10,
'eventmetricoutcome_set-2-id': '',
'eventmetricoutcome_set-2-metric': metrics[1].id,
'eventmetricoutcome_set-2-expected_outcome': 10,
'eventmetricoutcome_set-TOTAL_FORMS': 2,
'eventmetricoutcome_set-INITIAL_FORMS': 0}
formset = inlineformset_factory(
Event, Event.metrics.through,
form=EventMetricsForm,
formset=BaseEventMetricsFormset,
extra=2)
forms = formset(instance=Event(), data=data)
error_msg = 'This metric has already been selected.'
ok_(not forms.is_valid())
eq_(forms.errors[1]['metric'], error_msg)
def test_edit_event(self):
"""Edit event with inactive categories."""
start_form = {
'start_form_0_month': 1,
'start_form_0_day': 25,
'start_form_0_year': 2014,
'start_form_1_hour': 4,
'start_form_1_minute': 1}
end_form = {
'end_form_0_month': 1,
'end_form_0_day': 25,
'end_form_0_year': 2015,
'end_form_1_hour': 4,
'end_form_1_minute': 1}
owner = UserFactory.create(groups=['Mentor'])
active_areas = FunctionalAreaFactory.create_batch(2)
inactive_areas = FunctionalAreaFactory.create_batch(2, active=False)
event = EventFactory.create(owner=owner, categories=inactive_areas)
data = model_to_dict(event)
data['categories'] = [x.id for x in active_areas + inactive_areas]
data.update(start_form)
data.update(end_form)
form = EventForm(data=data, editable_owner=False, instance=event)
ok_(form.is_valid())
result = form.save()
for area in active_areas + inactive_areas:
ok_(area in result.categories.all())
def test_functional_area_list(self):
functional_area_1 = FunctionalAreaFactory.create()
functional_area_2 = FunctionalAreaFactory.create()
report = NGReportFactory.create(functional_areas=[functional_area_1])
NGReportFactory.create(functional_areas=[functional_area_2])
url = reverse('list_ng_reports_functional_area',
kwargs={'functional_area_slug': functional_area_1.slug})
response = self.get(url=url)
eq_(set(response.context['objects'].object_list), set([report]))
def test_functional_area_list(self):
functional_area_1 = FunctionalAreaFactory.create()
functional_area_2 = FunctionalAreaFactory.create()
report = NGReportFactory.create(functional_areas=[functional_area_1])
NGReportFactory.create(functional_areas=[functional_area_2])
url = reverse('list_ng_reports_functional_area',
kwargs={'functional_area_slug': functional_area_1.slug})
response = Client().get(url)
eq_(set(response.context['objects'].object_list), set([report]))
def test_edit_event(self):
"""Edit NGReport with inactive categories."""
activity = ActivityFactory.create()
active_area = FunctionalAreaFactory.create()
inactive_areas = FunctionalAreaFactory.create_batch(2, active=False)
report = NGReportFactory.create(activity=activity,
functional_areas=inactive_areas)
data = model_to_dict(report)
areas = [active_area.id] + [x.id for x in inactive_areas]
data['functional_areas'] = areas
form = NGReportForm(data, instance=report)
ok_(form.is_valid())
result = form.save()
for area in inactive_areas + [active_area]:
ok_(area in result.functional_areas.all())
def test_edit_event(self):
"""Edit NGReport with inactive categories."""
activity = ActivityFactory.create()
active_area = FunctionalAreaFactory.create()
inactive_areas = FunctionalAreaFactory.create_batch(2, active=False)
report = NGReportFactory.create(activity=activity,
functional_areas=inactive_areas)
data = model_to_dict(report)
areas = [active_area.id] + [x.id for x in inactive_areas]
data['functional_areas'] = areas
form = NGReportForm(data, instance=report)
ok_(form.is_valid())
result = form.save()
for area in inactive_areas + [active_area]:
ok_(area in result.functional_areas.all())
def test_edit_event(self):
"""Edit NGReport with inactive categories."""
activity = ActivityFactory.create()
campaign = CampaignFactory.create()
active_area = FunctionalAreaFactory.create()
inactive_areas = FunctionalAreaFactory.create_batch(2, active=False)
report = NGReportFactory.create(activity=activity, campaign=campaign, functional_areas=inactive_areas)
data = model_to_dict(report)
data["functional_areas"] = active_area.id
form = NGReportForm(data, instance=report)
ok_(form.is_valid())
result = form.save()
ok_(active_area in result.functional_areas.all())
eq_(result.functional_areas.all().count(), 1)
def test_base(self):
user = UserFactory.create()
categories = [FunctionalAreaFactory.create()]
initiative = CampaignFactory.create()
event = EventFactory.create(categories=categories,
owner=user,
campaign=initiative)
url = '/api/remo/v1/events/%s' % event.id
request = RequestFactory().get(url)
data = EventDetailedSerializer(event, context={
'request': request
}).data
eq_(data['name'], event.name)
eq_(data['description'], event.description)
eq_(data['start'], event.start)
eq_(data['end'], event.end)
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_base(self):
user = UserFactory.create()
activity = ActivityFactory.create()
campaign = CampaignFactory.create()
functional_area = FunctionalAreaFactory.create()
data = {
"report_date": "25 March 2012",
"activity": activity.id,
"campaign": campaign.id,
"longitude": 44.33,
"latitude": 55.66,
"location": "world",
"link": "https://example.com",
"link_description": "Test link.",
"activity_description": "Test activity",
"functional_areas": functional_area.id,
}
form = NGReportForm(data, instance=NGReport(user=user))
ok_(form.is_valid())
db_obj = form.save()
eq_(db_obj.report_date, date(2012, 03, 25))
eq_(db_obj.activity, activity)
eq_(db_obj.longitude, 44.33)
eq_(db_obj.latitude, 55.66)
eq_(db_obj.location, "world")
eq_(db_obj.link, "https://example.com/")
eq_(db_obj.link_description, "Test link.")
eq_(db_obj.activity_description, "Test activity"),
eq_(db_obj.functional_areas.all().count(), 1)
eq_(db_obj.functional_areas.all()[0], functional_area)
eq_(db_obj.mentor, user.userprofile.mentor)
def test_base_content_delete_unauthed(self):
"""Test delete base content unauthorized."""
user = UserFactory.create(groups=['Rep'])
area = FunctionalAreaFactory.create(name='test functional area')
self.post(reverse('delete_functional_area', kwargs={'pk': area.id}),
user=user,
follow=True)
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_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_edit_event(self):
"""Edit event with inactive categories."""
start_form = {
'start_form_0_month': 1,
'start_form_0_day': 25,
'start_form_0_year': 2014,
'start_form_1_hour': 4,
'start_form_1_minute': 1}
end_form = {
'end_form_0_month': 1,
'end_form_0_day': 25,
'end_form_0_year': 2015,
'end_form_1_hour': 4,
'end_form_1_minute': 1}
owner = UserFactory.create(groups=['Mentor'])
functional_area = [FunctionalAreaFactory.create()]
campaign = [CampaignFactory.create()]
event = EventFactory.create(owner=owner, categories=functional_area)
data = model_to_dict(event)
data['categories'] = functional_area[0].id
data['campaign'] = campaign[0].id
data.update(start_form)
data.update(end_form)
form = EventForm(data=data, editable_owner=False, instance=event)
ok_(form.is_valid())
result = form.save()
ok_(functional_area[0] in result.categories.all())
def test_base(self):
user = UserFactory.create()
activity = ActivityFactory.create()
campaign = CampaignFactory.create()
functional_area = FunctionalAreaFactory.create()
data = {
'report_date': '25 March 2012',
'activity': activity.id,
'campaign': campaign.id,
'longitude': 44.33,
'latitude': 55.66,
'location': 'world',
'link': 'https://example.com',
'link_description': 'Test link.',
'activity_description': 'Test activity',
'functional_areas': functional_area.id,
}
form = NGReportForm(data, instance=NGReport(user=user))
ok_(form.is_valid())
db_obj = form.save()
eq_(db_obj.report_date, date(2012, 03, 25))
eq_(db_obj.activity, activity)
eq_(db_obj.longitude, 44.33)
eq_(db_obj.latitude, 55.66)
eq_(db_obj.location, 'world')
eq_(db_obj.link, 'https://example.com')
eq_(db_obj.link_description, 'Test link.')
eq_(db_obj.activity_description, 'Test activity'),
eq_(db_obj.functional_areas.all().count(), 1)
eq_(db_obj.functional_areas.all()[0], functional_area)
eq_(db_obj.mentor, user.userprofile.mentor)
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_batch(2)
event = EventFactory.create(owner=owner, categories=areas)
data = model_to_dict(event)
data['categories'] = [x.id for x in areas]
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_edit_event(self):
"""Edit NGReport with inactive categories."""
activity = ActivityFactory.create()
campaign = CampaignFactory.create()
active_area = FunctionalAreaFactory.create()
inactive_areas = FunctionalAreaFactory.create_batch(2, active=False)
report = NGReportFactory.create(activity=activity, campaign=campaign,
functional_areas=inactive_areas)
data = model_to_dict(report)
data['functional_areas'] = active_area.id
form = NGReportForm(data, instance=report)
ok_(form.is_valid())
result = form.save()
ok_(active_area in result.functional_areas.all())
eq_(result.functional_areas.all().count(), 1)
def test_base(self):
user = UserFactory.create()
activity = ActivityFactory.create()
functional_area = FunctionalAreaFactory.create()
data = {
'report_date': '25 March 2012',
'activity': activity.id,
'longitude': 44.33,
'latitude': 55.66,
'location': 'world',
'link': 'https://example.com',
'link_description': 'Test link.',
'activity_description': 'Test activity',
'functional_areas': [functional_area.id],
}
form = NGReportForm(data, instance=NGReport(user=user))
ok_(form.is_valid())
db_obj = form.save()
eq_(db_obj.report_date, date(2012, 03, 25))
eq_(db_obj.activity, activity)
eq_(db_obj.longitude, 44.33)
eq_(db_obj.latitude, 55.66)
eq_(db_obj.location, 'world')
eq_(db_obj.link, 'https://example.com/')
eq_(db_obj.link_description, 'Test link.')
eq_(db_obj.activity_description, 'Test activity'),
eq_(db_obj.functional_areas.all().count(), 1)
eq_(db_obj.functional_areas.all()[0], functional_area)
eq_(db_obj.mentor, user.userprofile.mentor)
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_base_content_functional_area_delete_post(self):
"""Test delete functional area."""
admin = UserFactory.create(groups=['Admin'])
area = FunctionalAreaFactory.create(name='test functional area')
response = self.post(reverse('delete_functional_area',
kwargs={'pk': area.id}), user=admin,
follow=True)
eq_(response.status_code, 200)
query = FunctionalArea.objects.filter(name='test functional area')
eq_(query.exists(), False)
def categories(self, create, extracted, **kwargs):
"""Add event categories after event creation."""
if not create:
return
if extracted:
for category in extracted:
self.categories.add(category)
else:
area = FunctionalAreaFactory.create()
self.categories.add(area)
def categories(self, create, extracted, **kwargs):
"""Add event categories after event creation."""
if not create:
return
if extracted:
for category in extracted:
self.categories.add(category)
else:
area = FunctionalAreaFactory.create()
self.categories.add(area)
def test_mentor_functional_area_list(self):
mentor = UserFactory.create(groups=['Mentor'])
functional_area = FunctionalAreaFactory.create()
report = NGReportFactory.create(mentor=mentor, functional_areas=[functional_area])
NGReportFactory.create(functional_areas=[functional_area])
url = reverse('list_ng_reports_mentor_functional_area',
kwargs={'functional_area_slug': functional_area.slug,
'mentor': mentor.userprofile.display_name})
response = Client().get(url)
eq_(set(response.context['objects'].object_list), set([report]))
def test_rep_functional_area_list(self):
user = UserFactory.create(groups=['Rep'])
functional_area = FunctionalAreaFactory.create()
report = NGReportFactory.create(user=user,
functional_areas=[functional_area])
NGReportFactory.create(functional_areas=[functional_area])
url = reverse('list_ng_reports_rep_functional_area',
kwargs={'functional_area_slug': functional_area.slug,
'rep': user.userprofile.display_name})
response = self.get(url=url)
eq_(set(response.context['reports'].object_list), set([report]))
def test_base_content_functional_area_edit_post(self):
"""Test post edit functional area."""
admin = UserFactory.create(groups=['Admin'])
area = FunctionalAreaFactory.create(name='test functional area')
response = self.post(reverse('edit_functional_area',
kwargs={'pk': area.id}),
data={'name': 'edit functional area'},
user=admin, follow=True)
eq_(response.status_code, 200)
query = FunctionalArea.objects.filter(name='edit functional area')
eq_(query.exists(), True)
def test_base_content_functional_area_delete_post(self):
"""Test delete functional area."""
admin = UserFactory.create(groups=['Admin'])
area = FunctionalAreaFactory.create(name='test functional area')
response = self.post(reverse('delete_functional_area',
kwargs={'pk': area.id}),
user=admin,
follow=True)
eq_(response.status_code, 200)
query = Campaign.objects.filter(name='test functional area')
eq_(query.exists(), False)
def categories(self, create, extracted, **kwargs):
"""Add event categories after event creation."""
if not create:
return
if extracted:
for category in extracted:
self.categories.add(category)
else:
# add random number of categories
for i in range(randint(1, 6)):
area = FunctionalAreaFactory.create()
self.categories.add(area)
def categories(self, create, extracted, **kwargs):
"""Add event categories after event creation."""
if not create:
return
if extracted:
for category in extracted:
self.categories.add(category)
else:
# add random number of categories
for i in range(randint(1, 6)):
area = FunctionalAreaFactory.create()
self.categories.add(area)
def test_base_content_functional_area_edit_post(self):
"""Test post edit functional area."""
admin = UserFactory.create(groups=['Admin'])
area = FunctionalAreaFactory.create(name='test functional area')
with self.login(admin) as client:
response = client.post(reverse('edit_functional_area',
kwargs={'pk': area.id}),
data={'name': 'edit functional area'},
follow=True)
eq_(response.status_code, 200)
query = FunctionalArea.objects.filter(name='edit functional area')
eq_(query.exists(), True)
def test_mentor_functional_area_list(self):
mentor = UserFactory.create(groups=['Mentor'])
functional_area = FunctionalAreaFactory.create()
report = NGReportFactory.create(mentor=mentor,
functional_areas=[functional_area])
NGReportFactory.create(functional_areas=[functional_area])
url = reverse('list_ng_reports_mentor_functional_area',
kwargs={
'functional_area_slug': functional_area.slug,
'mentor': mentor.userprofile.display_name
})
response = self.get(url=url)
eq_(set(response.context['objects'].object_list), set([report]))
def test_rep_functional_area_list(self):
user = UserFactory.create(groups=['Rep'])
functional_area = FunctionalAreaFactory.create()
report = NGReportFactory.create(user=user,
functional_areas=[functional_area])
NGReportFactory.create(functional_areas=[functional_area])
url = reverse('list_ng_reports_rep_functional_area',
kwargs={
'functional_area_slug': functional_area.slug,
'rep': user.userprofile.display_name
})
response = Client().get(url)
eq_(set(response.context['objects'].object_list), set([report]))
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/remo/v1/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 setUp(self):
categories = FunctionalAreaFactory.create_batch(3)
goals = EventGoalFactory.create_batch(3)
metrics = EventMetricFactory.create_batch(3)
self.data = {
'name': u'Test edit event',
'description': u'This is a description',
'external_link': '',
'categories': [x.id for x in categories],
'goals': [x.id for x in goals],
'venue': u'Hackerspace.GR',
'lat': 38.01697,
'lon': 23.7314,
'city': u'Athens',
'region': u'Attica',
'country': u'Greece',
'start_form_0_month': 01,
'start_form_0_day': 25,
'start_form_0_year': 2014,
'start_form_1_hour': 04,
'start_form_1_minute': 01,
'end_form_0_month': 01,
'end_form_0_day': 03,
'end_form_0_year': 2018,
'end_form_1_hour': 03,
'end_form_1_minute': 00,
'timezone': u'Europe/Athens',
'mozilla_event': u'on',
'estimated_attendance': u'10',
'actual_attendance': u'10',
'extra_content': u'This is extra content',
'planning_pad_url': u'',
'hashtag': u'#testevent',
'swag_bug_form': u'',
'budget_bug_form': u'',
'eventmetricoutcome_set-0-id': '',
'eventmetricoutcome_set-0-metric': metrics[0].id,
'eventmetricoutcome_set-0-expected_outcome': 100,
'eventmetricoutcome_set-1-id': '',
'eventmetricoutcome_set-1-metric': metrics[1].id,
'eventmetricoutcome_set-1-expected_outcome': 10,
'eventmetricoutcome_set-TOTAL_FORMS': 2,
'eventmetricoutcome_set-INITIAL_FORMS': 0}
self.event_edit_url = reverse('events_edit_event',
kwargs={'slug': 'test-event'})
self.event_url = reverse('events_view_event',
kwargs={'slug': 'test-event'})
def test_email_reps_as_mozillian(self, faked_message):
"""Email all the reps associated with a functional area."""
mozillian = UserFactory.create(groups=['Mozillians'])
area = FunctionalAreaFactory.create()
UserFactory.create(groups=['Rep'],
userprofile__functional_areas=[area])
data = {'subject': 'This is subject',
'body': 'This is my body\n Multiline of course',
'functional_area': area.id}
with self.login(mozillian) as client:
response = client.post(reverse('dashboard'), data, follow=True)
ok_(faked_message.called)
eq_(faked_message.call_args[0][1], 'Email sent successfully.')
eq_(len(mail.outbox), 1)
self.assertJinja2TemplateUsed(response, 'dashboard_mozillians.jinja')
def setUp(self):
"""Setup method for some initial data."""
ActivityFactory.create(name=ACTIVITY_EVENT_ATTEND)
ActivityFactory.create(name=ACTIVITY_EVENT_CREATE)
functional_area = FunctionalAreaFactory.create()
metrics = EventMetricFactory.create_batch(3)
campaign = CampaignFactory.create()
self.data = {
'name': u'Test edit event',
'description': u'This is a description',
'external_link': '',
'categories': [functional_area.id],
'campaign': [campaign.id],
'venue': u'Hackerspace.GR',
'lat': 38.01697,
'lon': 23.7314,
'city': u'Athens',
'region': u'Attica',
'country': u'Greece',
'start_form_0_month': 01,
'start_form_0_day': 25,
'start_form_0_year': now().year + 1,
'start_form_1_hour': 04,
'start_form_1_minute': 01,
'end_form_0_month': 01,
'end_form_0_day': 03,
'end_form_0_year': now().year + 2,
'end_form_1_hour': 03,
'end_form_1_minute': 00,
'timezone': u'Europe/Athens',
'mozilla_event': u'on',
'estimated_attendance': u'10',
'actual_attendance': u'10',
'extra_content': u'This is extra content',
'planning_pad_url': u'',
'hashtag': u'#testevent',
'swag_bug_form': u'',
'budget_bug_form': u'',
'eventmetricoutcome_set-0-id': '',
'eventmetricoutcome_set-0-metric': metrics[0].id,
'eventmetricoutcome_set-0-expected_outcome': 100,
'eventmetricoutcome_set-1-id': '',
'eventmetricoutcome_set-1-metric': metrics[1].id,
'eventmetricoutcome_set-1-expected_outcome': 10,
'eventmetricoutcome_set-TOTAL_FORMS': 2,
'eventmetricoutcome_set-INITIAL_FORMS': 0
}
def test_email_reps_as_mozillian(self):
"""Email all the reps associated with a functional area."""
c = Client()
area = FunctionalAreaFactory.create()
UserFactory.create(groups=['Rep'],
userprofile__functional_areas=[area])
c.login(username='******', password='******')
data = {'subject': 'This is subject',
'body': 'This is my body\n Multiline of course',
'functional_area': area.id}
response = c.post(reverse('dashboard'), data, follow=True)
for m in response.context['messages']:
pass
eq_(m.tags, u'success')
eq_(len(mail.outbox), 1)
self.assertTemplateUsed(response, 'dashboard_mozillians.html')
def test_email_reps_as_mozillian(self):
"""Email all the reps associated with a functional area."""
c = Client()
area = FunctionalAreaFactory.create()
UserFactory.create(groups=['Rep'],
userprofile__functional_areas=[area])
c.login(username='******', password='******')
data = {'subject': 'This is subject',
'body': 'This is my body\n Multiline of course',
'functional_area': area.id}
response = c.post(reverse('dashboard'), data, follow=True)
for m in response.context['messages']:
pass
eq_(m.tags, u'success')
eq_(len(mail.outbox), 1)
self.assertTemplateUsed(response, 'dashboard_mozillians.html')
def setUp(self):
"""Setup method for some initial data."""
ActivityFactory.create(name=ACTIVITY_EVENT_ATTEND)
ActivityFactory.create(name=ACTIVITY_EVENT_CREATE)
functional_area = FunctionalAreaFactory.create()
metrics = EventMetricFactory.create_batch(3)
campaign = CampaignFactory.create()
self.data = {
'name': u'Test edit event',
'description': u'This is a description',
'external_link': '',
'categories': [functional_area.id],
'campaign': [campaign.id],
'venue': u'Hackerspace.GR',
'lat': 38.01697,
'lon': 23.7314,
'city': u'Athens',
'region': u'Attica',
'country': u'Greece',
'start_form_0_month': 01,
'start_form_0_day': 25,
'start_form_0_year': 2018,
'start_form_1_hour': 04,
'start_form_1_minute': 01,
'end_form_0_month': 01,
'end_form_0_day': 03,
'end_form_0_year': 2019,
'end_form_1_hour': 03,
'end_form_1_minute': 00,
'timezone': u'Europe/Athens',
'mozilla_event': u'on',
'estimated_attendance': u'10',
'actual_attendance': u'10',
'extra_content': u'This is extra content',
'planning_pad_url': u'',
'hashtag': u'#testevent',
'swag_bug_form': u'',
'budget_bug_form': u'',
'eventmetricoutcome_set-0-id': '',
'eventmetricoutcome_set-0-metric': metrics[0].id,
'eventmetricoutcome_set-0-expected_outcome': 100,
'eventmetricoutcome_set-1-id': '',
'eventmetricoutcome_set-1-metric': metrics[1].id,
'eventmetricoutcome_set-1-expected_outcome': 10,
'eventmetricoutcome_set-TOTAL_FORMS': 2,
'eventmetricoutcome_set-INITIAL_FORMS': 0}
def setUp(self):
"""Setup tests."""
self.mentor = UserFactory.create(groups=['Rep', 'Mentor'],
userprofile__initial_council=True)
self.rep = UserFactory.create(groups=['Rep'],
userprofile__mentor=self.mentor)
self.area = FunctionalAreaFactory.create()
self.mobilising_interest = MobilisingInterestFactory.create()
self.mobilising_skill = MobilisingSkillFactory.create()
profile = self.rep.userprofile
self.data = {
'display_name': profile.display_name,
'first_name': self.rep.first_name,
'email': self.rep.email,
'last_name': self.rep.last_name,
'local_name': profile.local_name,
'private_email': self.rep.email,
'twitter_account': profile.twitter_account,
'city': profile.city,
'region': profile.region,
'country': profile.country,
'lon': profile.lat,
'lat': profile.lon,
'mozillians_profile_url': profile.mozillians_profile_url,
'wiki_profile_url': profile.wiki_profile_url,
'jabber_id': u'*****@*****.**',
'irc_name': profile.irc_name,
'linkedin_url': u'http://www.linkedin.com/',
'facebook_url': u'http://www.facebook.com/',
'diaspora_url': u'https://joindiaspora.com/',
'personal_website_url': u'http://www.example.com/',
'personal_blog_feed': u'http://example.com/',
'bio': u'This is my bio.',
'date_joined_program': '2011-07-01',
'mentor': profile.mentor.id,
'functional_areas': self.area.id,
'mobilising_skills': self.mobilising_skill.id,
'mobilising_interests': self.mobilising_interest.id
}
display_name = {'display_name': profile.display_name}
self.user_url = reverse('profiles_view_profile', kwargs=display_name)
self.user_edit_url = reverse('profiles_edit', kwargs=display_name)
self.user_delete_url = reverse('profiles_delete', kwargs=display_name)
def test_base(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/remo/v1/users/%s' % user.id
request = RequestFactory().get(url)
profile = user.userprofile
data = UserProfileDetailedSerializer(user.userprofile,
context={
'request': request
}).data
eq_(data['first_name'], user.first_name)
eq_(data['last_name'], user.last_name)
eq_(data['display_name'], profile.display_name)
eq_(data['date_joined_program'],
profile.date_joined_program.strftime('%Y-%m-%d'))
eq_(data['date_left_program'], profile.date_left_program)
eq_(data['city'], profile.city)
eq_(data['region'], profile.region)
eq_(data['country'], profile.country)
eq_(data['twitter_account'], profile.twitter_account)
eq_(data['jabber_id'], profile.jabber_id)
eq_(data['irc_name'], profile.irc_name)
eq_(data['wiki_profile_url'], profile.wiki_profile_url)
eq_(data['irc_channels'], profile.irc_channels)
eq_(data['linkedin_url'], profile.linkedin_url)
eq_(data['facebook_url'], profile.facebook_url)
eq_(data['diaspora_url'], profile.diaspora_url)
eq_(data['bio'], profile.bio)
eq_(data['mozillians_profile_url'], profile.mozillians_profile_url)
eq_(data['timezone'], profile.timezone)
eq_(data['groups'][0]['name'], 'Rep')
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['functional_areas'][0]['name'], functional_areas[0].name)
eq_(data['functional_areas'][1]['name'], functional_areas[1].name)
def setUp(self):
"""Setup tests."""
self.mentor = UserFactory.create(groups=['Rep', 'Mentor'],
userprofile__initial_council=True)
self.rep = UserFactory.create(groups=['Rep'], userprofile__mentor=self.mentor)
self.area = FunctionalAreaFactory.create()
self.mobilising_interest = MobilisingInterestFactory.create()
self.mobilising_skill = MobilisingSkillFactory.create()
profile = self.rep.userprofile
self.data = {'display_name': profile.display_name,
'first_name': self.rep.first_name,
'email': self.rep.email,
'last_name': self.rep.last_name,
'local_name': profile.local_name,
'private_email': self.rep.email,
'twitter_account': profile.twitter_account,
'city': profile.city,
'region': profile.region,
'country': profile.country,
'lon': profile.lat,
'lat': profile.lon,
'mozillians_profile_url': profile.mozillians_profile_url,
'wiki_profile_url': profile.wiki_profile_url,
'jabber_id': u'*****@*****.**',
'irc_name': profile.irc_name,
'linkedin_url': u'http://www.linkedin.com/',
'facebook_url': u'http://www.facebook.com/',
'diaspora_url': u'https://joindiaspora.com/',
'personal_website_url': u'http://www.example.com/',
'personal_blog_feed': u'http://example.com/',
'bio': u'This is my bio.',
'date_joined_program': '2011-07-01',
'mentor': profile.mentor.id,
'functional_areas': self.area.id,
'mobilising_skills': self.mobilising_skill.id,
'mobilising_interests': self.mobilising_interest.id}
display_name = {'display_name': profile.display_name}
self.user_url = reverse('profiles_view_profile', kwargs=display_name)
self.user_edit_url = reverse('profiles_edit', kwargs=display_name)
self.user_delete_url = reverse('profiles_delete', kwargs=display_name)
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()
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)
profile = user.userprofile
data = UserProfileDetailedSerializer(user.userprofile,
context={'request': request}).data
eq_(data['first_name'], user.first_name)
eq_(data['last_name'], user.last_name)
eq_(data['display_name'], profile.display_name)
eq_(data['date_joined_program'],
profile.date_joined_program.strftime('%Y-%m-%d'))
eq_(data['date_left_program'], profile.date_left_program)
eq_(data['city'], profile.city)
eq_(data['region'], profile.region)
eq_(data['country'], profile.country)
eq_(data['twitter_account'], profile.twitter_account)
eq_(data['jabber_id'], profile.jabber_id)
eq_(data['irc_name'], profile.irc_name)
eq_(data['wiki_profile_url'], profile.wiki_profile_url)
eq_(data['irc_channels'], profile.irc_channels)
eq_(data['linkedin_url'], profile.linkedin_url)
eq_(data['facebook_url'], profile.facebook_url)
eq_(data['diaspora_url'], profile.diaspora_url)
eq_(data['bio'], profile.bio)
eq_(data['mozillians_profile_url'], profile.mozillians_profile_url)
eq_(data['timezone'], profile.timezone)
eq_(data['groups'][0]['name'], 'Rep')
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['functional_areas'][0]['name'], functional_areas[0].name)
eq_(data['functional_areas'][1]['name'], functional_areas[1].name)
def setUp(self):
self.functional_area = FunctionalAreaFactory.create()
def test_base(self):
functional_area = FunctionalAreaFactory.create()
serializer = FunctionalAreaSerializer(functional_area)
eq_(serializer.data, {'name': functional_area.name})
def test_base_content_delete_unauthed(self):
"""Test delete base content unauthorized."""
user = UserFactory.create(groups=['Rep'])
area = FunctionalAreaFactory.create(name='test functional area')
self.post(reverse('delete_functional_area', kwargs={'pk': area.id}),
user=user, follow=True)
def test_base(self):
functional_area = FunctionalAreaFactory.create()
serializer = FunctionalAreaSerializer(functional_area)
eq_(serializer.data, {'name': functional_area.name})
def setUp(self):
self.functional_area = FunctionalAreaFactory.create()
