class TestAmity(unittest.TestCase): """ Test amity """ def setUp(self): self.amity = Amity() self.offices = self.amity.offices self.living_spaces = self.amity.living_spaces self.fellows = self.amity.fellows self.staff = self.amity.staff self.new_offices = self.amity.create_room("O", "Occulus", "Narnia") self.new_living_space = self.amity.create_room("L", 'mombasa') self.new_fellow = self.amity.add_person("hum", "musonye", "fellow", "Y") self.new_staff = self.amity.add_person("hum", "musonye", "staff", "N") self.unallocated_fellows = self.amity.unallocated_fellow self.unallocated_staff = self.amity.unallocated_staff def test_create_living_space(self): """ Tests whether a livingspace(room) is created. """ initial_room_count = len(self.living_spaces) self.amity.create_room("L", 'php') new_room_count = len(self.living_spaces) self.assertEqual(new_room_count, initial_room_count + 1) def test_create_office(self): """ Tests whether an office(room) is created. """ initial_room_count = len(self.offices) self.amity.create_room("O", "Camelot") new_room_count = len(self.offices) self.assertEqual(new_room_count, initial_room_count + 1) def test_create_multiple_rooms(self): """ Tests whether multiple rooms can be created. """ initial_room_count = len(self.living_spaces) self.amity.create_room("L", "Scalar", "Laravel") new_room_count = len(self.living_spaces) self.assertEqual(new_room_count, initial_room_count + 2) def test_room_already_exists(self): """ Test behaiviour of create room, when you create an already existing room """ self.new_living_space msg = self.amity.create_room("L", "mombasa") self.assertEqual("Room Already Exists!", msg) def test_invalid_room_type(self): """ Tests whether message is return when invalid room type param is passed""" new_room = self.amity.create_room("S", "Laravel") self.assertEqual(new_room, "Inavlid Room Type!") def test_vacant_rooms_returned(self): """ Tests whether rooms that have remaining slots are returned. """ new_room = Office('mombasa') self.amity.check_vacant_rooms() vacant_status = new_room.is_full() self.assertFalse(vacant_status) def test_is_full_returns_true(self): """ Tests whether the system knows when a room is fully occupied. """ new_room = Office('mombasa') new_room.occupants.append(136648) new_room.occupants.append(136650) new_room.occupants.append(136651) new_room.occupants.append(136652) new_room.occupants.append(136653) new_room.occupants.append(136654) vacant_status = new_room.is_full() self.assertTrue(vacant_status) def test_is_full_returns_false(self): """ Tests whether the system knows when a room is not fully occupied. """ new_room = Office('mombasa') new_room.occupants.append(136648) new_room.occupants.append(136650) new_room.occupants.append(136651) vacant_status = new_room.is_full() self.assertFalse(vacant_status) def test_add_fellow(self): """ Tests if a fellow is added successfully added. """ new_fellow = self.new_fellow self.assertEqual("Person Created Successfully!", new_fellow) def test_add_staff(self): """ Tests if a staff is added successfully added """ new_staff = self.new_staff self.assertEqual("Person Created Successfully!", new_staff) def test_new_fellow_in_unallocated(self): """ Tests whether a newly created fellow is saved to the unallocated list. """ unallocated_status = True if len(self.unallocated_fellows) > 0 else False self.assertTrue(unallocated_status) def test_new_staff_in_unallocated(self): """ Tests whether a newly created staff is saved to the unallocated list. """ unallocated_status = True if len(self.unallocated_staff) > 0 else False self.assertTrue(unallocated_status) def test_allocate_staff(self): """ Tests whether a new staff member is allocated an office. """ staff = self.staff[-1] self.amity.allocate_person(str(staff.employee_id)) unallocated_length = len(self.unallocated_staff) self.assertEqual(0, unallocated_length) def test_allocate_fellow(self): """ Tests whether a new fellow is allocated an office and livingspace. """ fellow = self.fellows[-1] self.amity.allocate_person(str(fellow.employee_id)) unallocated_length = len(self.unallocated_fellows) self.assertEqual(0, unallocated_length) def test_if_person_not_found(self): """ Tests whether a non-existent person can be allocated a room. """ non_existent_person = 1000001 allocated_status = self.amity.allocate_person(str(non_existent_person)) self.assertEqual("Person not found!", allocated_status) def test_if_livingspaces_not_found(self): """ Test whether allocate_person works when no living_spaces are created. """ fellow = self.fellows[-1] self.amity.living_spaces = [] allocated_msg = self.amity.allocate_person(str(fellow.employee_id)) self.assertIn("LivingSpace not available!", allocated_msg) def test_if_offices_not_found(self): """ Test whether allocate_person works when no offices are created. """ fellow = self.fellows[-1] self.amity.offices = [] allocated_msg = self.amity.allocate_person(str(fellow.employee_id)) self.assertIn("Office not available!", allocated_msg) def test_when_staff_wants_lspace(self): """ Tests whether the system returns an error message when Staff wants_accomodation = Y """ self.amity.add_person("alexis", "sanchez", "staff", "Y") staff = self.staff[-1] allocated_msg = self.amity.allocate_person(str(staff.employee_id)) self.assertIn("Cannot assign LivingSpace to staff!", allocated_msg) def test_reallocate_if_person_not_found(self): """ Tests whether a non-existent person can be reallocated to a room. """ non_existent_person = 1000001 allocated_status = self.amity.reallocate_person(str(non_existent_person), 'mombasa') self.assertEqual("Person not found", allocated_status) def test_if_new_room_name_exists(self): """ Test whether reallocate_person finds new_room_name. """ fellow = self.fellows[-1] self.amity.allocate_person(str(fellow.employee_id)) reallocated_status = self.amity.reallocate_person(str(fellow.employee_id), 'mogadishu') self.assertEqual("Room does not Exist!", reallocated_status) def test_reallocate_lspace(self): """ Test whether a person can be reallocated from one room to another. """ fellow = self.fellows[-1] self.amity.allocate_person(str(fellow.employee_id)) self.amity.create_room("L", 'kilifi') reallocated_status = self.amity.reallocate_person(str(fellow.employee_id), 'kilifi') self.assertIn("Successfully Reallocated", reallocated_status) def test_reallocate_office(self): """ Test whether a person can be reallocated from one room to another. """ fellow = self.fellows[-1] self.amity.allocate_person(str(fellow.employee_id)) self.amity.create_room("O", 'kilaguni') reallocated_status = self.amity.reallocate_person(str(fellow.employee_id), 'kilaguni') self.assertIn("Successfully Reallocated", reallocated_status) def test_staff_reallocated_lspace(self): """ Test that error message is returned when staff is reallocated to \ LivingSpace """ staff = self.staff[-1] self.amity.allocate_person(str(staff.employee_id)) reallocated_status = self.amity.reallocate_person(str(staff.employee_id), 'mombasa') self.assertIn("Cannot reallocate staff to livingspace!", reallocated_status) def test_load_people(self): """ Test whether load_people adds people to room from a text file. """ self.amity.fellows = [] self.amity.load_people("people") self.assertTrue(self.amity.fellows) def test_load_people_from_non_existent_file(self): """ Tests whether people can be loaded from a non-existent file. """ load_people = self.amity.load_people("persons") self.assertEqual("File: persons, Not Found!", load_people) def test_allocations_outputs_file(self): """ Tests whether allocations can be printed on file: new_allocations. """ staff = self.staff[-1] self.amity.allocate_person(str(staff.employee_id)) self.amity.print_allocations("new_allocations") file_path = os.path.abspath("data/new_allocations.txt") file_status = os.path.isfile(file_path) self.assertTrue(file_status) def test_allocations_outputs_screen(self): """ Tests whether allocations can be printed on file: new_allocations. """ staff = self.staff[-1] self.amity.allocate_person(str(staff.employee_id)) data = self.amity.print_allocations() self.assertTrue(data) def test_output_when_no_room(self): """ Test print_allocations when no rooms in the system """ self.amity.offices = [] self.amity.living_spaces = [] data = self.amity.print_allocations() self.assertIn("No Rooms Found.", data) def test_output_to_file(self): """ Tests whether the unallocated can be printed on file: new_unallocated. """ staff = self.staff[-1] self.amity.allocate_person(str(staff.employee_id)) self.amity.print_unallocated("new_unallocated") file_path = os.path.abspath("data/new_unallocated.txt") file_status = os.path.isfile(file_path) self.assertTrue(file_status) def test_unallocated_outputs_screen(self): """ Tests whether the unallocated can be printed on file: new_unallocated. """ staff = self.staff[-1] self.amity.allocate_person(str(staff.employee_id)) data = self.amity.print_unallocated() self.assertTrue(data) def test_print_non_existent_room(self): """ Test whether a non-existent room can be printed on screen. """ print_room = self.amity.print_room("arkham") self.assertIn("Room not found!", print_room) def test_when_no_occupants_in_room(self): """ Test whether a room with no occupants can be printed on screen. """ print_room = self.amity.print_room("mombasa") self.assertIn("No occupants in room", print_room) def test_print_correct_occupants(self): """ Test whether a room and its occupants can be printed on screen. """ fellow = self.fellows[-1] self.amity.allocate_person(str(fellow.employee_id)) print_room = self.amity.print_room("mombasa") self.assertIn("Hum Musonye", print_room) def test_save_state_creates_db(self): """ Test whether save_state creates a SQLite database. """ self.amity.save_state("test") file_path = os.path.abspath("test.db") file_status = os.path.isfile(file_path) self.assertTrue(file_status) def test_non_existent_db(self): """ Tests how load_state behaves when passed a nn existent db name. """ load_state = self.amity.load_state("amity_lagos") self.assertEqual("Database amity_lagos.db not found!", load_state) def test_load_test(self): """ Test whether load_state persists data from db to amity system. """ self.amity.add_person("bat", "man", "fellow", "Y") self.amity.save_state("test_load") self.amity.load_state("test_load") is_loaded = True if len(self.amity.fellows) > 1 else False self.assertTrue(is_loaded)
class ScreenOut(cmd.Cmd): """main class""" os.system('clear') fig_font = Figlet(font='poison', justify='left', width=200) print("\n") print(colored(fig_font.renderText('( AMITY )'),\ 'green', attrs=['bold'])) intro = colored('Version 1.0\t\t Enter "quit" to exit \n', 'green', attrs=['bold']) nice = colored('(amity) ~ ', 'cyan', attrs=['blink']) prompt = nice def __init__(self): cmd.Cmd.__init__(self) self.amity = Amity() @docopt_cmd def do_create_room(self, args): """Usage: create_room <room_type> <room_name>...""" room_type = args['<room_type>'] room_names = args['<room_name>'] msg = self.amity.create_room(room_type, *room_names) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_add_person(self, args): """Usage: add_person <fname> <lname> <role> [<wants_accomodation>]""" fname = args['<fname>'] lname = args['<lname>'] role = args['<role>'] wants_accomodation = args['<wants_accomodation>'] try: if wants_accomodation.upper() not in ['Y', 'N']: msg = "Invalid accomodation parameter! Please use Y or N ✘" msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) if role.upper() not in ['FELLOW', 'STAFF']: msg = "Invalid role parameter! Please use FELLOW or STAFF ✘" msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg = self.amity.add_person(fname, lname, role, wants_accomodation) msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) except AttributeError: msg = "Please indicate if person wants accomodation! ✘" msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_allocate_person(self, args): """Usage: allocate_person <person_id>""" person_id = args['<person_id>'] msg = self.amity.allocate_person(person_id) if "!" not in msg: msg += ' ✔' msg = colored(msg, 'yellow', attrs=['bold', 'dark']) print(msg) else: msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_reallocate_person(self, args): """Usage: reallocate_person <person_id> <new_room_name>""" person_id = args['<person_id>'] room = args['<new_room_name>'] msg = self.amity.reallocate_person(person_id, room) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_load_people(self, arg): """Usage: load_people""" msg = self.amity.load_people('people') if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_print_allocations(self, args): """Usage: print_allocations [--o=filename.txt]""" if args['--o']: filename = args['--o'] msg = self.amity.print_allocations(filename) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) else: msg = self.amity.print_allocations() if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg = colored(msg, 'yellow', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_print_unallocated(self, args): """Usage: print_unallocated [--o=filename.txt]""" if args['--o']: filename = args['--o'] msg = self.amity.print_unallocated(filename) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) else: msg = self.amity.print_unallocated() if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg = colored(msg, 'yellow', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_print_room(self, args): """Usage: print_room <room_name>""" room_name = args['<room_name>'] msg = self.amity.print_room(room_name) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'yellow', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_save_state(self, args): """Usage: save_state [--db=sqlite_database]""" db = args['--db'] msg = self.amity.save_state(db) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg += ' ✔' msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) @docopt_cmd def do_load_state(self, args): """Usage: load_state [<sqlite_database>]""" db = args['<sqlite_database>'] msg = self.amity.load_state(db) if "!" in msg: msg += ' ✘' msg = colored(msg, 'red', attrs=['bold', 'dark']) print(msg) else: msg = colored(msg, 'green', attrs=['bold', 'dark']) print(msg) def do_quit(self, arg): """Quits out of Interactive Mode.""" os.system('clear') bye = Figlet(font='jazmine') delay_print('\n\n' + \ colored(bye.renderText('Bye ...'), 'yellow', attrs=['bold'])) exit()