def test_conference_volunteer_post_offer_form_invalid(self):
proposal = ClassProposalFactory(display=True)
url = reverse(self.view_name, urlconf="gbe.urls")
login_as(PersonaFactory().performer_profile, self)
data = self.get_class_form()
data["%d-volunteering" % proposal.id] = 1
response = self.client.post(url, data=data)
nt.assert_equal(response.status_code, 200)
nt.assert_true(conf_volunteer_save_error in response.content)
def test_get_edit_troupe(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)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Tell Us About Your Troupe')
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()
self.privileged_user = ProfileFactory.create().user_object
grant_privilege(self.privileged_user, 'Act Coordinator', 'assign_act')
grant_privilege(self.privileged_user, 'Act Reviewers')
def test_review_act_w_troupe(self):
# causes a check on act complete state that is different from soloist
troupe = TroupeFactory()
member = PersonaFactory()
troupe.membership.add(member)
act = ActFactory(performer=troupe,
submitted=True,
b_conference=self.current_conf)
login_as(member.performer_profile, self)
url = reverse("home", urlconf="gbe.urls")
response = self.client.get(url)
self.assertContains(response, act.b_title)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.performer = PersonaFactory()
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Vendor Reviewers')
self.conference = current_conference()
self.vendors = VendorFactory.create_batch(
4,
b_conference=self.conference,
submitted=True)
def test_edit_bid_not_post(self):
'''edit_costume, not post, should take us to edit process'''
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()
login_as(costume.profile, self)
response = self.client.get(url)
expected_text = "Displaying a Costume"
self.assertTrue(expected_text in response.content)
self.assertContains(response, costume.b_description)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.ticketingexclusion = TicketingExclusionFactory.create()
self.roleexclusion = RoleExclusionFactory.create()
self.teacher = PersonaFactory.create()
booking = book_worker_item_for_role(
self.teacher,
self.roleexclusion.role,
)
self.roleexclusion.event = booking.event.eventitem
self.roleexclusion.save()
self.conference = booking.event.eventitem.get_conference()
def test_edit_as_member(self):
'''edit_troupe view, edit flow success
'''
persona = PersonaFactory()
troupe = TroupeFactory()
troupe.membership.add(persona)
troupe.save()
url = reverse(self.view_name, args=[troupe.pk], urlconf='gbe.urls')
login_as(persona.performer_profile.profile, self)
response = self.client.get(url)
self.assertRedirects(
response,
reverse('troupe_view', urlconf='gbe.urls', args=[str(troupe.pk)]))
def test_inactive_user_not_listed(self):
staff_context = StaffAreaContext()
volunteer_sched_event = staff_context.add_volunteer_opp()
inactive_persona = PersonaFactory(
contact__user_object__is_active=False)
login_as(self.privileged_user, self)
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[staff_context.conference.conference_slug,
volunteer_sched_event.pk])
response = self.client.get(url)
self.assertNotIn(str(inactive_persona), response.content)
self.assertNotIn(str(inactive_persona.contact), 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.assertContains(response, self.troupe_string)
self.assertContains(response, troupe_header_text)
self.assertNotContains(
response,
'<a href="#" data-toggle="modal" data-target="#DeleteModal" ' +
'data-backdrop="true" class="btn gbe-btn-secondary">Delete</a>',
html=True)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.ticketingexclusion = TicketingExclusionFactory.create()
self.roleexclusion = RoleExclusionFactory.create()
self.teacher = PersonaFactory.create()
booking = book_worker_item_for_role(
self.teacher,
self.roleexclusion.role,
)
self.roleexclusion.event = booking.event.eventitem
self.roleexclusion.save()
self.conference = booking.event.eventitem.get_conference()
def setUp(self):
self.client = Client()
self.performer = PersonaFactory()
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Act Reviewers')
grant_privilege(self.privileged_user, 'Act Coordinator')
self.eval_cat = EvaluationCategoryFactory()
self.eval_cat_invisible = EvaluationCategoryFactory(visible=False)
self.act = ActFactory()
self.url = reverse('act_review',
urlconf='gbe.urls',
args=[self.act.pk])
def test_role_match(self):
'''
profile has a role match condition
'''
teacher = PersonaFactory()
booking = book_worker_item_for_role(teacher, self.role_condition.role)
conference = booking.event.eventitem.get_conference()
ticket_items, role_items = get_checklist_items(
teacher.performer_profile, conference)
nt.assert_equal(len(role_items), 1)
nt.assert_equal(role_items[self.role_condition.role],
[self.role_condition.checklistitem])
def test_edit_act_w_bad_post_makes_good_readonly(self):
context = ActTechInfoContext(schedule_rehearsal=True)
context.act.b_description = "Describe the act here"
context.act.video_link = "http://video/link/video.mov"
context.act.video_choice = '2'
context.act.save()
random_performer = PersonaFactory()
url = reverse('act_techinfo_edit',
urlconf='gbe.urls',
args=[context.act.pk])
login_as(context.performer.contact, self)
response = self.client.post(url, {})
self.assertEqual(response.status_code, 200)
self.check_good_info(response, context, random_performer)
def test_class_bid_post_invalid_form_no_submit(self):
url = reverse(self.view_name, urlconf='gbe.urls')
other_performer = PersonaFactory()
other_profile = other_performer.performer_profile
login_as(self.performer.performer_profile, self)
data = self.get_class_form(submit=False, invalid=True)
data['theclass-teacher'] = other_performer.pk
response = self.client.post(url, data=data, follow=True)
self.assertEqual(200, response.status_code)
self.assertContains(response, 'Submit a Class')
self.assertContains(
response,
'Select a valid choice. That choice is not one of the available' +
' choices.')
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)
self.assertContains(response, 'This field is required.', count=2)
def test_view_troupe(self):
'''view_troupe view, success
'''
persona = PersonaFactory()
contact = persona.performer_profile
troupe = TroupeFactory(contact=contact)
url = reverse('troupe_view',
args=[troupe.resourceitem_id],
urlconf='gbe.urls')
login_as(contact.profile.user_object, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, troupe.name)
def test_edit_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(invalid=True)
login_as(costume.profile, self)
response = self.client.post(url, data=data)
expected_string = "Costume Information"
self.assertTrue(expected_string in response.content)
self.assertEqual(response.status_code, 200)
def test_view_troupe_as_random_person(self):
'''view_troupe view, success
'''
persona = PersonaFactory()
random = ProfileFactory()
contact = persona.performer_profile
troupe = TroupeFactory(contact=contact)
url = reverse('troupe_view',
args=[troupe.resourceitem_id],
urlconf='gbe.urls')
login_as(random.user_object, self)
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 404)
def setUp(self):
self.room = RoomFactory()
self.teacher = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True)
self.room.conferences.add(self.current_conference)
self.day = ConferenceDayFactory(conference=self.current_conference)
self.url = reverse(
self.view_name,
args=[self.current_conference.conference_slug, "master"],
urlconf='gbe.scheduling.urls'
) + "?pick_event=Next&event_type=master"
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def test_costume_bid_post_invalid_form_no_submit(self):
url = reverse(self.view_name, urlconf='gbe.urls')
other_performer = PersonaFactory()
other_profile = other_performer.performer_profile
login_as(self.performer.performer_profile, self)
data = self.get_costume_form(submit=False, invalid=True)
response = self.client.post(url, data=data, follow=True)
self.assertEqual(200, response.status_code)
self.assertTrue('Displaying a Costume' in response.content)
self.assertFalse(other_performer.name in response.content)
current_user_selection = '<option value="%d">%s</option>'
persona_id = self.performer.pk
selection_string = current_user_selection % (persona_id,
self.performer.name)
self.assertTrue(selection_string in response.content)
def test_good_user_get_volunteer_w_teacher_as_persona(self):
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
login_as(self.privileged_user, self)
staff_context = StaffAreaContext()
volunteer_sched_event = staff_context.add_volunteer_opp()
teacher = PersonaFactory()
teacher, alloc = staff_context.book_volunteer(
volunteer_sched_event=volunteer_sched_event,
volunteer=teacher,
role="Teacher")
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[staff_context.conference.conference_slug,
volunteer_sched_event.pk])
response = self.client.get(url)
def setUp(self):
self.url = reverse(
self.view_name,
urlconf='gbe.urls')
self.factory = RequestFactory()
self.client = Client()
self.performer = PersonaFactory()
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Act Reviewers')
self.conference = current_conference()
self.acts = ActFactory.create_batch(
4,
b_conference=self.conference,
submitted=True)
def test_personal_schedule_only_active(self):
'''a teacher booked into a class, with an active role condition
should have a booking
'''
role_condition = RoleEligibilityConditionFactory()
teacher = PersonaFactory(contact__user_object__is_active=False)
context = ClassContext(teacher=teacher)
login_as(self.priv_profile, self)
response = self.client.get(
self.url, data={"conf_slug": context.conference.conference_slug})
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, str(teacher.performer_profile))
self.assertNotContains(response, context.bid.e_title)
def test_volunteer_has_show_conflict(self):
show_context = ShowContext(
conference=self.context.conference,
performer=PersonaFactory(performer_profile=self.context.profile),
starttime=self.context.opp_event.start_time)
login_as(self.privileged_profile, self)
response = self.client.get(self.url, follow=True)
assert ("no available volunteers" not in response.content)
assert_link(
response,
reverse(self.view_name,
args=[
self.context.conference.conference_slug,
show_context.sched_event.pk
],
urlconf="gbe.scheduling.urls"))
def test_historical_no_interest(self):
context = ClassContext(
conference=self.previous_conf,
teacher=PersonaFactory(performer_profile=self.profile))
interested = []
for i in range(0, 3):
interested += [context.set_interest()]
url = reverse('home', urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url, data={'historical': 1})
content = response.content
for person in interested:
self.assertNotContains(
response, "%s <%s>;</br>" %
(person.display_name, person.user_object.email))
self.assertNotContains(response, interested_explain_msg)
def test_conference_volunteer_post_offer_form_valid(self):
proposal = ClassProposalFactory(display=True)
url = reverse(self.view_name, urlconf="gbe.urls")
persona = PersonaFactory()
login_as(persona.performer_profile, self)
data = self.get_class_form()
data["%d-volunteering" % proposal.id] = 1
data["%d-bid" % proposal.pk] = proposal.id
data['%d-how_volunteer' % proposal.pk] = 'Any of the Above'
data['%d-presenter' % proposal.pk] = persona.pk
response = self.client.post(url, data=data, follow=True)
nt.assert_true(('http://testserver/gbe',
302) in response.redirect_chain)
expected_string = 'Your profile needs an update'
nt.assert_true(expected_string in response.content)
nt.assert_equal(response.status_code, 200)
def setUp(self):
self.client = Client()
self.performer = PersonaFactory()
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Volunteer Reviewers')
self.volunteer = VolunteerFactory(
submitted=True,
profile__user_object__email="*****@*****.**")
self.prefs = ProfilePreferencesFactory(
profile=self.volunteer.profile,
in_hotel="Maybe",
inform_about=True,
show_hotel_infobox=True)
self.url = reverse(self.view_name, urlconf='gbe.urls')
def __init__(self,
bid=None,
moderator=None,
conference=None,
room=None,
starttime=None):
self.moderator = moderator or PersonaFactory()
self.conference = conference or ConferenceFactory()
self.bid = bid or ClassFactory(b_conference=self.conference,
e_conference=self.conference,
accepted=3)
self.room = room or RoomFactory()
self.sched_event = None
self.sched_event = self.schedule_instance(room=self.room,
starttime=starttime)
self.days = [ConferenceDayFactory(conference=self.conference)]
def test_review_act_techinfo_troupe_member(self):
'''review_act_techinfo view should load for Tech Crew
and fail for others
'''
troupe = TroupeFactory()
member = PersonaFactory()
troupe.membership.add(member)
self.context.act.performer = troupe
self.context.act.save()
self.set_the_basics()
login_as(member.performer_profile, self)
response = self.client.get(self.url)
self.assertContains(response, self.context.act.b_title)
self.assertContains(response, str(self.context.act.performer))
self.assertContains(response, str(self.context.show))
self.assertContains(response, self.context.act.tech.introduction_text)
def test_teacher_interest(self):
'''Basic test of landing_page view
'''
context = ClassContext(
conference=self.current_conf,
teacher=PersonaFactory(performer_profile=self.profile))
interested = []
for i in range(0, 3):
interested += [context.set_interest()]
url = reverse('home', urlconf='gbe.urls')
login_as(self.profile, self)
response = self.client.get(url)
for person in interested:
self.assertContains(
response, "%s <%s>;" %
(person.display_name, person.user_object.email))
self.assertContains(response, interested_explain_msg)
