def test_list_profile_w_search_by_first_name(self):
profile1 = ProfileFactory()
profile2 = ProfileFactory()
login_as(self.user, self)
response = self.client.get("%s?q=%s" %
(self.url, profile1.user_object.first_name))
self.assertContains(response, profile1.display_name)
self.assertContains(response, profile1.pk)
self.assertNotContains(response, profile2.display_name)
def test_edit_volunteer_profile_is_not_coordinator(self):
user = ProfileFactory().user_object
volunteer = VolunteerFactory()
url = reverse('volunteer_edit',
urlconf='gbe.urls',
args=[volunteer.pk])
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertEqual(403, response.status_code)
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, 'Costume Reviewers')
self.coordinator = ProfileFactory()
grant_privilege(self.coordinator, 'Costume Reviewers')
grant_privilege(self.coordinator, 'Costume Coordinator')
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.coordinator = ProfileFactory()
grant_privilege(self.coordinator.user_object, 'Vendor Reviewers')
grant_privilege(self.coordinator.user_object, 'Vendor Coordinator')
def setUp(self):
self.client = Client()
self.privileged_user = User.objects.create_superuser(
'myuser', '*****@*****.**', "mypassword")
self.privileged_profile = ProfileFactory(
user_object=self.privileged_user)
grant_privilege(self.privileged_profile.user_object, 'Registrar')
self.to_profile = ProfileFactory()
self.url = reverse(self.view_name,
urlconf="gbe.email.urls",
args=[self.to_profile.resourceitem_id])
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_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_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.user = ProfileFactory().user_object
grant_privilege(self.user, u'Theme Editor')
self.version = StyleVersionFactory(currently_live=True,
currently_test=True)
self.url = reverse(self.view_name, urlconf="gbe.themes.urls")
def test_not_users_personae(self):
troupe = TroupeFactory()
user = ProfileFactory()
login_as(user, self)
response = self.client.get(self.url)
self.assertNotContains(response, troupe.name)
self.assertNotContains(response, troupe.pk)
def test_assign_volunteers_bad_user(self):
''' user does not have Volunteer Coordinator, permission is denied'''
volunteer = VolunteerFactory()
url = reverse(self.view_name, args=[volunteer.pk], urlconf='gbe.urls')
login_as(ProfileFactory(), self)
response = self.client.get(url)
nt.assert_equal(403, response.status_code)
def test_view_vendor_wrong_user(self):
vendor = VendorFactory()
url = reverse(self.view_name, args=[vendor.pk], urlconf='gbe.urls')
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertEqual(403, response.status_code)
def test_view_list_only_classes(self):
'''
/scheduler/view_list/ should return all events in the current
conference, assuming a current conference exists
'''
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)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=['Class'])
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertNotContains(response, show.e_title)
self.assertNotContains(response, generic_event.e_title)
self.assertContains(response, accepted_class.e_title)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=['class'])
response = self.client.get(url)
self.assertNotContains(response, show.e_title)
self.assertNotContains(response, generic_event.e_title)
self.assertContains(response, accepted_class.e_title)
def setUp(self):
Conference.objects.all().delete()
self.client = Client()
self.profile = ProfileFactory()
self.conference = current_conference()
UserMessage.objects.all().delete()
self.business = BusinessFactory(owners=[self.profile])
def test_review_act_load_review_listing_test_avg(self):
evaluation1 = FlexibleEvaluationFactory(
evaluator=self.privileged_profile,
category=self.eval_cat,
ranking=0)
evaluation2 = FlexibleEvaluationFactory(evaluator=ProfileFactory(),
ranking=2,
bid=evaluation1.bid)
FlexibleEvaluationFactory(evaluator=evaluation2.evaluator,
category=self.eval_cat,
ranking=4,
bid=evaluation1.bid)
FlexibleEvaluationFactory(category=self.eval_cat,
ranking=0,
bid=evaluation1.bid)
url = reverse('act_review',
urlconf='gbe.urls',
args=[evaluation1.bid.pk])
login_as(self.privileged_user, self)
response = self.client.get(url)
reviewer_string = '<th class="rotate"><div><span>%s</span></div></th>'
self.assertContains(response,
reviewer_string % str(evaluation1.evaluator),
html=True)
self.assertContains(response,
reviewer_string % str(evaluation2.evaluator),
html=True)
self.assertContains(response, evaluation1.category.category, 4)
self.assertContains(response, evaluation2.category.category, 4)
self.assertContains(response, "<td>2</td>", 1)
self.assertContains(response, "<td>2.0</td>", 1)
self.assertContains(response, "<td>1.33</td>", 1)
self.assertContains(response, "<td>0</td>", 2)
self.assertContains(response, "<td>4</td>", 1)
def test_pick_drop_in(self):
special = GenericEventFactory(e_conference=self.context.conference,
type="Drop-In")
specialstaffcontext = VolunteerContext(event=special, role="Teacher")
limited_profile = ProfileFactory()
grant_privilege(limited_profile.user_object, "Registrar")
login_as(limited_profile, self)
data = {
'email-select-conference': [
self.context.conference.pk,
],
'email-select-roles': [
'Teacher',
],
'event-select-event_collections': "Drop-In",
'refine': True,
}
response = self.client.post(self.url, data=data, follow=True)
print response
self.assertNotContains(response,
self.context.teacher.contact.user_object.email)
self.assertContains(response,
specialstaffcontext.profile.user_object.email)
self.assertNotContains(response, special.e_title)
assert_checkbox(response,
"event_collections",
1,
"Drop-In",
"All Drop-In Classes",
prefix="event-select")
def test_review_costume_bad_user(self):
url = reverse(self.view_name, urlconf="gbe.urls")
login_as(ProfileFactory(), self)
response = self.client.get(
url,
data={'conf_slug': self.conference.conference_slug})
nt.assert_equal(403, response.status_code)
def test_no_purchases(self):
'''should get no tickets, this person never purchased any
'''
elcheapo = ProfileFactory().user_object
ticket_set = get_purchased_tickets(elcheapo)
self.assertEqual(ticket_set, [])
def test_volunteer_conflict_sends_notification_w_bid_details(self):
privileged_profile = ProfileFactory()
grant_privilege(privileged_profile.user_object, 'Class Reviewers')
EmailTemplate.objects.all().delete()
subject_format = "bidder: %s, bid: %s"
EmailTemplateSenderFactory(
from_email="*****@*****.**",
template__name='class submission notification',
template__subject="bidder: %s, bid: %s" %
("{{ bidder }}", "{{ bid.b_title }}"))
url = reverse(self.view_name, urlconf='gbe.urls')
login_as(self.performer.performer_profile, self)
data = {
'theclass-teacher': self.performer.pk,
'theclass-b_title': 'A class',
'theclass-b_description': 'a description',
'theclass-length_minutes': 60,
'theclass-maximum_enrollment': 20,
'theclass-fee': 0,
'theclass-schedule_constraints': ['0'],
'submit': 1,
}
response = self.client.post(url, data=data, follow=True)
assert_right_mail_right_addresses(
0,
1,
"bidder: %s, bid: %s" %
(str(self.performer.performer_profile), data['theclass-b_title']),
[privileged_profile.contact_email],
from_email="*****@*****.**")
def test_unauthorized_user(self):
url = reverse(self.view_name,
args=[self.deleted_profile.pk],
urlconf='gbe.urls')
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
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_no_avail_conf(self):
clear_conferences()
login_as(ProfileFactory(), self)
response = self.client.get(reverse("event_list",
urlconf="gbe.scheduling.urls"),
follow=True)
self.assertEqual(404, response.status_code)
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 setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.vendor = VendorFactory()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Vendor Coordinator')
self.data = {'accepted': '3'}
def set_interest(self, interested_profile=None):
interested_profile = interested_profile or ProfileFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=interested_profile,
role="Interested"))
return interested_profile
def set_staff_lead(self, staff_lead=None):
staff_lead = staff_lead or ProfileFactory()
ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=staff_lead,
role="Staff Lead"))
return staff_lead
def setUp(self):
self.client = Client()
self.profile = ProfileFactory()
self.context = ClassContext()
self.url = reverse(self.view_name,
args=[self.context.sched_event.pk, "on"],
urlconf="gbe.scheduling.urls")
def test_edit_act_no_act(self):
'''Should get 404 if no valid act ID'''
profile = ProfileFactory()
url = reverse(self.view_name, args=[0], urlconf="gbe.urls")
login_as(profile, self)
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 404)
def test_not_users_business(self):
business = BusinessFactory()
user = ProfileFactory()
login_as(user, self)
response = self.client.get(self.url)
self.assertNotContains(response, business.name)
self.assertNotContains(response, business.pk)
def test_edit_persona_change_image(self):
ProfileFactory(user_object__username="******")
pic_filename = open("tests/gbe/gbe_pagebanner.png", 'rb')
response, new_name = self.submit_business(pic_filename)
business_reloaded = Business.objects.get(pk=self.business.pk)
self.assertEqual(str(business_reloaded.img), "gbe_pagebanner.png")
