class TestReallocatePerson(unittest.TestCase):
"""Reallocation test cases"""
def setUp(self):
self.dojo = Dojo()
def test_person_exists(self):
"""test_person_exists"""
self.dojo.create_room("red", "office")
reallocate = self.dojo.reallocate_person("mwenda", "red")
msg = colored("Person Mwenda does not exist!", "red")
self.assertEqual(reallocate, msg)
def test_room_exists(self):
"""test_room_exists"""
self.dojo.add_person("miriti", 'fellow')
reallocate = self.dojo.reallocate_person("miriti", "red")
error = colored("Room red does not exist!", "red")
self.assertEqual(reallocate, error)
def test_reallocated(self):
"""test_reallocated successfully"""
self.dojo.add_person('miriti', 'staff')
self.dojo.create_room('blue', 'office')
first = self.dojo.print_room("blue")
self.assertEqual("0 names printed", first)
self.dojo.reallocate_person("miriti", "blue")
results = self.dojo.print_room('blue')
self.assertEqual(results, "1 names printed")
class TestPrintUnallocated(unittest.TestCase):
"""testcase for print unallocated"""
def setUp(self):
self.dojo = Dojo()
def test_print_un_allocated(self):
'''test_print_un_allocated'''
self.dojo.create_room('blue', 'office')
self.dojo.add_person('Ken', 'fellow', 'Y')
unallocated = self.dojo.print_unallocated()
outcome = "1 names printed"
self.assertEqual(outcome, unallocated)
def test_no_un_allocations(self):
"""test_no_un_allocations"""
unallocated = self.dojo.print_unallocated()
msg = colored("No unallocated Employeee at the moment!", "red")
self.assertEqual(unallocated, msg)
class TestAddPerson(unittest.TestCase):
"""add_person command testcases"""
def setUp(self):
self.dojo=Dojo()
def test_person_can_only_be_staff_or_fellow(self):
person1=self.dojo.add_person('mwenda','1213','Y')
self.assertEqual('Person type can only be a fellow or a staff!',person1)
def test_person_name_only_string(self):
person2=self.dojo.add_person('mwenda',1213,'Y')
person3=self.dojo.add_person(123,'office','Y')
error='names and person type should be a strings!'
self.assertEqual(error,person2)
self.assertEqual(error,person3)
def test_person_created_successfully(self):
employee_count = len(self.dojo.all_employees)
mwenda = self.dojo.add_person("mwenda", "staff")
new_count = len(self.dojo.all_employees)
self.assertEqual((new_count - employee_count), 1)
class TestPrintRoom(unittest.TestCase):
"""testcase for print room"""
def setUp(self):
self.dojo = Dojo()
def test_print_room(self):
'''test that members of a room are printed'''
self.dojo.create_room('blue', 'office')
self.dojo.add_person('mwenda', 'fellow', 'Y')
self.dojo.add_person('miriti', 'staff')
self.dojo.add_person('Eric', 'fellow')
results = self.dojo.print_room('blue')
expected = "3 names printed"
self.assertEqual(results, expected)
def test_room_must_be_avialable(self):
"""test that cannot print rooms not available"""
room = self.dojo.print_room('bluered')
msg = colored("Room bluered does not exist!", "red")
self.assertEqual(room, msg)
class TestAddPerson(unittest.TestCase):
def setUp(self):
self.dojo = Dojo()
self.initial_people = len(self.dojo.all_people)
def test_create_people_successfully(self):
self.fellow = self.dojo.add_person('Joshua', 'Ondieki', 'Fellow')
self.staff = self.dojo.add_person('Annette', 'Kamau', 'Staff')
new_people = len(self.dojo.all_people)
self.assertEqual(new_people - self.initial_people, 2)
def test_it_fails_with_existing_person(self):
exist_person = self.dojo.add_person('Joshua', 'Ondieki', 'Fellow')
try_overwrite_f = self.dojo.add_person('Joshua', 'Ondieki', 'Fellow')
exist_person = self.dojo.add_person('Evans', 'Musomi', 'Staff')
try_overwrite_s = self.dojo.add_person('Evans', 'Musomi', 'Staff')
self.assertTrue(try_overwrite_f == error('Joshua Ondieki exists!')
and try_overwrite_s == error('Evans Musomi exists!'))
def test_it_fails_with_invalid_person_type(self):
invalid_type = self.dojo.add_person('Loice', 'Andia', 'BFA')
self.assertEqual(error('Only fellow and staff allowed!'), invalid_type)
def test_fails_with_person_name_not_string(self):
invalid_person = self.dojo.add_person(['Oj'], 'Josh', 'Fellow')
invalid_person1 = self.dojo.add_person({'Oj': 'Josh'}, {}, 'Fellow')
invalid_person2 = self.dojo.add_person(['Oj'], ['Josh'], 'Staff')
invalid_person3 = self.dojo.add_person({'Oj': 'Josh'}, {}, 'Staff')
self.assertEqual(invalid_person,
error('People names can only be strings!'))
self.assertEqual(invalid_person1,
error('People names can only be strings!'))
self.assertEqual(invalid_person2,
error('People names can only be strings!'))
self.assertEqual(invalid_person3,
error('People names can only be strings!'))
class DojoTestCase(unittest.TestCase):
def setUp(self):
self.dojo = Dojo()
def test_initial_room_check(self):
self.assertEqual(self.dojo.rooms, {})
def test_create_room_successfully(self):
initial_room_count = len(self.dojo.rooms)
blue_office = self.dojo.create_room('office', 'blue')
self.assertTrue(blue_office)
new_room_count = len(self.dojo.rooms)
self.assertEqual(new_room_count - initial_room_count, 1)
def test_create_room_if_office_already_exists(self):
self.dojo.rooms = {'office': ['blue']}
self.assertEqual(self.dojo.create_room('office', 'blue'),
'office already exists!', msg='office already exists!')
def test_create_room_if_livingspace_already_exists(self):
self.dojo.rooms = {'living_space': ['blue']}
self.assertEqual(self.dojo.create_room('living_space', 'blue'),
'living_space already exists!', msg='living_space already exists!')
def test_create_multiple_rooms(self):
self.assertEqual(self.dojo.create_room(
'office', 'blue', 'black', 'yellow'), self.dojo.rooms)
def test_create_unknown_room_type(self):
self.assertEqual(self.dojo.create_room('kitchen', 'green'),
'Unknown Room Type', msg='Unknown Room Type')
def test_initial_add_person_check(self):
self.assertEqual(self.dojo.people, [])
def test_add_person_successfully(self):
self.dojo.offices, self.dojo.living_space = {
'blue': [], 'green': []}, {'yellow': [], 'grey': []}
self.dojo.vacant_offices, self.dojo.vacant_livingspaces = [
'blue', 'green'], ['yellow', 'grey']
initial_people_count = len(self.dojo.people)
john_staff = self.dojo.add_person('john', 'staff', 'N')
self.assertTrue(john_staff)
new_people_count = len(self.dojo.people)
self.assertEqual(new_people_count - initial_people_count, 1)
def test_add_staff(self):
self.dojo.offices, self.dojo.living_space = {
'blue': [], 'green': []}, {'yellow': [], 'grey': []}
self.dojo.vacant_offices, self.dojo.vacant_livingspaces = [
'blue', 'green'], ['yellow', 'grey']
self.assertEqual(self.dojo.add_person('john me', 'staff', 'N'), self.dojo.people)
def test_add_fellow(self):
self.dojo.offices, self.dojo.living_space = {
'blue': [], 'green': []}, {'yellow': [], 'grey': []}
self.dojo.vacant_offices, self.dojo.vacant_livingspaces = [
'blue', 'green'], ['yellow', 'grey']
self.assertEqual(self.dojo.add_person('john me', 'fellow', 'Y'), self.dojo.people)
def test_add_person_when_person_already_exists(self):
self.dojo.offices, self.dojo.living_space = {
'blue': [], 'green': []}, {'yellow': [], 'grey': []}
self.dojo.vacant_offices, self.dojo.vacant_livingspaces = [
'blue', 'green'], ['yellow', 'grey']
self.dojo.people = ['john me']
self.assertEqual(self.dojo.add_person('john me', 'fellow', 'Y'),
'Person already exists', msg='Person already exists')
def test_add_unknown_person_type(self):
self.assertEqual(self.dojo.add_person('john me', 'follow', 'Y'),
'Unknown position', msg='Unknown position')
def test_person_office_allocation(self):
pass
def test_person_living_space_allocation(self):
pass
def test_vacant_space_reduction_after_allocation(self):
pass
def test_names_in_room_are_true(self):
pass
def test_allocations_written_to_text_file(self):
pass
def test_unallocated_names_written_to_text_file(self):
pass
def test_names_in_room_are_true(self):
pass
def test_allocations_written_to_text_file(self):
pass
def test_unallocated_names_written_to_text_file(self):
pass