129 lines
3.8 KiB
Python
129 lines
3.8 KiB
Python
import unittest
|
|
|
|
from logic.knights_queue import KnightsQueue
|
|
from models.knight import Knight
|
|
|
|
|
|
class KnightsQueueTest(unittest.TestCase):
|
|
def test_should_skip_dead_knights(self):
|
|
knight1 = Knight(None)
|
|
knight1.health = 0
|
|
|
|
knight2 = Knight(None)
|
|
knight2.health = 0
|
|
|
|
knight3 = Knight(None)
|
|
knight3.health = 1
|
|
|
|
knight4 = Knight(None)
|
|
knight4.health = 0
|
|
|
|
knight5 = Knight(None)
|
|
knight5.health = 0
|
|
|
|
knight6 = Knight(None)
|
|
knight6.health = 1
|
|
|
|
knights_queue = KnightsQueue([knight1, knight2, knight3], [knight4, knight5, knight6])
|
|
|
|
res1 = knights_queue.dequeue_knight()
|
|
res2 = knights_queue.dequeue_knight()
|
|
|
|
self.assertEqual(res1.health, 1)
|
|
self.assertEqual(res2.health, 1)
|
|
|
|
def test_should_return_first_alive_knight(self):
|
|
knight1 = Knight(None)
|
|
knight1.health = 222
|
|
|
|
knight2 = Knight(None)
|
|
knight2.health = -1
|
|
|
|
knight3 = Knight(None)
|
|
knight3.health = 1
|
|
|
|
knights_queue = KnightsQueue([knight1, knight2], [knight3])
|
|
|
|
res1 = knights_queue.dequeue_knight()
|
|
res2 = knights_queue.dequeue_knight()
|
|
res3 = knights_queue.dequeue_knight()
|
|
res4 = knights_queue.dequeue_knight()
|
|
|
|
self.assertEqual(res1, res3)
|
|
self.assertEqual(res2, res4)
|
|
|
|
def test_should_raise_when_knight_died_and_whole_team_dead(self):
|
|
with self.assertRaises(Exception):
|
|
knight1 = Knight(None)
|
|
knight1.health = 222
|
|
knight2 = Knight(None)
|
|
knight2.health = 1
|
|
|
|
knights_queue = KnightsQueue([knight1], [knight2])
|
|
knights_queue.dequeue_knight()
|
|
knights_queue.dequeue_knight()
|
|
knight2.health = -2
|
|
knights_queue.dequeue_knight()
|
|
knights_queue.dequeue_knight()
|
|
|
|
def test_should_make_valid_next_turn(self):
|
|
knight1 = Knight(None)
|
|
knight1.health = 222
|
|
knight2 = Knight(None)
|
|
knight2.health = 1
|
|
|
|
knights_queue = KnightsQueue([knight1], [knight2])
|
|
previous_turn = knights_queue.team_idx_turn
|
|
knights_queue.dequeue_knight()
|
|
current_turn = knights_queue.team_idx_turn
|
|
|
|
self.assertNotEqual(previous_turn, current_turn)
|
|
|
|
def test_should_raise_when_team_has_dead_knights(self):
|
|
with self.assertRaises(Exception):
|
|
knight1 = Knight(None)
|
|
knight1.health = 0
|
|
knight2 = Knight(None)
|
|
knight2.health = -1
|
|
knight3 = Knight(None)
|
|
knight3.health = -2
|
|
knight4 = Knight(None)
|
|
knight4.health = 20
|
|
|
|
knights_queue = KnightsQueue([knight1, knight2, knight3], [knight4])
|
|
|
|
knights_queue.dequeue_knight()
|
|
knights_queue.dequeue_knight()
|
|
|
|
def test_should_return_knight_from_any_team_and_add_to_queue_again(self):
|
|
knight1 = Knight(None)
|
|
knight1.health = 10
|
|
knight2 = Knight(None)
|
|
knight2.health = 20
|
|
knights_queue = KnightsQueue([knight1], [knight2])
|
|
|
|
result1 = knights_queue.dequeue_knight()
|
|
result2 = knights_queue.dequeue_knight()
|
|
result3 = knights_queue.dequeue_knight()
|
|
|
|
self.assertIsNotNone(result1)
|
|
self.assertIsNotNone(result2)
|
|
self.assertIsNotNone(result3)
|
|
self.assertTrue(result1.health == result3.health)
|
|
|
|
def test_should_raise_when_only_one_team_alive(self):
|
|
with self.assertRaises(Exception):
|
|
knight = Knight(None)
|
|
knight.health = 21
|
|
knights_queue = KnightsQueue([knight], [])
|
|
knights_queue.dequeue_knight()
|
|
|
|
def test_should_raise_when_no_team_alive(self):
|
|
with self.assertRaises(Exception):
|
|
knights_queue = KnightsQueue([], [])
|
|
knights_queue.dequeue_knight()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|