class TestAmity(unittest.TestCase):
def setUp(self):
self.test_amity = Amity()
"""Create living space"""
self.test_amity.create_room({
"<room_name>": ["LivingA"],
"Living": True,
"Office": False
})
"""Create office"""
self.test_amity.create_room({
"<room_name>": ["OfficeA"],
"Living": False,
"Office": True
})
# Assign rooms to variables
self.livinga = self.test_amity.livingspaces[0]
self.officea = self.test_amity.offices[0]
"""Add fellow that wants space"""
self.test_amity.add_person({
"<first_name>": "Test",
"<last_name>": "Fellow",
"<wants_space>": "Y",
"Fellow": True,
"Staff": False
})
"""Add staff member that wants space"""
self.test_amity.add_person({
"<first_name>": "Test",
"<last_name>": "Staff",
"<wants_space>": "Y",
"Fellow": False,
"Staff": True
})
# Assign people to variables
self.testfellow = self.test_amity.people[0]
self.teststaff = self.test_amity.people[1]
def test_create_room(self):
"""Test creation of rooms"""
# LivingA and OfficeA from setup() added to relevant lists
self.assertEqual(2, len(self.test_amity.rooms))
self.assertEqual(1, len(self.test_amity.livingspaces))
self.assertEqual(1, len(self.test_amity.offices))
"""Test creation of multiple living spaces"""
self.test_amity.create_room({
"<room_name>": ["LivingB", "LivingC"],
"Living": True,
"Office": False
})
# Two living spaces added to list of rooms and list of living spaces
self.assertEqual(4, len(self.test_amity.rooms))
self.assertEqual(3, len(self.test_amity.livingspaces))
"""Test creation of multiple offices"""
self.test_amity.create_room({
"<room_name>": ["OfficeB", "OfficeC"],
"Living": False,
"Office": True
})
# Two offices added to list of rooms and list of offices
self.assertEqual(6, len(self.test_amity.rooms))
self.assertEqual(3, len(self.test_amity.offices))
"""Test that duplicate rooms are not added"""
self.test_amity.create_room({
"<room_name>": ["OfficeA", "OfficeB"],
"Living": False,
"Office": True
})
# Duplicate rooms not added to any list
self.assertEqual(6, len(self.test_amity.rooms))
self.assertEqual(3, len(self.test_amity.offices))
def test_add_person(self):
"""Test addition of people"""
# Test Fellow and Test Staff from setup() added to relevant lists
self.assertEqual(2, len(self.test_amity.people))
self.assertEqual(1, len(self.test_amity.fellows))
self.assertEqual(1, len(self.test_amity.staff))
"""Test allocation of those who want space"""
# Check that people have been appended to rooms' lists of occupants
self.assertEqual(2, len(self.officea.occupants))
def test_vacant_offices(self):
"""Test that vacant rooms are added to relevant list"""
# Add office
self.test_amity.create_room({
"<room_name>": ["OfficeB"],
"Living": False,
"Office": True
})
self.test_amity.check_vacant_rooms()
# Check if OfficeB has been appended to relevant lists
self.assertEqual(2, len(self.test_amity.vacant_offices))
self.assertEqual(3, len(self.test_amity.vacant_rooms))
def test_reallocate_person(self):
"""Add another office"""
self.test_amity.create_room({
"<room_name>": ["OfficeB"],
"Living": False,
"Office": True
})
# Assign OfficeB to variable
officeb = self.test_amity.offices[1]
"""Test reallocation of Test Staff from OfficeA to OfficeB"""
self.test_amity.reallocate_person({
"<employee_id>":
int(self.teststaff.emp_id),
"<new_room_name>":
"OfficeB"
})
# Staff member no longer in OfficeA's list of occupants
self.assertEqual(1, len(self.officea.occupants))
# Staff member now in OfficeB's list of occupants
self.assertEqual(1, len(officeb.occupants))
"""Add another living space"""
self.test_amity.create_room({
"<room_name>": ["LivingB"],
"Living": True,
"Office": False
})
# Assign LivingB to variable
livingb = self.test_amity.livingspaces[1]
"""Test allocation of Test Fellow to LivingB"""
self.test_amity.reallocate_person({
"<employee_id>":
int(self.testfellow.emp_id),
"<new_room_name>":
"LivingB"
})
# Fellow now in LivingB's list of occupants
self.assertEqual(1, len(livingb.occupants))
"""Test that staff cannot be allocated to living space"""
self.test_amity.reallocate_person({
"<employee_id>":
int(self.teststaff.emp_id),
"<new_room_name>":
"LivingB"
})
# Staff not added to LivingB's list of occupants
self.assertEqual(1, len(livingb.occupants))
def test_load_people(self):
"""
Test that people can be added to the app from a
user-defined text file
"""
"""Add office to have more vacant offices for people from text file """
self.test_amity.create_room({
"<room_name>": ["OfficeC"],
"Living": False,
"Office": True
})
self.test_amity.load_people({"<filename>": "people.txt"})
# People from file are added to application
self.assertEqual(12, len(self.test_amity.people))
self.assertEqual(7, len(self.test_amity.fellows))
self.assertEqual(5, len(self.test_amity.staff))
def test_print_allocations(self):
"""
Test that allocations are displayed on screen
and printed to a text file if specified
"""
self.test_amity.print_allocations({"--o": "myfile.txt"})
# File is created
self.assertTrue(os.path.exists("myfile.txt"))
# Data is entered
with open("myfile.txt") as myfile:
lines = myfile.readlines()
self.assertTrue("LivingA\n" in lines)
self.assertTrue("OfficeA\n" in lines)
self.assertTrue("Test Fellow, Test Staff\n" in lines)
os.remove("myfile.txt")
def test_print_unallocated(self):
"""
Test that unallocated people are displayed on screen
and printed to a text file if specified
"""
# Add fellow that does not want space
self.test_amity.add_person({
"<first_name>": "Test",
"<last_name>": "Fellow2",
"<wants_space>": "N",
"Fellow": True,
"Staff": False
})
self.test_amity.print_unallocated({"--o": "myfile2.txt"})
# File is created
self.assertTrue(os.path.exists("myfile2.txt"))
# Data is entered
with open("myfile2.txt") as myfile:
lines = myfile.readlines()
self.assertTrue("Unallocated People\n" in lines)
self.assertTrue("Test Fellow2\n" in lines)
os.remove("myfile2.txt")
class TestAmityville(unittest.TestCase):
"""
Class test Amity
"""
def setUp(self):
self.amityville = Amity()
def tearDown(self):
"""
provide cleanup for all
clear list data for each test.
"""
# remove all entries in dict
self.amityville.office_allocations.clear()
self.amityville.livingspace_allocations.clear()
self.amityville.room_data.clear()
self.amityville.person_data.clear()
# remove all entries in list
del self.amityville.rooms[:]
del self.amityville.offices[:]
del self.amityville.livingspaces[:]
del self.amityville.people[:]
del self.amityville.staff[:]
del self.amityville.fellows[:]
del self.amityville.unallocated_livingspace[:]
del self.amityville.unallocated_office[:]
def test_create_room_already_exists(self):
"""
test if a room being created already exists
"""
self.amityville.create_room('SUN', 'OFFICE')
result = self.amityville.create_room('SUN', 'OFFICE')
self.assertEqual(result, 'SUN already exists.')
def test_create_room_livingspace(self):
"""
test if a livingspace is created
"""
result = self.amityville.create_room('MOON', 'LIVINGSPACE')
self.assertEqual(result, 'MOON created.')
def test_create_room_office(self):
"""
test if an office is created
"""
result = self.amityville.create_room('SUN', 'OFFICE')
self.assertEqual(result, 'SUN created.')
def test_create_room_invalid_room_type(self):
"""
Test for an invalid room type
"""
result = self.amityville.create_room('SUN', 'OFICE')
self.assertEqual(result, 'Invalid room type.')
def test_add_person_invalid_person_name(self):
"""
test if person name is valid
"""
result = self.amityville.add_person('asce1062', 'FELLOW', 'NO')
self.assertEqual(result, 'Invalid person name.')
def test_add_person_fellow(self):
"""
test if a fellow is added
"""
result = self.amityville.add_person('ALEX', 'FELLOW', 'NO')
self.assertEqual(
result,
'ALEX successfully added! \nAllocated to:\nOffice: No vaccant office.'
)
def test_add_person_staff(self):
"""
test if a staff member is added
"""
result = self.amityville.add_person('ALEX', 'STAFF', 'NO')
self.assertEqual(
result,
'ALEX successfully added! \nAllocated to:\nOffice: No vaccant office.'
)
def test_add_person_invalid_job_description(self):
"""
test if job description is valid
"""
result = self.amityville.add_person('ALEX', 'FELOW', 'NO')
self.assertEqual(result, 'Invalid job description.')
def test_add_person_invalid_accommodation_choice_fellow(self):
"""
test if accommodation input is valid
"""
result = self.amityville.add_person('ALEX', 'FELLOW', 'YEZ')
self.assertEqual(result, 'Invalid accommodation input.')
def test_add_person_invalid_accommodation_choice_staff(self):
"""
test if accommodation input is valid
"""
result = self.amityville.add_person('ALEX', 'STAFF', 'NEIN')
self.assertEqual(result, 'Invalid accommodation input.')
def test_add_person_staff_wants_accommodation(self):
"""
test if a staff request for accommodation
"""
result = self.amityville.add_person('ALEX', 'STAFF', 'YES')
self.assertEqual(result, 'Staff cannot be allocated a livingspace.')
def test_allocate_livingspace_to_nonexistent_fellow(self):
"""
test allocating a livingspace to a non existant fellow
"""
result = self.amityville.allocate_livingspace('ALEX')
self.assertEqual(result, 'ALEX does not exist.')
def test_allocate_livingspace_already_allocated_livingspace(self):
"""
test if a fellow has already been allocated a livingspace
"""
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
result = self.amityville.allocate_livingspace('ALEX')
self.assertEqual(result, 'ALEX already allocated a livingspace.')
def test_allocate_livingspace(self):
"""
test if a fellow is allocated a living space
"""
self.amityville.create_room('MOON', 'LIVINGSPACE')
result = self.amityville.add_person('ALEX', 'FELLOW', 'YES')
self.assertEqual(
result, 'ALEX successfully added! \nAllocated to:\nLivingSpace:'
' ALEX allocated to MOON.\nOffice: No vaccant office.')
def test_allocate_livingspace_no_vaccant_livingspace(self):
"""
test that there are no vaccant livingspaces
"""
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
self.amityville.add_person('JOE', 'FELLOW', 'YES')
self.amityville.add_person('TINA', 'FELLOW', 'YES')
self.amityville.add_person('IBRA', 'FELLOW', 'YES')
self.amityville.add_person('MILLY', 'FELLOW', 'YES')
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.allocate_livingspace('MILLY')
self.amityville.allocate_livingspace('IBRA')
self.amityville.allocate_livingspace('TINA')
self.amityville.allocate_livingspace('JOE')
result = self.amityville.allocate_livingspace('ALEX')
self.assertEqual(result, 'No vaccant livingspace.')
def test_allocate_office_to_nonexistent_staff(self):
"""
test allocating a livingspace to a non existant fellow
"""
result = self.amityville.allocate_office('ALEX')
self.assertEqual(result, 'ALEX does not exist.')
def test_allocate_office_already_allocated_office(self):
"""
test if a staff has already been allocated an office
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.allocate_office('ALEX')
self.assertEqual(result, 'ALEX already allocated to an office.')
def test_allocate_office(self):
"""
test if a staff is allocated an office
"""
self.amityville.add_person('ALEX', 'STAFF', 'NO')
self.amityville.create_room('SUN', 'OFFICE')
result = self.amityville.allocate_office('ALEX')
self.assertEqual(result, 'ALEX allocated to SUN.')
def test_allocate_office_no_vaccant_office(self):
"""
test that there are no vaccant offices
"""
self.amityville.add_person('ALEX', 'STAFF', 'NO')
self.amityville.add_person('JOE', 'STAFF', 'NO')
self.amityville.add_person('TINA', 'STAFF', 'NO')
self.amityville.add_person('IBRA', 'STAFF', 'NO')
self.amityville.add_person('MILLY', 'STAFF', 'NO')
self.amityville.add_person('PAU', 'STAFF', 'NO')
self.amityville.add_person('JONA', 'STAFF', 'NO')
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.allocate_office('JONA')
self.amityville.allocate_office('PAU')
self.amityville.allocate_office('MILLY')
self.amityville.allocate_office('IBRA')
self.amityville.allocate_office('TINA')
self.amityville.allocate_office('JOE')
result = self.amityville.allocate_office('ALEX')
self.assertEqual(result, 'No vaccant office.')
def test_reallocate_person_nonexistent_rooms(self):
"""
test there are no rooms added in order to reallocate
"""
#
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.reallocate_person('S1', 'SUN')
self.assertEqual(result, 'SUN does not exist.')
def test_reallocate_person_nonexistent_people(self):
"""
test there is no one to reallocate
"""
self.amityville.create_room('SUN', 'OFFICE')
result = self.amityville.reallocate_person('S1', 'SUN')
self.assertEqual(result, 'S1 does not exist.')
def test_reallocate_person_livingspace(self):
"""
test if person is reallocated to a livingspace
"""
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
self.amityville.create_room('LIGHT', 'LIVINGSPACE')
result = self.amityville.reallocate_person('F1', 'LIGHT')
self.assertEqual(result, 'ALEX has been reallocated to LIGHT.')
def test_reallocate_person_office(self):
"""
test if person is reallocated to an office.
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
self.amityville.create_room('SHINE', 'OFFICE')
result = self.amityville.reallocate_person('S1', 'SHINE')
self.assertEqual(result, 'ALEX has been reallocated to SHINE.')
def test_reallocate_person_staff_to_livingspace(self):
"""
test if a staff is reallocated to a living space
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.reallocate_person('S1', 'MOON')
self.assertEqual(result,
'Cannot reallocate staff member to a livingspace.')
def test_reallocate_person_to_full_livingspace(self):
"""
test if room being reallocated to is already full
"""
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
self.amityville.add_person('JOE', 'FELLOW', 'YES')
self.amityville.add_person('TINA', 'FELLOW', 'YES')
self.amityville.add_person('IBRA', 'FELLOW', 'YES')
self.amityville.create_room('LIGHT', 'LIVINGSPACE')
self.amityville.add_person('MILLY', 'FELLOW', 'YES')
result = self.amityville.reallocate_person('F5', 'MOON')
self.assertEqual(result, 'MOON is already full.')
def test_reallocate_person_to_full_office(self):
"""
test if room being reallocated to is already full
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
self.amityville.add_person('JOE', 'STAFF', 'NO')
self.amityville.add_person('TINA', 'STAFF', 'NO')
self.amityville.add_person('IBRA', 'STAFF', 'NO')
self.amityville.add_person('MILLY', 'STAFF', 'NO')
self.amityville.add_person('PAU', 'STAFF', 'NO')
self.amityville.create_room('SHINE', 'OFFICE')
self.amityville.add_person('JONA', 'STAFF', 'NO')
result = self.amityville.reallocate_person('s7', 'SUN')
self.assertEqual(result, 'SUN is already full.')
def test_reallocate_person_to_currently_occupied_livingspace(self):
"""
test if the room being reallocated to is the one they are currently residing in
"""
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
result = self.amityville.reallocate_person('F1', 'MOON')
self.assertEqual(result, 'ALEX already allocated to MOON.')
def test_reallocate_person_to_currently_occupied_office(self):
"""
test if the room being reallocated to is the one they are currently residing in
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.reallocate_person('S1', 'SUN')
self.assertEqual(result, 'ALEX already allocated to SUN.')
def test_reallocate_person_to_a_livingspace_and_not_yet_allocated_a_livingspace(
self):
"""
test reallocating a person who is not yet allocated.
"""
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
self.amityville.create_room('MOON', 'LIVINGSPACE')
result = self.amityville.reallocate_person('F1', 'MOON')
self.assertEqual(result, 'ALEX not yet allocated to any livingspace.')
def test_reallocate_person_to_an_office_and_not_yet_allocated_an_office(
self):
"""
test reallocating a person who is not yet allocated.
"""
self.amityville.add_person('ALEX', 'STAFF', 'NO')
self.amityville.create_room('SHINE', 'OFFICE')
result = self.amityville.reallocate_person('S1', 'SHINE')
self.assertEqual(result, 'ALEX not yet allocated to any office.')
def test_print_people_details_no_data_yet(self):
"""
test print people details and no people added to the system yet.
"""
result = self.amityville.print_people_details()
self.assertEqual(result, 'No one exists in the system yet.')
def test_load_people_wrong_file_name(self):
"""
test if people are loaded from wrong file.
"""
filename = 'peoplee'
result = self.amityville.load_people(filename)
self.assertEqual(result, 'File does not exist.')
def test_load_people(self):
"""
test if people are loaded from a file.
"""
filename = 'people'
result = self.amityville.load_people(filename)
self.assertEqual(result, 'People successfully loaded.')
def test_load_people_no_filename(self):
"""
test if no file name is provided.
"""
result = self.amityville.load_people('')
self.assertEqual(result, 'Filename must be provided.')
def test_load_people_invalid_accommodation(self):
"""
Test if invalid accommodation input is handled.
"""
filename = 'invalid_accommodation'
result = self.amityville.load_people(filename)
self.assertEqual(result, 'Invalid accommodation input.')
def test_load_people_invalid_number_of_arguments_less(self):
"""
test if arguments provided are less than or equal to 2.
"""
filename = 'invalid_number_of_arguments_less'
result = self.amityville.load_people(filename)
self.assertEqual(result, 'Invalid number of arguments input.')
def test_load_people_invalid_number_of_arguments_more(self):
"""
test if arguments provided are more than 4.
"""
filename = 'invalid_number_of_arguments_more'
result = self.amityville.load_people(filename)
self.assertEqual(result, 'Invalid number of arguments input.')
def test_load_people_invalid_job_description(self):
"""
test for invalid job description.
"""
filename = 'invalid_job_description'
result = self.amityville.load_people(filename)
self.assertEqual(result, 'Invalid job description.')
def test_load_rooms_from_file_wrong_file_name(self):
"""
test if rooms are loaded from a wrong file.
"""
filename = 'room'
result = self.amityville.load_rooms(filename)
self.assertEqual(result, 'File does not exist.')
def test_load_rooms_from_file(self):
"""
test if rooms are loaded from file.
"""
filename = 'rooms'
result = self.amityville.load_rooms(filename)
self.assertEqual(result, 'Rooms successfully loaded from file.')
def test_load_rooms_from_file_no_filename(self):
"""
test if no file name is provided.
"""
filename = ''
result = self.amityville.load_rooms(filename)
self.assertEqual(result, 'Filename must be provided.')
def test_load_rooms_from_file_invalid_input(self):
"""
test if there are more than 2 arguments.
"""
filename = 'rooms_invalid_input'
result = self.amityville.load_rooms(filename)
self.assertEqual(result, 'Invalid number of arguments input.')
def test_print_allocations_to_screen(self):
"""
test if allocations are successfully printed to the screen.
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
filename = ''
result = self.amityville.print_allocations(filename)
self.assertEqual(result, 'Done.')
def test_print_allocations_to_file(self):
"""
test if allocations are successfully printed out to a file.
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
filename = 'allocations'
result = self.amityville.print_allocations(filename)
self.assertEqual(result, 'Done.')
def test_print_specific_room_allocations(self):
"""
test if specific room allocations are printed to the screen.
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.print_specific_room_allocations('SUN')
self.assertEqual(result, 'Done.')
def test_print_specific_room_allocations_invalid_input(self):
"""
test if invalid input is handled.
"""
result = \
self.amityville.print_specific_room_allocations('SUN(1)')
self.assertEqual(result, 'Invalid input.')
def test_print_unallocated_to_screen(self):
"""
test if un-allocations are printed to the screen.
"""
filename = ''
result = self.amityville.print_unallocated(filename)
self.assertEqual(result, 'Done.')
def test_print_unallocated_to_file(self):
"""
test if un-allocations are printed into a file.
"""
filename = 'unallocated'
result = self.amityville.print_unallocated(filename)
self.assertEqual(result, 'Done.')
def test_print_rooms(self):
"""
test if existing rooms are printed to the screen.
"""
result = self.amityville.print_rooms()
self.assertEqual(result, 'Done.')
def test_print_fellows(self):
"""
test if existing fellows are printed to the screen.
"""
result = self.amityville.print_fellows()
self.assertEqual(result, 'Done.')
def test_print_staff(self):
"""
test if existing staff are printed to the screen.
"""
result = self.amityville.print_staff()
self.assertEqual(result, 'Done.')
def test_print_all_people(self):
"""
test if all existing people are printed to the screen.
"""
result = self.amityville.print_all_people()
self.assertEqual(result, 'Done.')
def test_print_people_details(self):
"""
test print people details.
"""
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.print_people_details()
self.assertEqual(result, 'Done.')
def test_save_state(self):
"""
test if program state is saved to db
"""
rooms = 'rooms'
self.amityville.load_rooms(rooms)
people = 'people'
self.amityville.load_people(people)
dbname = 'amity'
self.amityville.clear_db(dbname)
result = self.amityville.save_state(dbname)
self.assertEqual(result, 'Data saved successfully.')
def test_save_state_no_dbname_provided(self):
"""
test if program state is saved to db
"""
rooms = 'rooms'
self.amityville.load_rooms(rooms)
people = 'people'
self.amityville.load_people(people)
dbname = ''
self.amityville.clear_db(dbname)
result = self.amityville.save_state()
self.assertEqual(result, 'Data saved successfully.')
def test_save_state_no_rooms_exist(self):
"""
test if program state is saved to db
"""
people = 'people'
self.amityville.load_people(people)
dbname = 'amity'
self.amityville.clear_db(dbname)
result = self.amityville.save_state(dbname)
self.assertEqual(result, 'Data saved successfully.')
def test_load_state(self):
"""
test if program state saved to db is loaded to program.
"""
dbname = 'amity'
people = 'people'
rooms = 'rooms'
self.amityville.clear_db(dbname)
self.amityville.load_rooms(rooms)
self.amityville.load_people(people)
self.amityville.save_state(dbname)
result = self.amityville.load_state(dbname)
self.assertEqual(result,
'Data has been loaded into the system successfully.')
def test_load_state_no_db_name_provided(self):
"""
test if program state saved to db is loaded to program.
"""
dbname = ''
people = 'people'
rooms = 'rooms'
self.amityville.clear_db(dbname)
self.amityville.load_rooms(rooms)
self.amityville.load_people(people)
self.amityville.save_state(dbname)
result = self.amityville.load_state(dbname)
self.assertEqual(result,
'Data has been loaded into the system successfully.')
def test_load_state_no_rooms_exist(self):
"""
test if program state saved to db is loaded to program.
"""
dbname = 'amity'
people = 'people'
self.amityville.clear_db(dbname)
self.amityville.load_people(people)
self.amityville.save_state(dbname)
result = self.amityville.load_state(dbname)
self.assertEqual(result,
'Data has been loaded into the system successfully.')
def test_clear_db(self):
"""
test if db is cleared
"""
dbname = 'amity'
result = self.amityville.clear_db(dbname)
self.assertEqual(result, 'Database cleared successfully.')
def test_clear_db_no_name(self):
"""
test if db is cleared
"""
dbname = ''
result = self.amityville.clear_db(dbname)
self.assertEqual(result, 'Database cleared successfully.')
def test_delete_person_person_id_does_not_exist(self):
"""
test if removing a person who does not exist in the system.
"""
result = self.amityville.delete_person('F1')
self.assertEqual(result, 'F1 does not exist.')
def test_delete_person_fellow(self):
"""
test deleting a fellow from amity
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.create_room('MOON', 'LIVINGSPACE')
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
result = self.amityville.delete_person('F1')
self.assertEqual(
result, 'F1: ALEX who is a FELLOW has been removed from amity.')
def test_delete_person_fellow_not_yet_allocated(self):
"""
test deleting a fellow from amity who has not yet been allocated
"""
self.amityville.add_person('ALEX', 'FELLOW', 'YES')
result = self.amityville.delete_person('F1')
self.assertEqual(
result, 'F1: ALEX who is a FELLOW has been removed from amity.')
def test_delete_person_staff(self):
"""
test deleting a staff from amity
"""
self.amityville.create_room('SUN', 'OFFICE')
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.delete_person('S1')
self.assertEqual(
result, 'S1: ALEX who is a STAFF has been removed from amity.')
def test_delete_person_staff_not_yet_allocated(self):
"""
test deleting a staff from amity who has not yet been allocated
"""
self.amityville.add_person('ALEX', 'STAFF', 'NO')
result = self.amityville.delete_person('S1')
self.assertEqual(
result, 'S1: ALEX who is a STAFF has been removed from amity.')
def test_delete_room_non_existant(self):
"""
test deleting a room that is not yet created
"""
result = self.amityville.delete_room('MOON')
self.assertEqual(result, 'MOON does not exist.')
def test_delete_room_livingspace(self):
"""
test deleting a livingspace from amity
"""
self.amityville.create_room('MOON', 'LIVINGSPACE')
result = self.amityville.delete_room('MOON')
self.assertEqual(
result,
'Room MOON which is a LIVINGSPACE has been removed from amity.')
def test_delete_room_office(self):
"""
test deleting an office from amity
"""
self.amityville.create_room('SUN', 'OFFICE')
result = self.amityville.delete_room('SUN')
self.assertEqual(
result, 'Room SUN which is an OFFICE has been removed from amity.')
class TestAmity(unittest.TestCase):
def setUp(self):
self.test_amity = Amity()
"""Create living space"""
self.test_amity.create_room({
"<room_name>": ["LivingA"],
"Living": True,
"Office": False
})
"""Create office"""
self.test_amity.create_room({
"<room_name>": ["OfficeA"],
"Living": False,
"Office": True
})
# Assign rooms to variables
self.livinga = self.test_amity.livingspaces[0]
self.officea = self.test_amity.offices[0]
"""Add fellow that wants space"""
self.test_amity.add_person({
"<first_name>": "Test",
"<last_name>": "Fellow",
"<wants_space>": "Y",
"Fellow": True,
"Staff": False
})
"""Add staff member that wants space"""
self.test_amity.add_person({
"<first_name>": "Test",
"<last_name>": "Staff",
"<wants_space>": "Y",
"Fellow": False,
"Staff": True
})
# Assign people to variables
self.testfellow = self.test_amity.people[0]
self.teststaff = self.test_amity.people[1]
def test_create_room(self):
"""Test creation of rooms"""
# LivingA and OfficeA from setup() added to relevant lists
self.assertEqual(2, len(self.test_amity.rooms))
self.assertEqual(1, len(self.test_amity.livingspaces))
self.assertEqual(1, len(self.test_amity.offices))
"""Test creation of multiple living spaces"""
self.test_amity.create_room({
"<room_name>": ["LivingB", "LivingC"],
"Living": True,
"Office": False
})
# Two living spaces added to list of rooms and list of living spaces
self.assertEqual(4, len(self.test_amity.rooms))
self.assertEqual(3, len(self.test_amity.livingspaces))
"""Test creation of multiple offices"""
self.test_amity.create_room({
"<room_name>": ["OfficeB", "OfficeC"],
"Living": False,
"Office": True
})
# Two offices added to list of rooms and list of offices
self.assertEqual(6, len(self.test_amity.rooms))
self.assertEqual(3, len(self.test_amity.offices))
"""Test that duplicate rooms are not added"""
self.test_amity.create_room({
"<room_name>": ["OfficeA", "OfficeB"],
"Living": False,
"Office": True
})
# Duplicate rooms not added to any list
self.assertEqual(6, len(self.test_amity.rooms))
self.assertEqual(3, len(self.test_amity.offices))
def test_add_person(self):
"""Test addition of people"""
# Test Fellow and Test Staff from setup() added to relevant lists
self.assertEqual(2, len(self.test_amity.people))
self.assertEqual(1, len(self.test_amity.fellows))
self.assertEqual(1, len(self.test_amity.staff))
"""Test allocation of those who want space"""
# Check that people have been appended to rooms' lists of occupants
self.assertEqual(2, len(self.officea.occupants))
def test_vacant_offices(self):
"""Test that vacant rooms are added to relevant list"""
# Add office
self.test_amity.create_room({
"<room_name>": ["OfficeB"],
"Living": False,
"Office": True
})
self.test_amity.check_vacant_rooms()
# Check if OfficeB has been appended to relevant lists
self.assertEqual(2, len(self.test_amity.vacant_offices))
self.assertEqual(3, len(self.test_amity.vacant_rooms))
def test_reallocate_person(self):
"""Add another office"""
self.test_amity.create_room({
"<room_name>": ["OfficeB"],
"Living": False,
"Office": True
})
# Assign OfficeB to variable
officeb = self.test_amity.offices[1]
"""Test reallocation of Test Staff from OfficeA to OfficeB"""
self.test_amity.reallocate_person({
"<employee_id>": int(self.teststaff.emp_id),
"<new_room_name>": "OfficeB"
})
# Staff member no longer in OfficeA's list of occupants
self.assertEqual(1, len(self.officea.occupants))
# Staff member now in OfficeB's list of occupants
self.assertEqual(1, len(officeb.occupants))
"""Add another living space"""
self.test_amity.create_room({
"<room_name>": ["LivingB"],
"Living": True,
"Office": False
})
# Assign LivingB to variable
livingb = self.test_amity.livingspaces[1]
"""Test allocation of Test Fellow to LivingB"""
self.test_amity.reallocate_person({
"<employee_id>": int(self.testfellow.emp_id),
"<new_room_name>": "LivingB"
})
# Fellow now in LivingB's list of occupants
self.assertEqual(1, len(livingb.occupants))
"""Test that staff cannot be allocated to living space"""
self.test_amity.reallocate_person({
"<employee_id>": int(self.teststaff.emp_id),
"<new_room_name>": "LivingB"
})
# Staff not added to LivingB's list of occupants
self.assertEqual(1, len(livingb.occupants))
def test_load_people(self):
"""
Test that people can be added to the app from a
user-defined text file
"""
"""Add office to have more vacant offices for people from text file """
self.test_amity.create_room({
"<room_name>": ["OfficeC"],
"Living": False,
"Office": True
})
self.test_amity.load_people({"<filename>": "people.txt"})
# People from file are added to application
self.assertEqual(12, len(self.test_amity.people))
self.assertEqual(7, len(self.test_amity.fellows))
self.assertEqual(5, len(self.test_amity.staff))
def test_print_allocations(self):
"""
Test that allocations are displayed on screen
and printed to a text file if specified
"""
self.test_amity.print_allocations({
"--o": "myfile.txt"
})
# File is created
self.assertTrue(os.path.exists("myfile.txt"))
# Data is entered
with open("myfile.txt") as myfile:
lines = myfile.readlines()
self.assertTrue("LivingA\n" in lines)
self.assertTrue("OfficeA\n" in lines)
self.assertTrue("Test Fellow, Test Staff\n" in lines)
os.remove("myfile.txt")
def test_print_unallocated(self):
"""
Test that unallocated people are displayed on screen
and printed to a text file if specified
"""
# Add fellow that does not want space
self.test_amity.add_person({
"<first_name>": "Test",
"<last_name>": "Fellow2",
"<wants_space>": "N",
"Fellow": True,
"Staff": False
})
self.test_amity.print_unallocated({
"--o": "myfile2.txt"
})
# File is created
self.assertTrue(os.path.exists("myfile2.txt"))
# Data is entered
with open("myfile2.txt") as myfile:
lines = myfile.readlines()
self.assertTrue("Unallocated People\n" in lines)
self.assertTrue("Test Fellow2\n" in lines)
os.remove("myfile2.txt")
class AmityTest(unittest.TestCase):
def setUp(self):
self.amity = Amity()
self.amity.room_types = {
"office": {Office('MOMBASA'): ['Lavender Ayodi'],
Office('HOGWARTS'): [],
Office('LAGOS'): []},
"livingspace": {LivingSpace('KENYA'): [],
LivingSpace('PLATFORM'): [],
LivingSpace('VALHALLA'): []}
}
self.amity.persons = {
'fellow': [Fellow('Lavender Ayodi')],
'staff': [Staff('John Doe')]
}
def _create_rooms(self):
room_types = {
"office": {Office('MOMBASA'), Office('HOGWARTS'), Office('LAGOS')},
"livingspace": {LivingSpace('KENYA'), LivingSpace('PLATFORM'),
LivingSpace('VALHALLA')}
}
keys = room_types.keys()
for room in keys:
for names in room_types.get(room):
self.amity._assign_room_name(room, names)
def test_create_room_without_name(self):
room_created = self.amity.create_room("", 'livingspace')
self.assertIn("Error", room_created)
def test_create_room_without_type(self):
room_created = self.amity.create_room("Platform", "")
self.assertIn("Error", room_created)
def test_room_created_exists(self):
self.amity.create_room('Lagos', 'office')
room_created = self.amity.create_room('Lagos', 'office')
print (self.amity.rooms)
self.assertIn("Error", room_created)
def test_amity_room_object(self):
rooms = self.amity.rooms.keys()
self.assertEqual(len(rooms), 2)
self.assertIn("office", rooms)
self.assertIn("livingspace", rooms)
def test_create_office(self):
office = self.amity.create_room("Platform", "office")
self.assertIn("Success", office)
def test_create_livingspace(self):
livingspace = self.amity.create_room("Rongai", "livingspace")
print (livingspace)
self.assertIn("Success", livingspace)
def test_create_invalid(self):
livingspace = self.amity.create_room("Rongai", "school")
self.assertIn("Error", livingspace)
def test_add_person_without_name(self):
person_added = self.amity.add_person('', 'fellow', 'N')
self.assertIn('Error', person_added)
def test_add_person_exists(self):
self._create_rooms()
self.amity.add_person('LESLEY AYODI', 'staff', 'Y')
person_added = self.amity.add_person('LESLEY AYODI', 'staff', 'Y')
self.assertIn('Error', person_added)
def test_add_person_to_room(self):
self.amity.create_room('MOMBASA', 'office')
room_allocated = self.amity.add_person('EMILY MBELENGA', 'fellow', 'N')
self.assertIn("Done", room_allocated)
def test_add_invalid_person_type(self):
self.amity.create_room('MOMBASA', 'office')
type_added = self.amity.add_person('LESLEY AYODI', 'cook', 'N')
self.assertIn('Error', type_added)
def test_invalid_room_type(self):
self.amity.create_room('MOMBASA', 'office')
self.amity.add_person('LESLEY AYODI', 'staff', 'N')
room_occupants = self.amity._find_room_occupant('offic', 'MOMBASA')
self.assertIn("Error", room_occupants)
def test_invalid_room_name(self):
self.amity.create_room('MOMBASA', 'office')
self.amity.add_person('LESLEY AYODI', 'staff', 'N')
room_occupants = self.amity._find_room_occupant('office', 'MOMBA')
self.assertIn("Error", room_occupants)
def test_reallocate_person(self):
reallocate_person = self.amity.reallocate_person(
"office", 'MOMBASA', 'HOGWARTS', 'Lavender Ayodi')
self.assertIn("Success", reallocate_person)
def test_reallocate_invalid_person(self):
reallocate_person = self.amity.reallocate_person(
"office", 'MOMBASA', 'LAGOS', 'ISABEL AYODI')
self.assertIn('Error', reallocate_person)
def test_reallocate_invalid_room(self):
invalid_room = self.amity.reallocate_person(
"office", 'MOMBASA', 'LAGOS', 'ISABEL AYODI')
self.assertIn('Error', invalid_room)
def test_full_room(self):
self.amity.create_room('Lagos', 'office')
self.amity.add_person('Lesley Ayodi', 'staff', 'N')
self.amity.create_room('Mombasa', 'office')
occupants = ['A', 'B', 'C', 'D', 'E', 'F']
office = self.amity.rooms.get('office')
office['Mombasa'] = occupants
reallocate_person = self.amity.reallocate_person(
"office", 'Lagos', 'Mombasa', 'Lesley Ayodi')
self.assertEqual(False, reallocate_person)
def test_print_allocations(self):
self.amity.add_person('Lesley Ayodi', 'staff', 'N')
allocated_room = self.amity.print_allocations('room.txt')
self.assertEqual(True, allocated_room)
def test_print_allocations_terminal(self):
self.amity.add_person('Lesley Ayodi', 'staff', 'N')
allocated_room = self.amity.print_allocations('room.txt')
self.assertEqual(True, allocated_room)
def test_print_unallocated_persons(self):
self.amity.add_person('LESLEY AYODI', 'fellow', 'Y')
self.amity.add_person('LAVENDER AYODI', 'fellow', 'Y')
self.amity.add_person('BRIAN MUTHUI', 'fellow', 'Y')
self.amity.add_person('DENNIS MWANGI', 'fellow', 'Y')
self.amity.add_person('MBARAK MBIGO', 'fellow', 'Y')
self.amity.add_person('DENNIS YESWA', 'fellow', 'Y')
self.amity.add_person('CYNTHIA ABURA', 'fellow', 'Y')
unallocated = self.amity.print_unallocated('unallocated.txt')
self.assertEqual(len(unallocated), 1)
def test_print_room_occupants(self):
self.amity.create_room('MOMBASA', 'office')
self.amity.add_person('LESLEY AYODI', 'staff', 'N')
self.amity.add_person('LAVENDER AYODI', 'fellow', 'N')
self.amity.add_person('PATIENCE AYODI', 'staff', 'N')
available_occupants = self.amity.print_room('office', 'MOMBASA')
self.assertIn('Success', available_occupants)
def test_load_people_from_file(self):
persons_list = self.amity.persons.get('fellow')
self.assertEqual(len(persons_list), 1)
self.amity.load_people("people.txt")
self.assertEqual(len(persons_list), 5)
def test_save_state_works(self):
saved_state = self.amity.save_state('test_amity.db')
self.assertEqual(True, saved_state)
def test_load_state_works(self):
loaded_state = self.amity.load_state('test_amity.db')
self.assertEqual(True, loaded_state)