def test_null_values_in_create_shift(self):
# Register Event
event = ['event-name', '2050-05-24', '2050-05-28']
created_event = create_event_with_details(event)
self.settings.go_to_events_page()
settings = self.settings
# Create Job with not-null values
job = ['job', '2050-05-24', '2050-05-28', '', created_event]
create_job_with_details(job)
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_create_shift_page()
# Create Shift
shift = ['', '', '', '']
settings.fill_shift_form(shift)
# Checks:
# Shift not created
# Error messages appear
self.assertEqual(len(settings.get_help_blocks()), 4)
self.assertEqual(settings.get_shift_date_error(), 'This field is required.')
self.assertEqual(settings.get_shift_start_time_error(), 'This field is required.')
self.assertEqual(settings.get_shift_end_time_error(), 'This field is required.')
self.assertEqual(settings.get_shift_max_volunteer_error(), 'This field is required.')
def test_edit_job_with_invalid_event_date(self):
# register event first to create job
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
invalid_job_one = ['event-name', 'changed job name', 'job description', '2050-05-03', '2050-11-09']
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
# edit job with start date outside event start date
settings.navigate_to_job_list_view()
settings.go_to_edit_job_page()
settings.fill_job_form(invalid_job_one)
# check job not edited and proper error message displayed
self.assertNotEqual(self.driver.current_url, self.live_server_url + settings.job_list_page)
self.assertEqual(settings.get_warning_context(), 'Job dates should lie within Event dates')
invalid_job_two = ['event-name', 'changed job name', 'job description', '2050-09-14', '2050-12-31']
settings.navigate_to_job_list_view()
settings.go_to_edit_job_page()
settings.fill_job_form(invalid_job_two)
# check job not edited and proper error message displayed
self.assertNotEqual(self.driver.current_url, self.live_server_url + settings.job_list_page)
self.assertEqual(settings.get_warning_context(), 'Job dates should lie within Event dates')
def setUpModule():
"""
- Creates objects which can be reused by multiple test classes
- Creates jobs that can be used later for shift creation
"""
global e1, e2, j1, j2, j3
event_1 = ["Software Conference", "2012-10-3", "2012-11-25"]
event_2 = ["Django Conference", "2012-10-13", "2012-11-25"]
e1 = create_event_with_details(event_1)
e2 = create_event_with_details(event_2)
job_1 = [
"Software Developer", "2012-10-22", "2012-10-25", "A software job", e1
]
job_2 = [
"Systems Administrator", "2012-10-8", "2012-10-16",
"A systems administrator job", e1
]
job_3 = [
"Project Manager", "2012-11-2", "2012-11-12", "A management job", e1
]
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
j3 = create_job_with_details(job_3)
def test_edit_job(self):
# register event first to create job
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
edit_job = [
'event-name', 'changed job name', 'job description', '2050-08-25',
'2050-08-25'
]
settings.navigate_to_job_list_view()
settings.go_to_edit_job_page()
settings.fill_job_form(edit_job)
settings.navigate_to_job_list_view()
# check job edited
self.assertEqual(settings.remove_i18n(self.driver.current_url),
self.live_server_url + settings.job_list_page)
self.assertEqual(settings.get_job_name(), 'changed job name')
def test_delete_event_with_associated_job(self):
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
# check event created
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), created_event.name)
# delete event
self.delete_event_from_list()
self.assertNotEqual(settings.get_danger_message(), None)
self.assertEqual(
settings.get_template_error_message(),
'You cannot delete an event that a job is currently associated with.'
)
# check event NOT deleted
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), 'event-name')
def test_delete_job_without_associated_shift(self):
# register event first to create job
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_job_list_view()
self.assertEqual(settings.get_job_name(), 'job')
self.assertEqual(settings.get_job_event(), 'event-name')
# delete job
self.delete_job_from_list()
settings.navigate_to_job_list_view()
# check event deleted
self.assertEqual(settings.remove_i18n(self.driver.current_url),
self.live_server_url + settings.job_list_page)
with self.assertRaises(NoSuchElementException):
settings.get_results()
def test_edit_event_with_invalid_job_date(self):
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# Create Job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), created_event.name)
settings.go_to_edit_event_page()
# Edit event such that job is no longer in the new date range
new_event = ['new-event-name', '2017-08-30', '2017-09-21']
settings.fill_event_form(new_event)
# check event not edited and error message displayed
self.assertNotEqual(self.driver.current_url,
self.live_server_url + settings.event_list_page)
self.assertEqual(
settings.element_by_xpath(
self.elements.TEMPLATE_ERROR_MESSAGE).text,
'You cannot edit this event as the following associated job no longer '
'lies within the new date range :')
def test_delete_event_with_associated_job(self):
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
# check event created
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), created_event.name)
# delete event
self.delete_event_from_list()
self.assertNotEqual(settings.get_danger_message(), None)
self.assertEqual(settings.get_template_error_message(),
'You cannot delete an event that a job is currently associated with.')
# check event NOT deleted
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), 'event-name')
def setUpModule():
"""
- Creates objects which can be reused by multiple test classes
- Creates jobs that can be used later for shift creation
"""
global e1, e2, j1, j2, j3
event_1 = ["Software Conference", "2012-10-3", "2012-11-25"]
event_2 = ["Django Conference", "2012-10-13", "2012-11-25"]
e1 = create_event_with_details(event_1)
e2 = create_event_with_details(event_2)
job_1 = [
"Software Developer", "2012-10-22", "2012-10-25", "A software job", e1
]
job_2 = [
"Systems Administrator", "2012-10-8", "2012-10-16",
"A systems administrator job", e1
]
job_3 = [
"Project Manager", "2012-11-2", "2012-11-12", "A management job", e1
]
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
j3 = create_job_with_details(job_3)
def test_edit_event_with_invalid_job_date(self):
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# Create Job
job = ['job', '2050-08-21', '2050-08-21', '', created_event]
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), created_event.name)
settings.go_to_edit_event_page()
# Edit event such that job is no longer in the new date range
new_event = ['new-event-name', '2017-08-30', '2017-09-21']
settings.fill_event_form(new_event)
# check event not edited and error message displayed
self.assertNotEqual(self.driver.current_url, self.live_server_url + settings.event_list_page)
self.assertEqual(settings.element_by_xpath(self.elements.TEMPLATE_ERROR_MESSAGE).text,
'You cannot edit this event as the following associated job no longer '
'lies within the new date range :')
def setUpModule():
"""
- Creates objects which can be reused by multiple test classes
- Creates shifts with limited slots and with multiple slots for use
"""
global e1
global j1, j2
global s1, s2, s3
event_1 = ["Open Source Event", "2012-9-1", "2012-11-23"]
e1 = create_event_with_details(event_1)
job_1 = [
"Software Developer", "2012-10-22", "2012-10-30", "A software job", e1
]
job_2 = [
"Systems Administrator", "2012-9-1", "2012-10-26",
"A systems administrator job", e1
]
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
shift_1 = ["2012-10-28", "9:00", "15:00", 1, j1]
shift_2 = ["2012-10-25", "10:00", "16:00", 2, j1]
shift_3 = ["2012-10-22", "10:00", "16:00", 4, j2]
s1 = create_shift_with_details(shift_1)
s2 = create_shift_with_details(shift_2)
s3 = create_shift_with_details(shift_3)
def setUpModule():
"""
- Creates objects which can be reused by multiple test classes
- Creates shifts with limited slots and with multiple slots for use
"""
global e1
global j1, j2
global s1, s2, s3
event_1 = ["Open Source Event", "2012-9-1", "2012-11-23"]
e1 = create_event_with_details(event_1)
job_1 = [
"Software Developer", "2012-10-22", "2012-10-30", "A software job", e1
]
job_2 = [
"Systems Administrator", "2012-9-1", "2012-10-26",
"A systems administrator job", e1
]
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
shift_1 = ["2012-10-28", "9:00", "15:00", 1, j1]
shift_2 = ["2012-10-25", "10:00", "16:00", 2, j1]
shift_3 = ["2012-10-22", "10:00", "16:00", 4, j2]
s1 = create_shift_with_details(shift_1)
s2 = create_shift_with_details(shift_2)
s3 = create_shift_with_details(shift_3)
def test_null_values_in_edit_job(self):
# Register Event
event = ['event-name', '2050-05-24', '2050-05-28']
created_event = create_event_with_details(event)
self.settings.go_to_events_page()
settings = self.settings
# Create Job with not-null values
job = ['job', '2050-05-24', '2050-05-28', '', created_event]
create_job_with_details(job)
# Go to Edit job page
settings.live_server_url = self.live_server_url
settings.navigate_to_job_list_view()
settings.go_to_edit_job_page()
# Edit job with null values
settings.fill_job_form([created_event.id, '', '', '', ''])
# Checks:
# Job not edited
# Error messages appear
self.assertNotEqual(self.driver.current_url, self.live_server_url + settings.job_list_page)
self.assertEqual(len(settings.get_help_blocks()), 3)
self.assertEqual(settings.get_job_name_error(), 'This field is required.')
self.assertEqual(settings.get_job_start_date_error(), 'This field is required.')
self.assertEqual(settings.get_job_end_date_error(), 'This field is required.')
def test_event_job_field(self):
"""
Test search results for event job field
"""
search_page = self.search_page
search_page.live_server_url = self.live_server_url
credentials_1 = ['event-name', '2015-01-01', '2015-03-01']
event_1 = create_event_with_details(credentials_1)
credentials_2 = [
'event-nameq', '2015-02-01', '2015-04-01']
event_2 = create_event_with_details(credentials_2)
expected_result_one = ['event-name', 'Jan.', '1,', '2015', 'March', '1,', '2015', 'Details', 'Edit', 'Delete']
expected_result_two = ['event-nameq', 'Feb.', '1,', '2015', 'April', '1,', '2015', 'Details', 'Edit', 'Delete']
# job_1 for event_1, job_2 for event_2
job = ['job-name', '2015-02-01', '2015-02-15', 'job-description', event_1]
job_1 = create_job_with_details(job)
job = ['job-nameq', '2015-02-02', '2015-02-15', 'job-descriptionq', event_2]
job_2 = create_job_with_details(job)
# search job_1 and job_2
search_page.navigate_to_event_search_page()
search_page.search_job_field("job-name")
search_results = search_page.get_search_results()
result = search_page.get_results_list(search_results)
self.assertEqual(len(result), 2)
self.assertTrue(expected_result_one in result)
self.assertTrue(expected_result_two in result)
def test_intersection_of_all_fields(self):
"""
Test search results for different combinations of event name, start date, end date, city, state, country and job
"""
search_page = self.search_page
search_page.live_server_url = self.live_server_url
credentials_1 = ['event-name', '2015-01-01', '2015-03-01']
event_1 = create_event_with_details(credentials_1)
event_1.country = 'event-country'
event_1.state = 'event-state'
event_1.city = 'event-city'
event_1.save()
job = ['job', '2015-02-01', '2015-02-15', 'descriptionq', event_1]
job_1 = create_job_with_details(job)
credentials_2 = [
'event-nameq', '2015-02-01', '2015-04-01']
event_2 = create_event_with_details(credentials_2)
event_2.country = 'event-countryq'
event_2.state = 'event-stateq'
event_2.city = 'event-cityq'
event_2.save()
job = ['jobq', '2015-02-02', '2015-02-15', 'job-description', event_2]
job_2 = create_job_with_details(job)
expected_result_one = ['event-name', 'Jan.', '1,', '2015', 'March', '1,', '2015', 'Details', 'Edit', 'Delete']
expected_result_two = ['event-nameq', 'Feb.', '1,', '2015', 'April', '1,', '2015', 'Details', 'Edit', 'Delete']
search_page.navigate_to_event_search_page()
search_page.search_name_field('event')
search_page.search_start_date_field('2015-01-01')
search_page.search_end_date_field('2015-04-01')
search_page.search_state_field('event')
search_page.search_country_field('event')
search_page.search_job_field('job')
search_page.submit_form()
search_results = search_page.get_search_results()
result = search_page.get_results_list(search_results)
self.assertTrue(expected_result_one in result)
self.assertTrue(expected_result_two in result)
search_page.search_name_field('event')
search_page.search_country_field('wrong-country')
search_page.search_job_field(job_1.id)
search_page.submit_form()
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: //table//tbody',
search_page.get_search_results)
search_page.search_state_field('event')
search_page.search_city_field('wrong-city')
search_page.submit_form()
self.assertRaisesRegexp(NoSuchElementException,
'Unable to locate element: //table//tbody',
search_page.get_search_results)
def setup_test_data(cls):
event_1 = ["Software Conference","2012-10-3","2012-10-24"]
cls.e1 = create_event_with_details(event_1)
job_1 = ["Software Developer","2012-10-22","2012-10-23","A software job",e1]
job_2 = ["Systems Administrator","2012-10-8","2012-10-16","A systems administrator job",e1]
cls.j1 = create_job_with_details(job_1)
cls.j2 = create_job_with_details(job_2)
shift_1 = ["2012-10-23","1:00","3:00",1,cls.j1]
cls.s1 = create_shift_with_details(shift_1)
def test_edit_event_with_invalid_job_date(self):
"""
Test edit of event with invalid date such that
the job dates do not lie in it.
"""
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-21',
'description': '',
'event': created_event
}
create_job_with_details(job)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_event_list_view()
self.assertEqual(settings.get_event_name(), created_event.name)
settings.go_to_edit_event_page()
# Edit event such that job is no longer in the new date range
new_event = {
'name': 'new-event-name',
'start_date': '2017-08-30',
'end_date': '2017-09-21',
'address': 'event-address',
'venue': 'event-venue',
'description': 'event-description'
}
settings.fill_event_form(new_event)
# check event not edited and error message displayed
self.assertNotEqual(self.driver.current_url,
self.live_server_url + settings.event_list_page)
self.assertEqual(
settings.element_by_xpath(
self.elements.TEMPLATE_ERROR_MESSAGE).text,
'You cannot edit this event as the following associated '
'job no longer lies within the new date range :')
def setUpModule():
"""
- Creates objects which can be reused by multiple test classes
- Creates jobs that can be used later for shift creation
"""
global e1, e2, j1, j2, j3
event_1 = {
'name': "Software Conference",
'start_date': "2012-10-3",
'end_date': "2012-11-25",
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
}
event_2 = {
'name': "Django Conference",
'start_date': "2012-10-13",
'end_date': "2012-11-25",
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
}
e1 = create_event_with_details(event_1)
e2 = create_event_with_details(event_2)
job_1 = {
'name': "Software Developer",
'start_date': "2012-10-22",
'end_date': "2012-10-25",
'description': "A software job",
'event': e1
}
job_2 = {
'name': "Systems Administrator",
'start_date': "2012-10-8",
'end_date': "2012-10-16",
'description': "A systems administrator job",
'event': e1
}
job_3 = {
'name': "Project Manager",
'start_date': "2012-11-2",
'end_date': "2012-11-12",
'description': "A management job",
'event': e1
}
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
j3 = create_job_with_details(job_3)
def setUpModule():
"""
Creates events, jobs and shifts which can be reused by multiple test classes
"""
global e1, e2, e3, e4, e5
global j1, j2, j3, j4, j5
global s1, s2, s3, s4
event_1 = ["Open Source Event", "2012-10-22", "2012-10-23"]
event_2 = ["Python Event", "2013-11-12", "2013-11-13"]
event_3 = ["Django Event", "2015-07-02", "2015-07-03"]
event_4 = ["Systers Event", "2015-07-25", "2015-08-08"]
event_5 = ["Anita Borg Event", "2015-07-07", "2015-07-08"]
e1 = create_event_with_details(event_1)
e2 = create_event_with_details(event_2)
e3 = create_event_with_details(event_3)
e4 = create_event_with_details(event_4)
e5 = create_event_with_details(event_5)
job_1 = [
"Software Developer", "2012-10-22", "2012-10-23", "A software job", e1
]
job_2 = [
"Systems Administrator", "2013-11-12", "2013-11-13",
"A systems administrator job", e2
]
job_3 = [
"Backend Dev", "2012-10-8", "2012-10-16", "A java developer job", e4
]
job_4 = ["Instructor", "2012-10-22", "2012-10-23", "", e4]
job_5 = ["Instructor", "2012-10-22", "2012-10-23", "", e3]
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
j3 = create_job_with_details(job_3)
j4 = create_job_with_details(job_4)
j5 = create_job_with_details(job_5)
# shifts with limited, plenty and no slots
shift_1 = ["2012-10-23", "9:00", "15:00", 1, j1]
shift_2 = ["2012-10-23", "10:00", "16:00", 2, j1]
shift_3 = ["2013-11-12", "12:00", "18:00", 4, j2]
shift_4 = ["2013-10-23", "10:00", "18:00", 1, j4]
s1 = create_shift_with_details(shift_1)
s2 = create_shift_with_details(shift_2)
s3 = create_shift_with_details(shift_3)
s4 = create_shift_with_details(shift_4)
def setUpModule():
"""
Creates events, jobs and shifts which can be reused by multiple test classes
"""
global e1, e2, e3, e4, e5
global j1, j2, j3, j4, j5
global s1, s2, s3, s4
event_1 = ["Open Source Event", "2012-10-22", "2012-10-23"]
event_2 = ["Python Event", "2013-11-12", "2013-11-13"]
event_3 = ["Django Event", "2015-07-02", "2015-07-03"]
event_4 = ["Systers Event", "2015-07-25", "2015-08-08"]
event_5 = ["Anita Borg Event", "2015-07-07", "2015-07-08"]
e1 = create_event_with_details(event_1)
e2 = create_event_with_details(event_2)
e3 = create_event_with_details(event_3)
e4 = create_event_with_details(event_4)
e5 = create_event_with_details(event_5)
job_1 = [
"Software Developer", "2012-10-22", "2012-10-23", "A software job", e1
]
job_2 = [
"Systems Administrator", "2013-11-12", "2013-11-13",
"A systems administrator job", e2
]
job_3 = [
"Backend Dev", "2012-10-8", "2012-10-16", "A java developer job", e4
]
job_4 = ["Instructor", "2012-10-22", "2012-10-23", "", e4]
job_5 = ["Instructor", "2012-10-22", "2012-10-23", "", e3]
j1 = create_job_with_details(job_1)
j2 = create_job_with_details(job_2)
j3 = create_job_with_details(job_3)
j4 = create_job_with_details(job_4)
j5 = create_job_with_details(job_5)
# shifts with limited, plenty and no slots
shift_1 = ["2012-10-23", "9:00", "15:00", 1, j1]
shift_2 = ["2012-10-23", "10:00", "16:00", 2, j1]
shift_3 = ["2013-11-12", "12:00", "18:00", 4, j2]
shift_4 = ["2013-10-23", "10:00", "18:00", 1, j4]
s1 = create_shift_with_details(shift_1)
s2 = create_shift_with_details(shift_2)
s3 = create_shift_with_details(shift_3)
s4 = create_shift_with_details(shift_4)
def register_dataset():
"""
Utility function to create data for testing
:return: Shift type of object.
"""
e1 = create_event_with_details({
'name': 'event',
'start_date': '2050-06-15',
'end_date': '2050-06-17',
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
})
j1 = create_job_with_details({
'name': 'job',
'start_date': '2050-06-15',
'end_date': '2050-06-15',
'description': 'job description',
'event': e1
})
s1 = create_shift_with_details({
'date': '2050-06-15',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '6',
'job': j1,
'address': 'shift-address',
'venue': 'shift-venue'
})
return s1
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 register_dataset(self):
e1 = create_event_with_details(['event', '2017-06-15', '2017-06-17'])
j1 = create_job_with_details(
['job', '2017-06-15', '2017-06-15', 'job description', e1])
s1 = create_shift_with_details(
['2017-06-15', '09:00', '15:00', '6', j1])
return s1
def test_delete_shift(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)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
self.assertNotEqual(settings.get_results(), None)
# delete shift
self.delete_shift_from_list()
# check deletion of shift
settings.navigate_to_shift_list_view()
self.assertEqual(settings.get_message_context(),
'There are currently no shifts. Please create shifts first.')
# database check to ensure that shift is deleted
self.assertEqual(len(Shift.objects.all()), 0)
def test_assign_shifts_with_no_shifts(self):
"""
Test no 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
org_obj = create_organization_with_details(self.org_name)
volunteer_1 = create_volunteer_with_details(self.volunteer_1, org_obj)
# Create events
event = ['event-name', '2017-05-20', '2017-05-20']
event_1 = create_event_with_details(event)
# Create jobs
job = ['job name', '2017-05-20', '2017-05-20', 'job description', event_1]
job_1 = create_job_with_details(job)
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()
# No events shown in table
self.assertEqual(sign_up_page.get_info_box().text,
sign_up_page.no_event_message)
def register_unlogged_dataset(self):
"""
Utility function to register data for testing.
"""
created_event = create_event_with_details({
'name': 'event-unlogged',
'start_date': '2015-06-01',
'end_date': '2015-06-10',
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
})
created_job = create_job_with_details({
'name': 'jobUnlogged',
'start_date': '2015-06-01',
'end_date': '2015-06-10',
'description': 'job description',
'event': created_event
})
created_shift = create_shift_with_details({
'date': '2015-06-01',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '10',
'job': created_job,
'address': 'shift-address',
'venue': 'shift-venue'
})
registered_shift =\
register_volunteer_for_shift_utility(created_shift, self.v1)
def register_logged_dataset(self):
"""
Utility function to create valid data for test.
"""
# Create shift and log hours
e1 = create_event_with_details({
'name': 'event',
'start_date': '2015-06-15',
'end_date': '2015-06-17',
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
})
j1 = create_job_with_details({
'name': 'job',
'start_date': '2015-06-15',
'end_date': '2015-06-15',
'description': 'job description',
'event': e1
})
s1 = create_shift_with_details({
'date': '2015-06-15',
'start_time': '09:00',
'end_time': '15:00',
'max_volunteers': '6',
'job': j1,
'address': 'shift-address',
'venue': 'shift-venue'
})
log_hours_with_details(self.v1, s1, '12:00', '13:00')
def test_edit_job(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-21', '',created_event]
created_job = create_job_with_details(job)
settings = self.settings
settings.live_server_url = self.live_server_url
edit_job = ['event-name','changed job name','job description',
'2017-08-25', '2017-08-25']
settings.navigate_to_job_list_view()
settings.go_to_edit_job_page()
settings.fill_job_form(edit_job)
# check job edited
self.assertEqual(self.driver.current_url,
self.live_server_url + settings.job_list_page)
self.assertEqual(settings.get_job_name(), 'changed job name')
# database check to ensure that job edited correctly
self.assertEqual(len(Job.objects.all()), 1)
self.assertNotEqual(len(Job.objects.filter(name=edit_job[1])), 0)
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 create_shift(shift):
"""
Utility function to create a valid shift.
:param shift: Iterable containing details of shift.
:return: Shift type object.
"""
# Register event to create job
event = {
'name': 'event-name',
'start_date': '2050-05-20',
'end_date': '2050-05-20',
'description': 'event-description',
'address': 'event-address',
'venue': 'event-venue'
}
e1 = create_event_with_details(event)
# Create job to create shift
job = {
'name': 'job name',
'start_date': '2050-05-20',
'end_date': '2050-05-20',
'description': 'job description',
'event': e1
}
j1 = create_job_with_details(job)
# Create shift to assign
shift['job'] = j1
s1 = create_shift_with_details(shift)
return s1
def test_edit_shift_with_invalid_date(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)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# edit shift with date not between job dates
invalid_shift = ['02/05/2017', '04:00', '13:00', '2']
settings.fill_shift_form(invalid_shift)
# verify that shift was not edited and error message displayed
self.assertEqual(settings.get_warning_context(),
'Shift date should lie within Job dates')
# database check to ensure that shift was not edited
self.assertEqual(len(Shift.objects.all()), 1)
self.assertNotEqual(len(Shift.objects.filter(date=created_shift.date)), 0)
def test_edit_shift_with_invalid_timings(self):
# register event first to create job
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-30', '', created_event]
created_job = create_job_with_details(job)
# create shift
shift = ['2050-08-21', '09:00', '12:00', '10', created_job]
create_shift_with_details(shift)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# edit shift with end hours less than start hours
invalid_shift = ['08/30/2050', '18:00', '13:00', '5']
settings.fill_shift_form(invalid_shift)
# verify that shift was not edited and error message displayed
self.assertEqual(settings.get_warning_context(),
'Shift end time should be greater than start time')
def test_delete_job_without_associated_shift(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-21', '',created_event]
created_job = create_job_with_details(job)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_job_list_view()
self.assertEqual(settings.get_job_name(), 'job')
self.assertEqual(settings.get_job_event(), 'event-name')
# delete job
self.delete_job_from_list()
# check event deleted
self.assertEqual(self.driver.current_url,
self.live_server_url + settings.job_list_page)
with self.assertRaises(NoSuchElementException):
settings.get_results()
# database check to ensure that job is deleted
self.assertEqual(len(Job.objects.all()), 0)
def test_create_shift(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)
settings = self.settings
settings.live_server_url = self.live_server_url
# create shift
settings.navigate_to_shift_list_view()
settings.go_to_create_shift_page()
shift = ['08/30/2017', '09:00', '12:00', '10']
settings.fill_shift_form(shift)
# verify that shift was created
self.assertNotEqual(settings.get_results(), None)
with self.assertRaises(NoSuchElementException):
settings.get_help_block()
# database check to ensure that shift created with proper job
self.assertEqual(len(Shift.objects.all()), 1)
self.assertNotEqual(len(Shift.objects.filter(job=created_job)), 0)
def test_edit_job_with_invalid_shift_date(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-21', '',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)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_job_list_view()
invalid_job_one = ['event-name','changed job name','job description',
'2017-09-01', '2017-09-11']
# edit job with date range such that the shift start date no longer
# falls in the range
settings.go_to_edit_job_page()
settings.fill_job_form(invalid_job_one)
# check job not edited and proper error message displayed
self.assertNotEqual(self.driver.current_url,
self.live_server_url +settings.job_list_page)
self.assertEqual(settings.get_template_error_message(),
'You cannot edit this job as 1 associated shift no longer lies within the new date range')
# database check to ensure that job not edited
self.assertEqual(len(Job.objects.all()), 1)
self.assertNotEqual(len(Job.objects.filter(name=created_job.name)), 0)
def test_simplify_shift(self):
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
event = ['event-name', '2050-05-24', '2050-05-28']
created_event = create_event_with_details(event)
job = ['job', '2050-05-24', '2050-05-28', '', created_event]
created_job = create_job_with_details(job)
settings.navigate_to_shift_list_view()
settings.go_to_create_shift_page()
# Check correctness of Job name and date.
self.assertEqual(settings.get_shift_job(), 'job')
self.assertEqual(settings.get_shift_job_start_date(), 'May 24, 2050')
self.assertEqual(settings.get_shift_job_end_date(), 'May 28, 2050')
# Create shift and check job details in edit form
shift = ['2050-05-28', '09:00', '12:00', '10', created_job]
create_shift_with_details(shift)
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# Check correctness of Job name and date.
self.assertEqual(settings.get_shift_job(), 'job')
self.assertEqual(settings.get_shift_job_start_date(), 'May 24, 2050')
self.assertEqual(settings.get_shift_job_end_date(), 'May 28, 2050')
def test_delete_job_with_associated_shifts(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-21', '',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)
settings = self.settings
settings.live_server_url = self.live_server_url
# delete job
settings.navigate_to_job_list_view()
self.delete_job_from_list()
self.assertNotEqual(settings.get_danger_message(), None)
self.assertEqual(settings.get_template_error_message(),
'You cannot delete a job that a shift is currently associated with.')
# check job NOT deleted
settings.navigate_to_job_list_view()
self.assertEqual(settings.get_job_name(), 'job')
# database check to ensure that job is not deleted
self.assertEqual(len(Job.objects.all()), 1)
self.assertNotEqual(len(Job.objects.filter(name = created_job.name)), 0)
def test_edit_shift_with_invalid_timings(self):
# register event first to create job
event = ['event-name', '2050-08-21', '2050-09-28']
created_event = create_event_with_details(event)
# create job
job = ['job', '2050-08-21', '2050-08-30', '', created_event]
created_job = create_job_with_details(job)
# create shift
shift = ['2050-08-21', '09:00', '12:00', '10', created_job]
create_shift_with_details(shift)
self.settings.go_to_events_page()
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# edit shift with end hours less than start hours
invalid_shift = ['08/30/2050', '18:00', '13:00', '5']
settings.fill_shift_form(invalid_shift)
# verify that shift was not edited and error message displayed
self.assertEqual(settings.get_warning_context(), 'Shift end time should be greater than start time')
def test_create_shift_with_invalid_date(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)
settings = self.settings
settings.live_server_url = self.live_server_url
# create shift
settings.navigate_to_shift_list_view()
settings.go_to_create_shift_page()
shift = ['06/30/2017', '14:00', '18:00', '5']
settings.fill_shift_form(shift)
# verify that shift was not created and error message displayed
self.assertEqual(settings.get_warning_context(),
'Shift date should lie within Job dates')
# database check to ensure that shift was not created
self.assertEqual(len(Shift.objects.all()), 0)
def test_null_values_in_edit_job(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 with values
job = ['job', '2017-08-21', '2017-08-21', '',created_event]
created_job = create_job_with_details(job)
# verify the job was created and proceed to edit it
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_job_list_view()
settings.go_to_edit_job_page()
# send null values to fields
settings.fill_job_form([created_event.id,'','','',''])
# check that job was not edited and that error messages appear as
# expected
self.assertNotEqual(self.driver.current_url,
self.live_server_url + settings.job_list_page)
self.assertEqual(len(settings.get_help_blocks()), 3)
self.assertEqual(settings.get_job_name_error(), 'This field is required.')
self.assertEqual(settings.get_job_start_date_error(), 'This field is required.')
self.assertEqual(settings.get_job_end_date_error(), 'This field is required.')
# database check to ensure that job not edited
self.assertEqual(len(Job.objects.all()), 1)
self.assertNotEqual(len(Job.objects.filter(name=created_job.name)), 0)
def test_edit_shift(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)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# edit shift with date between job dates
shift = ['08/25/2017', '10:00', '13:00', '2']
settings.fill_shift_form(shift)
with self.assertRaises(NoSuchElementException):
settings.get_help_block()
self.assertEqual(settings.get_shift_date(), 'Aug. 25, 2017')
# database check to ensure that shift was edited
self.assertEqual(len(Shift.objects.all()), 1)
self.assertEqual(len(Shift.objects.filter(date=created_shift.date)), 0)
def test_null_values_in_edit_shift(self):
# register event to create job
event = ['event-name', '2017-08-21', '2017-09-28']
created_event = create_event_with_details(event)
# create job with values
job = ['job', '2017-08-21', '2017-08-21', '',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)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# edit shift with null values
shift = ['', '', '', '']
settings.fill_shift_form(shift)
# verify that shift was not edited and error messages appear as
# expected
self.assertEqual(len(settings.get_help_blocks()), 4)
self.assertEqual(settings.get_shift_date_error(), 'This field is required.')
self.assertEqual(settings.get_shift_start_time_error(), 'This field is required.')
self.assertEqual(settings.get_shift_end_time_error(), 'This field is required.')
self.assertEqual(settings.get_shift_max_volunteer_error(), 'This field is required.')
# database check to ensure that shift was not edited
self.assertEqual(len(Shift.objects.all()), 1)
self.assertNotEqual(len(Shift.objects.filter(date=created_shift.date)), 0)
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_max_volunteer_field(self):
event = ['event-name', '2017-08-21', '2017-09-28']
created_event = create_event_with_details(event)
job = ['job', '2017-08-21', '2017-08-21', '',created_event]
created_job = create_job_with_details(job)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_create_shift_page()
invalid_shift = ['01/01/2016','12:00','11:00','0']
settings.fill_shift_form(invalid_shift)
# verify that error message displayed
self.assertEqual(settings.get_shift_max_volunteer_error(),
'Ensure this value is greater than or equal to 1.')
# Create shift and try editing it with 0 value
shift = ['2017-08-21', '09:00', '12:00', '10', created_job]
created_shift = create_shift_with_details(shift)
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
settings.fill_shift_form(invalid_shift)
# verify that error message displayed
self.assertEqual(settings.get_shift_max_volunteer_error(),
'Ensure this value is greater than or equal to 1.')
def setup_test_data(cls):
cls.e1 = e1
cls.j1 = j1
cls.j3 = j3
# job with no shifts
cls.j2 = j2
# job with shift which has no slot
job_4 = ["Information Technologist","2012-11-2","2012-12-2","An IT job",e1]
cls.j4 = create_job_with_details(job_4)
shift_1 = ["2012-10-23","1:00","3:00",1,cls.j1]
shift_2 = ["2012-10-25","2:00","4:00",2,cls.j1]
shift_3 = ["2012-10-24","12:00","18:00",4,cls.j3]
# shift with no slots
shift_4 = ["2012-11-7","12:00","18:00",1,cls.j4]
cls.s1 = create_shift_with_details(shift_1)
cls.s2 = create_shift_with_details(shift_2)
cls.s3 = create_shift_with_details(shift_3)
cls.s4 = create_shift_with_details(shift_4)
# creating volunteers who would register for the shifts
volunteer_1 = ['Yoshi',"Yoshi","Turtle","Mario Land","Nintendo Land","Nintendo State","Nintendo Nation","2374983247","*****@*****.**"]
volunteer_2 = ['John',"John","Doe","7 Alpine Street","Maplegrove","Wyoming","USA","23454545","*****@*****.**"]
volunteer_3 = ['Ash',"Ash","Ketchum","Pallet Town","Kanto","Gameboy","Japan","23454545","*****@*****.**"]
cls.v1 = create_volunteer_with_details(volunteer_1)
cls.v2 = create_volunteer_with_details(volunteer_2)
cls.v3 = create_volunteer_with_details(volunteer_3)
def test_simplify_shift(self):
event = ['event-name', '2017-08-21', '2017-09-28']
created_event = create_event_with_details(event)
job = ['job', '2017-08-21', '2017-08-21', '',created_event]
created_job = create_job_with_details(job)
settings = self.settings
settings.live_server_url = self.live_server_url
settings.navigate_to_shift_list_view()
settings.go_to_create_shift_page()
# verify that the correct job name and date are displayed
self.assertEqual(settings.get_shift_job(), 'job')
self.assertEqual(settings.get_shift_job_start_date(), 'Aug. 21, 2017')
self.assertEqual(settings.get_shift_job_end_date(), 'Aug. 21, 2017')
# Create shift and check job details in edit form
shift = ['2017-08-21', '09:00', '12:00', '10', created_job]
created_shift = create_shift_with_details(shift)
settings.navigate_to_shift_list_view()
settings.go_to_edit_shift_page()
# verify that the correct job name and date are displayed
self.assertEqual(settings.get_shift_job(), 'job')
self.assertEqual(settings.get_shift_job_start_date(), 'Aug. 21, 2017')
self.assertEqual(settings.get_shift_job_end_date(), 'Aug. 21, 2017')
