def test_get_eval(self):
q1 = EventEvalQuestionFactory(answer_type="grade")
q2 = EventEvalQuestionFactory(answer_type="text",
help_text="so helpful")
q3 = EventEvalQuestionFactory(answer_type="boolean")
q4 = EventEvalQuestionFactory(visible=False,
help_text="unhelpful")
login_as(self.profile, self)
response = self.client.get(self.url, follow=True)
self.assertContains(response, self.context.bid.e_title)
self.assertContains(response, self.context.teacher)
self.assertContains(response, q1.question)
self.assertContains(response, q2.question)
self.assertContains(response, q2.help_text)
self.assertContains(response, q3.question)
self.assertNotContains(response, q4.question)
self.assertNotContains(response, q4.help_text)
n = 0
grade_input = '<input id="id_question%d_%d" name="question%d" ' + \
'type="radio" value="%s" />'
answer_textarea = '<textarea cols="40" id="id_question%d" ' + \
'name="question%d" rows="10">'
boolean_checkbox = '<input id="id_question%d" name="question%d" ' + \
'type="checkbox" />'
for grade in new_grade_options:
self.assertContains(
response,
grade_input % (q1.pk, n, q1.pk, grade[0]))
n = n + 1
self.assertContains(
response,
answer_textarea % (q2.pk, q2.pk))
self.assertContains(
response,
boolean_checkbox % (q3.pk, q3.pk))
def test_edit_event_and_continue(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
data = self.edit_event()
data['edit_event'] = "Save and Continue"
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertRedirects(
response,
"%s?volunteer_open=True" % self.url)
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s 11:00 AM' % (
data['e_title'],
self.extra_day.day.strftime(DATE_FORMAT))
)
self.assertContains(response, data['e_title'])
self.assertContains(response, data['e_description'])
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.extra_day.pk,
self.extra_day.day.strftime(DATE_FORMAT)))
self.assertContains(response,
'name="max_volunteer" type="number" value="3" />')
self.assertContains(
response,
'name="duration" step="any" type="number" value="2.5" />')
def test_vol_opp_present(self):
vol_context = VolunteerContext()
vol_context.sched_event.max_volunteer = 7
vol_context.sched_event.save()
vol_context.opp_event.set_locations([])
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[vol_context.conference.conference_slug,
vol_context.sched_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url, follow=True)
self.assertContains(
response,
'name="opp_event_id" type="hidden" value="%d" />' % (
vol_context.opportunity.pk)
)
self.assertContains(
response,
'name="opp_sched_id" type="hidden" value="%d" />' % (
vol_context.opp_event.pk)
)
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
vol_context.window.day.pk,
vol_context.window.day.day.strftime("%b. %-d, %Y")),
3)
self.assertContains(
response,
'name="max_volunteer" type="number" value="2" />')
self.assertContains(
response,
'name="duration" step="any" type="number" value="1.0" />')
def test_set_eval(self):
q1 = EventEvalQuestionFactory(answer_type="grade")
q2 = EventEvalQuestionFactory(answer_type="text")
q3 = EventEvalQuestionFactory(answer_type="boolean")
login_as(self.profile, self)
response = self.client.post(
self.url,
data={
'question%d' % self.q0.pk: "A",
'question%d' % q1.pk: "B",
'question%d' % q2.pk: "This is Test Text.",
'question%d' % q3.pk: True,
},
follow=True)
assert_alert_exists(
response,
'info',
'Info',
eval_success_msg)
self.assertEqual(
2,
EventEvalGrade.objects.filter(
event=self.context.sched_event).count())
self.assertEqual(
1,
EventEvalComment.objects.filter(
event=self.context.sched_event).count())
self.assertEqual(
1,
EventEvalBoolean.objects.filter(
event=self.context.sched_event).count())
self.assertRedirects(response, reverse('home', urlconf='gbe.urls'))
def test_edit_event_w_staffing(self):
login_as(self.privileged_user, self)
data = self.edit_event()
data['alloc_0-worker'] = self.privileged_user.profile.pk
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertRedirects(
response,
"%s?%s-day=%d&filter=Filter&new=[%dL]" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug]),
self.context.conference.conference_slug,
self.extra_day.pk,
self.context.sched_event.pk))
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s 11:00 AM' % (
data['e_title'],
self.extra_day.day.strftime(DATE_FORMAT))
)
self.assertContains(
response,
'<tr class="bid-table success">\n ' +
'<td class="bid-table">%s</td>' % data['e_title'])
def test_past_staff_lead(self):
context = StaffAreaContext()
context.conference.status = "completed"
context.conference.save()
login_as(context.staff_lead, self)
response = self.client.get(self.url)
self.assertEqual(403, response.status_code)
def test_special_not_registrar(self):
coordinator = ProfileFactory().user_object
grant_privilege(coordinator, 'Volunteer Coordinator')
login_as(coordinator, self)
response = self.client.get(self.url)
self.assertNotIn("/profile/admin/", response.content)
self.assertNotIn("/profile/delete/", response.content)
def test_edit_troupe_bad_data(self):
'''edit_troupe view, edit flow success
'''
persona = PersonaFactory()
contact = persona.performer_profile
troupe = TroupeFactory(contact=contact)
url = reverse(self.view_name,
args=[troupe.pk],
urlconf='gbe.urls')
login_as(contact.profile, self)
data = {'contact': persona.performer_profile.pk,
'name': "New Troupe",
'homepage': persona.homepage,
'bio': "bio",
'experience': 'bad',
'awards': "many",
'membership': [persona.pk]}
response = self.client.post(
url,
data=data,
follow=True
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Tell Us About Your Troupe')
expected_string = "Enter a whole number."
self.assertTrue(expected_string in response.content)
def test_create_troupe_performer_exists(self):
contact = PersonaFactory()
login_as(contact.performer_profile, self)
url = reverse(self.view_name, urlconf='gbe.urls')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue(self.troupe_string in response.content)
def test_review_volunteer_all_well(self):
'''default conference selected, make sure it returns the right page'''
login_as(self.privileged_user, self)
response = self.client.get(self.url)
nt.assert_equal(response.status_code, 200)
nt.assert_true('Bid Information' in response.content)
def test_review_volunteer_w_conf(self):
''' when a specific conf has specific bids, check bid details'''
volunteer = VolunteerFactory(
submitted=True)
interest = VolunteerInterestFactory(
volunteer=self.volunteer
)
volunteer.profile.user_object.email = "*****@*****.**"
volunteer.profile.user_object.save()
prefs = ProfilePreferencesFactory(
profile=volunteer.profile,
in_hotel="Maybe",
inform_about=True,
show_hotel_infobox=True)
login_as(self.privileged_user, self)
response = self.client.get(
self.url,
{'conf_slug': self.volunteer.b_conference.conference_slug})
nt.assert_equal(response.status_code, 200)
nt.assert_true('Bid Information' in response.content)
nt.assert_true(str(self.volunteer.number_shifts) in response.content)
nt.assert_true(self.volunteer.background in response.content)
nt.assert_true(self.volunteer.profile.display_name in response.content)
nt.assert_true(interest.interest.interest in response.content)
nt.assert_true(
self.volunteer.profile.user_object.email in response.content)
nt.assert_true(self.prefs.in_hotel in response.content)
nt.assert_true("Needs Review" in response.content)
nt.assert_true("Review" in response.content)
def test_review_volunteer_bad_user(self):
''' user does not have the right privilege and permission is denied'''
login_as(ProfileFactory(), self)
response = self.client.get(
self.url,
{'conf_slug': self.volunteer.b_conference.conference_slug})
nt.assert_equal(response.status_code, 403)
def test_review_volunteer_no_profile(self):
''' user does not have a profile, gets permission denied'''
login_as(UserFactory(), self)
response = self.client.get(
self.url,
{'conf_slug': self.volunteer.b_conference.conference_slug})
nt.assert_equal(response.status_code, 403)
def test_edit_volunteer_no_volunteer(self):
url = reverse('volunteer_edit',
urlconf='gbe.urls',
args=[0])
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertEqual(404, response.status_code)
def test_review_volunteer_has_old_commitments(self):
''' when a volunteer is booked in old conference, it should not show'''
past_conference = ConferenceFactory(accepting_bids=False,
status='completed')
past_opportunity = GenericEventFactory(
e_conference=past_conference,
volunteer_type=AvailableInterestFactory(interest='Security/usher'),
type='Volunteer')
past_opportunity.save()
booked_sched = sEvent(
eventitem=past_opportunity,
starttime=datetime(2016, 2, 6, 9, 0, 0, 0, pytz.utc),
max_volunteer=1)
booked_sched.save()
worker = Worker(_item=self.volunteer.profile, role='Volunteer')
worker.save()
volunteer_assignment = ResourceAllocationFactory(
event=booked_sched,
resource=worker
)
login_as(self.privileged_user, self)
response = self.client.get(
self.url,
{'conf_slug': self.volunteer.b_conference.conference_slug})
nt.assert_equal(response.status_code, 200)
nt.assert_true('Bid Information' in response.content)
nt.assert_false(str(past_opportunity) in response.content,
msg="The commitment %s is showing up" % (
str(past_opportunity)))
def test_edit_area_and_continue(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
data = self.edit_area()
data['edit_event'] = "Save and Continue"
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertRedirects(
response,
"%s?volunteer_open=True" % self.url)
assert_alert_exists(
response,
'success',
'Success',
'Staff Area has been updated.<br>Title: %s' % (
data['title']))
self.assertContains(response, data['title'])
self.assertContains(response, data['description'])
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.privileged_user.profile.pk,
str(self.privileged_user.profile)))
self.assertContains(
response,
'name="default_volunteers" type="number" value="3" />')
def test_volunteer_conflict_sends_warning_to_areastaff(self):
context = VolunteerContext()
area = StaffAreaFactory(conference=context.conference,
staff_lead=context.profile)
EventLabelFactory(
event=context.opp_event,
text=area.slug)
change_window = context.add_window()
context.bid.available_windows.add(context.window)
form = self.get_form(context)
form['available_windows'] = [change_window.pk]
url = reverse('volunteer_edit',
urlconf='gbe.urls',
args=[context.bid.pk])
login_as(context.profile, self)
response = self.client.post(
url,
form,
follow=True)
assert_right_mail_right_addresses(
1,
3,
"URGENT: Volunteer Schedule Conflict Occurred",
[self.privileged_profile.contact_email,
context.profile.contact_email])
def test_authorized_user_can_access_master(self):
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
assert_event_was_picked_in_wizard(response, "master")
assert_role_choice(response, "Teacher")
assert_role_choice(response, "Volunteer")
def test_vol_opp_present(self):
self.context.area.default_room = self.room
self.context.area.save()
vol_opp = self.context.add_volunteer_opp()
self.extra_day = ConferenceDayFactory(
conference=self.context.conference,
day=self.context.conf_day.day + timedelta(days=1))
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
response = self.client.get(self.url, follow=True)
self.assertContains(
response,
'name="opp_event_id" type="hidden" value="%d" />' % (
vol_opp.eventitem.event_id)
)
self.assertContains(
response,
'name="opp_sched_id" type="hidden" value="%d" />' % (
vol_opp.pk)
)
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.context.conf_day.pk,
self.context.conf_day.day.strftime("%b. %-d, %Y")))
self.assertContains(
response,
'name="max_volunteer" type="number" value="7" />')
def test_create_master(self):
login_as(self.privileged_user, self)
data = self.edit_class()
response = self.client.post(
self.url,
data=data,
follow=True)
new_class = GenericEvent.objects.get(e_title=data['e_title'])
self.assertEqual(new_class.type, "Master")
occurrence = Event.objects.get(
eventitem__eventitem_id=new_class.eventitem_id)
self.assertRedirects(
response,
"%s?%s-day=%d&filter=Filter&new=[%dL]" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.current_conference.conference_slug]),
self.current_conference.conference_slug,
self.day.pk,
occurrence.pk))
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s 11:00 AM' % (
data['e_title'],
self.day.day.strftime(DATE_FORMAT))
)
self.assertContains(
response,
'<tr class="bid-table success">\n ' +
'<td class="bid-table">%s</td>' % data['e_title'])
def test_set_ticket(self):
grant_privilege(self.privileged_user, 'Ticketing - Admin')
bpt_event = BrownPaperEventsFactory(
conference=self.current_conference)
login_as(self.privileged_user, self)
data = self.edit_class()
data['bpt_events'] = bpt_event.pk
response = self.client.post(
self.url,
data=data,
follow=True)
new_class = GenericEvent.objects.get(e_title=data['e_title'])
self.assertEqual(new_class.type, "Master")
occurrence = Event.objects.get(
eventitem__eventitem_id=new_class.eventitem_id)
self.assertRedirects(
response,
"%s?%s-day=%d&filter=Filter&new=[%dL]" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.current_conference.conference_slug]),
self.current_conference.conference_slug,
self.day.pk,
occurrence.pk))
assert_alert_exists(
response,
'success',
'Success',
link_event_to_ticket_success_msg + '%s - %s, ' % (
bpt_event.bpt_event_id,
bpt_event.title)
)
def post_class_proposal(self):
current_conference()
url = reverse(self.view_name, urlconf="gbe.urls")
data = self.get_class_form(valid=True)
login_as(UserFactory(), self)
response = self.client.post(url, data=data, follow=True)
return response
def test_schedule(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertTrue(response.content.count('\n') > 1)
self.assertTrue(len(
(response.content.split('\r\n')[1].split('","'))) >= 8)
self.assertIn(self.showcontext.show.e_title, response.content)
def test_copy_child_event(self):
target_context = StaffAreaContext()
target_day = ConferenceDayFactory(
conference=target_context.conference,
day=self.context.conf_day.day + timedelta(days=340))
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'copied_event': self.vol_opp.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
max_pk = Event.objects.latest('pk').pk
redirect_url = "%s?%s-day=%d&filter=Filter&new=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[target_context.conference.conference_slug]),
target_context.conference.conference_slug,
target_day.pk,
str([max_pk]),)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s' % (
self.vol_opp.eventitem.e_title,
datetime.combine(
target_day.day,
self.vol_opp.starttime.time()).strftime(
DATETIME_FORMAT)))
def test_copy_only_parent_event(self):
another_day = ConferenceDayFactory()
data = {
'copy_mode': 'include_parent',
'copy_to_day': another_day.pk,
'pick_event': "Finish",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
max_area = StaffArea.objects.latest('pk')
redirect_url = "%s?%s-day=%d&filter=Filter&alt_id=%s" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[another_day.conference.conference_slug]),
another_day.conference.conference_slug,
another_day.pk,
max_area.pk,)
self.assertRedirects(response, redirect_url)
self.assertRedirects(response, redirect_url)
assert_alert_exists(
response,
'success',
'Success',
'A new Staff Area was created.<br>Staff Area: %s' % (
max_area.title))
def test_copy_opportunity(self):
login_as(self.privileged_profile, self)
data = self.get_basic_data(self.context)
data['duplicate_slot'] = 'duplicate_slot'
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
'<div id="collapse3" class="panel-collapse collapse in">')
slots = EventContainer.objects.filter(
parent_event=self.context.sched_event)
self.assertTrue(len(slots), 1)
for slot in slots:
self.assertContains(
response,
'<input id="id_e_title" maxlength="128" '
'name="e_title" type="text" value="%s" />' % (
slot.child_event.eventitem.child().e_title))
self.assertRedirects(
response,
"%s?changed_id=%d&rehearsal_open=True" % (
reverse(
'edit_show',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug,
self.context.sched_event.pk]),
slot.child_event.pk))
def test_authorized_user_pick_mode_only_children(self):
target_context = StaffAreaContext()
delta = timedelta(days=340)
target_day = ConferenceDayFactory(
conference=target_context.conference,
day=self.context.conf_day.day + delta)
data = {
'copy_mode': 'copy_children_only',
'target_event': target_context.area.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(
response,
'<input checked="checked" id="id_copy_mode_0" name="copy_mode" ' +
'type="radio" value="copy_children_only" />')
self.assertContains(
response,
'<option value="%d" selected="selected">' % (
target_context.area.pk))
self.assertContains(response, "Choose Sub-Events to be copied")
self.assertContains(response, "%s - %s" % (
self.vol_opp.eventitem.e_title,
(self.vol_opp.start_time + delta).strftime(
self.copy_date_format)))
def test_create_volunteer_post_form_invalid(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
data = self.get_volunteer_form(invalid=True)
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 200)
def test_create_slot(self):
login_as(self.privileged_profile, self)
response = self.client.post(
self.url,
data=self.get_new_slot_data(self.context),
follow=True)
self.assertContains(
response,
'<div id="collapse3" class="panel-collapse collapse in">')
slots = EventContainer.objects.filter(
parent_event=self.context.sched_event)
self.assertTrue(slots.exists())
for slot in slots:
self.assertEqual(slot.child_event.eventitem.child().e_title,
'New Rehearsal Slot')
self.assertRedirects(
response,
"%s?changed_id=%d&rehearsal_open=True" % (
reverse('edit_show',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug,
self.context.sched_event.pk]),
slot.child_event.pk))
self.assertEqual(EventLabel.objects.filter(
text=slot.child_event.eventitem.child(
).e_conference.conference_slug,
event=slot.child_event).count(), 1)
self.assertEqual(EventLabel.objects.filter(
event=slot.child_event).count(), 1)
self.assertContains(
response,
'<input id="id_e_title" maxlength="128" name="e_title" ' +
'type="text" value="New Rehearsal Slot" />')
def test_propose_invalid_class(self):
current_conference()
url = reverse(self.view_name, urlconf="gbe.urls")
data = self.get_class_form(valid=False)
login_as(UserFactory(), self)
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 200)
def test_class_already_evaled(self):
context = ClassContext(starttime=datetime.now() - timedelta(days=1))
eval_profile = context.set_eval_answerer()
login_as(eval_profile, self)
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[context.bid.eventitem_id])
response = self.client.get(url)
eval_link = reverse("eval_event",
args=[
context.sched_event.pk,
],
urlconf="gbe.scheduling.urls")
self.assertNotContains(response, "%s?next=%s" % (eval_link, url))
self.assertContains(response, "You have already rated this class")
def test_delete_event(self):
url = reverse('bptevent_edit',
urlconf='ticketing.urls',
args=[self.ticketing_event.pk])
login_as(self.privileged_user, self)
response = self.client.get("%s?delete_item=True" % url, follow=True)
self.assertRedirects(
response,
"%s?conference=%s&open_panel=ticket&updated_events=[None]" %
(reverse('ticket_items', urlconf='ticketing.urls'),
str(self.ticketing_event.conference.conference_slug)))
self.assertFalse(
TicketingEvents.objects.filter(
id=self.ticketing_event.id).exists())
self.assertContains(response, delete_event_success_message)
def test_create_area(self):
login_as(self.privileged_user, self)
data = self.edit_area()
response = self.client.post(self.url, data=data, follow=True)
new_area = StaffArea.objects.get(slug=data['slug'],
conference=self.current_conference)
self.assertEqual(new_area.conference, self.current_conference)
self.assertRedirects(
response,
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.current_conference.conference_slug]))
assert_alert_exists(
response, 'success', 'Success',
'Staff area has been created.<br>Title: %s' % data['title'])
def test_act_bid_not_post(self):
'''act_bid, not post, not paid should take us to bid process'''
make_act_app_purchase(self.current_conference,
self.performer.performer_profile.user_object)
msg = UserMessageFactory(view='MakeActView',
code='BID_INSTRUCTIONS',
summary="Act Bid Instructions",
description="Test Bid Instructions Message")
login_as(self.performer.performer_profile, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Propose an Act')
self.assertNotContains(response, fee_instructions)
self.assertContains(response, "Test Bid Instructions Message")
self.assertContains(response, 'value="Submit For Approval"')
def test_reduced_login_first_get(self):
for priv, roles in role_option_privs.iteritems():
limited_profile = ProfileFactory()
grant_privilege(limited_profile.user_object, priv)
login_as(limited_profile, self)
response = self.client.get(self.url, follow=True)
assert_checkbox(response, "conference", 0,
self.context.conference.pk,
self.context.conference.conference_slug)
n = 0
for role in sorted(roles):
assert_checkbox(response, "roles", n, role, role)
n = n + 1
self.assertNotContains(response, "Email Everyone")
def test_submit_bid_post_invalid(self):
'''edit_costume, not submitting and no other problems,
should redirect to home'''
persona = PersonaFactory()
costume = CostumeFactory(profile=persona.performer_profile,
performer=persona)
url = reverse(self.view_name, args=[costume.pk], urlconf='gbe.urls')
data = self.get_costume_form(submit=True)
data['b_title'] = ''
data['b_description'] = ''
login_as(costume.profile, self)
response = self.client.post(url, data=data)
print response.content
self.assertContains(response, 'This field is required.', count=2)
def test_show_interest_also_volunteer(self):
self.url = reverse(self.view_name,
args=[self.context.sched_event.pk, "off"],
urlconf="gbe.scheduling.urls")
booking = ResourceAllocationFactory(event=self.context.sched_event,
resource=WorkerFactory(
_item=self.profile,
role="Interested"))
LabelFactory(allocation=booking, text="label text")
login_as(self.profile, self)
response = self.client.get(self.url, follow=True)
redirect_url = reverse('home', urlconf='gbe.urls')
self.assertRedirects(response, redirect_url)
self.assertNotContains(response, self.context.bid.e_title)
assert_alert_exists(response, 'success', 'Success', unset_favorite_msg)
def test_make_purchaser(self):
login_as(self.privileged_user, self)
response = self.client.post(self.url,
data={
'ticket_item': self.ticket.pk,
'profile': self.profile.pk,
},
follow=True)
self.assertEqual(self.profile.user_object.purchaser_set.count(), 1)
buyer = self.profile.user_object.purchaser_set.first()
self.assertRedirects(
response, "%s?changed_id=%d" %
(reverse("transactions", urlconf="ticketing.urls"),
buyer.transaction_set.first().pk))
self.assertContains(response, create_comp_msg)
def test_assign_volunteers_old_bid(self):
''' bid is froma past conference'''
context = VolunteerContext()
context.conference.status = 'completed'
context.conference.save()
url = reverse(self.view_name,
args=[context.bid.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse('volunteer_view',
urlconf='gbe.urls',
args=[context.bid.pk]))
def test_good_user_get_success_redirect(self):
login_as(self.privileged_profile, self)
redirect_to = "%s?%s-day=%d" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.context.conference.conference_slug]),
self.context.conference.conference_slug, self.context.days[0].pk)
response = self.client.get("%s?next=%s" % (self.url, redirect_to),
follow=True)
self.assertRedirects(response, redirect_to)
self.assertNotContains(response,
'<td>%s</td>' % self.context.bid.e_title)
self.assertContains(response, "This event has been deleted.")
check_class = Class.objects.get(pk=self.context.bid.pk)
self.assertFalse(check_class.visible)
def test_clone_bid_wrong_user(self):
# apparently cleaning is not needed, causes problem in Djang 1.11
# Conference.objects.all().delete()
bid = ActFactory(b_conference=self.old_conference)
Act.objects.filter(b_title=bid.b_title,
b_conference=self.current_conference).delete()
url = reverse(self.view_name,
urlconf="gbe.urls",
kwargs={
'bid_type': 'Act',
'bid_id': bid.id
})
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def test_create_opportunity_bad_parent(self):
grant_privilege(self.privileged_user, 'Scheduling Mavens')
login_as(self.privileged_profile, self)
max_id = Event.objects.aggregate(Max('pk'))['pk__max']+1
self.url = reverse(
self.view_name,
urlconf="gbe.scheduling.urls",
args=[self.context.conference.conference_slug, max_id])
response = self.client.post(
self.url,
data=self.get_new_opp_data(self.context),
follow=True)
self.assertContains(
response,
"Occurrence id %d not found" % (max_id))
def test_edit_area_and_continue(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
data = self.edit_area()
data['edit_event'] = "Save and Continue"
response = self.client.post(self.url, data=data, follow=True)
self.assertRedirects(response, "%s?volunteer_open=True" % self.url)
assert_alert_exists(
response, 'success', 'Success',
'Staff Area has been updated.<br>Title: %s' % (data['title']))
self.assertContains(response, data['title'])
self.assertContains(response, data['description'])
assert_option_state(response, self.privileged_user.profile.pk,
str(self.privileged_user.profile), True)
self.assertContains(response, 'name="default_volunteers" value="3"')
def clone_act(self):
bid = ActFactory(b_conference=self.old_conference)
Act.objects.filter(b_title=bid.b_title,
b_conference=self.current_conference).delete()
url = reverse(self.view_name,
urlconf="gbe.urls",
kwargs={
'bid_type': 'Act',
'bid_id': bid.id
})
login_as(bid.performer.contact, self)
response = self.client.get(url, follow=True)
return response, bid
def test_copy_single_event_room_conf_mismatch(self):
another_day = ConferenceDayFactory(
day=self.context.conf_day.day + timedelta(days=1))
data = {
'copy_to_day': another_day.pk,
'room': self.context.room.pk,
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[self.context.opp_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(response, copy_errors['room_conf_mismatch'])
def test_post_form_edit_exiting_alloc_used_email_tmpl(self):
new_volunteer = ProfileFactory()
data = self.get_edit_data()
data['worker'] = new_volunteer.pk,
data['role'] = 'Producer',
login_as(self.privileged_profile, self)
response = self.client.post(self.url, data=data, follow=True)
msg = assert_email_template_used(
"A change has been made to your Volunteer Schedule!")
self.unsub_link = Site.objects.get_current().domain + reverse(
'email_update',
urlconf='gbe.urls',
args=[new_volunteer.user_object.email])
assert (self.unsub_link in msg.body)
assert (self.get_param in msg.body)
def test_authorized_user_get_set_staff_area(self):
staff = StaffAreaContext()
vol_sched_event = staff.add_volunteer_opp()
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[vol_sched_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url)
self.assertContains(
response,
'<option value="%d" selected>%s</option>' % (
staff.area.pk,
staff.area.title),
html=True)
def test_authorized_user_get_no_child_event(self):
login_as(self.privileged_user, self)
staff = StaffAreaContext()
self.url = reverse(
self.view_name,
args=[self.context.opp_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(
response,
self.context.conf_day.day.strftime(GBE_DATE_FORMAT))
self.assertContains(response, copy_mode_solo_choices[0][1])
self.assertContains(response, staff.area.title)
self.assertContains(response, self.context.event.e_title)
def test_create_opportunity_bad_parent(self):
grant_privilege(self.privileged_user, 'Scheduling Mavens')
login_as(self.privileged_profile, self)
self.url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[
self.context.conference.conference_slug,
self.context.sched_event.pk + 1
])
response = self.client.post(self.url,
data=self.get_new_opp_data(self.context),
follow=True)
self.assertContains(
response,
"Occurrence id %d not found" % (self.context.sched_event.pk + 1))
def test_copy_single_no_date(self):
data = {
'room': self.context.room.pk,
'copy_mode': ['choose_day'],
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
self.url = reverse(
self.view_name,
args=[self.context.opp_event.pk],
urlconf='gbe.scheduling.urls')
response = self.client.post(self.url,
data=data,
follow=True)
self.assertContains(response, copy_errors['no_day'])
def test_ticket_exclusion(self):
self.ticket_condition.delete()
self.ticketingexclusion = TicketingExclusionFactory(
condition=self.role_condition)
self.ticketingexclusion.tickets.add(self.ticket_item)
login_as(self.privileged_user, self)
response = self.client.get(self.url)
print(response.content)
self.assertContains(response, intro_role_cond_message)
self.assertContains(response, intro_ticket_cond_message)
self.assertContains(response,
self.role_condition.checklistitem.description)
self.assertContains(response, self.role_condition.role)
self.assertContains(response, str(self.ticket_item), 1)
def test_create_opportunity_error(self):
grant_privilege(self.privileged_user, 'Scheduling Mavens')
login_as(self.privileged_profile, self)
data = self.get_new_opp_data(self.context)
data['new_opp-max_volunteer'] = ''
# number of volunteers is missing, it's required
response = self.client.post(self.url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
opps = EventContainer.objects.filter(
parent_event=self.context.sched_event).count()
self.assertEqual(opps, 1)
self.assertContains(
response,
'<ul class="errorlist"><li>This field is required.</li></ul>')
def test_disabled_eval(self):
eval_profile = self.classcontext.set_eval_answerer()
url = reverse('calendar',
urlconf="gbe.scheduling.urls",
args=['Conference'])
login_as(eval_profile, self)
data = {'day': "02-06-2016"}
response = self.client.get(url, data=data)
eval_link = reverse("eval_event",
args=[
self.classcontext.sched_event.pk,
],
urlconf="gbe.scheduling.urls")
self.assertNotContains(response, "%s?next=%s" % (eval_link, url))
self.assertContains(response, "You have already rated this class")
def test_authorized_user_pick_mode_no_event(self):
show_context = VolunteerContext()
url = reverse(
self.view_name,
args=[show_context.sched_event.pk],
urlconf='gbe.scheduling.urls')
data = {
'copy_mode': 'copy_children_only',
'pick_mode': "Next",
}
login_as(self.privileged_user, self)
response = self.client.post(url, data=data, follow=True)
self.assertContains(
response,
'Must choose the target event when copying sub-events.')
def test_auth_user_can_pick_staff(self):
login_as(self.privileged_user, self)
response = self.client.post(self.url,
data={
'pick_topic':
True,
'volunteer_topic':
"staff_%d" % self.staff_area.area.pk
},
follow=True)
self.assertRedirects(
response,
"%s?volunteer_open=True" % reverse('edit_staff',
urlconf='gbe.scheduling.urls',
args=[self.staff_area.area.pk]))
def test_authorized_user_can_get_volunteer_mgmt(self):
self.context.area.default_location = self.room
self.context.area.save()
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Volunteer Management")
self.assertContains(response, "Save and Continue")
self.assertContains(
response,
'name="new_opp-max_volunteer" type="number" value="7" />')
self.assertContains(
response, '<option value="%d" selected="selected">%s</option>' %
(self.room.pk, str(self.room)), 2)
def test_email_fail(self):
template = EmailTemplateFactory(
name='volunteer changed schedule',
content="{% include 'gbe/email/bad.tmpl' %}")
self.context.worker.role = "Pending Volunteer"
self.context.worker.save()
login_as(self.privileged_user, self)
approve_url = reverse(self.approve_name,
urlconf='gbe.scheduling.urls',
args=[
"approve", self.context.profile.pk,
self.context.allocation.pk
])
response = self.client.get(approve_url)
self.assertContains(response, volunteer_allocate_email_fail_msg)
def test_logged_in_have_interest(self):
profile = self.showcontext.set_interest()
login_as(profile, self)
url = reverse('calendar',
urlconf="gbe.scheduling.urls",
args=['General'])
data = {'day': "02-06-2016"}
response = self.client.get(url, data=data)
set_fav_link = reverse("set_favorite",
args=[self.showcontext.sched_event.pk, "off"],
urlconf="gbe.scheduling.urls")
self.assertContains(response, "%s?next=%s" % (set_fav_link, url))
self.assertContains(
response,
'<div class="col-lg-12 col-md-12 col-sm-12 col-xs-12 interested">')
def test_act_no_role(self):
UserMessage.objects.all().delete()
ActCastingOptionFactory()
new_context = ActTechInfoContext()
url = reverse(self.view_name,
args=[self.context.act.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
data = self.data
data.pop('casting', None)
response = self.client.post(url, data=self.data, follow=True)
with self.assertRaises(ActResource.DoesNotExist):
ActResource.objects.get(_item=self.context.act)
assert_alert_exists(response, 'danger', 'Error', no_casting_msg)
def test_approve_volunteer_w_conf(self):
''' check conference selector, no data is in table.'''
second_context = VolunteerContext()
login_as(self.privileged_user, self)
response = self.client.get(
self.url, {'conf_slug': second_context.conference.conference_slug})
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Approve Pending Volunteers')
self.assertContains(
response, '<option value = "%s" selected>' %
(second_context.conference.conference_slug))
self.assertContains(
response, '<option value = "%s">' %
(self.context.conference.conference_slug))
