def schedule_instance(self, starttime=None, room=None, teacher=None):
room = room or self.room
teacher = teacher or self.teacher
if starttime:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr,
starttime=starttime)
elif self.sched_event:
one_day = timedelta(1)
sched_event = SchedEventFactory(
eventitem=self.bid.eventitem_ptr,
starttime=self.sched_event.starttime + one_day)
else:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr,
starttime=noon(self.days[0]))
ResourceAllocationFactory(
event=sched_event,
resource=LocationFactory(_item=room.locationitem_ptr))
ResourceAllocationFactory(event=sched_event,
resource=WorkerFactory(
_item=teacher.workeritem_ptr,
role='Teacher'))
EventLabelFactory(event=sched_event,
text=self.conference.conference_slug)
EventLabelFactory(event=sched_event, text="Conference")
return sched_event
def test_no_schedule(self):
Conference.objects.all().delete()
show = ShowFactory()
SchedEventFactory.create(eventitem=show.eventitem_ptr)
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertTrue(response.content.count('\n') == 1)
self.assertTrue('Session Title' in response.content)
def test_no_schedule(self):
Conference.objects.all().delete()
show = ShowFactory()
SchedEventFactory.create(eventitem=show.eventitem_ptr)
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertTrue(response.content.count('\n') == 1)
self.assertTrue('Session Title' in response.content)
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(_item=workeritem, role=role)
if eventitem:
event = SchedEventFactory.create(eventitem=eventitem)
else:
event = SchedEventFactory.create()
booking = ResourceAllocationFactory.create(event=event, resource=worker)
return booking
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(_item=workeritem, role=role)
if eventitem:
event = SchedEventFactory.create(eventitem=eventitem)
else:
event = SchedEventFactory.create()
EventLabelFactory(event=event,
text=event.eventitem.e_conference.conference_slug)
EventLabelFactory(event=event, text=event.eventitem.calendar_type)
booking = ResourceAllocationFactory.create(event=event, resource=worker)
return booking
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(
_item=workeritem,
role=role)
if eventitem:
event = SchedEventFactory.create(
eventitem=eventitem)
else:
event = SchedEventFactory.create()
booking = ResourceAllocationFactory.create(
event=event,
resource=worker
)
return booking
def schedule_instance(self, starttime=None, room=None):
room = room or self.room
if starttime:
sched_event = SchedEventFactory(eventitem=self.show.eventitem_ptr,
starttime=starttime)
else:
sched_event = SchedEventFactory(eventitem=self.show.eventitem_ptr,
starttime=noon(self.days[0]))
EventLabelFactory(event=sched_event,
text=self.conference.conference_slug)
EventLabelFactory(event=sched_event, text="General")
ResourceAllocationFactory(
event=sched_event,
resource=LocationFactory(_item=room.locationitem_ptr))
return sched_event
def book_act_item_for_show(actitem, eventitem):
booking = ResourceAllocationFactory.create(
event=SchedEventFactory.create(
eventitem=eventitem),
resource=ActResourceFactory.create(
_item=actitem))
return booking
def add_volunteer_opp(self, volunteer_sched_event=None, room=None):
if not self.conference.conferenceday_set.exists():
if volunteer_sched_event:
self.conf_day = ConferenceDayFactory(
day=volunteer_sched_event.starttime.date(),
conference=self.conference)
else:
self.conf_day = ConferenceDayFactory(
conference=self.conference)
else:
self.conf_day = self.conference.conferenceday_set.first()
if not volunteer_sched_event:
vol_event = GenericEventFactory(e_conference=self.conference,
type="Volunteer")
volunteer_sched_event = SchedEventFactory(
eventitem=vol_event,
max_volunteer=self.area.default_volunteers,
starttime=noon(self.conf_day))
if not room:
room = RoomFactory()
ResourceAllocationFactory(event=volunteer_sched_event,
resource=LocationFactory(_item=room))
EventLabelFactory(event=volunteer_sched_event, text=self.area.slug)
EventLabelFactory(event=volunteer_sched_event,
text=self.conference.conference_slug)
EventLabelFactory(event=volunteer_sched_event, text="Volunteer")
return volunteer_sched_event
def test_no_rehearsal_in_events(self):
'''no rehearsal data shows up'''
# horrible setup process. Need to fix
data = self.set_basic_opportunity()
rehearsal = GenericEventFactory(
e_conference=data['context'].conference, type="Rehearsal Slot")
rehearsal_slot = SchedEventFactory(eventitem=rehearsal,
starttime=datetime(
2016, 2, 6, 13, 0, 0, 0,
pytz.utc),
max_volunteer=10)
EventLabelFactory(event=rehearsal_slot,
text=data['context'].conference.conference_slug)
volunteer = VolunteerFactory(b_conference=data['context'].conference,
submitted=True)
url = reverse(self.view_name, args=[volunteer.pk], urlconf="gbe.urls")
login_as(self.privileged_user, self)
response = self.client.get(url)
nt.assert_not_in(str(rehearsal),
response.content,
msg="Event Title for rehearsal should not show up")
nt.assert_not_in(date_format(rehearsal_slot.starttime,
"SHORT_DATETIME_FORMAT"),
response.content,
msg="end time for rehearsal shouldn't show up")
def book_act_item_for_show(actitem, eventitem):
booking = ResourceAllocationFactory.create(
event=SchedEventFactory.create(eventitem=eventitem),
resource=ActResourceFactory.create(_item=actitem))
EventLabelFactory(event=booking.event,
text=eventitem.e_conference.conference_slug)
EventLabelFactory(event=booking.event, text=eventitem.calendar_type)
return booking
def setUp(self):
self.client = Client()
self.context = ActTechInfoContext()
self.show = ShowFactory()
self.sched_event = SchedEventFactory(eventitem=self.show.eventitem_ptr)
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.pk, 'casting': '', 'accepted': '2'}
def __init__(self,
performer=None,
act=None,
show=None,
sched_event=None,
conference=None,
room_name=None,
schedule_rehearsal=False,
act_role="Regular Act",
set_waitlist=False):
if conference:
self.show = show or ShowFactory(e_conference=conference)
else:
self.show = show or ShowFactory()
self.conference = conference or self.show.e_conference
self.performer = performer or PersonaFactory()
self.act = act or ActFactory(performer=self.performer,
b_conference=self.conference,
accepted=3,
submitted=True)
role = "Performer"
if set_waitlist:
self.act.accepted = 2
self.act.save()
act_role = "Waitlisted"
role = "Waitlisted"
self.tech = self.act.tech
# schedule the show
if sched_event:
self.sched_event = sched_event
else:
self.sched_event = SchedEventFactory(
eventitem=self.show.eventitem_ptr)
EventLabelFactory(event=self.sched_event,
text=self.conference.conference_slug)
room_name = room_name or "Dining Room"
self.room = RoomFactory(name=room_name)
self.room.conferences.add(self.conference)
if not sched_event:
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room.locationitem_ptr))
# schedule the act into the show
self.booking = ResourceAllocationFactory(event=self.sched_event,
resource=WorkerFactory(
_item=self.act.performer,
role=role))
self.order = OrderingFactory(allocation=self.booking,
class_id=self.act.pk,
class_name="Act",
role=act_role)
if schedule_rehearsal:
self.rehearsal = self._schedule_rehearsal(self.sched_event,
self.act)
def __init__(self,
profile=None,
bid=None,
event=None,
opportunity=None,
role=None):
if not event:
self.window = VolunteerWindowFactory()
self.conference = self.window.day.conference
else:
self.conference = event.e_conference
if not VolunteerWindow.objects.filter(
day__conference=self.conference).exists():
self.window = VolunteerWindowFactory(
day__conference=self.conference)
else:
self.window = VolunteerWindow.objects.all().first()
self.conf_day = self.window.day
self.profile = profile or ProfileFactory()
if not hasattr(self.profile, 'preferences'):
ProfilePreferencesFactory(profile=self.profile)
if bid is False:
self.bid = None
elif bid:
self.bid = bid
self.profile = self.bid.profile
else:
self.bid = VolunteerFactory(
b_conference=self.conference,
profile=self.profile)
self.interest = VolunteerInterestFactory(
volunteer=self.bid)
self.event = event or ShowFactory(
e_conference=self.conference)
self.role = role or "Volunteer"
self.room = RoomFactory()
self.sched_event = SchedEventFactory(
eventitem=self.event.eventitem_ptr,
starttime=datetime.combine(self.window.day.day,
self.window.start))
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room))
EventLabelFactory(event=self.sched_event,
text="General")
EventLabelFactory(event=self.sched_event,
text=self.conference.conference_slug)
self.worker = WorkerFactory(_item=self.profile.workeritem,
role=self.role)
self.opportunity, self.opp_event = self.add_opportunity(opportunity)
self.allocation = ResourceAllocationFactory(resource=self.worker,
event=self.opp_event)
def book_act_item_for_show(actitem, eventitem):
booking = ResourceAllocationFactory.create(
event=SchedEventFactory.create(eventitem=eventitem),
resource=WorkerFactory.create(_item=actitem.performer,
role="Performer"))
order = OrderingFactory(allocation=booking,
class_id=actitem.pk,
class_name="Act")
EventLabelFactory(event=booking.event,
text=eventitem.e_conference.conference_slug)
EventLabelFactory(event=booking.event, text=eventitem.calendar_type)
return booking
def schedule_instance(self, starttime=None, room=None, moderator=None):
room = room or self.room
moderator = moderator or self.moderator
if starttime:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr,
starttime=starttime)
elif self.sched_event:
one_day = timedelta(1)
sched_event = SchedEventFactory(
eventitem=self.bid.eventitem_ptr,
starttime=self.sched_event.starttime + one_day)
else:
sched_event = SchedEventFactory(eventitem=self.bid.eventitem_ptr)
ResourceAllocationFactory(
event=sched_event,
resource=LocationFactory(_item=room.locationitem_ptr))
ResourceAllocationFactory(event=sched_event,
resource=WorkerFactory(
_item=moderator.workeritem_ptr,
role='Moderator'))
return sched_event
def book_worker_item_for_role(workeritem, role, eventitem=None):
worker = WorkerFactory.create(
_item=workeritem,
role=role)
if eventitem:
event = SchedEventFactory.create(
eventitem=eventitem)
else:
event = SchedEventFactory.create()
EventLabelFactory(
event=event,
text=event.eventitem.e_conference.conference_slug
)
EventLabelFactory(
event=event,
text=event.eventitem.calendar_type
)
booking = ResourceAllocationFactory.create(
event=event,
resource=worker
)
return booking
def test_act_changestate_book_act_with_conflict(self):
grant_privilege(self.privileged_user, 'Act Reviewers')
conflict = SchedEventFactory(
starttime=self.context.sched_event.starttime)
ResourceAllocationFactory(
event=conflict,
resource=WorkerFactory(
_item=self.context.performer.performer_profile))
url = reverse(self.view_name,
args=[self.context.act.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data, follow=True)
self.assertContains(response, "is booked for")
def book_act_item_for_show(actitem, eventitem):
booking = ResourceAllocationFactory.create(
event=SchedEventFactory.create(
eventitem=eventitem),
resource=ActResourceFactory.create(
_item=actitem))
EventLabelFactory(
event=booking.event,
text=eventitem.e_conference.conference_slug
)
EventLabelFactory(
event=booking.event,
text=eventitem.calendar_type
)
return booking
def _create_scheduled_show_with_acts(conference=None, qty=6):
if not conference:
conference = ConferenceFactory()
conf_day = ConferenceDayFactory(conference=conference)
show = ShowFactory(e_conference=conference)
sEvent = SchedEventFactory(eventitem=show.eventitem_ptr,
starttime=utc.localize(
datetime.combine(conf_day.day, time(20,
0))))
acts = [ActFactory(accepted=3) for i in range(qty)]
for act in acts:
ar = ActResourceFactory(_item=act.actitem_ptr)
ResourceAllocationFactory(event=sEvent, resource=ar)
return show, sEvent, acts
def make_rehearsal(self, room=True):
rehearsal = GenericEventFactory(e_conference=self.conference,
type='Rehearsal Slot')
start_time = datetime.combine(self.days[0].day,
(self.sched_event.start_time -
timedelta(hours=4)).time())
slot = SchedEventFactory(eventitem=rehearsal.eventitem_ptr,
starttime=start_time,
max_volunteer=10)
if room:
ResourceAllocationFactory(
event=slot, resource=LocationFactory(_item=self.room))
EventContainerFactory(parent_event=self.sched_event, child_event=slot)
EventLabelFactory(event=slot, text=self.conference.conference_slug)
return rehearsal, slot
def _schedule_rehearsal(self, s_event, act=None):
rehearsal = GenericEventFactory(type="Rehearsal Slot",
e_conference=self.conference)
rehearsal_event = SchedEventFactory(
eventitem=rehearsal.eventitem_ptr,
max_volunteer=10,
starttime=self.sched_event.starttime)
event_container = EventContainerFactory(child_event=rehearsal_event,
parent_event=s_event)
EventLabelFactory(event=rehearsal_event,
text=self.conference.conference_slug)
if act:
ResourceAllocationFactory(
resource=ActResourceFactory(_item=act.actitem_ptr),
event=rehearsal_event)
return rehearsal_event
def test_repeated_lead_shows_once(self):
show = ShowFactory()
sched_events = [
SchedEventFactory.create(eventitem=show.eventitem_ptr)
for i in range(2)
]
staff_lead = ProfileFactory()
lead_worker = WorkerFactory(_item=staff_lead.workeritem_ptr,
role="Staff Lead")
for se in sched_events:
ResourceAllocationFactory.create(event=se, resource=lead_worker)
response = self.client.get(
reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[show.eventitem_id]))
self.assertEqual(200, response.status_code)
self.assertEqual(1, response.content.count(staff_lead.display_name))
def add_opportunity(self, opportunity=None, start_time=None):
opportunity = opportunity or GenericEventFactory(
e_conference=self.conference, type='Volunteer')
start_time = start_time or datetime.combine(self.conf_day.day,
time(12, 0, 0))
opp_event = SchedEventFactory(eventitem=opportunity.eventitem_ptr,
starttime=start_time,
max_volunteer=2)
ResourceAllocationFactory(event=opp_event,
resource=LocationFactory(_item=self.room))
EventContainerFactory(parent_event=self.sched_event,
child_event=opp_event)
EventLabelFactory(event=opp_event,
text=self.conference.conference_slug)
EventLabelFactory(event=opp_event, text="Volunteer")
return opportunity, opp_event
def __init__(self,
profile=None,
event=None,
sched_event=None,
opportunity=None,
role=None,
conference=None):
if not event:
self.conference = conference or ConferenceFactory()
else:
self.conference = event.e_conference
if ConferenceDay.objects.filter(conference=self.conference).exists():
self.conf_day = ConferenceDay.objects.filter(
conference=self.conference).first()
else:
self.conf_day = ConferenceDayFactory(conference=self.conference)
self.profile = profile or ProfileFactory()
if not hasattr(self.profile, 'preferences'):
ProfilePreferencesFactory(profile=self.profile)
self.role = role or "Volunteer"
self.room = RoomFactory()
self.room.conferences.add(self.conference)
self.event = event or ShowFactory(e_conference=self.conference)
if not sched_event:
self.sched_event = SchedEventFactory(
eventitem=self.event.eventitem_ptr,
starttime=datetime.combine(self.conf_day.day, time(12, 0, 0)))
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room))
EventLabelFactory(event=self.sched_event, text="General")
EventLabelFactory(event=self.sched_event,
text=self.conference.conference_slug)
else:
self.sched_event = sched_event
self.worker = WorkerFactory(_item=self.profile.workeritem,
role=self.role)
self.opportunity, self.opp_event = self.add_opportunity(opportunity)
self.allocation = ResourceAllocationFactory(resource=self.worker,
event=self.opp_event)
def test_act_changestate_book_act_with_conflict(self):
# accepted -> waitlist (#2, see above)
# change show, change role
EmailTemplateSenderFactory(from_email="*****@*****.**",
template__name='act wait list',
template__subject="test template")
grant_privilege(self.privileged_user, 'Act Reviewers')
conflict = SchedEventFactory(
starttime=self.context.sched_event.starttime)
EventLabelFactory(event=conflict,
text=self.context.conference.conference_slug)
ResourceAllocationFactory(
event=conflict,
resource=WorkerFactory(
_item=self.context.performer.performer_profile))
login_as(self.privileged_user, self)
response = self.client.post(self.url, data=self.data, follow=True)
self.assertContains(response,
"Conflicting booking: %s" % str(conflict))
assert_email_template_used("test template", "*****@*****.**")
def test_booking_is_good(self):
# horrible setup process. Need to fix
data = self.set_basic_opportunity()
booked_sched = SchedEventFactory(
eventitem=data['current_sched'].eventitem,
starttime=datetime(2016, 2, 6, 9, 0, 0, 0, pytz.utc),
max_volunteer=1)
data['context'].book_volunteer(booked_sched,
volunteer=data['volunteer'].profile)
EventLabelFactory(event=booked_sched,
text=data['context'].conference.conference_slug)
EventLabelFactory(event=booked_sched, text="Volunteer")
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_in(date_format(booked_sched.start_time,
"SHORT_DATETIME_FORMAT"),
response.content,
msg="start time for booked_sched didn't show up")
nt.assert_in(date_format(booked_sched.end_time,
"SHORT_DATETIME_FORMAT"),
response.content,
msg="end time for booked_sched didn't show up")
nt.assert_is_not_none(re.search(
'''<td class="bid-table">\s+Y\s+</td>''', response.content),
msg="The booked event should show as full")
# using \ to make sure the formatting of the reg ex is correct.
checked_box = '''<input id="id_events_\d"\s+name="events"\s''' + \
'''type="checkbox" value="''' + str(booked_sched.pk) + \
'''"\s+checked="checked"/>'''
nt.assert_is_not_none(
re.search(checked_box, response.content),
msg="The booked event should appear as checked in form")
def _schedule_rehearsal(self, s_event, act=None):
rehearsal = GenericEventFactory(type="Rehearsal Slot",
e_conference=self.conference)
rehearsal_event = SchedEventFactory(
eventitem=rehearsal.eventitem_ptr,
max_commitments=10,
starttime=self.sched_event.starttime)
event_container = EventContainerFactory(child_event=rehearsal_event,
parent_event=s_event)
EventLabelFactory(event=rehearsal_event,
text=self.conference.conference_slug)
if act:
booking = ResourceAllocationFactory(event=rehearsal_event,
resource=WorkerFactory(
_item=act.performer,
role="Performer"))
OrderingFactory(allocation=booking,
class_id=act.pk,
class_name="Act")
return rehearsal_event
def __init__(self,
performer=None,
act=None,
show=None,
sched_event=None,
conference=None,
room_name=None,
cue_count=1,
schedule_rehearsal=False,
act_role=""):
self.show = show or ShowFactory()
self.conference = conference or self.show.e_conference
self.performer = performer or PersonaFactory()
self.act = act or ActFactory(performer=self.performer,
b_conference=self.conference,
accepted=3,
submitted=True)
self.tech = self.act.tech
self.audio = self.tech.audio
self.lighting = self.tech.lighting
self.stage = self.tech.stage
for i in range(cue_count):
CueInfoFactory.create(techinfo=self.tech, cue_sequence=i)
# schedule the show
self.sched_event = sched_event or SchedEventFactory(
eventitem=self.show.eventitem_ptr)
room_name = room_name or "Dining Room"
self.room = RoomFactory(name=room_name)
if not sched_event:
ResourceAllocationFactory(
event=self.sched_event,
resource=LocationFactory(_item=self.room.locationitem_ptr))
# schedule the act into the show
ResourceAllocationFactory(event=self.sched_event,
resource=ActResourceFactory(
_item=self.act.actitem_ptr,
role=act_role))
if schedule_rehearsal:
self.rehearsal = self._schedule_rehearsal(self.sched_event,
self.act)
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 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_assign_volunteer_show_unavailable_event(self):
'''test how event shows when volunteer not available'''
data = self.set_basic_opportunity()
unavail_sched = SchedEventFactory(
eventitem=data['current_sched'].eventitem,
starttime=datetime(2016, 2, 7, 12, 0, 0, 0, pytz.utc),
max_volunteer=10)
EventLabelFactory(event=unavail_sched,
text=data['context'].conference.conference_slug)
EventLabelFactory(event=unavail_sched, text="Volunteer")
unavail_window = VolunteerWindowFactory(
day__conference=data['context'].conference,
day__day=date(2016, 2, 7),
start=time(11),
end=time(15))
volunteer = VolunteerFactory(b_conference=data['context'].conference,
submitted=True)
VolunteerInterestFactory(volunteer=data['volunteer'])
data['volunteer'].unavailable_windows.add(unavail_window)
data['volunteer'].save()
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_equal(response.status_code, 200)
nt.assert_true('Assign Volunteer to Opportunities' in response.content)
# event names
nt.assert_equal(
response.content.count(str(data['current_sched'].eventitem)),
2,
msg="There should be 2 schedule items for current_sched.eventitem")
nt.assert_in(date_format(unavail_sched.start_time,
"SHORT_DATETIME_FORMAT"),
response.content,
msg="start time for unavail_sched didn't show up")
nt.assert_in(date_format(unavail_sched.end_time, "TIME_FORMAT"),
response.content,
msg="end time for unavail_sched didn't show up")
nt.assert_is_not_none(
re.search(
date_format(unavail_sched.start_time, "SHORT_DATETIME_FORMAT"),
response.content),
msg="unavail_window shows with unavail_sched is not found")
nt.assert_equal(
response.content.count('''<td class="bid-table">10</td>'''),
2,
msg="unavail_sched and current_sched should have 10 volunteers")
nt.assert_true(
"Not Free<br>" in response.content,
msg="The volunteer should be not free for unavail_sched event")
nt.assert_is_not_none(
re.search('''<td class="bid-table">\s+N\s+</td>''',
response.content),
msg="The unavailable event should be not yet full")
def book_act_item_for_show(actitem, eventitem):
booking = ResourceAllocationFactory.create(
event=SchedEventFactory.create(eventitem=eventitem),
resource=ActResourceFactory.create(_item=actitem))
return booking
