def test_is_signed_up(self):
""" Uses volunteers v1,v2 and shifts s1,s2,s3 """
# test cases where not signed up yet
self.assertFalse(is_signed_up(self.v1.id, self.s1.id))
self.assertFalse(is_signed_up(self.v1.id, self.s2.id))
self.assertFalse(is_signed_up(self.v1.id, self.s3.id))
# test cases where signed up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
self.assertTrue(is_signed_up(self.v1.id, self.s1.id))
self.assertTrue(is_signed_up(self.v1.id, self.s2.id))
self.assertTrue(is_signed_up(self.v1.id, self.s3.id))
# test case where more than one volunteer signs up for the same shift
self.assertFalse(is_signed_up(self.v2.id, self.s1.id))
self.assertFalse(is_signed_up(self.v2.id, self.s2.id))
self.assertFalse(is_signed_up(self.v2.id, self.s3.id))
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
self.assertFalse(is_signed_up(self.v2.id, self.s1.id))
self.assertTrue(is_signed_up(self.v2.id, self.s2.id))
self.assertTrue(is_signed_up(self.v2.id, self.s3.id))
def test_generate_report(self):
""" Uses shifts s1, s2 and volunteer v1
Tests test_generate_report(volunteer_shift_list) """
# register will return an exception on error
# (such as when invalid parameters are passed)
# if an exception does get raised, this test will automatically fail
register(self.v1.id, self.s1.id)
volunteer_shift_1 = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNotNone(volunteer_shift_1)
register(self.v1.id, self.s2.id)
volunteer_shift_2 = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
)
self.assertIsNotNone(volunteer_shift_2)
volunteer_shift_list = [
volunteer_shift_1,
volunteer_shift_2
]
reports = generate_report(volunteer_shift_list)
self.assertEqual(len(reports), 2)
self.assertIsNotNone(reports)
def test_get_volunteer_report(self):
# register volunteer for 2 shifts, log hours for one
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s3.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift_list_1 = get_volunteer_shifts(self.v1.id, self.e1.name,
self.j1.name,
"2012-10-22",
"2012-10-30")
report_1 = generate_report(volunteer_shift_list_1)
volunteer_shift_list_2 = get_volunteer_shifts(self.v1.id, self.e1.name,
self.j2.name, "2012-9-1",
"2012-10-26")
report_2 = generate_report(volunteer_shift_list_2)
# verify that report for logged shift appears
self.assertEqual(len(report_1), 1)
self.assertEqual(len(report_2), 0)
self.assertEqual(self.e1.name, report_1[0]["event_name"])
self.assertEqual(self.j1.name, report_1[0]["job_name"])
def test_get_administrator_report(self):
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s3.id)
start_time = datetime.time(hour=11, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
add_shift_hours(self.v2.id, self.s3.id, start_time, end_time)
report_1 = get_administrator_report(self.v1.first_name, "", "",
self.e1.name, self.j1.name,
"2012-10-22", "2012-10-30")
report_2 = get_administrator_report(self.v1.first_name, "", "",
self.e1.name, self.j2.name,
"2012-9-1", "2012-10-26")
report_3 = get_administrator_report("", "", "", self.e1.name,
self.j2.name, "", "")
# verify that report for logged shift appears
self.assertEqual(len(report_1), 1)
self.assertEqual(len(report_2), 0)
self.assertEqual(len(report_3), 1)
self.assertEqual(self.v1.first_name, report_1[0]["first_name"])
self.assertEqual(self.v2.first_name, report_3[0]["first_name"])
def test_generate_report(self):
""" Uses shifts s1, s2 and volunteer v1
Tests test_generate_report(volunteer_shift_list) """
# register will return an exception on error
# (such as when invalid parameters are passed)
# if an exception does get raised, this test will automatically fail
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
register(self.v1.id, self.s1.id)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift_1 = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNotNone(volunteer_shift_1)
register(self.v1.id, self.s2.id)
add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
volunteer_shift_2 = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id)
self.assertIsNotNone(volunteer_shift_2)
volunteer_shift_list = [volunteer_shift_1, volunteer_shift_2]
reports = generate_report(volunteer_shift_list)
self.assertEqual(len(reports), 2)
self.assertIsNotNone(reports)
def test_get_signed_up_jobs_for_volunteer(self):
""" Uses jobs j1,j3, shifts s1,s2,s3 and volunteers v1,v2"""
# volunteer 1 registers for 3 shifts belonging to two jobs - registers for s1 first to check if sorting is successful
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s3.id)
register(self.v1.id, self.s2.id)
# volunteer 2 registers for 2 shifts, where s1 has no available slots
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s3.id)
job_list_for_vol_1 = get_signed_up_jobs_for_volunteer(self.v1.id)
job_list_for_vol_2 = get_signed_up_jobs_for_volunteer(self.v2.id)
job_list_for_vol_3 = get_signed_up_jobs_for_volunteer(self.v3.id)
# tests for returned jobs, their order and duplication for volunteer 1
self.assertEqual(len(job_list_for_vol_1), 2)
self.assertIn(self.j1.name, job_list_for_vol_1)
self.assertIn(self.j3.name, job_list_for_vol_1)
self.assertEqual(job_list_for_vol_1[0], self.j3.name)
self.assertEqual(job_list_for_vol_1[1], self.j1.name)
# tests for returned jobs for volunteer 2
self.assertEqual(len(job_list_for_vol_2), 1)
self.assertIn(self.j3.name, job_list_for_vol_2)
self.assertNotIn(self.j1.name, job_list_for_vol_2)
# test for returned jobs for unregistered volunteer 3
self.assertEqual(len(job_list_for_vol_3), 0)
def test_get_volunteers_by_shift_id(self):
""" Uses volunteers v1,v2,v3 and shifts s1,s2,s3 """
# sign up
register(self.v3.id, self.s1.id)
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s3.id)
register(self.v3.id, self.s3.id)
register(self.v2.id, self.s3.id)
# get volunteer lists
volunteer_list_for_shift_1 = get_volunteers_by_shift_id(self.s1.id)
volunteer_list_for_shift_2 = get_volunteers_by_shift_id(self.s2.id)
volunteer_list_for_shift_3 = get_volunteers_by_shift_id(self.s3.id)
# test typical case
self.assertEqual(len(volunteer_list_for_shift_1), 1)
self.assertEqual(len(volunteer_list_for_shift_2), 0)
self.assertEqual(len(volunteer_list_for_shift_3), 3)
self.assertIn(self.v3, volunteer_list_for_shift_1)
self.assertNotIn(self.v1, volunteer_list_for_shift_1)
self.assertIn(self.v1, volunteer_list_for_shift_3)
self.assertIn(self.v2, volunteer_list_for_shift_3)
self.assertIn(self.v3, volunteer_list_for_shift_3)
#test order
self.assertEqual(volunteer_list_for_shift_3[0], self.v3)
self.assertEqual(volunteer_list_for_shift_3[1], self.v2)
self.assertEqual(volunteer_list_for_shift_3[2], self.v1)
def test_is_signed_up(self):
""" Uses volunteers v1,v2 and shifts s1,s2,s3 """
# test cases where not signed up yet
self.assertFalse(is_signed_up(self.v1.id, self.s1.id))
self.assertFalse(is_signed_up(self.v1.id, self.s2.id))
self.assertFalse(is_signed_up(self.v1.id, self.s3.id))
# test cases where signed up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
self.assertTrue(is_signed_up(self.v1.id, self.s1.id))
self.assertTrue(is_signed_up(self.v1.id, self.s2.id))
self.assertTrue(is_signed_up(self.v1.id, self.s3.id))
# test case where more than one volunteer signs up for the same shift
self.assertFalse(is_signed_up(self.v2.id, self.s1.id))
self.assertFalse(is_signed_up(self.v2.id, self.s2.id))
self.assertFalse(is_signed_up(self.v2.id, self.s3.id))
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
self.assertFalse(is_signed_up(self.v2.id, self.s1.id))
self.assertTrue(is_signed_up(self.v2.id, self.s2.id))
self.assertTrue(is_signed_up(self.v2.id, self.s3.id))
def test_get_signed_up_events_for_volunteer(self):
""" Uses events e1,e2, volunteers v1,v2,v3 and shift s1,s2,s3"""
# volunteer 1 registers for 3 shifts belonging to two events - registers for s3 first to check if sorting is successful
register(self.v1.id, self.s3.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s1.id)
# volunteer 2 registers for 2 shifts, where s1 has no available slots
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s3.id)
event_list_for_vol_1 = get_signed_up_events_for_volunteer(self.v1.id)
event_list_for_vol_2 = get_signed_up_events_for_volunteer(self.v2.id)
event_list_for_vol_3 = get_signed_up_events_for_volunteer(self.v3.id)
# tests for returned events, their order and duplication for volunteer 1
self.assertEqual(len(event_list_for_vol_1), 2)
self.assertIn(self.e1.name, event_list_for_vol_1)
self.assertIn(self.e2.name, event_list_for_vol_1)
self.assertEqual(event_list_for_vol_1[0], self.e1.name)
self.assertEqual(event_list_for_vol_1[1], self.e2.name)
# tests for returned events for volunteer 2
self.assertEqual(len(event_list_for_vol_2), 1)
self.assertIn(self.e2.name, event_list_for_vol_2)
self.assertNotIn(self.e1.name, event_list_for_vol_2)
# test for returned events for unregistered volunteer 3
self.assertEqual(len(event_list_for_vol_3), 0)
VolunteerShift.objects.all().delete()
def test_get_signed_up_events_for_volunteer(self):
""" Uses events e1,e2, volunteers v1,v2,v3 and shift s1,s2,s3"""
# volunteer 1 registers for 3 shifts belonging to two events - registers for s3 first to check if sorting is successful
register(self.v1.id, self.s3.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s1.id)
# volunteer 2 registers for 2 shifts, where s1 has no available slots
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s3.id)
event_list_for_vol_1 = get_signed_up_events_for_volunteer(self.v1.id)
event_list_for_vol_2 = get_signed_up_events_for_volunteer(self.v2.id)
event_list_for_vol_3 = get_signed_up_events_for_volunteer(self.v3.id)
# tests for returned events, their order and duplication for volunteer 1
self.assertEqual(len(event_list_for_vol_1), 2)
self.assertIn(self.e1.name, event_list_for_vol_1)
self.assertIn(self.e2.name, event_list_for_vol_1)
self.assertEqual(event_list_for_vol_1[0], self.e1.name)
self.assertEqual(event_list_for_vol_1[1], self.e2.name)
# tests for returned events for volunteer 2
self.assertEqual(len(event_list_for_vol_2), 1)
self.assertIn(self.e2.name, event_list_for_vol_2)
self.assertNotIn(self.e1.name, event_list_for_vol_2)
# test for returned events for unregistered volunteer 3
self.assertEqual(len(event_list_for_vol_3), 0)
VolunteerShift.objects.all().delete()
def test_get_volunteers_by_shift_id(self):
""" Uses volunteers v1,v2,v3 and shifts s1,s2,s3 """
# sign up
register(self.v3.id, self.s1.id)
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s3.id)
register(self.v3.id, self.s3.id)
register(self.v2.id, self.s3.id)
# get volunteer lists
volunteer_list_for_shift_1 = get_volunteers_by_shift_id(self.s1.id)
volunteer_list_for_shift_2 = get_volunteers_by_shift_id(self.s2.id)
volunteer_list_for_shift_3 = get_volunteers_by_shift_id(self.s3.id)
# test typical case
self.assertEqual(len(volunteer_list_for_shift_1), 1)
self.assertEqual(len(volunteer_list_for_shift_2), 0)
self.assertEqual(len(volunteer_list_for_shift_3), 3)
self.assertIn(self.v3, volunteer_list_for_shift_1)
self.assertNotIn(self.v1, volunteer_list_for_shift_1)
self.assertIn(self.v1, volunteer_list_for_shift_3)
self.assertIn(self.v2, volunteer_list_for_shift_3)
self.assertIn(self.v3, volunteer_list_for_shift_3)
#test order
self.assertEqual(volunteer_list_for_shift_3[0], self.v3)
self.assertEqual(volunteer_list_for_shift_3[1], self.v2)
self.assertEqual(volunteer_list_for_shift_3[2], self.v1)
def test_get_signed_up_jobs_for_volunteer(self):
""" Uses jobs j1,j3, shifts s1,s2,s3 and volunteers v1,v2"""
# volunteer 1 registers for 3 shifts belonging to two jobs - registers for s1 first to check if sorting is successful
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s3.id)
register(self.v1.id, self.s2.id)
# volunteer 2 registers for 2 shifts, where s1 has no available slots
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s3.id)
job_list_for_vol_1 = get_signed_up_jobs_for_volunteer(self.v1.id)
job_list_for_vol_2 = get_signed_up_jobs_for_volunteer(self.v2.id)
job_list_for_vol_3 = get_signed_up_jobs_for_volunteer(self.v3.id)
# tests for returned jobs, their order and duplication for volunteer 1
self.assertEqual(len(job_list_for_vol_1), 2)
self.assertIn(self.j1.name, job_list_for_vol_1)
self.assertIn(self.j3.name, job_list_for_vol_1)
self.assertEqual(job_list_for_vol_1[0], self.j3.name)
self.assertEqual(job_list_for_vol_1[1], self.j1.name)
# tests for returned jobs for volunteer 2
self.assertEqual(len(job_list_for_vol_2), 1)
self.assertIn(self.j3.name, job_list_for_vol_2)
self.assertNotIn(self.j1.name, job_list_for_vol_2)
# test for returned jobs for unregistered volunteer 3
self.assertEqual(len(job_list_for_vol_3), 0)
def test_delete_shift(self):
# Test delete_shift(shift_id)
self.assertTrue(delete_shift(self.s1.id))
self.assertFalse(delete_shift(100))
register(self.v1.id, self.s2.id)
self.assertFalse(delete_shift(self.s2.id))
def test_delete_shift(self):
# Test delete_shift(shift_id)
self.assertTrue(delete_shift(self.s1.id))
self.assertFalse(delete_shift(100))
register(self.v1.id, self.s2.id)
self.assertFalse(delete_shift(self.s2.id))
def test_get_shifts_with_open_slots_for_volunteer(self):
""" Uses volunteer v1, v2 """
register(self.v1.id, self.s2.id)
register(self.v2.id, self.s1.id)
open_slots_1 = get_shifts_with_open_slots_for_volunteer(self.j1.id, self.v1.id)
open_slots_2 = get_shifts_with_open_slots_for_volunteer(self.j2.id, self.v1.id)
self.assertIsNotNone(open_slots_1)
self.assertIsNotNone(open_slots_2)
self.assertEqual(len(open_slots_1), 0)
self.assertEqual(len(open_slots_2), 1)
self.assertEqual(self.s3.id, open_slots_2[0]["id"])
def test_remove_empty_jobs_for_volunteer(self):
""" Uses jobs j1,j2,j3,j4, shift s3 and volunteer v1 """
# volunteer registers for a shift with multiple slots
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s4.id)
job_list = [self.j1, self.j2, self.j3, self.j4]
job_list = remove_empty_jobs_for_volunteer(job_list, self.v1.id)
# Only open and non empty jobs should be left
self.assertIn(self.j1, job_list)
self.assertNotIn(self.j2, job_list)
self.assertNotIn(self.j3, job_list)
self.assertNotIn(self.j4, job_list)
def test_remove_empty_jobs_for_volunteer(self):
""" Uses jobs j1,j2,j3,j4, shift s3 and volunteer v1 """
# volunteer registers for a shift with multiple slots
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s4.id)
job_list = [self.j1, self.j2, self.j3, self.j4]
job_list = remove_empty_jobs_for_volunteer(job_list, self.v1.id)
# Only open and non empty jobs should be left
self.assertIn(self.j1, job_list)
self.assertNotIn(self.j2, job_list)
self.assertNotIn(self.j3, job_list)
self.assertNotIn(self.j4, job_list)
def test_get_all_volunteer_shifts_with_hours(self):
# Test get_all_volunteer_shifts_with_hours()
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
hours_list = get_all_volunteer_shifts_with_hours()
self.assertEqual(len(hours_list), 1)
self.assertEqual(self.v1.id, hours_list[0].volunteer_id)
self.assertEqual(self.s1.id, hours_list[0].shift_id)
self.assertIsNotNone(get_all_volunteer_shifts_with_hours())
def test_get_all_volunteer_shifts_with_hours(self):
# Test get_all_volunteer_shifts_with_hours()
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
hours_list = get_all_volunteer_shifts_with_hours()
self.assertEqual(len(hours_list), 1)
self.assertEqual(self.v1.id, hours_list[0].volunteer_id)
self.assertEqual(self.s1.id, hours_list[0].shift_id)
self.assertIsNotNone(get_all_volunteer_shifts_with_hours())
def test_get_future_shifts_by_volunteer_id(self):
""" Uses shifts s2, s4 and volunteer v1 """
register_event_utility()
register_job_utility()
s4 = register_shift_utility()
# sign up
register(self.v1.id, s4.id)
register(self.v1.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
# test typical case
shift_list = get_future_shifts_by_volunteer_id(self.v1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 1)
self.assertNotIn(self.s2, shift_list)
self.assertIn(s4, shift_list)
def test_get_shifts_with_open_slots_for_volunteer(self):
""" Uses volunteer v1, v2 """
register(self.v1.id, self.s2.id)
register(self.v2.id, self.s1.id)
open_slots_1 = get_shifts_with_open_slots_for_volunteer(
self.j1.id, self.v1.id)
open_slots_2 = get_shifts_with_open_slots_for_volunteer(
self.j2.id, self.v1.id)
self.assertIsNotNone(open_slots_1)
self.assertIsNotNone(open_slots_2)
self.assertEqual(len(open_slots_1), 0)
self.assertEqual(len(open_slots_2), 1)
self.assertEqual(self.s3.id, open_slots_2[0]["id"])
def test_get_future_shifts_by_volunteer_id(self):
""" Uses shifts s2, s4 and volunteer v1 """
register_event_utility()
register_job_utility()
s4 = register_shift_utility()
# sign up
register(self.v1.id, s4.id)
register(self.v1.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
# test typical case
shift_list = get_future_shifts_by_volunteer_id(self.v1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 1)
self.assertNotIn(self.s2, shift_list)
self.assertIn(s4, shift_list)
def test_get_shifts_with_open_slots(self):
""" Uses jobs j1, j2
Tests get_shifts_with_open_slots(j_id) """
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s3.id)
shift_list_1 = get_shifts_with_open_slots(self.j1.id)
shift_list_2 = get_shifts_with_open_slots(self.j2.id)
self.assertIsNotNone(shift_list_1)
self.assertIsNotNone(shift_list_2)
self.assertEqual(len(shift_list_1), 1)
self.assertEqual(len(shift_list_2), 1)
self.assertNotEqual(self.s1.id, shift_list_1[0]["id"])
self.assertEqual(self.s2.id, shift_list_1[0]["id"])
self.assertEqual(self.s3.id, shift_list_2[0]["id"])
def test_get_volunteer_report(self):
# register volunteer for 2 shifts, log hours for one
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s3.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
report_1 = get_volunteer_report(self.v1.id, self.e1.name, self.j1.name, "2012-10-22", "2012-10-30")
report_2 = get_volunteer_report(self.v1.id, self.e1.name, self.j2.name, "2012-9-1", "2012-10-26")
# verify that report for logged shift appears
self.assertEqual(len(report_1), 1)
self.assertEqual(len(report_2), 0)
self.assertEqual(self.e1.name, report_1[0]["event_name"])
self.assertEqual(self.j1.name, report_1[0]["job_name"])
def test_get_shifts_with_open_slots(self):
""" Uses jobs j1, j2
Tests get_shifts_with_open_slots(j_id) """
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s3.id)
shift_list_1 = get_shifts_with_open_slots(self.j1.id)
shift_list_2 = get_shifts_with_open_slots(self.j2.id)
self.assertIsNotNone(shift_list_1)
self.assertIsNotNone(shift_list_2)
self.assertEqual(len(shift_list_1), 1)
self.assertEqual(len(shift_list_2), 1)
self.assertNotEqual(self.s1.id, shift_list_1[0]["id"])
self.assertEqual(self.s2.id, shift_list_1[0]["id"])
self.assertEqual(self.s3.id, shift_list_2[0]["id"])
def test_delete_shift(self):
""" Test delete_shift(shift_id) """
u1 = User.objects.create_user("Yoshi")
v1 = Volunteer(
first_name="Yoshi",
last_name="Turtle",
address="Mario Land",
city="Nintendo Land",
state="Nintendo State",
country="Nintendo Nation",
phone_number="2374983247",
email="*****@*****.**",
user=u1,
)
v1.save()
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j1.save()
s1 = Shift(date="2012-10-23", start_time="1:00", end_time="12:00", max_volunteers=1, job=j1)
s2 = Shift(date="2011-11-11", start_time="11:00", end_time="12:00", max_volunteers=3, job=j1)
s1.save()
s2.save()
self.assertTrue(delete_shift(s1.id))
self.assertFalse(delete_shift(100))
register(v1.id, s2.id)
self.assertFalse(delete_shift(s2.id))
def test_get_administrator_report(self):
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s3.id)
start_time = datetime.time(hour=11, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
add_shift_hours(self.v2.id, self.s3.id, start_time, end_time)
report_1 = get_administrator_report(self.v1.first_name,"","",self.e1.name,self.j1.name,"2012-10-22", "2012-10-30")
report_2 = get_administrator_report(self.v1.first_name,"","",self.e1.name,self.j2.name,"2012-9-1", "2012-10-26")
report_3 = get_administrator_report("","","",self.e1.name,self.j2.name,"", "")
# verify that report for logged shift appears
self.assertEqual(len(report_1), 1)
self.assertEqual(len(report_2), 0)
self.assertEqual(len(report_3), 1)
self.assertEqual(self.v1.first_name, report_1[0]["first_name"])
self.assertEqual(self.v2.first_name, report_3[0]["first_name"])
def test_get_unlogged_shifts_by_volunteer_id(self):
""" Uses shifts s1, s2 and volunteer v1 """
# sign up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
# test typical case
shift_list = get_unlogged_shifts_by_volunteer_id(self.v1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 1)
self.assertNotIn(self.s1, shift_list)
self.assertIn(self.s2, shift_list)
self.assertNotIn(self.s3, shift_list)
def test_get_unlogged_shifts_by_volunteer_id(self):
""" Uses shifts s1, s2 and volunteer v1 """
# sign up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
# test typical case
shift_list = get_unlogged_shifts_by_volunteer_id(self.v1.id)
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 1)
self.assertNotIn(self.s1, shift_list)
self.assertIn(self.s2, shift_list)
self.assertNotIn(self.s3, shift_list)
def test_get_volunteer_shifts_with_hours(self):
""" Uses volunteers v1 and v2
Test get_volunteer_shifts_with_hours(v_id) """
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
v1_hours = get_volunteer_shifts_with_hours(self.v1)
v2_hours = get_volunteer_shifts_with_hours(self.v2)
self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v1))
self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v2))
self.assertEqual(len(v1_hours), 1)
self.assertEqual(self.s1.id, v1_hours[0].shift_id)
self.assertEqual(len(v2_hours), 0)
def test_get_volunteer_shifts_with_hours(self):
""" Uses volunteers v1 and v2
Test get_volunteer_shifts_with_hours(v_id) """
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
v1_hours = get_volunteer_shifts_with_hours(self.v1)
v2_hours = get_volunteer_shifts_with_hours(self.v2)
self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v1))
self.assertIsNotNone(get_volunteer_shifts_with_hours(self.v2))
self.assertEqual(len(v1_hours), 1)
self.assertEqual(self.s1.id, v1_hours[0].shift_id)
self.assertEqual(len(v2_hours), 0)
def test_cancel_shift_registration(self):
""" Uses shifts s1, s2, s3 and volunteers v1,v2 """
# test cases when try to cancel when they aren't signed up for a shift
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v1.id, self.s1.id)
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v1.id, self.s2.id)
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v2.id, self.s1.id)
# register volunteers to shifts
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
# test typical cases
cancel_shift_registration(self.v1.id, self.s1.id)
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v2.id, self.s1.id)
cancel_shift_registration(self.v2.id, self.s2.id)
def test_cancel_shift_registration(self):
""" Uses shifts s1, s2, s3 and volunteers v1,v2 """
# test cases when try to cancel when they aren't signed up for a shift
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v1.id, self.s1.id)
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v1.id, self.s2.id)
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v2.id, self.s1.id)
# register volunteers to shifts
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
# test typical cases
cancel_shift_registration(self.v1.id, self.s1.id)
with self.assertRaises(ObjectDoesNotExist):
cancel_shift_registration(self.v2.id, self.s1.id)
cancel_shift_registration(self.v2.id, self.s2.id)
def sign_up(request, shift_id, volunteer_id):
if shift_id:
shift = get_shift_by_id(shift_id)
if shift:
user = request.user
admin = None
volunteer = None
try:
admin = user.administrator
except ObjectDoesNotExist:
pass
try:
volunteer = user.volunteer
except ObjectDoesNotExist:
pass
if not admin and not volunteer:
return HttpResponse(status=403)
if volunteer:
if (int(volunteer.id) != int(volunteer_id)):
return HttpResponse(status=403)
if request.method == 'POST':
try:
result = register(volunteer_id, shift_id)
if result == "IS_VALID":
if admin:
return HttpResponseRedirect(
reverse('shift:manage_volunteer_shifts',
args=(volunteer_id, )))
if volunteer:
return HttpResponseRedirect(
reverse('shift:view_volunteer_shifts',
args=(volunteer_id, )))
else:
return render(request, 'shift/sign_up_error.html',
{'error_code': result})
except ObjectDoesNotExist:
raise Http404
else:
return render(request, 'shift/sign_up.html', {
'shift': shift,
'volunteer_id': volunteer_id
})
else:
raise Http404
else:
raise Http404
def test_remove_empty_events_for_volunteer(self):
"""
Uses Events e1,e2,e3,e4,e5, shift s2 and volunteer v1 where
with job that has shift with open slots - e2
Event with job and shift that volunteer already signed up for - e1
Event with job and shift that have no slots remaining - e4
Event with job that has no shifts - e3
Event with no jobs - e5
"""
register(self.v1.id, self.s2.id)
register(self.v2.id, self.s4.id)
event_list = [self.e1, self.e2, self.e3, self.e4, self.e5]
event_list = remove_empty_events_for_volunteer(event_list, self.v1.id)
# Only events with jobs that have open slots should remain
self.assertIn(self.e1, event_list)
self.assertIn(self.e2, event_list)
self.assertNotIn(self.e3, event_list)
self.assertNotIn(self.e4, event_list)
self.assertNotIn(self.e5, event_list)
VolunteerShift.objects.all().delete()
def test_remove_empty_events_for_volunteer(self):
"""
Uses Events e1,e2,e3,e4,e5, shift s2 and volunteer v1 where
with job that has shift with open slots - e2
Event with job and shift that volunteer already signed up for - e1
Event with job and shift that have no slots remaining - e4
Event with job that has no shifts - e3
Event with no jobs - e5
"""
register(self.v1.id, self.s2.id)
register(self.v2.id, self.s4.id)
event_list = [self.e1, self.e2, self.e3, self.e4, self.e5]
event_list = remove_empty_events_for_volunteer(event_list, self.v1.id)
# Only events with jobs that have open slots should remain
self.assertIn(self.e1, event_list)
self.assertIn(self.e2, event_list)
self.assertNotIn(self.e3, event_list)
self.assertNotIn(self.e4, event_list)
self.assertNotIn(self.e5, event_list)
VolunteerShift.objects.all().delete()
def test_clear_shift_hours(self):
""" Uses shifts s1, s2, s3 and volunteer v1 """
register(self.v1.id, self.s1.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
))
register(self.v1.id, self.s2.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
))
register(self.v1.id, self.s3.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s3.id
))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=6, minute=0)
add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
clear_shift_hours(self.v1.id, self.s1.id)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
clear_shift_hours(self.v1.id, self.s2.id)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
clear_shift_hours(self.v1.id, self.s3.id)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s3.id
)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
def test_add_shift_hours(self):
""" Uses shifts s1, s2, s3 and volunteers v1,v2,v3 """
# register will return an exception on error
# (such as when invalid parameters are passed)
# if an exception does get raised, this test will automatically fail
register(self.v1.id, self.s1.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
))
register(self.v1.id, self.s2.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
))
register(self.v1.id, self.s3.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s3.id
))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=6, minute=0)
add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s3.id
)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
def test_clear_shift_hours(self):
""" Uses shifts s1, s2, s3 and volunteer v1 """
register(self.v1.id, self.s1.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id))
register(self.v1.id, self.s2.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id))
register(self.v1.id, self.s3.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s3.id))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=6, minute=0)
add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
clear_shift_hours(self.v1.id, self.s1.id)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
clear_shift_hours(self.v1.id, self.s2.id)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
clear_shift_hours(self.v1.id, self.s3.id)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s3.id)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
def test_add_shift_hours(self):
""" Uses shifts s1, s2, s3 and volunteers v1,v2,v3 """
# register will return an exception on error
# (such as when invalid parameters are passed)
# if an exception does get raised, this test will automatically fail
register(self.v1.id, self.s1.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id))
register(self.v1.id, self.s2.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id))
register(self.v1.id, self.s3.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s3.id))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(self.v1.id, self.s2.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=6, minute=0)
add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s3.id)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
def test_get_shift_slots_remaining(self):
""" Uses shifts s1, s2, s3
Tests get_shift_slots_remaining(s_id) """
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s3.id)
register(self.v3.id, self.s3.id)
slots_s1 = get_shift_slots_remaining(self.s1.id)
slots_s2 = get_shift_slots_remaining(self.s2.id)
slots_s3 = get_shift_slots_remaining(self.s3.id)
self.assertIsNotNone(slots_s1)
self.assertIsNotNone(slots_s2)
self.assertIsNotNone(slots_s3)
self.assertEqual(slots_s1, 0)
self.assertEqual(slots_s2, 2)
self.assertEqual(slots_s3, 2)
def test_get_shift_slots_remaining(self):
""" Uses shifts s1, s2, s3
Tests get_shift_slots_remaining(s_id) """
register(self.v1.id, self.s1.id)
register(self.v2.id, self.s3.id)
register(self.v3.id, self.s3.id)
slots_s1 = get_shift_slots_remaining(self.s1.id)
slots_s2 = get_shift_slots_remaining(self.s2.id)
slots_s3 = get_shift_slots_remaining(self.s3.id)
self.assertIsNotNone(slots_s1)
self.assertIsNotNone(slots_s2)
self.assertIsNotNone(slots_s3)
self.assertEqual(slots_s1, 0)
self.assertEqual(slots_s2, 2)
self.assertEqual(slots_s3, 2)
def test_get_logged_volunteers_by_shift_id(self):
""" Uses volunteers v1,v2,v3 and shift s3 """
# sign up
register(self.v3.id, self.s3.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s3.id)
start_time = datetime.time(hour=1, minute=0)
end_time = datetime.time(hour=2, minute=0)
add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
start_time = datetime.time(hour=2, minute=0)
end_time = datetime.time(hour=3, minute=0)
add_shift_hours(self.v3.id, self.s3.id, start_time, end_time)
# get volunteer list
logged_volunteer_list_for_shift = get_logged_volunteers_by_shift_id(self.s3.id)
# test typical case and order
self.assertEqual(len(logged_volunteer_list_for_shift), 2)
self.assertEqual(logged_volunteer_list_for_shift[0].volunteer, self.v3)
self.assertEqual(logged_volunteer_list_for_shift[1].volunteer, self.v1)
def test_get_logged_volunteers_by_shift_id(self):
""" Uses volunteers v1,v2,v3 and shift s3 """
# sign up
register(self.v3.id, self.s3.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s3.id)
start_time = datetime.time(hour=1, minute=0)
end_time = datetime.time(hour=2, minute=0)
add_shift_hours(self.v1.id, self.s3.id, start_time, end_time)
start_time = datetime.time(hour=2, minute=0)
end_time = datetime.time(hour=3, minute=0)
add_shift_hours(self.v3.id, self.s3.id, start_time, end_time)
# get volunteer list
logged_volunteer_list_for_shift = get_logged_volunteers_by_shift_id(
self.s3.id)
# test typical case and order
self.assertEqual(len(logged_volunteer_list_for_shift), 2)
self.assertEqual(logged_volunteer_list_for_shift[0].volunteer, self.v3)
self.assertEqual(logged_volunteer_list_for_shift[1].volunteer, self.v1)
def test_edit_shift_hours(self):
""" Uses shift s1 and volunteer v1 """
register(self.v1.id, self.s1.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=11, minute=0)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=1, minute=0)
end_time = datetime.time(hour=4, minute=0)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=4, minute=15)
end_time = datetime.time(hour=12, minute=35)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=2, minute=5)
end_time = datetime.time(hour=4, minute=15)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=5, minute=30)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
def test_register(self):
""" Uses volunteers v1,v2 and shifts s1,s2,s3 """
ERROR_CODE_ALREADY_SIGNED_UP = "ERROR_CODE_ALREADY_SIGNED_UP"
ERROR_CODE_NO_SLOTS_REMAINING = "ERROR_CODE_NO_SLOTS_REMAINING"
# test typical cases
register(self.v1.id, self.s1.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
))
register(self.v1.id, self.s2.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
))
register(self.v1.id, self.s3.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s3.id
))
# test cases where volunteer tries to sign up for a shift
# they are already signed up for
self.assertEqual(register(self.v1.id, self.s1.id), ERROR_CODE_ALREADY_SIGNED_UP)
self.assertEqual(register(self.v1.id, self.s2.id), ERROR_CODE_ALREADY_SIGNED_UP)
self.assertEqual(register(self.v1.id, self.s3.id), ERROR_CODE_ALREADY_SIGNED_UP)
# test case where more than one volunteer signs up for the same shift
# v2 can't sign up for s1 because there are no slots remaining
self.assertEqual(register(self.v2.id, self.s1.id), ERROR_CODE_NO_SLOTS_REMAINING)
register(self.v2.id, self.s2.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v2.id,
shift_id=self.s2.id
))
register(self.v2.id, self.s3.id)
self.assertIsNotNone(VolunteerShift.objects.get(
volunteer_id=self.v2.id,
shift_id=self.s3.id
))
# test cases where a volunteer tries to sign up for a shift
# they are already signed up for
self.assertEqual(register(self.v2.id, self.s2.id), ERROR_CODE_ALREADY_SIGNED_UP)
self.assertEqual(register(self.v2.id, self.s3.id), ERROR_CODE_ALREADY_SIGNED_UP)
def test_edit_shift_hours(self):
u1 = User.objects.create_user("Yoshi")
v1 = Volunteer(
first_name="Yoshi",
last_name="Turtle",
address="Mario Land",
city="Nintendo Land",
state="Nintendo State",
country="Nintendo Nation",
phone_number="2374983247",
email="*****@*****.**",
user=u1,
)
v1.save()
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j1.save()
s1 = Shift(date="2012-10-23", start_time="1:00", end_time="12:00", max_volunteers=1, job=j1)
s1.save()
register(v1.id, s1.id)
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(v1.id, s1.id, start_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=11, minute=0)
edit_shift_hours(v1.id, s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=1, minute=0)
end_time = datetime.time(hour=4, minute=0)
edit_shift_hours(v1.id, s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=4, minute=15)
end_time = datetime.time(hour=12, minute=35)
edit_shift_hours(v1.id, s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=2, minute=5)
end_time = datetime.time(hour=4, minute=15)
edit_shift_hours(v1.id, s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=5, minute=30)
edit_shift_hours(v1.id, s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
def test_generate_report(self):
""" Tests test_generate_report(volunteer_shift_list) """
u1 = User.objects.create_user("Yoshi")
v1 = Volunteer(
first_name="Yoshi",
last_name="Turtle",
address="Mario Land",
city="Nintendo Land",
state="Nintendo State",
country="Nintendo Nation",
phone_number="2374983247",
email="*****@*****.**",
user=u1,
)
v1.save()
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j2 = Job(
name="Systems Administrator",
start_date="2012-9-1",
end_date="2012-10-26",
description="A systems administrator job",
event=e1,
)
j1.save()
j2.save()
s1 = Shift(date="2012-10-23", start_time="9:00", end_time="3:00", max_volunteers=1, job=j1)
s2 = Shift(date="2012-10-23", start_time="10:00", end_time="4:00", max_volunteers=2, job=j1)
s3 = Shift(date="2012-10-23", start_time="12:00", end_time="6:00", max_volunteers=4, job=j2)
s1.save()
s2.save()
s3.save()
shift_list = [s1, s2, s3]
self.assertIsNotNone(shift_list)
self.assertNotEqual(shift_list, False)
self.assertEqual(len(shift_list), 3)
self.assertIn(s1, shift_list)
self.assertIn(s2, shift_list)
self.assertIn(s3, shift_list)
# register will return an exception on error
# (such as when invalid parameters are passed)
# if an exception does get raised, this test will automatically fail
register(v1.id, s1.id)
volunteer_shift_1 = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNotNone(volunteer_shift_1)
register(v1.id, s2.id)
volunteer_shift_2 = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s2.id)
self.assertIsNotNone(volunteer_shift_2)
register(v1.id, s3.id)
volunteer_shift_3 = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s3.id)
self.assertIsNotNone(volunteer_shift_3)
volunteer_shift_list = [volunteer_shift_1, volunteer_shift_2, volunteer_shift_3]
self.assertIsNotNone(generate_report(volunteer_shift_list))
def test_send_reminder(self):
location = [
"Test address", "Atlanta", "Georgia", "USA",
"Near the south entrance"
]
set_shift_location(self.s1, location)
set_shift_location(self.s2, location)
set_shift_location(self.s3, location)
self.v1.reminder_days = 1
self.v2.reminder_days = 7
self.v1.save()
self.v2.save()
# sign up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
# test typical case
result = send_reminder()
self.assertEqual(result, 2)
def test_clear_shift_hours(self):
u1 = User.objects.create_user("Yoshi")
v1 = Volunteer(
first_name="Yoshi",
last_name="Turtle",
address="Mario Land",
city="Nintendo Land",
state="Nintendo State",
country="Nintendo Nation",
phone_number="2374983247",
email="*****@*****.**",
user=u1,
)
v1.save()
e1 = Event(name="Open Source Event", start_date="2012-10-22", end_date="2012-10-23")
e1.save()
j1 = Job(
name="Software Developer",
start_date="2012-10-22",
end_date="2012-10-23",
description="A software job",
event=e1,
)
j2 = Job(
name="Systems Administrator",
start_date="2012-9-1",
end_date="2012-10-26",
description="A systems administrator job",
event=e1,
)
j1.save()
j2.save()
s1 = Shift(date="2012-10-23", start_time="9:00", end_time="3:00", max_volunteers=1, job=j1)
s2 = Shift(date="2012-10-23", start_time="10:00", end_time="4:00", max_volunteers=2, job=j1)
s3 = Shift(date="2012-10-23", start_time="12:00", end_time="6:00", max_volunteers=4, job=j2)
s1.save()
s2.save()
s3.save()
register(v1.id, s1.id)
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id))
register(v1.id, s2.id)
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s2.id))
register(v1.id, s3.id)
self.assertIsNotNone(VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s3.id))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(v1.id, s1.id, start_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=12, minute=0)
add_shift_hours(v1.id, s2.id, start_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=6, minute=0)
add_shift_hours(v1.id, s3.id, start_time, end_time)
clear_shift_hours(v1.id, s1.id)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s1.id)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
clear_shift_hours(v1.id, s2.id)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s2.id)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
clear_shift_hours(v1.id, s3.id)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=v1.id, shift_id=s3.id)
self.assertIsNone(volunteer_shift.start_time)
self.assertIsNone(volunteer_shift.end_time)
def test_send_reminder(self):
city_name = 'Roorkee'
state_name = 'Uttarakhand'
country_name = 'India'
country = get_country_by_name(country_name)
state = get_state_by_name(state_name)
city = get_city_by_name(city_name)
location = {
'address': "Test address",
'city': city,
'state': state,
'country': country,
'venue': "Near the south entrance"
}
set_shift_location(self.s1, location)
set_shift_location(self.s2, location)
set_shift_location(self.s3, location)
self.v1.reminder_days = 1
self.v2.reminder_days = 7
self.v1.save()
self.v2.save()
# sign up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
# test typical case
result = send_reminder()
self.assertEqual(result, 2)
def sign_up(request, shift_id, volunteer_id):
if shift_id:
shift = get_shift_by_id(shift_id)
if shift:
user = request.user
admin = None
volunteer = None
try:
admin = user.administrator
except ObjectDoesNotExist:
pass
try:
volunteer = user.volunteer
except ObjectDoesNotExist:
pass
if not admin and not volunteer:
return HttpResponse(status=403)
if volunteer:
if int(volunteer.id) != int(volunteer_id):
return HttpResponse(status=403)
if request.method == 'POST':
try:
result = register(volunteer_id, shift_id)
if result == "IS_VALID":
if admin:
vol_email = Volunteer.objects.get(
pk=volunteer_id).email
shift_object = get_shift_by_id(shift_id)
job_object = Job.objects.get(shift=shift_object)
event_object = Event.objects.get(job=job_object)
message = render_to_string(
'shift/sign_up_email.txt', {
'admin_first_name': admin.first_name,
'admin_last_name': admin.last_name,
'shift_start_time':
shift_object.start_time,
'shift_end_time': shift_object.end_time,
'admin_email': admin.email,
'job_name': job_object.name,
'event_name': event_object.name,
'shift_date': shift_object.date,
})
try:
send_mail("Shift Assigned",
message,
"*****@*****.**",
[vol_email],
fail_silently=False)
except Exception:
raise Exception(
"There was an error in sending email.")
return HttpResponseRedirect(
reverse('shift:manage_volunteer_shifts',
args=(volunteer_id, )))
if volunteer:
return HttpResponseRedirect(
reverse('shift:view_volunteer_shifts',
args=(volunteer_id, )))
else:
return render(request, 'shift/sign_up_error.html',
{'error_code': result})
except ObjectDoesNotExist:
raise Http404
else:
return render(request, 'shift/sign_up.html', {
'shift': shift,
'volunteer_id': volunteer_id
})
else:
raise Http404
else:
raise Http404
def test_get_volunteer_shift_by_id(self):
""" Uses shifts s1,s2,s3 and volunteers v1,v2"""
# test cases where signed up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
self.assertEqual(
get_volunteer_shift_by_id(self.v1.id, self.s1.id),
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id))
self.assertEqual(
get_volunteer_shift_by_id(self.v1.id, self.s2.id),
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id))
self.assertEqual(
get_volunteer_shift_by_id(self.v1.id, self.s3.id),
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s3.id))
# self.assertEqual(get_volunteer_shift_by_id(v2.id, s1.id),
# VolunteerShift.objects.get(volunteer_id=v2.id, shift_id=s1.id))
# why does this throw DoesNotExist?
self.assertEqual(
get_volunteer_shift_by_id(self.v2.id, self.s2.id),
VolunteerShift.objects.get(volunteer_id=self.v2.id,
shift_id=self.s2.id))
self.assertEqual(
get_volunteer_shift_by_id(self.v2.id, self.s3.id),
VolunteerShift.objects.get(volunteer_id=self.v2.id,
shift_id=self.s3.id))
def sign_up(request, shift_id, volunteer_id):
if shift_id:
shift = get_shift_by_id(shift_id)
if shift:
user = request.user
admin = None
volunteer = None
try:
admin = user.administrator
except ObjectDoesNotExist:
pass
try:
volunteer = user.volunteer
except ObjectDoesNotExist:
pass
if not admin and not volunteer:
return HttpResponse(status=403)
if volunteer:
if (int(volunteer.id) != int(volunteer_id)):
return HttpResponse(status=403)
if request.method == 'POST':
try:
result = register(volunteer_id, shift_id)
if result == "IS_VALID":
if admin:
vol_email = Volunteer.objects.get(
pk=volunteer_id).email
shift_object = get_shift_by_id(shift_id)
job_object = Job.objects.get(shift=shift_object)
event_object = Event.objects.get(job=job_object)
message = render_to_string(
'shift/sign_up_email.txt',
{
'admin_first_name': admin.first_name,
'admin_last_name': admin.last_name,
'shift_start_time': shift_object.start_time,
'shift_end_time': shift_object.end_time,
'admin_email': admin.email,
'job_name': job_object.name,
'event_name': event_object.name,
'shift_date': shift_object.date,
})
try:
send_mail("Shift Assigned", message,
"*****@*****.**", [vol_email],
fail_silently=False)
except:
raise Exception("There was an error in sending email.")
return HttpResponseRedirect(
reverse(
'shift:manage_volunteer_shifts',
args=(volunteer_id, )))
if volunteer:
return HttpResponseRedirect(
reverse(
'shift:view_volunteer_shifts',
args=(volunteer_id, )))
else:
return render(request, 'shift/sign_up_error.html', {
'error_code': result
})
except ObjectDoesNotExist:
raise Http404
else:
return render(request, 'shift/sign_up.html', {
'shift': shift,
'volunteer_id': volunteer_id
})
else:
raise Http404
else:
raise Http404
def test_get_volunteer_shift_by_id(self):
""" Uses shifts s1,s2,s3 and volunteers v1,v2"""
# test cases where signed up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
self.assertEqual(
get_volunteer_shift_by_id(self.v1.id, self.s1.id),
VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s1.id
))
self.assertEqual(
get_volunteer_shift_by_id(self.v1.id, self.s2.id),
VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s2.id
)
)
self.assertEqual(
get_volunteer_shift_by_id(self.v1.id, self.s3.id),
VolunteerShift.objects.get(
volunteer_id=self.v1.id,
shift_id=self.s3.id
)
)
# self.assertEqual(get_volunteer_shift_by_id(v2.id, s1.id),
# VolunteerShift.objects.get(volunteer_id=v2.id, shift_id=s1.id))
# why does this throw DoesNotExist?
self.assertEqual(
get_volunteer_shift_by_id(self.v2.id, self.s2.id),
VolunteerShift.objects.get(
volunteer_id=self.v2.id,
shift_id=self.s2.id
)
)
self.assertEqual(
get_volunteer_shift_by_id(self.v2.id, self.s3.id),
VolunteerShift.objects.get(
volunteer_id=self.v2.id,
shift_id=self.s3.id
)
)
def test_send_reminder(self):
location = ["Test address","Atlanta","Georgia","USA","Near the south entrance"]
set_shift_location(self.s1,location)
set_shift_location(self.s2,location)
set_shift_location(self.s3,location)
self.v1.reminder_days=1
self.v2.reminder_days=7
self.v1.save()
self.v2.save()
# sign up
register(self.v1.id, self.s1.id)
register(self.v1.id, self.s2.id)
register(self.v1.id, self.s3.id)
register(self.v2.id, self.s1.id)
register(self.v2.id, self.s2.id)
register(self.v2.id, self.s3.id)
# test typical case
result = send_reminder()
self.assertEqual(result,2)
def test_register(self):
""" Uses volunteers v1,v2 and shifts s1,s2,s3 """
ERROR_CODE_ALREADY_SIGNED_UP = "ERROR_CODE_ALREADY_SIGNED_UP"
ERROR_CODE_NO_SLOTS_REMAINING = "ERROR_CODE_NO_SLOTS_REMAINING"
# test typical cases
register(self.v1.id, self.s1.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id))
register(self.v1.id, self.s2.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s2.id))
register(self.v1.id, self.s3.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s3.id))
# test cases where volunteer tries to sign up for a shift
# they are already signed up for
self.assertEqual(register(self.v1.id, self.s1.id),
ERROR_CODE_ALREADY_SIGNED_UP)
self.assertEqual(register(self.v1.id, self.s2.id),
ERROR_CODE_ALREADY_SIGNED_UP)
self.assertEqual(register(self.v1.id, self.s3.id),
ERROR_CODE_ALREADY_SIGNED_UP)
# test case where more than one volunteer signs up for the same shift
# v2 can't sign up for s1 because there are no slots remaining
self.assertEqual(register(self.v2.id, self.s1.id),
ERROR_CODE_NO_SLOTS_REMAINING)
register(self.v2.id, self.s2.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v2.id,
shift_id=self.s2.id))
register(self.v2.id, self.s3.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v2.id,
shift_id=self.s3.id))
# test cases where a volunteer tries to sign up for a shift
# they are already signed up for
self.assertEqual(register(self.v2.id, self.s2.id),
ERROR_CODE_ALREADY_SIGNED_UP)
self.assertEqual(register(self.v2.id, self.s3.id),
ERROR_CODE_ALREADY_SIGNED_UP)
def test_edit_shift_hours(self):
""" Uses shift s1 and volunteer v1 """
register(self.v1.id, self.s1.id)
self.assertIsNotNone(
VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id))
start_time = datetime.time(hour=9, minute=0)
end_time = datetime.time(hour=10, minute=0)
add_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
start_time = datetime.time(hour=10, minute=0)
end_time = datetime.time(hour=11, minute=0)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=1, minute=0)
end_time = datetime.time(hour=4, minute=0)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=4, minute=15)
end_time = datetime.time(hour=12, minute=35)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=2, minute=5)
end_time = datetime.time(hour=4, minute=15)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
start_time = datetime.time(hour=5, minute=0)
end_time = datetime.time(hour=5, minute=30)
edit_shift_hours(self.v1.id, self.s1.id, start_time, end_time)
volunteer_shift = VolunteerShift.objects.get(volunteer_id=self.v1.id,
shift_id=self.s1.id)
self.assertIsNotNone(volunteer_shift.start_time)
self.assertIsNotNone(volunteer_shift.end_time)
self.assertEqual(volunteer_shift.start_time, start_time)
self.assertEqual(volunteer_shift.end_time, end_time)
