def test_act_tech_troupe_member_view(self):
troupe = TroupeFactory()
member = PersonaFactory()
troupe.membership.add(member)
act = ActFactory(performer=troupe,
submitted=True,
b_conference=self.current_conf,
accepted=3)
current_act_context = ActTechInfoContext(
performer=troupe,
act=act,
conference=self.current_conf,
schedule_rehearsal=True)
act.tech = TechInfoFactory(
track_artist="",
track=SimpleUploadedFile("file.mp3", b"file_content"),
prop_setup="text",
starting_position="Onstage",
primary_color="text",
feel_of_act="text",
pronouns="text",
introduction_text="text")
act.tech.save()
event_id = make_act_app_ticket(self.current_conf)
login_as(member.performer_profile, self)
url = reverse("home", urlconf="gbe.urls")
response = self.client.get(url)
self.assertContains(
response,
reverse("act_techinfo_detail",
urlconf="gbe.reporting.urls",
args=[act.pk]))
def test_valid_act_payment_received(self):
privileged_profile = ProfileFactory()
grant_privilege(
privileged_profile.user_object,
'Act Reviewers')
act = ActFactory()
tickets = setup_fees(act.b_conference, is_act=True)
act_params = IPN_POST_PARAMS
act_params["mc_currency"] = "USD"
act_params["receiver_email"] = PayPalSettings.objects.first(
).business_email
act_params["custom"] = "%s-%d-User-%d" % (
"Act",
act.pk,
act.performer.contact.user_object.pk)
act_params["mc_gross"] = 10.00
ipn_obj = self.assertGotSignal(valid_ipn_received,
params=act_params)
purchaser = Purchaser.objects.get(
matched_to_user=act.performer.contact.user_object)
transaction = Transaction.objects.get(purchaser=purchaser)
self.assertEqual(transaction.ticket_item, tickets[0])
self.assertEqual(transaction.invoice, ipn_obj.invoice)
self.assertEqual(purchaser.first_name, ipn_obj.first_name)
assert_right_mail_right_addresses(
0,
1,
"Act Submission Occurred",
[privileged_profile.contact_email])
def test_low_donation(self):
privileged_profile = ProfileFactory()
grant_privilege(
privileged_profile.user_object,
'Act Reviewers')
act = ActFactory()
tickets = setup_fees(act.b_conference, is_act=True)
act_params = IPN_POST_PARAMS
act_params["mc_currency"] = "USD"
act_params["receiver_email"] = PayPalSettings.objects.first(
).business_email
act_params["custom"] = "%s-%d-User-%d" % (
"Act",
act.pk,
act.performer.contact.user_object.pk)
act_params["mc_gross"] = "5.00"
ipn_obj = self.assertGotSignal(valid_ipn_received,
params=act_params)
msg = assert_right_mail_right_addresses(
0,
1,
"PayPal Purchase Processing Error",
[admin[1] for admin in settings.ADMINS])
self.assertTrue("Transaction was not paid" in msg.body)
self.assertTrue(reverse("admin:%s_%s_change" % (
"ipn",
"paypalipn"), args=(ipn_obj.id, )) in msg.body)
def test_act_changestate_authorized_user(self):
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data)
nt.assert_equal(response.status_code, 302)
def test_review_summer_act(self):
act = ActFactory(b_conference__act_style="summer")
url = reverse('act_review', urlconf='gbe.urls', args=[act.pk])
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'The Summer Act')
def test_incomplete_exclude(self):
dual_context = ClassContext(conference=self.context.conference)
act = ActFactory(b_conference=self.context.conference,
performer=dual_context.teacher,
submitted=True,
accepted=3)
second_conference = ClassContext()
login_as(self.privileged_profile, self)
data = {
'email-select-conference':
[self.context.conference.pk, second_conference.conference.pk],
'email-select-bid_type': ["Class"],
'email-select-state': [0, 1, 2, 3, 4, 5],
'email-select-x_bid_type': ["Act"],
'email-select-x_state': [0, 1, 2, 3, 4, 5],
'filter':
True,
}
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(response,
self.context.teacher.contact.user_object.email)
self.assertContains(
response, second_conference.teacher.contact.user_object.email)
self.assertContains(response,
dual_context.teacher.contact.user_object.email)
self.assertContains(response, "Excluded: 0")
def test_send_email_reduced_to_list_no_hack(self):
reduced_profile = self.reduced_login()
second_bid = ActFactory(submitted=True)
random = ProfileFactory()
data = {
'to': [
second_bid.performer.contact.user_object.email,
random.user_object.email
],
'sender':
"*****@*****.**",
'subject':
"Subject",
'html_message':
"<p>Test Message</p>",
'email-select-conference':
[self.context.conference.pk, second_bid.b_conference.pk],
'email-select-bid_type': ['Act'],
'email-select-state': [0, 1, 2, 3, 4, 5],
'send':
True
}
response = self.client.post(self.url, data=data, follow=True)
self.assertContains(
response, 'Select a valid choice. %s is %s' %
(random.user_object.email, 'not one of the available choices.'))
def test_edit_act_no_duration(self):
act = ActFactory()
act_form = self.get_act_form(act, submit=True)
del act_form['theact-act_duration']
response = self.post_edit_paid_act_submission(act_form)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "This field is required.")
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 book_act(self, act=None, act_role=''):
act = act or ActFactory(
b_conference=self.conference, accepted=3, submitted=True)
booking = ResourceAllocationFactory(event=self.sched_event,
resource=ActResourceFactory(
_item=act, role=act_role))
return (act, booking)
def test_send_email_reduced_w_fixed_from(self):
reduced_profile = self.reduced_login()
second_bid = ActFactory(submitted=True)
data = {
'to':
second_bid.performer.contact.user_object.email,
'sender':
"*****@*****.**",
'subject':
"Subject",
'html_message':
"<p>Test Message</p>",
'email-select-conference':
[self.context.conference.pk, second_bid.b_conference.pk],
'email-select-bid_type': ['Act'],
'email-select-state': [0, 1, 2, 3, 4, 5],
'send':
True
}
response = self.client.post(self.url, data=data, follow=True)
assert_queued_email(
[
second_bid.performer.contact.user_object.email,
],
data['subject'],
data['html_message'],
reduced_profile.user_object.email,
extras=[
self.get_param,
reverse('email_update',
urlconf='gbe.urls',
args=[second_bid.performer.contact.user_object.email])
])
def post_act_conflict(conference, performer, data, url, testcase):
original = ActFactory(b_conference=conference, performer=performer)
login_as(performer.performer_profile, testcase)
data['theact-b_title'] = original.b_title
data['theact-b_conference'] = conference.pk
response = testcase.client.post(url, data=data, follow=True)
return response, original
def post_title_collision(self):
original = ActFactory()
url = reverse(self.view_name, args=[original.pk], urlconf="gbe.urls")
make_act_app_purchase(original.b_conference,
original.performer.performer_profile.user_object)
return post_act_conflict(original.b_conference, original.performer,
self.get_act_form(original, submit=True), url,
self)
def test_unbooked_performer(self):
'''
Submitted an act, didn't make it to a show
'''
act = ActFactory(b_conference=self.conference)
profile = act.performer.performer_profile
result = profile.get_roles(self.conference)
nt.assert_equal(len(result), 0)
def test_acts_to_review(self):
staff_profile = ProfileFactory(user_object__is_staff=True)
grant_privilege(staff_profile, "Act Reviewers")
login_as(staff_profile, self)
act = ActFactory(submitted=True, b_conference=self.current_conf)
url = reverse('home', urlconf='gbe.urls')
response = self.client.get(url)
nt.assert_true(act.b_title in response.content)
def post_edit_paid_act_draft(self):
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf="gbe.urls")
login_as(act.performer.contact, self)
act_form = self.get_act_form(act)
act_form['draft'] = True
response = self.client.post(url, act_form, follow=True)
return response
def test_unbooked_performer(self):
'''
Submitted an act, didn't make it to a show
'''
act = ActFactory()
profile = act.performer.performer_profile
result = profile.has_role_in_event("Performer", self.booking)
nt.assert_false(result)
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)
data = self.get_act_form()
data['theact-performer'] = act.performer.pk
response = self.client.post(url, data, follow=True)
return response
def test_edit_act_profile_is_not_contact(self):
user = PersonaFactory().performer_profile.user_object
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf="gbe.urls")
login_as(user, self)
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 404)
def test_edit_act_user_has_no_profile(self):
user = UserFactory()
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf="gbe.urls")
login_as(user, self)
response = self.client.post(url,
data=self.get_act_form(act, submit=True))
self.assertEqual(response.status_code, 302)
def test_submit_act_not_owner(self):
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf='gbe.urls')
login_as(ProfileFactory(), self)
response = self.client.get(url)
error_string = "Error: You don't own that act."
self.assertContains(response, error_string)
def test_act_edit_post_form_not_valid(self):
'''act_edit, if form not valid, should return to ActEditForm'''
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf="gbe.urls")
login_as(act.performer.performer_profile, self)
response = self.client.post(url, self.get_act_form(act, invalid=True))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Propose an Act')
def test_withdrawn_act(self):
act = ActFactory(accepted=4)
login_as(self.profile, self)
response = self.client.get(
reverse(self.view_name,
urlconf='gbe.reporting.urls',
args=[act.id]))
self.assertContains(response, "Act state is Withdrawn")
def test_submit_act(self):
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf='gbe.urls')
login_as(act.performer.performer_profile, self)
response = self.client.get(url, follow=True)
self.assertRedirects(response, reverse('home', urlconf='gbe.urls'))
self.assertContains(response, "Welcome to GBE")
self.assertEqual(response.status_code, 200)
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_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 test_submit_act(self):
act = ActFactory()
url = reverse(self.view_name, args=[act.pk], urlconf='gbe.urls')
login_as(act.performer.performer_profile, self)
response = self.client.get(url, follow=True)
redirect = ('http://testserver/gbe', 302)
nt.assert_true(redirect in response.redirect_chain)
nt.assert_true("Profile View" in response.content)
nt.assert_equal(response.status_code, 200)
def test_review_act_old_act(self):
conference = ConferenceFactory(status="completed",
accepting_bids=False)
act = ActFactory(b_conference=conference)
url = reverse('act_review', urlconf='gbe.urls', args=[act.pk])
login_as(self.privileged_user, self)
response = self.client.get(url, follow=True)
self.assertRedirects(
response, reverse('act_view', urlconf='gbe.urls', args=[act.pk]))
self.assertContains(response, 'Review Bids')
def test_act_submit_second_paid_act(self):
prev_act = ActFactory(submitted=True,
performer=self.performer,
b_conference=self.current_conference)
make_act_app_purchase(self.current_conference,
self.performer.performer_profile.user_object)
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_act_was_reviewed(self):
staff_profile = ProfileFactory(user_object__is_staff=True)
grant_privilege(staff_profile, "Act Reviewers")
login_as(staff_profile, self)
reviewed_act = ActFactory(submitted=True,
b_conference=self.current_conf)
FlexibleEvaluationFactory(bid=reviewed_act, evaluator=staff_profile)
url = reverse('home', urlconf='gbe.urls')
response = self.client.get(url)
self.assertNotContains(response, reviewed_act.b_title)
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)
