def test_basic_profile(self):
'''
Simplest user - just has a profile, doesn't have any role
'''
profile = ProfileFactory()
result = profile.get_roles(self.conference)
nt.assert_equal(len(result), 0)
def test_basic_profile_teacher(self):
'''
Simplest user - just has a profile, doesn't have any booking
'''
profile = ProfileFactory()
result = profile.has_role_in_event(self.role,
self.booking.event.eventitem)
nt.assert_false(result)
def test_list_ticket_user_is_not_ticketing(self):
'''
The user does not have the right privileges.
'''
user = ProfileFactory.create().user_object
login_as(user, self)
response = self.client.get(self.url)
self.assertEqual(403, response.status_code)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
group, created = Group.objects.get_or_create(
name='Ticketing - Transactions')
self.privileged_user = ProfileFactory.create().\
user_object
self.privileged_user.groups.add(group)
self.url = reverse('transactions', urlconf='ticketing.urls')
def test_user_is_not_ticketing(self):
'''
The user does not have the right privileges. Send PermissionDenied
'''
user = ProfileFactory.create().user_object
request = self.factory.get(
reverse('transactions', urlconf='ticketing.urls'),
)
request.user = user
response = transactions(request)
def setUp(self):
self.client = Client()
Conference.objects.all().delete()
self.conference = ConferenceFactory()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.url = reverse(self.view_name,
urlconf="scheduler.urls")
self.showcontext = ShowContext(conference=self.conference)
self.classcontext = ClassContext(conference=self.conference)
def setUp(self):
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Volunteer Coordinator')
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.context = VolunteerContext()
self.url = reverse(
self.view_name,
args=[self.context.conference.conference_slug,
self.context.opp_event.pk],
urlconf="gbe.scheduling.urls")
def setUp(self):
AvailableInterest.objects.all().delete()
self.client = Client()
self.user = ProfileFactory.create().user_object
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
self.url = reverse(self.view_name,
urlconf="gbe.scheduling.urls")
self.volunteer_context = VolunteerContext()
self.day = self.volunteer_context.window.day
self.class_context = ClassContext(conference=self.day.conference)
self.another_interest = AvailableInterestFactory(interest="one more")
self.show_context = ShowContext(conference=self.day.conference)
self.staff_context = StaffAreaContext(conference=self.day.conference)
booking, self.vol_opp = self.staff_context.book_volunteer()
def test_show_volunteer(self):
'''staff_area view should load
'''
vol_context = VolunteerContext(event=self.context.show,
sched_event=self.context.sched_event)
self.profile = ProfileFactory()
grant_privilege(self.profile, 'Scheduling Mavens')
login_as(self.profile, self)
response = self.client.get(self.url)
self.assertContains(response, vol_context.opportunity.e_title)
self.assertContains(
response,
reverse('mail_to_individual',
urlconf='gbe.email.urls',
args=[vol_context.profile.resourceitem_id]))
self.assertContains(
response,
reverse('detail_view',
urlconf='gbe.scheduling.urls',
args=[vol_context.opp_event.eventitem_id]))
def test_feature_grid_for_admin(self):
ActCastingOptionFactory(casting="Regular Act",
show_as_special=False,
display_order=0)
ActCastingOptionFactory(display_order=1)
context = ActTechInfoContext(act_role="Hosted By...")
url = reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[context.show.eventitem_id])
superuser = User.objects.create_superuser('test_feature_editor',
'*****@*****.**',
'secret')
ProfileFactory(user_object=superuser)
set_image(context.performer)
login_as(superuser, self)
response = self.client.get(url)
self.assertEqual(200, response.status_code)
self.assertContains(response,
"/admin/gbe/performer/%d" % context.performer.pk)
def test_env_stuff_w_inactive_purchaser(self):
'''env_stuff view should load with no conf choice
'''
Conference.objects.all().delete()
inactive = ProfileFactory(display_name="DON'T SEE THIS",
user_object__is_active=False)
ticket_context = PurchasedTicketContext(profile=inactive)
transaction = ticket_context.transaction
grant_privilege(self.profile, 'Registrar')
login_as(self.profile, self)
response = self.client.get(
reverse('env_stuff', urlconf="gbe.reporting.urls"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get('Content-Disposition'),
"attachment; filename=env_stuff.csv")
self.assertContains(
response, "Badge Name,First,Last,Tickets,Ticket format,Personae," +
"Staff Lead,Volunteering,Presenter,Show")
self.assertNotContains(response, inactive.display_name)
def setUp(self):
self.context = VolunteerContext(event=GenericEventFactory())
self.context.sched_event.max_volunteer = 7
self.context.sched_event.save()
self.context.event.duration = Duration(hours=1, minutes=30)
self.context.event.save()
self.room = self.context.room
self.staff_lead = self.context.set_staff_lead()
self.extra_day = ConferenceDayFactory(
conference=self.context.conference,
day=self.context.conf_day.day + timedelta(days=1))
self.url = reverse(self.view_name,
args=[
self.context.conference.conference_slug,
self.context.sched_event.pk
],
urlconf='gbe.scheduling.urls')
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def test_valid_vendor_payment_already_submitted(self):
privileged_profile = ProfileFactory()
grant_privilege(
privileged_profile.user_object,
'Vendor Reviewers')
vendor = VendorFactory(submitted=True)
profile = vendor.business.owners.all().first()
tickets = setup_fees(vendor.b_conference, is_vendor=True)
vendor_params = IPN_POST_PARAMS
vendor_params["receiver_email"] = PayPalSettings.objects.first(
).business_email
vendor_params["custom"] = "%s-%d-User-%d" % (
"Vendor",
vendor.pk,
profile.user_object.pk)
cost = 0
for ticket in tickets:
cost = cost + ticket.cost
vendor_params["mc_currency"] = "USD"
vendor_params["mc_gross"] = cost
vendor_params["item_number"] = str(tickets[0].pk)
ipn_obj = self.assertGotSignal(valid_ipn_received,
params=vendor_params)
self.assertEqual(Purchaser.objects.filter(
matched_to_user=profile.user_object).count(), 1)
self.assertEqual(Transaction.objects.filter(
purchaser__matched_to_user=profile.user_object).count(), 1)
msg = assert_right_mail_right_addresses(
0,
2,
"PayPal Purchase Processing Error",
[admin[1] for admin in settings.ADMINS])
self.assertTrue(
"Payment recieved for a bid that has already been " +
"submitted. Bid name: %s, Bid Type: %s, Bid PK: %s" % (
vendor.b_title,
"Vendor",
vendor.pk))
self.assertTrue(reverse("admin:%s_%s_change" % (
"ipn",
"paypalipn"), args=(ipn_obj.id, )) in msg.body)
def test_no_techinfo_edit_no_order_change(self):
'''Act Coordinator can't edit act tech, or the order
This should be an act w/out tech info.
'''
self.context.order_act(self.context.act, "3")
self.profile = ProfileFactory()
grant_privilege(self.profile, 'Act Coordinator')
login_as(self.profile, self)
response = self.client.get(self.url)
self.assertContains(response, self.context.act.b_title)
self.assertContains(response, 'class="gbe-table-row gbe-table-danger"',
1)
self.assertContains(
response, '<i class="fas fa-window-close gbe-text-danger"></i>')
self.assertNotContains(
response,
reverse("act_tech_wizard",
urlconf='gbe.urls',
args=[self.context.act.id]))
self.assertContains(response,
"<td data-order=\'3\'>\n 3\n </td>")
def setUp(self):
self.room = RoomFactory()
# because there was a bug around duplicate room names
RoomFactory(name=self.room.name)
self.teacher = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True)
self.day = ConferenceDayFactory(conference=self.current_conference)
self.room.conferences.add(self.current_conference)
self.test_class = ClassFactory(b_conference=self.current_conference,
e_conference=self.current_conference,
accepted=3,
teacher=self.teacher,
submitted=True)
self.url = reverse(
self.view_name,
args=[self.current_conference.conference_slug],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def test_change_image_foreign_char(self):
ProfileFactory(user_object__username="******")
pic_filename = open("tests/gbe/gbe_pagebanner.png", 'rb')
login_as(self.profile, self)
new_name = "Bitsy Brûlée"
url = reverse(self.view_name,
urlconf="gbe.urls",
args=[self.business.pk])
data = {
'name': new_name,
'website': 'foo.bar.com/~quux',
'description': 'stuff about business',
'physical_address': "the place where you live",
'publish_physical_address': True,
'upload_img': pic_filename
}
response = self.client.post(url, data, follow=True)
business_reloaded = Business.objects.get(pk=self.business.pk)
self.assertEqual(str(business_reloaded.img), "gbe_pagebanner.png")
def test_export_badge_report_inactive_user(self):
'''loads with the default conference selection.
'''
inactive = ProfileFactory(
display_name="DON'T SEE THIS",
user_object__is_active=False
)
ticket_context = PurchasedTicketContext(profile=inactive)
transaction = ticket_context.transaction
grant_privilege(self.profile, 'Registrar')
login_as(self.profile, self)
response = self.client.get(reverse('badge_report',
urlconf='gbe.reporting.urls'))
self.assertEqual(response.status_code, 200)
self.assertIn(
transaction.purchaser.first_name,
response.content)
self.assertNotIn(
inactive.display_name,
response.content)
def test_ticket_purchase(self):
'''a ticket purchaser gets a checklist item
'''
transaction = TransactionFactory()
purchaser = ProfileFactory(
user_object=transaction.purchaser.matched_to_user)
conference = transaction.ticket_item.bpt_event.conference
ticket_condition = TicketingEligibilityConditionFactory(
tickets=[transaction.ticket_item])
context = ClassContext(
conference=transaction.ticket_item.bpt_event.conference)
context.set_interest(interested_profile=purchaser)
request = self.factory.get('reports/schedule_all?conf_slug=' +
conference.conference_slug)
login_as(self.priv_profile, self)
response = self.client.get(
self.url, data={"conf_slug": conference.conference_slug})
self.assertEqual(response.status_code, 200)
nt.assert_true(str(purchaser) in response.content,
msg="Buyer is not in the list")
nt.assert_true(str(ticket_condition.checklistitem) in response.content)
def test_review_act_load_review_all_blank_category(self):
evaluation1 = FlexibleEvaluationFactory(
evaluator=self.privileged_profile,
category=self.eval_cat,
ranking=-1)
evaluation2 = FlexibleEvaluationFactory(evaluator=ProfileFactory(),
category=self.eval_cat,
ranking=-1,
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)
self.assertContains(response, "<td></td>", 3)
reviewer_string = '<th class="rotate"><div><span>%s</span></div></th>'
self.assertContains(response,
reviewer_string % str(evaluation1.evaluator))
self.assertContains(response,
reviewer_string % str(evaluation2.evaluator))
self.assertContains(response, evaluation1.category.category, 4)
def test_valid_vendor_payment_received(self):
privileged_profile = ProfileFactory()
grant_privilege(
privileged_profile.user_object,
'Vendor Reviewers')
vendor = VendorFactory()
profile = vendor.business.owners.all().first()
tickets = setup_fees(vendor.b_conference, is_vendor=True)
vendor_params = IPN_POST_PARAMS
vendor_params["receiver_email"] = PayPalSettings.objects.first(
).business_email
vendor_params["custom"] = "%s-%d-User-%d" % (
"Vendor",
vendor.pk,
profile.user_object.pk)
cost = 0
for ticket in tickets:
cost = cost + ticket.cost
vendor_params["mc_currency"] = "USD"
vendor_params["mc_gross"] = cost
vendor_params["item_number"] = "%d %d" % (tickets[0].pk, tickets[1].pk)
ipn_obj = self.assertGotSignal(valid_ipn_received,
params=vendor_params)
self.assertTrue(Purchaser.objects.filter(
matched_to_user=profile.user_object).exists())
purchaser = Purchaser.objects.get(
matched_to_user=profile.user_object)
self.assertEqual(purchaser.first_name, ipn_obj.first_name)
transactions = Transaction.objects.filter(purchaser=purchaser)
for ticket in tickets:
self.assertTrue(transactions.filter(ticket_item=ticket).exists())
self.assertEqual(
transactions.filter(ticket_item=ticket).first().invoice,
ipn_obj.invoice)
assert_right_mail_right_addresses(
0,
1,
"Vendor Submission Occurred",
[privileged_profile.contact_email])
def setUp(self):
self.client = Client()
self.context = ActTechInfoContext()
self.show = ShowFactory(e_conference=self.context.conference)
self.sched_event = SchedEventFactory(eventitem=self.show.eventitem_ptr)
EventLabelFactory(event=self.sched_event,
text=self.context.conference.conference_slug)
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Act Coordinator')
grant_privilege(self.privileged_user, 'Act Reviewers')
self.data = {
'show': self.show.eventitem_id,
'casting': 'Regular Act',
'accepted': '2'
}
self.url = reverse(self.view_name,
args=[self.context.act.pk],
urlconf='gbe.urls')
self.regular_casting = ActCastingOptionFactory(
casting="Regular Act",
show_as_special=False,
display_header="Check Out these Performers",
display_order=1)
def test_change_image_foreign_char(self):
ProfileFactory(user_object__username="******")
pic_filename = open("tests/gbe/gbe_pagebanner.png", 'rb')
login_as(self.persona.performer_profile, self)
new_name = "Bitsy Brûlée"
url = reverse(self.view_name,
urlconf="gbe.urls",
args=[self.persona.resourceitem_id, 0])
data = {
'performer_profile': self.persona.performer_profile.pk,
'contact': self.persona.performer_profile.pk,
'name': new_name,
'homepage': self.persona.homepage,
'bio': "bio",
'experience': 1,
'awards': "many",
'upload_img': pic_filename
}
response = self.client.post(url, data, follow=True)
persona_reloaded = Persona.objects.get(pk=self.persona.pk)
self.assertEqual(str(persona_reloaded.img), "gbe_pagebanner.png")
def test_ticket_purchase_solo_profile(self):
'''a ticket purchaser gets a checklist item
'''
transaction = TransactionFactory()
purchaser = ProfileFactory(
user_object=transaction.purchaser.matched_to_user)
conference = transaction.ticket_item.ticketing_event.conference
ticket_condition = TicketingEligibilityConditionFactory(
tickets=[transaction.ticket_item])
request = self.factory.get('reports/schedule_all?conf_slug=' +
conference.conference_slug)
login_as(self.priv_profile, self)
response = self.client.get(
reverse('welcome_letter',
urlconf='gbe.reporting.urls',
args=[purchaser.pk]),
data={"conf_slug": conference.conference_slug})
self.assertEqual(response.status_code, 200)
self.assertContains(response,
str(purchaser),
msg_prefix="Buyer is not in the list")
self.assertContains(response, str(ticket_condition.checklistitem))
def test_bad_reciever(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"] = "*****@*****.**"
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(
"Email not valid: %s" % ipn_obj.receiver_email in msg.body)
self.assertTrue(reverse("admin:%s_%s_change" % (
"ipn",
"paypalipn"), args=(ipn_obj.id, )) in msg.body)
def test_reduced_login_first_get(self):
for priv, roles in role_option_privs.items():
limited_profile = ProfileFactory()
grant_privilege(limited_profile.user_object, priv)
login_as(limited_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)
n = 0
for role in sorted(roles):
self.assert_checkbox(response,
"roles",
n,
role,
role,
checked=False)
n = n + 1
self.assertNotContains(response, "Email Everyone")
def test_review_volunteer_as_coordinator(self):
''' volunteer coordinators get special privileges'''
coord_profile = ProfileFactory()
grant_privilege(coord_profile, 'Volunteer Reviewers')
grant_privilege(coord_profile, 'Volunteer Coordinator')
login_as(coord_profile, 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(
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)
nt.assert_true("Assign" in response.content)
nt.assert_true("Edit" in response.content)
def test_view_volunteers(self):
this_class = ClassFactory.create(accepted=3,
e_conference=self.conf,
b_conference=self.conf)
staff_context = StaffAreaContext(conference=self.conf)
opportunity = staff_context.add_volunteer_opp()
opportunity.starttime = datetime.now() + timedelta(days=1)
opportunity.save()
login_as(ProfileFactory(), self)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=["Volunteer"])
response = self.client.get(
url, data={"conference": self.conf.conference_slug})
vol_link = reverse('set_volunteer',
args=[opportunity.pk, 'on'],
urlconf='gbe.scheduling.urls')
self.assertContains(response, opportunity.eventitem.e_title)
self.assertContains(response, vol_link)
self.assertContains(response,
'volunteered.gif" class="volunteer-icon"')
self.assertNotContains(response, this_class.e_title)
self.assertNotContains(response, 'fa-star')
self.assertNotContains(response, 'fa-star-o')
def test_get_transaction_user_by_id(self, m_urlopen):
'''
get a transaction for a real user with transaction id match
'''
BrownPaperEvents.objects.all().delete()
BrownPaperSettings.objects.all().delete()
event = BrownPaperEventsFactory()
ticket = TicketItemFactory(bpt_event=event,
ticket_id='%s-%s' %
(event.bpt_event_id, '3255985'))
BrownPaperSettingsFactory()
profile = ProfileFactory(purchase_email='*****@*****.**')
a = Mock()
order_filename = open("tests/ticketing/orderlist.xml", 'r')
a.read.side_effect = [
File(order_filename).read().replace(
'tracker12345', 'ID-' + str(profile.user_object.pk))
]
m_urlopen.return_value = a
nt.assert_equal(process_bpt_order_list(), 1)
transaction = get_object_or_404(Transaction, reference='A12345678')
nt.assert_equal(str(transaction.order_date),
"2014-08-16 00:26:56+00:00")
nt.assert_equal(transaction.shipping_method, 'Will Call')
nt.assert_equal(transaction.order_notes, 'None')
nt.assert_equal(transaction.payment_source, 'Brown Paper Tickets')
nt.assert_equal(transaction.purchaser.email, '*****@*****.**')
nt.assert_equal(transaction.purchaser.phone, '111-222-3333')
nt.assert_equal(transaction.purchaser.matched_to_user,
profile.user_object)
nt.assert_equal(transaction.purchaser.first_name, 'John')
nt.assert_equal(transaction.purchaser.last_name, 'Smith')
profile.user_object.delete()
def test_post_form_valid_make_new_allocation(self):
context = StaffAreaContext()
volunteer_opp = context.add_volunteer_opp()
allocations = volunteer_opp.resources_allocated.all()
volunteer = ProfileFactory()
url = reverse(
self.view_name,
args=[context.conference.conference_slug, volunteer_opp.pk],
urlconf="gbe.scheduling.urls")
data = self.get_create_data()
data['worker'] = volunteer.pk,
login_as(self.privileged_profile, self)
response = self.client.post(url, data=data, follow=True)
alloc = volunteer_opp.resources_allocated.all().order_by(
'pk').reverse().first()
self.assertIsNotNone(alloc)
self.assert_good_post(response,
volunteer_opp,
volunteer,
alloc,
'Do these notes work?',
allocations=3)
def test_get_vendor(self):
inactive = ProfileFactory(user_object__is_active=False)
vendor = VendorFactory(business__owners=[inactive])
response = self.client.get('/admin/gbe/vendor/', follow=True)
self.assertContains(response, str(inactive))
self.assertContains(response, vendor.business.name)
def setUp(self):
self.ticketingcondition = TicketingEligibilityConditionFactory()
self.transaction = TransactionFactory()
self.purchaser = ProfileFactory(
user_object=self.transaction.purchaser.matched_to_user)
self.conference = self.transaction.ticket_item.bpt_event.conference
def setUp(self):
self.client = Client()
self.performer = PersonaFactory()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Registrar')
def setUp(self):
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Registrar')
self.deleted_profile = ProfileFactory()
def set_eval_answerer(self, eval_profile=None):
eval_profile = eval_profile or ProfileFactory()
answer = EventEvalGradeFactory(profile=eval_profile,
event=self.sched_event)
return eval_profile
def test_interest_not_visible_without_permission(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 403)
def setUp(self):
self.client = Client()
# Conference Setup
self.factory = RequestFactory()
self.current_conf = ConferenceFactory(accepting_bids=True,
status='upcoming')
self.previous_conf = ConferenceFactory(accepting_bids=False,
status='completed')
# User/Human setup
self.profile = ProfileFactory()
self.performer = PersonaFactory(performer_profile=self.profile,
contact=self.profile)
# Bid types previous and current
self.current_act = ActFactory(performer=self.performer,
submitted=True,
b_conference=self.current_conf)
self.previous_act = ActFactory(performer=self.performer,
submitted=True,
b_conference=self.previous_conf)
self.current_class = ClassFactory(teacher=self.performer,
submitted=True,
accepted=3,
b_conference=self.current_conf,
e_conference=self.current_conf)
self.previous_class = ClassFactory(teacher=self.performer,
submitted=True,
accepted=3,
b_conference=self.previous_conf,
e_conference=self.previous_conf)
self.current_vendor = VendorFactory(profile=self.profile,
submitted=True,
b_conference=self.current_conf)
self.previous_vendor = VendorFactory(profile=self.profile,
submitted=True,
b_conference=self.previous_conf)
self.current_costume = CostumeFactory(profile=self.profile,
submitted=True,
b_conference=self.current_conf)
self.previous_costume = CostumeFactory(profile=self.profile,
submitted=True,
b_conference=self.previous_conf)
self.current_volunteer = VolunteerFactory(
profile=self.profile,
submitted=True,
b_conference=self.current_conf)
self.previous_volunteer = VolunteerFactory(
profile=self.profile,
submitted=True,
b_conference=self.previous_conf)
# Event assignments, previous and current
current_opportunity = GenericEventFactory(
e_conference=self.current_conf, type='Volunteer')
previous_opportunity = GenericEventFactory(
e_conference=self.previous_conf)
self.current_sched = SchedEventFactory(eventitem=current_opportunity,
starttime=datetime(
2016, 2, 5, 12, 30, 0, 0,
pytz.utc),
max_volunteer=10)
self.previous_sched = SchedEventFactory(eventitem=previous_opportunity,
starttime=datetime(
2015, 2, 25, 12, 30, 0, 0,
pytz.utc),
max_volunteer=10)
self.current_class_sched = SchedEventFactory(
eventitem=self.current_class,
starttime=datetime(2016, 2, 5, 2, 30, 0, 0, pytz.utc),
max_volunteer=10)
self.previous_class_sched = SchedEventFactory(
eventitem=self.previous_class,
starttime=datetime(2015, 2, 25, 2, 30, 0, 0, pytz.utc),
max_volunteer=10)
worker = WorkerFactory(_item=self.profile, role='Volunteer')
for schedule_item in [self.current_sched, self.previous_sched]:
volunteer_assignment = ResourceAllocationFactory(
event=schedule_item, resource=worker)
LabelFactory(text="label %d" % volunteer_assignment.pk,
allocation=volunteer_assignment)
persona_worker = WorkerFactory(_item=self.performer, role='Teacher')
for schedule_item in [
self.current_class_sched, self.previous_class_sched
]:
volunteer_assignment = ResourceAllocationFactory(
event=schedule_item, resource=worker)
def test_get_business(self):
inactive = ProfileFactory(user_object__is_active=False)
business = BusinessFactory(owners=[inactive])
response = self.client.get('/admin/gbe/business/', follow=True)
self.assertContains(response, str(inactive))
def test_no_priv(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 403)
def setUp(self):
self.client = Client()
self.privileged_user = ProfileFactory.create().\
user_object
grant_privilege(self.privileged_user, 'Ticketing - Admin')
self.url = reverse(self.view_name, urlconf='ticketing.urls')
