def setUp(self):
"""
Method consists of statements to be executed before
start of each test.
"""
create_admin()
create_volunteer()
def setUp(self):
"""
Method consists of statements to be executed before
start of each test.
"""
create_admin()
create_volunteer()
def test_only_logged_shifts_are_reported(self):
# register dataset
org = create_organization_with_details('organization-one')
volunteer = create_volunteer()
volunteer.organization = org
volunteer.save()
# register event first to create job
event = ['Hackathon', '2017-08-21', '2017-09-28']
created_event = create_event_with_details(event)
# create job
job = ['Developer', '2017-08-21', '2017-08-30', '', created_event]
created_job = create_job_with_details(job)
# create shift
shift = ['2017-08-21', '09:00', '15:00', '10', created_job]
created_shift = create_shift_with_details(shift)
# shift is assigned to volunteer-one, but hours have not been logged
volunteer_shift = register_volunteer_for_shift_utility(
created_shift, volunteer)
report_page = self.report_page
# check admin report with null fields, should not return the above shift
report_page.fill_report_form(['', '', '', '', ''])
self.assertEqual(report_page.get_alert_box_text(),
report_page.no_results_message)
def setUp(self):
"""
Method consists of statements to be executed before
start of each test.
"""
self.v1 = create_volunteer()
self.login_volunteer()
def test_view_with_logged_hours(self):
"""
Test display of shift details with hours logged in the shift.
"""
shift_details_page = self.shift_details_page
shift_details_page.live_server_url = self.live_server_url
volunteer = create_volunteer()
log_hours_with_details(volunteer, self.shift, '13:00', '14:00')
self.wait_for_home_page()
shift_details_page.navigate_to_shift_details_view()
# verify that the shift slot is decreased by 1
self.assertEqual(shift_details_page.get_shift_job(), 'job')
self.assertEqual(shift_details_page.get_max_shift_volunteer(), '5')
# verify that assigned volunteers shows up
self.assertEqual(len(shift_details_page.get_registered_volunteers()),
1)
self.assertEqual(shift_details_page.get_registered_volunteer_email(),
'*****@*****.**')
# verify that hours are logged by volunteer
self.assertEqual(len(shift_details_page.get_logged_volunteers()), 1)
self.assertEqual(shift_details_page.get_logged_volunteer_name(),
'Prince')
self.assertEqual(shift_details_page.get_logged_start_time(), '1 p.m.')
self.assertEqual(shift_details_page.get_logged_end_time(), '2 p.m.')
def test_view_with_only_registered_volunteers(self):
"""
Test display of shift details with registered volunteer.
"""
shift_details_page = self.shift_details_page
shift_details_page.live_server_url = self.live_server_url
volunteer = create_volunteer()
volunteer_shift = register_volunteer_for_shift_utility(
self.shift, volunteer)
self.wait_for_home_page()
shift_details_page.navigate_to_shift_details_view()
# verify that the shift slot is decreased by 1
self.assertEqual(shift_details_page.get_shift_job(), 'job')
self.assertEqual(shift_details_page.get_max_shift_volunteer(), '5')
# verify that assigned volunteers shows up but no logged hours yet
self.assertEqual(len(shift_details_page.get_registered_volunteers()),
1)
self.assertEqual(shift_details_page.get_registered_volunteer_name(),
'Prince')
self.assertEqual(shift_details_page.get_registered_volunteer_email(),
'*****@*****.**')
self.assertEqual(shift_details_page.get_message_box(),
'There are no logged hours at the moment')
def setUp(self):
"""
Method consists of statements to be executed before
start of each test.
"""
self.v1 = create_volunteer()
self.login_volunteer()
def test_shift_edit_request(self):
"""
checks the edit request link received by admin
"""
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=14, minute=0)
logged_shift = log_hours_with_details(volunteer_1, shift_1, start, end)
start_time = datetime.time(hour=9, minute=30)
end_time = datetime.time(hour=14, minute=0)
edit_request = \
create_edit_request_with_details(start_time, end_time, logged_shift)
response = self.client.get(
reverse('shift:edit_request_manager',
args=[shift_1.id, volunteer_1.id, edit_request.id]))
self.assertEqual(response.status_code, 302)
def test_only_logged_shifts_are_reported(self):
# register dataset
org = create_organization_with_details('organization-one')
volunteer = create_volunteer()
volunteer.organization = org
volunteer.save()
# register event first to create job
event = ['Hackathon', '2017-08-21', '2017-09-28']
created_event = create_event_with_details(event)
# create job
job = ['Developer', '2017-08-21', '2017-08-30', '',created_event]
created_job = create_job_with_details(job)
# create shift
shift = ['2017-08-21', '09:00', '15:00', '10', created_job]
created_shift = create_shift_with_details(shift)
# shift is assigned to volunteer-one, but hours have not been logged
volunteer_shift = register_volunteer_for_shift_utility(created_shift, volunteer)
report_page = self.report_page
# check admin report with null fields, should not return the above shift
report_page.fill_report_form(['','','','',''])
self.assertEqual(report_page.get_alert_box_text(),report_page.no_results_message)
def test_delete_shift_with_volunteer(self):
# register event first to create job
event = ['event-name', '2017-08-21', '2017-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2017-08-21', '2017-08-30', '',created_event]
created_job = create_job_with_details(job)
# create shift
shift = ['2017-08-21', '09:00', '12:00', '10', created_job]
created_shift = create_shift_with_details(shift)
# create volunteer for shift
volunteer = create_volunteer()
shift_volunteer = register_volunteer_for_shift_utility(
created_shift, volunteer)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
# delete shift
self.delete_shift_from_list()
# check error message displayed and shift not deleted
self.assertEqual(settings.get_template_error_message(),
'You cannot delete a shift that a volunteer has signed up for.')
# database check to ensure that shift is not deleted
self.assertEqual(len(Shift.objects.all()), 1)
self.assertNotEqual(len(Shift.objects.filter(date = created_shift.date)), 0)
def test_jobs_page_with_no_jobs(self):
"""
Test no job present at shifts sign up page for volunteer to sign up for.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
manage_shift_page.live_server_url = self.live_server_url
# Register volunteers
volunteer_1 = create_volunteer()
# Create events
event = {
'name': 'event-name',
'start_date': '2017-05-20',
'end_date': '2017-05-20',
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
}
event_1 = create_event_with_details(event)
self.wait_for_home_page()
# Open manage volunteer shift
manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
manage_shift_page.assign_shift()
self.assertEqual(sign_up_page.get_info_box().text,
sign_up_page.no_event_message)
def test_edit_request_email_volunteer(self):
"""
checks if the volunteer gets an email when his hours are edited
by admin upon his request
"""
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=14, minute=0)
logged_shift = log_hours_with_details(volunteer_1, shift_1, start, end)
start_time = datetime.time(hour=9, minute=30)
end_time = datetime.time(hour=14, minute=0)
edit_request = \
create_edit_request_with_details(start_time, end_time, logged_shift)
vol_email = volunteer_1.email
mail.outbox = []
mail.send_mail("Log Hours Edited", "message",
"*****@*****.**", [vol_email])
self.assertEqual(len(mail.outbox), 1)
msg = mail.outbox[0]
self.assertEqual(msg.subject, "Log Hours Edited")
self.assertEqual(msg.to, ['*****@*****.**'])
def setUp(self):
"""
Method consists of statements to be executed before
start of each test.
"""
self.admin = create_admin()
self.volunteer = create_volunteer()
self.volunteer_id = str(self.volunteer.id)
def test_assign_same_shift_to_volunteer_twice(self):
"""
Test errors while assignment of same shift
to volunteer to which they are already assigned.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
self.manage_shift_page.live_server_url = self.live_server_url
# Register volunteers
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
self.wait_for_home_page()
# Open manage volunteer shift
manage_shift_page.navigate_to_manage_shift_page()
# Volunteer-one does not have any registered shifts
manage_shift_page.select_volunteer(1)
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
manage_shift_page.assign_shift()
# Events shown in table
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-info',
sign_up_page.get_info_box)
manage_shift_page.navigate_to_shift_assignment_page()
# Confirm on shift assignment to volunteer-one
manage_shift_page.submit_form()
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-danger',
sign_up_page.get_danger_box)
# Assign same shift to voluteer-one again
# Check volunteer-one has one registered shift now
self.assertEqual(sign_up_page.get_shift_job(), 'job name')
manage_shift_page.assign_shift()
# Events page
self.assertEqual(sign_up_page.get_info_box().text,
sign_up_page.no_event_message)
def test_delete_shift_with_volunteer(self):
"""
Test deletion of shift with volunteer linked with it.
"""
# register event first to create job
event = {
'name': 'event-name',
'start_date': '2050-08-21',
'end_date': '2050-09-28',
'address': 'event-address',
'venue': 'event-venue',
'description': 'event-description'
}
created_event = create_event_with_details(event)
# create job
job = {
'name': 'job',
'start_date': '2050-08-21',
'end_date': '2050-08-30',
'description': '',
'event': created_event
}
created_job = create_job_with_details(job)
# create shift
shift = {
'date': '2050-08-21',
'start_time': '09:00',
'end_time': '12:00',
'max_volunteers': '10',
'job': created_job,
'address': 'shift-address',
'venue': 'shift-venue'
}
created_shift = create_shift_with_details(shift)
# create volunteer for shift
volunteer = create_volunteer()
register_volunteer_for_shift_utility(created_shift, volunteer)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
# delete shift
self.delete_shift_from_list()
# check error message displayed and shift not deleted
self.assertEqual(
settings.get_template_error_message(),
'You cannot delete a shift that a volunteer has signed up for.')
def test_check_report_hours(self):
self.report_page.go_to_admin_report()
vol = create_volunteer()
register_past_event_utility()
register_past_job_utility()
shift = register_past_shift_utility()
start=datetime.time(hour=10, minute=0)
end=datetime.time(hour=11, minute=0)
logged_shift = log_hours_with_details(vol, shift, start, end)
create_report_with_details(vol, logged_shift)
report_page = self.report_page
report_page.get_page(self.live_server_url, PageUrls.administrator_report_page)
self.assertEqual(report_page.get_hours(), '1.00')
def test_check_report_hours(self):
self.report_page.go_to_admin_report()
vol = create_volunteer()
register_past_event_utility()
register_past_job_utility()
shift = register_past_shift_utility()
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=11, minute=0)
logged_shift = log_hours_with_details(vol, shift, start, end)
create_report_with_details(vol, logged_shift)
report_page = self.report_page
report_page.get_page(self.live_server_url,
PageUrls.administrator_report_page)
self.assertEqual(report_page.get_hours(), '1.00')
def test_delete_org_with_users_linked(self):
# Create volunteer
volunteer = create_volunteer()
self.organization_page.go_to_events_page()
organization_page = self.organization_page
organization_page.live_server_url = self.live_server_url
# Navigate to organization view and Delete Organization
organization_page.navigate_to_organization_view()
self.delete_organization_from_list()
# Check error message
self.assertNotEqual(organization_page.get_danger_message(), None)
self.assertEqual(organization_page.get_template_error_message(),
'You cannot delete an organization that users are currently associated with.')
def test_reject_report(self):
self.report_page.go_to_admin_report()
vol = create_volunteer()
register_past_event_utility()
register_past_job_utility()
shift = register_past_shift_utility()
start=datetime.time(hour=10, minute=0)
end=datetime.time(hour=11, minute=0)
logged_shift = log_hours_with_details(vol, shift, start, end)
create_report_with_details(vol, logged_shift)
report_page = self.report_page
report_page.get_page(self.live_server_url, PageUrls.administrator_report_page)
self.assertEqual(report_page.get_rejection_context(), 'Reject')
report_page.reject_report()
with self.assertRaises(NoSuchElementException):
report_page.get_report()
def test_table_layout(self):
"""
Test the shift table has details displayed correctly.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
manage_shift_page.live_server_url = self.live_server_url
# Register volunteers
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
self.wait_for_home_page()
# Open manage volunteer shift
self.manage_shift_page.navigate_to_manage_shift_page()
# Volunteer-one does not have any registered shifts
manage_shift_page.select_volunteer(1)
manage_shift_page.assign_shift()
# Events shown in table
self.assertRaisesRegexp(
NoSuchElementException, 'Message: Unable to locate element: '
'.alert-info', sign_up_page.get_info_box)
self.assertEqual(sign_up_page.get_view_jobs(),
manage_shift_page.VIEW_JOB)
sign_up_page.click_to_view_jobs()
# Arrived on page2 with jobs
self.assertEqual(sign_up_page.get_view_shifts(),
manage_shift_page.VIEW_SHIFT)
sign_up_page.click_to_view_shifts()
# Arrived on page3 with shifts, assign shift to volunteer one
self.assertEqual(sign_up_page.get_sign_up(),
manage_shift_page.shift_assignment_text)
def test_reject_report(self):
self.report_page.go_to_admin_report()
vol = create_volunteer()
register_past_event_utility()
register_past_job_utility()
shift = register_past_shift_utility()
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=11, minute=0)
logged_shift = log_hours_with_details(vol, shift, start, end)
create_report_with_details(vol, logged_shift)
report_page = self.report_page
report_page.get_page(self.live_server_url,
PageUrls.administrator_report_page)
self.assertEqual(report_page.get_rejection_context(), 'Reject')
report_page.reject_report()
with self.assertRaises(NoSuchElementException):
report_page.get_report()
def test_email_on_report_approval(self):
vol = create_volunteer()
register_past_event_utility()
register_past_job_utility()
shift = register_past_shift_utility()
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=11, minute=0)
logged_shift = log_hours_with_details(vol, shift, start, end)
report = create_report_with_details(vol, logged_shift)
mail.send_mail("Report Approved", "message", "*****@*****.**",
[vol.email])
self.assertEqual(len(mail.outbox), 1)
msg = mail.outbox[0]
self.assertEqual(msg.subject, 'Report Approved')
self.assertEqual(msg.to, ['*****@*****.**'])
response = self.client.get('/administrator/report/approve/%s' %
report.id)
self.assertEqual(response.status_code, 302)
def test_landing_page_with_registered_volunteers(self):
"""
Test details on manage shifts page with data registered.
"""
manage_shift_page = self.manage_shift_page
manage_shift_page.live_server_url = self.live_server_url
# Register volunteer
volunteer_1 = create_volunteer()
self.wait_for_home_page()
manage_shift_page.navigate_to_manage_shift_page()
self.assertNotEqual(manage_shift_page.find_table_row(), None)
manage_shift_page.select_volunteer(1)
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
def test_delete_org_with_associated_users(self):
# create org
org = create_organization()
volunteer = create_volunteer()
volunteer.organization = org
volunteer.save()
# delete org
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_organization_view()
self.delete_organization_from_list()
# check org not deleted message received
self.assertNotEqual(settings.get_danger_message(), None)
self.assertEqual(settings.get_template_error_message(),
'You cannot delete an organization that users are currently associated with.')
def test_delete_org_with_associated_users(self):
# create org
org = create_organization()
volunteer = create_volunteer()
volunteer.organization = org
volunteer.save()
# delete org
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_organization_view()
self.delete_organization_from_list()
# check org not deleted message received
self.assertNotEqual(settings.get_danger_message(), None)
self.assertEqual(
settings.get_template_error_message(),
'You cannot delete an organization that users are currently associated with.'
)
def test_delete_org_with_associated_users(self):
# create org
org = create_organization()
volunteer = create_volunteer()
volunteer.organization = org
volunteer.save()
# delete org
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_organization_view()
self.delete_organization_from_list()
# check org not deleted message received
self.assertNotEqual(settings.get_danger_message(), None)
self.assertEqual(settings.get_template_error_message(),
'You cannot delete an organization that users are currently associated with.')
# database check to ensure that organization is not deleted
self.assertEqual(len(Organization.objects.all()), 1)
self.assertNotEqual(len(Organization.objects.filter(name=org.name)), 0)
def test_email_on_reject_report(self):
self.report_page.go_to_admin_report()
vol = create_volunteer()
register_past_event_utility()
register_past_job_utility()
shift = register_past_shift_utility()
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=11, minute=0)
logged_shift = log_hours_with_details(vol, shift, start, end)
create_report_with_details(vol, logged_shift)
report_page = self.report_page
report_page.get_page(self.live_server_url,
PageUrls.administrator_report_page)
self.assertEqual(report_page.get_rejection_context(), 'Reject')
report_page.reject_report()
mail.outbox = []
mail.send_mail("Report Rejected", "message", "*****@*****.**",
[vol.email])
self.assertEqual(len(mail.outbox), 1)
msg = mail.outbox[0]
self.assertEqual(msg.subject, 'Report Rejected')
self.assertEqual(msg.to, ['*****@*****.**'])
def test_events_page_with_no_events(self):
"""
Test no event present at shifts sign up page
for volunteer to sign up for.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
# Register volunteers
volunteer_1 = create_volunteer()
manage_shift_page.live_server_url = self.live_server_url
self.wait_for_home_page()
# Open manage volunteer shift
self.manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
manage_shift_page.assign_shift()
self.assertEqual(sign_up_page.get_info_box().text,
sign_up_page.no_event_message)
def test_clear_hours(self):
"""
Test clearing of shift hours.
"""
manage_shift_page = self.manage_shift_page
self.manage_shift_page.live_server_url = self.live_server_url
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
start = datetime.time(hour=10, minute=0)
end = datetime.time(hour=14, minute=0)
logged_shift = log_hours_with_details(volunteer_1, shift_1, start, end)
self.wait_for_home_page()
# Open manage volunteer shift
manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
self.assertEqual(manage_shift_page.get_clear_shift_hours_text(),
'Clear Hours')
manage_shift_page.click_to_clear_hours()
manage_shift_page.submit_form()
self.assertEqual(
manage_shift_page.get_logged_info_box(),
"This volunteer does not have any shifts with logged hours.")
def test_cancel_assigned_shift(self):
"""
Test successful cancellation of shift.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
self.manage_shift_page.live_server_url = self.live_server_url
self.wait_for_home_page()
# Register volunteers
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
# Open manage volunteer shift
manage_shift_page.navigate_to_manage_shift_page()
# Volunteer-one does not have any registered shifts
manage_shift_page.select_volunteer(1)
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
manage_shift_page.assign_shift()
# Events shown in table
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-info',
sign_up_page.get_info_box)
sign_up_page.click_to_view_jobs()
sign_up_page.click_to_view_shifts()
# Arrived on shifts page, assign shift to volunteer one
slots_remaining_before_assignment = sign_up_page.get_remaining_slots()
sign_up_page.click_to_sign_up()
# Confirm on shift assignment to volunteer-one
sign_up_page.submit_form()
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-danger',
sign_up_page.get_danger_box)
# Check shift assignment to volunteer-one
manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
self.check_shift_details({
'job': 'job name',
'date': 'May 20, 2050',
'start_time': '9 a.m.',
'end_time': '3 p.m.'
})
# Cancel assigned shift
self.assertEqual(manage_shift_page.get_cancel_shift().text,
'Cancel Shift Registration')
manage_shift_page.cancel_shift()
self.assertNotEqual(manage_shift_page.get_cancellation_box(), None)
self.assertEqual(manage_shift_page.get_cancellation_message(),
'Yes, Cancel this Shift')
manage_shift_page.submit_form()
self.wait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'alert-info')))
# Check cancellation email
mail.outbox = []
mail.send_mail("Shift Cancelled", "message", "*****@*****.**",
[volunteer_1.email])
self.assertEqual(len(mail.outbox), 1)
msg = mail.outbox[0]
self.assertEqual(msg.subject, 'Shift Cancelled')
self.assertEqual(msg.to, ['*****@*****.**'])
# Check cancelled shift reflects in volunteer shift details
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
# Check slots remaining increases by one, after cancellation of
# assigned shift
manage_shift_page.assign_shift()
sign_up_page.click_to_view_jobs()
sign_up_page.click_to_view_shifts()
slots_after_cancellation = sign_up_page.get_remaining_slots()
self.assertEqual(slots_remaining_before_assignment,
slots_after_cancellation)
def setUp(self):
self.volunteer = create_volunteer()
self.login_volunteer()
def test_slots_remaining_in_shift(self):
"""
Test correct display of the remaining number of slots for shift.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
manage_shift_page.live_server_url = self.live_server_url
# Register volunteers
volunteer_1 = create_volunteer()
city_name = 'Bothell'
state_name = 'Washington'
country_name = 'United States'
city = get_city_by_name(city_name)
state = get_state_by_name(state_name)
country = get_country_by_name(country_name)
volunteer_2 = {
'username': '******',
'first_name': 'volunteer-two',
'last_name': 'volunteer-two',
'address': 'volunteer-two',
'city': city,
'state': state,
'country': country,
'phone_number': '9999999999',
'email': '*****@*****.**',
}
org_name = 'Google'
org_obj = create_organization_with_details(org_name)
volunteer_2 = create_volunteer_with_details(volunteer_2, org_obj)
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
# Open manage volunteer shift
manage_shift_page.navigate_to_manage_shift_page()
# Volunteer-one does not have any registered shifts
manage_shift_page.select_volunteer(1)
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
manage_shift_page.assign_shift()
# Events shown in table
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-info',
sign_up_page.get_info_box)
manage_shift_page.navigate_to_shift_assignment_page()
# Confirm on shift assignment to volunteer-one
manage_shift_page.submit_form()
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-danger',
sign_up_page.get_danger_box)
# Check shift assignment to volunteer-one
manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
self.check_shift_details({
'job': 'job name',
'date': 'May 20, 2050',
'start_time': '9 a.m.',
'end_time': '3 p.m.'
})
# Open manage volunteer shift again to assign shift to volunteer two
manage_shift_page.navigate_to_manage_shift_page()
# Volunteer-two does not have any registered shifts
manage_shift_page.select_volunteer(2)
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
manage_shift_page.assign_shift()
# No events shown in table
self.assertEqual(sign_up_page.get_info_box().text,
sign_up_page.no_event_message)
def setUp(self):
create_volunteer()
def setUp(self):
self.admin = create_admin()
self.volunteer = create_volunteer()
self.volunteer_id = str(self.volunteer.id)
def setUp(self):
admin = create_admin()
volunteer = create_volunteer()
def test_assign_shifts_with_registered_shifts(self):
"""
Test assignment of shift present at shifts sign up page
for volunteer to sign up for.
"""
sign_up_page = self.sign_up_page
manage_shift_page = self.manage_shift_page
manage_shift_page.live_server_url = self.live_server_url
# Register volunteers
volunteer_1 = create_volunteer()
shift = {
'date': '2050-05-20',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '1',
'address': 'shift-address',
'venue': 'venue-address',
}
shift_1 = self.create_shift(shift)
self.wait_for_home_page()
# Volunteer-one does not have any registered shifts
manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
self.assertEqual(manage_shift_page.get_info_box(),
manage_shift_page.no_volunteer_shift_message)
manage_shift_page.assign_shift()
# Events shown in table
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-info',
sign_up_page.get_info_box)
manage_shift_page.navigate_to_shift_assignment_page()
# Confirm on shift assignment to volunteer-one
manage_shift_page.submit_form()
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: .alert-danger',
sign_up_page.get_danger_box)
# Check shift assignment to volunteer-one
manage_shift_page.navigate_to_manage_shift_page()
manage_shift_page.select_volunteer(1)
self.check_shift_details({
'job': 'job name',
'date': 'May 20, 2050',
'start_time': '9 a.m.',
'end_time': '3 p.m.'
})
# check shift assignment email
mail.outbox = []
mail.send_mail("Shift Assigned", "message", "*****@*****.**",
[volunteer_1.email])
self.assertEqual(len(mail.outbox), 1)
msg = mail.outbox[0]
self.assertEqual(msg.subject, 'Shift Assigned')
self.assertEqual(msg.to, ['*****@*****.**'])
def setUp(self):
self.admin = create_admin()
self.volunteer = create_volunteer()
self.volunteer_id = str(self.volunteer.id)
def setUp(self):
self.v1 = create_volunteer()
self.login_volunteer()
