class TestCreateRoom(unittest.TestCase):
"""create_room command test cases"""
def setUp(self):
"""create Dojo() object"""
self.dojo = Dojo()
def test_room_type_can_only_be_office_or_livingspace(self):
room1 = self.dojo.create_room("room1", "room")
error = "Only offices and livingrooms allowed!"
self.assertEqual(error, room1[0])
def test_room_name_only_string(self):
room2 = self.dojo.create_room(1212, 1212)
err = 'names and person type should be a strings!'
self.assertTrue(err, room2[0])
def test_cannot_create_duplicate_rooms(self):
room = self.dojo.create_room("stive", "office")
dup = self.dojo.create_room("stive", "office")
err = "Room stive already exists!"
self.assertEqual(err, dup[0])
def test_room_created_successfully(self):
initial_room_count = len(self.dojo.rooms)
blue_office = self.dojo.create_room("Blue", "office")
self.assertTrue(blue_office)
new_room_count = len(self.dojo.rooms)
self.assertEqual(new_room_count - initial_room_count, 1)
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 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 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 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
class TestCreateRoom(unittest.TestCase):
def setUp(self):
self.dojo = Dojo()
self.initial_rooms = len(self.dojo.all_rooms)
def test_create_rooms_successfully(self):
amity_livingspace = self.dojo.create_room('Amity', 'livingspace')
spire_office = self.dojo.create_room('Spire', 'office')
self.new_rooms = len(self.dojo.all_rooms)
self.assertEqual(self.new_rooms - self.initial_rooms, 2)
self.assertEqual(
success('An office called Spire has been created successfully!'),
spire_office)
self.assertEqual(
success(
'A Livingspace called Amity has been created successfully!'),
amity_livingspace)
def test_it_fails_with_existing_room(self):
exist_room = self.dojo.create_room('Amhere', 'office')
try_overwrite_o = self.dojo.create_room('Amhere', 'office')
exist_room = self.dojo.create_room('Amhere', 'livingspace')
try_overwrite_l = self.dojo.create_room('Amhere', 'livingspace')
self.assertTrue(try_overwrite_o == error('Room Amhere exists!')
and try_overwrite_l == error('Room Amhere exists!'))
def test_it_fails_with_invalid_room_type(self):
invalid_type = self.dojo.create_room('Amhere', 'Kitchen')
self.assertEqual(error('Only offices and livingspaces allowed!'),
invalid_type)
def test_fails_with_room_name_not_string(self):
invalid_room = self.dojo.create_room(['Amhere'], 'office')
invalid_room1 = self.dojo.create_room({'Amhere': 'room'}, 'office')
invalid_room2 = self.dojo.create_room(['Amhere'], 'livingspace')
invalid_room3 = self.dojo.create_room({'Amhere': 'room'},
'livingspace')
self.assertEqual(invalid_room,
error('Room names can only be strings!'))
self.assertEqual(invalid_room1,
error('Room names can only be strings!'))
self.assertEqual(invalid_room2,
error('Room names can only be strings!'))
self.assertEqual(invalid_room3,
error('Room names can only be strings!'))