def setUp(self):
self.client = Client()
UserMessage.objects.all().delete()
clear_conferences()
self.old_conference = ConferenceFactory(status="completed",
accepting_bids=False)
self.current_conference = ConferenceFactory(status="upcoming",
accepting_bids=True)
def setUp(self):
self.url = reverse(self.create_name, urlconf='gbe.urls')
Conference.objects.all().delete()
self.client = Client()
self.performer = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True,
act_style='summer')
UserMessage.objects.all().delete()
def test_filter_by_conference_default(self):
conference = ConferenceFactory(status='upcoming')
otherconf = ConferenceFactory()
proposal = VendorFactory(b_conference=conference, accepted=3)
url = reverse(self.view_name, urlconf="gbe.urls")
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, proposal.business.name)
def test_filter_by_conference_default(self):
conference = ConferenceFactory(status='upcoming')
otherconf = ConferenceFactory()
proposal = VendorFactory(b_conference=conference, accepted=3)
url = reverse(self.view_name, urlconf="gbe.urls")
login_as(ProfileFactory(), self)
response = self.client.get(url)
nt.assert_equal(response.status_code, 200)
nt.assert_true(proposal.b_title in response.content)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.profile = ProfileFactory()
Conference.objects.all().delete()
UserMessage.objects.all().delete()
AvailableInterest.objects.all().delete()
self.conference = ConferenceFactory(accepting_bids=True)
days = ConferenceDayFactory.create_batch(3, conference=self.conference)
[VolunteerWindowFactory(day=day) for day in days]
self.interest = AvailableInterestFactory()
def test_filter_by_conference(self):
conference = ConferenceFactory(status='upcoming')
otherconf = ConferenceFactory()
proposal = VendorFactory(b_conference=conference, accepted=3)
url = reverse(self.view_name, urlconf="gbe.urls")
login_as(ProfileFactory(), self)
response = self.client.get(url, data={'conference': conference})
self.assertEqual(response.status_code, 200)
self.assertContains(response, proposal.business.name)
self.assertContains(
response, '<div class="col-lg-4 col-md-6 col-sm-12 col-12">')
self.assertNotContains(response, 'Featured Vendors')
def test_review_act_techinfo_with_conference_slug(self):
'''review_act_techinfo view show correct events for slug
'''
curr_conf = ConferenceFactory()
curr_show, _, curr_acts = _create_scheduled_show_with_acts(curr_conf)
old_conf = ConferenceFactory(status='completed')
old_show, _, old_acts = _create_scheduled_show_with_acts(old_conf)
login_as(self.profile, self)
response = self.client.get(
reverse(self.view_name, urlconf='gbe.reporting.urls'),
data={'conf_slug': curr_conf.conference_slug})
self.assertEqual(response.status_code, 200)
self.assertTrue(curr_show.e_title in response.content)
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_room_setup_by_conference_with_permission(self):
'''room_setup view should load for privileged users,
and fail for others
'''
Conference.objects.all().delete()
context = ClassContext()
one_day = timedelta(1)
ConferenceDayFactory(conference=context.conference,
day=context.sched_event.starttime.date())
ConferenceDayFactory(conference=context.conference,
day=context.sched_event.starttime.date() +
one_day)
context.schedule_instance(starttime=context.sched_event.starttime +
one_day)
current_conference = context.conference
ConferenceDayFactory(conference=context.conference,
day=context.sched_event.starttime.date())
current_conference = ConferenceFactory()
grant_privilege(self.profile, 'Act Reviewers')
login_as(self.profile, self)
response = self.client.get(
reverse('room_setup', urlconf='gbe.reporting.urls'),
data={'conf_slug': context.conference.conference_slug})
self.assertEqual(response.status_code, 200)
self.assertContains(response, context.bid.e_title, 2)
def __init__(self, profile=None, conference=None):
self.conference = conference or ConferenceFactory()
self.profile = profile or ProfileFactory()
self.transaction = TransactionFactory(
ticket_item__ticketing_event__conference=self.conference,
purchaser__matched_to_user=self.profile.user_object,
)
def __init__(self,
act=None,
performer=None,
conference=None,
room=None,
starttime=None,
act_role=''):
self.performer = performer or PersonaFactory()
self.conference = conference or ConferenceFactory()
if not self.conference.conferenceday_set.exists():
day = ConferenceDayFactory(conference=self.conference)
if starttime:
day.day = starttime.date()
day.save()
self.days = self.conference.conferenceday_set.all()
act = act or ActFactory(b_conference=self.conference,
performer=self.performer,
accepted=3,
submitted=True)
self.acts = [act]
self.show = ShowFactory(e_conference=self.conference)
self.room = room or RoomFactory()
self.sched_event = None
self.sched_event = self.schedule_instance(room=self.room,
starttime=starttime)
self.book_act(act, act_role)
def current_conference():
current_confs = Conference.objects.filter(status__in=('upcoming',
'ongoing'),
accepting_bids=True)
if current_confs.exists():
return current_confs.first()
return ConferenceFactory(status='upcoming', accepting_bids=True)
def test_no_past_conference_details(self):
'''only current conference events, and windows should be shown'''
# horrible setup process. Need to fix
data = self.set_basic_opportunity()
past_context = StaffAreaContext(conference=ConferenceFactory(
status='completed'))
past_opp = past_context.add_volunteer_opp()
past_opp.starttime = datetime(2015, 2, 25, 6, 0, 0, 0, pytz.utc)
past_opp.eventitem.max_volunteer = 10
past_opp.eventitem.save()
past_window = VolunteerWindowFactory(
day__conference=past_context.conference)
url = reverse(self.view_name,
args=[data['volunteer'].pk],
urlconf="gbe.urls")
login_as(self.privileged_user, self)
response = self.client.get(url)
nt.assert_not_in(
str(past_opp.eventitem),
response.content,
msg="Event Title for past_opportunity should not show up")
nt.assert_not_in(date_format(past_opp.starttime,
"SHORT_DATETIME_FORMAT"),
response.content,
msg="start time for past_sched shouldn't show up")
def __init__(self,
bid=None,
teacher=None,
conference=None,
room=None,
starttime=None):
self.teacher = teacher or PersonaFactory()
self.conference = conference or ConferenceFactory()
if not self.conference.conferenceday_set.exists():
day = ConferenceDayFactory(conference=self.conference)
if starttime:
day.day = starttime.date()
day.save()
self.days = self.conference.conferenceday_set.all()
self.starttime = starttime or noon(self.days[0])
self.bid = bid or ClassFactory(b_conference=self.conference,
e_conference=self.conference,
accepted=3,
teacher=self.teacher,
submitted=True)
self.room = room or RoomFactory()
self.room.conferences.add(self.conference)
self.sched_event = None
self.sched_event = self.schedule_instance(room=self.room,
starttime=starttime)
def test_full_login_first_get_2_conf(self):
extra_conf = ConferenceFactory()
login_as(self.privileged_profile, self)
response = self.client.get(self.url, follow=True)
self.assert_checkbox(response,
"conference",
0,
self.context.conference.pk,
self.context.conference.conference_slug,
checked=False)
self.assert_checkbox(response,
"conference",
1,
extra_conf.pk,
extra_conf.conference_slug,
checked=False)
self.assert_checkbox(response,
"x_conference",
0,
self.context.conference.pk,
self.context.conference.conference_slug,
checked=False)
self.assert_checkbox(response,
"x_conference",
1,
extra_conf.pk,
extra_conf.conference_slug,
checked=False)
def test_view_list_default_view_current_conf_exists(self):
'''
/scheduler/view_list/ should return all events in the current
conference, assuming a current conference exists
'''
other_conf = ConferenceFactory(status='completed')
show = ShowFactory(e_conference=self.conf)
generic_event = GenericEventFactory(e_conference=self.conf)
accepted_class = ClassFactory(accepted=3,
e_conference=self.conf,
b_conference=self.conf)
previous_class = ClassFactory(accepted=3,
e_conference=other_conf,
b_conference=other_conf)
rejected_class = ClassFactory(accepted=1,
e_conference=self.conf,
b_conference=self.conf)
url = reverse("event_list", urlconf="gbe.scheduling.urls")
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertContains(response, generic_event.e_title)
self.assertContains(response, show.e_title)
self.assertContains(response, accepted_class.e_title)
self.assertNotContains(response, rejected_class.e_title)
self.assertNotContains(response, previous_class.e_title)
def setUp(self):
self.client = Client()
self.priv_profile = ProfileFactory()
self.context = ClassContext()
self.old_conference = ConferenceFactory(status="completed")
self.old_context = ClassContext(conference=self.old_conference)
grant_privilege(self.priv_profile, 'Class Coordinator')
self.url = reverse(self.view_name, urlconf="gbe.reporting.urls")
def test_signup_w_available_slot(self):
other_conference = ConferenceFactory(status='completed')
response = self.client.get(self.url)
self.assertNotContains(response, other_conference.conference_name)
self.basic_event_check(response, self.staffcontext.conference,
self.volunteeropp, "not_yet_volunteered.gif")
self.assertContains(response, volunteer_instructions)
self.assertContains(response, "btn btn-default disabled", 2)
def test_no_role_this_conference(self):
'''
purchaser has no roles in this conference
'''
checklist_items = get_checklist_items_for_roles(
self.teacher.performer_profile, ConferenceFactory(), [])
nt.assert_equal(len(checklist_items), 0)
def setUp(self):
self.url = reverse(self.view_name, urlconf='gbe.urls')
Conference.objects.all().delete()
self.factory = RequestFactory()
self.client = Client()
self.performer = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True)
UserMessage.objects.all().delete()
def test_personal_schedule_succeed(self):
'''personal_schedule view should load for privileged users
and fail for others
'''
ConferenceFactory()
login_as(self.priv_profile, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
def setUp(self):
self.client = Client()
clear_conferences()
conference = ConferenceFactory()
save_the_date = datetime(2016, 02, 06, 12, 00, 00)
day = ConferenceDayFactory(conference=conference,
day=date(2016, 02, 06))
self.staffcontext = StaffAreaContext(conference=conference,
starttime=save_the_date)
self.showcontext = ShowContext(conference=conference,
starttime=save_the_date)
self.other_conference = ConferenceFactory(status='completed')
self.other_conf_day = ConferenceDayFactory(
conference=self.other_conference, day=date(2015, 02, 06))
self.other_show = ShowContext(conference=self.other_conference)
self.classcontext = ClassContext(conference=conference,
starttime=save_the_date)
self.volunteeropp = self.staffcontext.add_volunteer_opp()
def test_create_second_volunteer_old_conf_all_good(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
VolunteerFactory(profile=self.profile,
b_conference=ConferenceFactory(status='past'))
login_as(self.profile, self)
data = self.get_volunteer_form()
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 302)
def test_interest_not_shown(self):
context = ShowContext(conference=ConferenceFactory(status="completed"))
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[context.show.eventitem_id])
login_as(context.performer.performer_profile, self)
response = self.client.get(url)
self.assertNotContains(response, 'fa-star')
self.assertNotContains(response, 'fa-star-o')
def test_room_schedule_fail(self):
'''room_schedule view should load for privileged users,
and fail for others
'''
current_conference = ConferenceFactory()
login_as(self.profile, self)
response = self.client.get(
reverse('room_schedule', urlconf='gbe.reporting.urls'))
self.assertEqual(response.status_code, 403)
def test_act_submit_paid_act_w_old_comp_act(self):
prev_act = ActFactory(
submitted=True,
performer=self.performer,
b_conference=ConferenceFactory(status='completed'))
response, data = self.post_paid_act_submission()
self.assertEqual(response.status_code, 200)
self.assertContains(response, "View</a> act")
self.assertContains(response, data['theact-b_title'])
def setUp(self):
self.url = reverse(self.create_name, urlconf='gbe.urls')
Conference.objects.all().delete()
self.client = Client()
self.performer = PersonaFactory()
self.current_conference = ConferenceFactory(
accepting_bids=True,
act_style='summer')
UserMessage.objects.all().delete()
def test_list_reports_by_conference(self):
Conference.objects.all().delete()
conf = ConferenceFactory()
grant_privilege(self.profile, 'Act Reviewers')
login_as(self.profile, self)
response = self.client.get(reverse('report_list',
urlconf="gbe.reporting.urls"),
data={"conf_slug": conf.conference_slug})
self.assertEqual(response.status_code, 200)
def test_room_setup_not_visible_without_permission(self):
'''room_setup view should load for privileged users,
and fail for others
'''
current_conference = ConferenceFactory()
login_as(self.profile, self)
response = self.client.get(
reverse('room_setup', urlconf='gbe.reporting.urls'))
self.assertEqual(response.status_code, 403)
def test_review_staff_area_path(self):
'''review_staff_area view should load
'''
current_conference = ConferenceFactory()
grant_privilege(self.profile, 'Act Reviewers')
login_as(self.profile, self)
response = self.client.get(
reverse('staff_area', urlconf="gbe.reporting.urls"))
self.assertEqual(response.status_code, 200)
def __init__(self,
area=None,
staff_lead=None,
conference=None,
starttime=None):
self.staff_lead = staff_lead or ProfileFactory()
self.conference = conference or ConferenceFactory()
self.area = area or StaffAreaFactory(conference=self.conference,
staff_lead=self.staff_lead)
class TestCreateAct(TestCase):
'''Tests for create_act view'''
create_name = 'summer_act_create'
edit_name = 'summer_act_edit'
def setUp(self):
self.url = reverse(self.create_name, urlconf='gbe.urls')
Conference.objects.all().delete()
self.client = Client()
self.performer = PersonaFactory()
self.current_conference = ConferenceFactory(
accepting_bids=True,
act_style='summer')
UserMessage.objects.all().delete()
def get_act_form(self, submit=False, valid=True):
form_dict = {'theact-shows_preferences': [4],
'theact-b_title': 'An act',
'theact-track_title': 'a track',
'theact-track_artist': 'an artist',
'theact-b_description': 'a description',
'theact-performer': self.performer.resourceitem_id,
'theact-act_duration': '1:00',
'theact-b_conference': self.current_conference.pk,
'theact-is_summer': True,
}
if not valid:
form_dict['theact-shows_preferences'] = [2]
return form_dict
def post_paid_act_submission(self, act_form=None):
if not act_form:
act_form = self.get_act_form()
url = reverse(self.create_name, urlconf='gbe.urls')
login_as(self.performer.performer_profile, self)
act_form.update({'submit': ''})
make_act_app_purchase(self.current_conference,
self.performer.performer_profile.user_object)
response = self.client.post(url, data=act_form, follow=True)
return response, act_form
def post_edit_paid_act_draft(self):
act = ActFactory(b_conference=self.current_conference)
url = reverse(self.edit_name,
args=[act.pk],
urlconf="gbe.urls")
login_as(act.performer.contact, self)
response = self.client.post(url,
self.get_act_form(act),
follow=True)
return response
def test_bid_act_get_with_persona(self):
url = reverse(self.create_name, urlconf='gbe.urls')
login_as(self.performer.performer_profile, self)
response = self.client.get(url)
expected_string = 'Please also consider this act for GBE12'
self.assertTrue(expected_string in response.content)
self.assertEqual(response.status_code, 200)
def test_act_bid_post_form_not_valid(self):
login_as(self.performer.performer_profile, self)
url = reverse(self.create_name, urlconf='gbe.urls')
data = self.get_act_form(submit=True, valid=False)
response = self.client.post(url,
data=data)
self.assertEqual(response.status_code, 200)
self.assertTrue(
'Select a valid choice. 2 is not one of the available choices.'
in response.content)
def test_act_bid_get_with_redirect(self):
url = reverse("act_create", urlconf='gbe.urls')
login_as(self.performer.performer_profile, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse(self.create_name, urlconf="gbe.urls"))
def test_act_bid_get_with_redirect_other_way(self):
url = reverse(self.create_name, urlconf='gbe.urls')
self.current_conference.act_style = "normal"
self.current_conference.save()
login_as(self.performer.performer_profile, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse("act_create", urlconf="gbe.urls"))
def test_act_submit_paid_act(self):
response, data = self.post_paid_act_submission()
self.assertEqual(response.status_code, 200)
self.assertContains(response, "View</a> act")
self.assertContains(response, data['theact-b_title'])
def test_edit_bid_not_post(self):
'''edit_bid, not post, should take us to edit process'''
act = ActFactory(b_conference=self.current_conference)
url = reverse(self.edit_name,
args=[act.pk],
urlconf="gbe.urls")
login_as(act.performer.contact, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue(
'Thanks for submitting an act for consideration at the Summer'
in response.content)
def test_edit_bid_w_redirect(self):
'''edit_bid, not post, should take us to edit process'''
act = ActFactory(b_conference=self.current_conference)
url = reverse("act_edit",
args=[act.pk],
urlconf="gbe.urls")
login_as(act.performer.contact, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse(self.edit_name, args=[act.pk], urlconf="gbe.urls"))
def test_edit_bid_w_redirect_other_way(self):
'''edit_bid, not post, should take us to edit process'''
act = ActFactory()
url = reverse(self.edit_name,
args=[act.pk],
urlconf="gbe.urls")
login_as(act.performer.contact, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse("act_edit", args=[act.pk], urlconf="gbe.urls"))
def test_edit_act_draft_make_message(self):
response = self.post_edit_paid_act_draft()
self.assertEqual(200, response.status_code)
assert_alert_exists(
response, 'success', 'Success', default_act_draft_msg)
class TestCreateVolunteer(TestCase):
'''Tests for create_volunteer view'''
view_name = 'volunteer_create'
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.profile = ProfileFactory()
Conference.objects.all().delete()
UserMessage.objects.all().delete()
AvailableInterest.objects.all().delete()
self.conference = ConferenceFactory(accepting_bids=True)
days = ConferenceDayFactory.create_batch(3, conference=self.conference)
[VolunteerWindowFactory(day=day) for day in days]
self.interest = AvailableInterestFactory()
def get_volunteer_form(self, submit=False, invalid=False):
form = {'profile': 1,
'number_shifts': 2,
'available_windows': self.conference.windows().values_list(
'pk', flat=True)[0:2],
'unavailable_windows': self.conference.windows().values_list(
'pk', flat=True)[2],
'%d-rank' % self.interest.pk: 4,
'%d-interest' % self.interest.pk: self.interest.pk,
'b_title': 'title',
'background': 'background',
}
if submit:
form['submit'] = True
if invalid:
del(form['number_shifts'])
return form
def post_volunteer_submission(self, data=None):
if not data:
data = self.get_volunteer_form(submit=True)
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
num_volunteers_before = Volunteer.objects.count()
response = self.client.post(url, data=data, follow=True)
return response, num_volunteers_before
def test_create_volunteer_no_login(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
response = self.client.get(url, follow=True)
self.assertRedirects(
response,
"%s?next=%s" % (
reverse('register', urlconf='gbe.urls'),
url))
def test_create_volunteer_bad_profile(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
cptn_tinypants = ProfileFactory(display_name="", phone="")
ProfilePreferencesFactory(profile=cptn_tinypants)
login_as(cptn_tinypants.user_object, self)
response = self.client.get(url, follow=True)
self.assertRedirects(
response,
"%s?next=%s" % (
reverse('profile_update', urlconf='gbe.urls'),
url))
assert_alert_exists(
response, 'warning', 'Warning', no_profile_msg)
def test_create_volunteer_post_valid_form(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
data = self.get_volunteer_form()
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 302)
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_volunteer_no_post(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
def test_create_volunteer_post_with_submit_is_true(self):
response, num_volunteers_before = self.post_volunteer_submission()
self.assertEqual(response.status_code, 200)
self.assertIn('Profile View', response.content)
self.assertEqual(num_volunteers_before + 1, Volunteer.objects.count())
def test_create_volunteer_check_interest(self):
response, num_volunteers_before = self.post_volunteer_submission()
vol_interest = VolunteerInterest.objects.get(interest=self.interest)
self.assertEqual(vol_interest.volunteer.profile, self.profile)
def test_create_volunteer_with_get_request(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertIn('Volunteer', response.content)
assert_rank_choice_exists(response, self.interest)
assert_hidden_value(
response,
"id_b_title",
"b_title",
'volunteer bid: %s' % self.profile.display_name,
128)
def test_volunteer_submit_make_message(self):
response, data = self.post_volunteer_submission()
self.assertEqual(response.status_code, 200)
assert_alert_exists(
response, 'success', 'Success', default_volunteer_submit_msg)
def test_volunteer_submit_has_message(self):
msg = UserMessageFactory(
view='MakeVolunteerView',
code='SUBMIT_SUCCESS')
response, data = self.post_volunteer_submission()
self.assertEqual(response.status_code, 200)
assert_alert_exists(
response, 'success', 'Success', msg.description)
def test_no_biddable_conference(self):
self.conference.accepting_bids = False
self.conference.save()
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url, follow=True)
self.assertRedirects(
response,
reverse('home', urlconf='gbe.urls'))
assert_alert_exists(
response, 'danger', 'Error', default_volunteer_no_bid_msg)
def test_no_window_for_conference(self):
Conference.objects.all().delete()
ConferenceFactory(accepting_bids=True)
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url, follow=True)
self.assertRedirects(
response,
reverse('home', urlconf='gbe.urls'))
assert_alert_exists(
response, 'danger', 'Error', default_volunteer_no_bid_msg)
def test_no_interests(self):
AvailableInterest.objects.all().delete()
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url, follow=True)
self.assertRedirects(
response,
reverse('home', urlconf='gbe.urls'))
assert_alert_exists(
response, 'danger', 'Error', default_volunteer_no_bid_msg)
def test_no_interests_has_message(self):
msg = UserMessageFactory(
view='MakeVolunteerView',
code='NO_BIDDING_ALLOWED')
AvailableInterest.objects.all().delete()
url = reverse(self.view_name,
urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url, follow=True)
self.assertRedirects(
response,
reverse('home', urlconf='gbe.urls'))
assert_alert_exists(
response, 'danger', 'Error', msg.description)
def test_not_interested_at_all(self):
data = self.get_volunteer_form(submit=True)
data['%d-rank' % self.interest.pk] = 1
response, data = self.post_volunteer_submission(data)
self.assertEqual(response.status_code, 200)
assert_alert_exists(
response, 'danger', 'Error', default_volunteer_no_interest_msg)
def test_not_interested_at_all_make_message(self):
data = self.get_volunteer_form(submit=True)
data['%d-rank' % self.interest.pk] = 1
msg = UserMessageFactory(
view='MakeVolunteerView',
code='NO_INTERESTS_SUBMITTED')
response, data = self.post_volunteer_submission(data)
self.assertEqual(response.status_code, 200)
assert_alert_exists(
response, 'danger', 'Error', msg.description)
def test_volunteer_time_conflict_checked(self):
data = self.get_volunteer_form()
data['available_windows'] = data['unavailable_windows']
response, data = self.post_volunteer_submission(data=data)
assert unavailable_time_conflict in response.content
def test_create_second_volunteer_gets_redirect(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
volunteer = VolunteerFactory(
profile=self.profile,
b_conference=self.conference)
login_as(self.profile, self)
data = self.get_volunteer_form()
response = self.client.post(url, data=data, follow=True)
self.assertRedirects(
response,
reverse(
'volunteer_edit',
urlconf='gbe.urls',
args=[volunteer.id]))
assert_alert_exists(
response, 'success', 'Success', existing_volunteer_msg)
def test_create_second_volunteer_old_conf_all_good(self):
url = reverse(self.view_name,
urlconf='gbe.urls')
VolunteerFactory(profile=self.profile,
b_conference=ConferenceFactory(status='past'))
login_as(self.profile, self)
data = self.get_volunteer_form()
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 302)
def test_background_required(self):
data = self.get_volunteer_form(submit=True)
del data['background']
response, data = self.post_volunteer_submission(data)
self.assertEqual(response.status_code, 200)
self.assertIn("This field is required.", response.content)
