class App(cmd.Cmd): intro = 'A Room Allocation system for Andela Kenya facility Known As the dojo' prompt = '(dojo_space)' dojo = Dojo() @docopt_cmd def do_create_room(self, arg): """ Usage: create_room <room_type> <room_name>... """ room_type = arg["<room_type>"] room_name = arg["<room_name>"] if room_type == "office" or room_type == "living": self.dojo.create_room(room_type, room_name) else: print( "You've entered an invalid room type. Please choose either office or living" ) @docopt_cmd def do_add_person(self, arg): """ Usage: add_person <first_name> <last_name> <role> [<wants_accommodation>] """ first_name = arg["<first_name>"] last_name = arg["<last_name>"] role = arg["<role>"] accommodation = arg["<wants_accommodation>"] self.dojo.add_person(first_name, last_name, role, accommodation) @docopt_cmd def do_print_room(self, arg): """ Usage: print_room <room_name> """ self.dojo.print_room(arg["<room_name>"]) @docopt_cmd def do_print_allocation(self, arg): """ Usage: print_allocation [<filename>] """ self.dojo.print_allocations(arg["<filename>"]) @docopt_cmd def do_print_unallocated(self, arg): """ Usage: print_unallocated [<filename>] """ self.dojo.print_unallocated(arg["<filename>"]) def do_quit(self, arg): """ Quits out of program""" print('See you next time!') exit()
def test_create_room_complete(self): dojo = Dojo() initial_room_count = len(dojo.list_of_rooms) black_office = dojo.create_room("Black", "office") self.assertTrue(black_office, "An office called black has been created") new_room_count = len(dojo.list_of_rooms) self.assertEqual(new_room_count - initial_room_count, >1)
def test_load_state(self): """test for retrieving the current state from the database""" my_instance = Dojo() people_initial_list = len(my_instance.people) my_instance.load_state("alloc") people_new_list = len(my_instance.people) self.assertTrue(people_new_list > people_initial_list)
def test_successful_print_list_of_unallocated_on_screen(self): """ test successful printing of names of people not allocated a room on screen""" self.dojo = Dojo() self.dojo.add_person('Diego', 'Pamio', 'FELLOW') self.dojo.print_unallocated() saved = sys.stdout output = saved.getvalue() self.assertIn('Diego Pamio', output)
def test_create_office_successfully(self): dojo = Dojo() number_of_offices = len(dojo.offices_created) new_office = dojo.create_room("office", "Fox") new_number_of_offices = len(dojo.offices_created) self.assertEqual(number_of_offices + 1, new_number_of_offices, msg='New office Not Added')
def test_create_livingspace_successfully(self): dojo = Dojo() number_of_livingspaces = len(dojo.livingspaces_created) new_livingspace = dojo.create_room("livingspace", "Uganda") new_number_of_livingspaces = len(dojo.livingspaces_created) self.assertEqual(number_of_livingspaces + 1, new_number_of_livingspaces, msg='New livingspace Not Added')
def test_successful_print_list_of_allocation_on_screen(self): """ test successful printing of names of people allocated a room on screen""" self.dojo = Dojo() self.dojo.create_room("office", ["kenya"]) self.dojo.add_person('Kevin', 'Oriels', 'FELLOW') self.dojo.print_allocations() saved = sys.stdout output = saved.getvalue() self.assertIn('Kevin Oriels', output)
def test_create_room_already_taken(self): dojo = Dojo() dojo.create_room("office", "MergeConflict") self.assertEqual(dojo.create_room("office", "MergeConflict"), "MergeConflict already exists", msg='Room already exists') self.assertEqual(dojo.create_room("livingspace", "MergeConflict"), "MergeConflict already exists", msg='Room already exists')
def test_can_print_empty_room(self): """ test printing of names of people in room_name that does not exist """ self.dojo = Dojo() self.dojo.create_room("office", ["kenya"]) self.dojo.print_room("kenya") saved = sys.stdout output = saved.getvalue() self.assertIn("office space kenya contains no occupants", output)
def test_cannot_print_list_for_room_not_existing(self): """ test unsuccessful printing of names of people in room_name that does not exist """ self.dojo = Dojo() self.dojo.create_room("office", ["kenya"]) self.dojo.print_room("Britain") saved = sys.stdout output = saved.getvalue() self.assertIn("Sorry.That rooms does not exist.", output)
def test_add_staff_successfully(self): dojo = Dojo() dojo.create_room("office", "Office1") dojo.create_room("office", "Office2") number_of_staff = len(dojo.staff_added) new_staff = dojo.add_person("Maria", "staff") new_number_of_staff = len(dojo.staff_added) self.assertEqual(number_of_staff + 1, new_number_of_staff, msg='New staff Not Added')
def test_can_add_staff(self): """ Test successful addition of staff """ self.dojo = Dojo() self.dojo.create_room("office", ["kenya", "uganda"]) self.dojo.create_room("living", ["Nairobi", "Kampala"]) self.assertEqual(len(self.dojo.total_people), 0) self.dojo.add_person('Fred', 'Flint', 'STAFF') self.assertEqual(len(self.dojo.total_people), 1, ' staff member(s) has been added to the system!')
def test_can_print_names_of_people_in_room_on_screen(self): """ test successful printing of names of people in room_name on screen""" self.dojo = Dojo() self.dojo.create_room("office", ["kenya"]) self.dojo.add_person('Kevin', 'Oriels', 'FELLOW') self.dojo.print_room("kenya") saved = sys.stdout output = saved.getvalue() self.assertIn("office space kenya contains Kevin Oriels", output)
def test_successful_print_list_of_unallocated_to_txt_file(self): """ test successful printing of names of people not allocated a room to a txt file """ self.dojo = Dojo() self.dojo.add_person('Diego', 'Pamio', 'FELLOW') self.dojo.add_person('Trent', 'Renzor', 'FELLOW', 'Y') self.dojo.print_unallocated("unallocated_persons") self.assertTrue(os.path.isfile("unallocated_persons.txt")) unallocated_file = open("unallocated_persons.txt").readlines() first_line = unallocated_file[4] self.assertEquals(first_line, "Diego Pamio, Trent Renzor\n") os.remove("unallocated_persons.txt")
def test_add_fellow_with_accommodation_successfully(self): dojo = Dojo() dojo.create_room("office", "Office1") dojo.create_room("office", "Office2") dojo.create_room("livingspace", "livingspace1") dojo.create_room("livingspace", "livingspace2") number_of_fellows = len(dojo.fellows_added) new_fellow = dojo.add_person("Martina", "fellow", "Y") new_number_of_fellows = len(dojo.fellows_added) self.assertEqual(number_of_fellows + 1, new_number_of_fellows, msg='New fellow Not Added')
def test_add_staff_with_accommodation_unsuccessfully(self): dojo = Dojo() dojo.create_room("office", "Office1") dojo.create_room("office", "Office2") dojo.create_room("livingspace", "livingspace1") dojo.create_room("livingspace", "livingspace2") number_of_staff = len(dojo.staff_added) new_staff = dojo.add_person("Maria", "staff", "Y") new_number_of_staff = len(dojo.staff_added) self.assertEqual(number_of_staff, new_number_of_staff, msg='Staff cannot be allocated livingspace')
def test_can_add_person(self): """ Test successful addition of person """ self.dojo = Dojo() self.dojo.create_room("office", ["kenya", "uganda"]) self.dojo.create_room("living", ["Nairobi", "Kampala"]) self.dojo.add_person('Kevin', 'Oriels', 'FELLOW') self.dojo.add_person('John', 'john', 'STAFF', '') self.dojo.add_person('Anne', 'Ndinda', 'FELLOW', 'Y') self.dojo.add_person('Steve', 'Mcmon', 'FELLOW', 'N') self.assertEqual(len(self.dojo.total_people), 4, 'Person(s) were added to the system!')
def test_can_add_fellow(self): """ Test successful addition of fellows""" self.dojo = Dojo() self.dojo.create_room("office", ["kenya", "uganda"]) self.dojo.create_room("living", ["Nairobi", "Kampala"]) self.assertEqual(len(self.dojo.total_people), 0) self.dojo.add_person('Joe', 'jameson', 'FELLOW', 'Y') self.dojo.add_person('James', 'konia', 'FELLOW') self.dojo.add_person('Larry', 'smith', 'FELLOW', 'N') self.assertEqual(len(self.dojo.total_people), 3, 'staff member(s) were added to the system!')
def test_cannot_add_person_with_missing_arguments(self): """ Test failure in addition of persons with Missing arguments """ self.dojo = Dojo() self.dojo.create_room("office", ["kenya", "uganda"]) self.dojo.create_room("living", ["Nairobi", "Kampala"]) self.num_of_people = len(self.dojo.total_people) self.dojo.add_person('Kevin', '', '') self.dojo.add_person('', '', '', 'Y') self.dojo.add_person('', '', '', '') self.assertEqual( len(self.dojo.total_people), self.num_of_people, 'Person(s) cannot be created without necessary credentials')
def main(): dojo = Dojo(StockAgent, StockAgent, 'n7/5k2/8/8/8/8/8/3R3K w - - 0 1') (history, result) = dojo.play() mydir = 'results/svg/' filelist = [ f for f in os.listdir(mydir) if f.endswith(".svg") ] for f in filelist: os.remove(os.path.join(mydir, f)) for i in range(len(history)-1): with open('{}move_{}.svg'.format(mydir, i), 'w') as f: f.write(history[i]) print(result)
def test_successful_print_list_of_allocation_to_txt_file(self): """ test successful printing of names of people allocated a room to a txt file """ self.dojo = Dojo() self.dojo.create_room("office", ["kenya"]) self.dojo.create_room("living", ["Nairobi"]) self.dojo.add_person('Kevin', 'Oriels', 'FELLOW') self.dojo.print_allocations("allocated_persons") self.assertTrue(os.path.isfile("allocated_persons.txt")) allocated_file = open("allocated_persons.txt").readlines() first_line = allocated_file[1] third_line = allocated_file[5] self.assertEquals(first_line, "kenya \n") self.assertEquals(third_line, "Kevin Oriels\n") os.remove("allocated_persons.txt")
class DojoRoomAllocation(cmd.Cmd): os.system("clear") prompt = '\n ==== > DojoRoomAllocation: ' dojo = Dojo() @docopt_cmd def do_create_room(self, arg): """Usage: create_room <room_type> <room_names>... """ try: for room_name in arg['<room_names>']: print(dojo.create_room(arg['<room_type>'], room_name)) except Exception: msg = term.red + 'An error when running create_room command' + term.off @docopt_cmd def do_add_person(self, arg): """Usage: add_person <first_name> <last_name> <person_type> [--wants_accomodation=None] """ try: first_name = arg["<first_name>"] last_name = arg["<last_name>"] person_type = arg["<person_type>"] wants_accomodation = arg["--wants_accomodation"] print( person.add_person(first_name, last_name, person_type, wants_accomodation)) except Exception: msg = term.red + 'An error when running add_person command' + term.off def do_quit(self, arg): """Usage: quit """ os.system('clear') print('Thank you for using our app. Hope to see you back soon') exit()
def test_create_room_without_passing_arguments_unsuccessfully(self): dojo = Dojo() self.assertRaises(TypeError, dojo.create_room)
def test_room_already_exists(self): dojo = Dojo() black_office = dojo.create_room("Black", "office") black_exists = dojo.room_exists("Black")
class App(cmd.Cmd): print("WELCOME TO DOJO ROOM ALLOCATION") print("") print("ROOM ALLOCATION COMMANDS") print("") print("1. create_room <room_type> <room_name> ...") print("2. add_persons <name> <role> [<wants_accommodation>]") print("3. print_room <room_name>") print("4. print_allocations [<file_name>]") print("5. quit") print("") prompt = '(Dojo)' dojo = Dojo() @docopt_cmd def do_create_room(self, arg): """ Usage: create_room <room_type> <room_name>... """ room_name = arg["<room_name>"] room_type = arg["<room_type>"] if room_name and room_type: self.dojo.create_room(room_type,room_name) @docopt_cmd def do_add_persons(self, arg): """ Usage: add_persons <first_name> <role> [<wants_accommodation>] """ first_name = arg["<first_name>"] role = arg["<role>"].upper() accommodation = arg["<wants_accommodation>"] if accommodation is None: accommodation = "N" accommodation.upper() self.dojo.add_persons(first_name, role, accommodation) @staticmethod def do_quit(self): """ Quits out of program""" print('Thank you for using Dojo!') print('See you next time!') print('THIS IS ANDELA') exit() @docopt_cmd def do_print_room(self, arg): """ Usage: print_room <room_name> """ room_name = arg["<room_name>"] if room_name is not None: self.dojo.print_room(room_name) @docopt_cmd def do_print_allocations(self, arg): """ Usage: print_allocations [<filename>] """ self.dojo.print_allocations(arg["<filename>"])
class MyInteractive(cmd.Cmd): def introduction(): print("dojo space allocation!".center(70)) print("1. create_room <room_type> <room_name>...".center(70)) print( "2. add_person <first_name> <last_name> <person_type> <wants_space>" .center(70)) print("3. print_allocated".center(70)) print("4. print_unallocated".center(70)) print("other commands:".center(70)) print("1. help".center(70)) print("2. Exit".center(70)) intro = introduction() prompt = '(dojo)' file = None dojo = Dojo() @docopt_cmd def do_create_room(self, args): """Usage: create_room <room_type> <room_name>...""" room_name = args["<room_name>"] room_type = args["<room_type>"] if room_type == "living": self.dojo.create_room(room_type, room_name) if room_type == "office": self.dojo.create_room(room_type, room_name) @docopt_cmd def do_add_person(self, args): """Usage: add_person <first_name> <last_name> <person_type> <wants_space>""" first_name = args["<first_name>"] last_name = args["<last_name>"] person_type = args["<person_type>"] wants_space = args["<wants_space>"] person_name = (first_name + " " + last_name) if person_type == "fellow": self.dojo.add_person(person_name, "fellow", wants_space) if person_type == "staff": self.dojo.add_person(person_name, "staff", wants_space) @docopt_cmd def do_print_room(self, args): """Usage: print_room <room_name>""" room_name = args["<room_name>"] self.dojo.print_room(room_name) @docopt_cmd def do_print_allocated(self, args): """Usage: print_allocated""" self.dojo.print_allocated() @docopt_cmd def do_print_unallocated(self, args): """Usage: print_allocated""" self.dojo.print_unallocated() @docopt_cmd def do_exit(self, args): """Exit""" exit()
def setUp(self): self.class_instance = Dojo()
def setUp(self): """setup defaults""" self.held, sys.stdout = sys.stdout, StringIO() self.my_instance = Dojo()
def setUp(self): self.dojo = Dojo()
app.py load_state <sqlite_database> app.py (-i | --interactive) app.py (-h | --help | --version) Options: -i, --interactive Interactive Mode -h, --help Show this screen and exit. """ import sys import cmd from docopt import docopt, DocoptExit from pyfiglet import Figlet from termcolor import colored, cprint from dojo import Dojo dojo = Dojo() def docopt_cmd(func): """ This decorator is used to simplify the try/except block and pass the result of the docopt parsing to the called action. """ def fn(self, args): try: opt = docopt(fn.__doc__, args) except DocoptExit as e: # This is thrown if a false command is given. print('Invalid Command!')