class TestHigscore(unittest.TestCase):
"""Test Higscore Class."""
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.mock_player1 = Mock(spec=Player, name="player1",
score=42, decision=False)
self.mock_player2 = Mock(spec=Player, name="Computer",
score=65, decision=True)
self.assertIsInstance(self.mock_player1, Player)
self.assertIsInstance(self.mock_player2, Player)
self.score = Highscore(self.mock_player1, self.mock_player2)
def test_write_file(self):
"""Test write_file."""
self.player1 = Player("score1", False)
self.game.set_playing_now(self.game.player1)
self.player1.change_score(5)
self.score.write_file()
self.player2_name = Player("score2", False)
self.game.set_playing_now(self.game.player2)
self.player1.change_score(4)
def test_read_file(self):
"""Test read_file."""
self.score.get_path()
catch_output = io.StringIO()
sys.stdout = catch_output
self.score.read_file()
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn("player name: ", output)
self.assertIn(" (score) -> ", output)
def test_get_path(self):
"""Test get_path."""
exp = self.score.get_path()
self.assertTrue(exp, 'score.txt')
class Game():
"""Game Class."""
win_pig = 50
still_going = False
def __init__(self):
"""Initialize instances from other classes."""
self.computer_controlar = False
self.dice = Dice()
# Changable value
self.forbidden_face = 1
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.set_playing_now(self.player1)
# Basically, player2 may be computer in case user decided.
# However, computer_player object has been added to make the
# code easier to read. Since computer controlled by another class.
self.computer_player = Player("Computer", bool)
self.computer_player.set_level("easy")
self.score = Highscore(self.player1, self.player2)
self.histogram = Histogram()
def create_player(self, player_amount):
"""
Create Players accourding to passed parameter.
Get info from shell.py, fit equavelent players with names.
Turn computer_controller on/off.
"""
player1_name = input("Enter the first player's name >> ")
if player1_name == "":
player1_name = "USER1"
self.player1.set_name(player1_name)
self.player2.set_name("Computer")
# Hold player object temporarily above
if player_amount == 2:
player2_name = input("Enter the second player's name >> ")
if player2_name == "":
player2_name = "USER2"
self.player2.set_name(player2_name)
else:
self.player2 = self.computer_player
print("Game Starts!\n\n")
def switcher(self):
"""
Switch between players.
Considering who is playing now and whether
computer-controler true or false, take rule in switching turns
between players.
"""
if (self.get_computer_controler()
and self.get_playing_now() == self.player1):
self.set_playing_now(self.computer_player)
return self.computer_turn()
if (self.get_computer_controler()
and self.get_playing_now() == self.computer_player):
self.set_playing_now(self.player1)
if self.get_playing_now() == self.player1 and not (
self.get_computer_controler()):
print(">>>>> Start {} turn <<<<<\n".format(
self.player2.get_name()))
return self.set_playing_now(self.player2)
print(">>>>> Start {} turn <<<<<\n".format(self.player1.get_name()))
return self.set_playing_now(self.player1)
def roll(self):
"""
Reached by human players.
Call other methods to make operations depends on die rollments.
"""
force_stop = self.console(self.get_playing_now())
if not force_stop and self.get_game_status():
self.switcher()
def console(self, player):
"""Synchronize between players's scores and rolled dice."""
self.print_out_dice(player, self.dice.get_dice())
player.change_score(self.dice.get_dice())
player.set_score_list(self.dice.get_dice())
self.print_score(player)
# self.mock_in_console = self.dice.get_dice()
self.set_face(self.dice.get_dice()) # For test purpose.
if self.dice.get_dice() in (1, 6):
self.dice.roll_dice()
return False
if self.get_playing_now().get_score() >= self.win_pig:
self.end_game(self.playing_now)
self.set_game_status(False)
self.dice.roll_dice()
return True
def computer_turn(self):
"""Take orders from Intelligence class to control the decison."""
print(">>>>> Start Computer turn <<<<<\n")
while self.get_game_status():
reaction = self.computer_player.reaction.get_inti_decision(
self.computer_player, self.cheat())
if not reaction:
print("\t\t\t\t>>>>> Computer decide to HOLD <<<<<")
self.switcher()
break
print("\t\t\t\t>>>>> Computer decide to ROLL <<<<<")
self.playing_now = self.computer_player
force_stop = self.console(self.computer_player)
if not force_stop:
print("\t\t\t\t>>>>> Computer lose its turn <<<<<")
self.switcher()
break
def cheat(self):
"""Return the rolled dice to reach cheating feture."""
return self.dice.get_dice()
def check_levels(self, level):
"""Check if the entered level is valid."""
levels = ("easy", "normal", "hard")
if level in levels:
self.computer_player.set_level(level)
print("My level now is", level)
else:
raise ValueError("This kind of level is not available!!")
def change_name(self, name):
"""Change player name."""
self.playing_now.set_name(name)
@staticmethod
def print_score(player):
"""Print out player score and name."""
print("{} score is {}".format(player.get_name(), player.get_score()))
@staticmethod
def print_out_dice(player, number):
"""Print out rolled dice."""
print("{} got:".format(player.get_name()))
print(" ______")
print(r"|\______\ ")
print("|| |")
print("|| {} |".format(number))
print(r"\|______|" + "\n")
def highscore(self):
"""Call method sprint out from highscore file."""
self.score.read_file()
def end_game(self, player):
"""Call other methods to process game ending."""
self.score = Highscore(self.player1, self.player2)
# self.score.write_highscore()
self.set_game_status(False)
print("WOW! Congra {} you won the game!".format(player.get_name()))
self.histogram.print_histogram(self.player1, self.player2)
self.score.write_file()
def set_game_status(self, bool):
"""Set game status."""
self.still_going = bool
def get_game_status(self):
"""Check the game status."""
return self.still_going
def set_playing_now(self, player):
"""Change object's holder to help exchanging players."""
self.playing_now = player
def get_playing_now(self):
"""Return currently player."""
return self.playing_now
def set_computer_controler(self, bool):
"""Setter for a boolen variable.
Help in switching turns.
"""
self.computer_controlar = bool
def get_computer_controler(self):
"""Getter for a boolen variable.
Help to switching turns.
"""
return self.computer_controlar
# The following two methods helps to check
# the dice face while playing and exatly
# before the next rollment,
# do not effect the game, helping in testing
def set_face(self, num):
"""Set value in variable to hold dice face before automatic rolling.
This method used for testing purpose.
"""
self.forbidden_face = num
def get_face(self):
"""Return dice face before automatic rolling.
Method used for testing purpose.
"""
return self.forbidden_face
class TestGameClass(unittest.TestCase):
"""Test Game Class."""
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.game.set_game_status(True)
self.dice = Dice()
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.computer_player = Player(str, bool)
self.highscore = Highscore(self.player1, self.player2)
@patch('builtins.input', return_value='')
def test_create_player(self, mock):
"""Test create_player."""
# Test with one player name and no name entered
self.game.create_player(1)
self.game.player1_name = mock
self.assertEqual(self.game.player1.get_name(), "USER1")
@patch('builtins.input', return_value='name')
def test_create_player1(self, mock):
"""Test create_player."""
# Test with one player name and no name entered
self.game.create_player(1)
self.game.player1_name = mock
self.assertEqual(self.game.player1.get_name(), "name")
self.assertEqual(self.game.player2.get_name(), "Computer")
@patch('builtins.input', return_value='')
def test_create_player2(self, mock):
"""Test create_player."""
# Test with Two players name and no name entered
self.game.create_player(2)
self.game.player1_name = mock
self.game.player2_name = mock
self.assertEqual(self.game.player1.get_name(), "USER1")
self.assertEqual(self.game.player2.get_name(), "USER2")
# Check that computer_controler is off
self.assertFalse(self.game.get_computer_controler())
def test_switcher(self):
"""Test Switcher."""
# Testing switcher
self.game.set_game_status(True)
before_switching = self.game.get_playing_now()
self.game.switcher()
after_switching = self.game.get_playing_now()
self.assertNotEqual(before_switching, after_switching)
# another test and assuming it is ccomputer's turn
self.game.set_game_status(True)
self.game.set_playing_now(self.computer_player)
self.game.switcher()
self.assertEqual(self.game.get_playing_now(), self.game.player1)
def test_roll(self):
"""Test roll."""
res = self.game.roll()
if self.game.get_face() in (1, 6):
self.assertFalse(res)
def test_console(self):
"""Test console."""
ret_bool = self.game.console(self.game.get_playing_now())
if self.game.get_face() in (1, 6):
self.assertFalse(ret_bool)
# Test that the game ends when the currently player
# reached the winning score
if self.game.get_playing_now().get_score() >= self.game.win_pig:
self.assertFalse(self.game.get_game_status())
self.game.end_game(self.game.get_playing_now())
def test_computer_turn(self):
"""Test computer_turn."""
# Testing prints message:
self.game.computer_turn()
# Most output from method inculds :
printing_res = ' Computer '
catch_output = io.StringIO()
sys.stdout = catch_output
self.game.computer_turn()
# print player's name and score and catch it.
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(str(printing_res), output)
# Testing switcher() be called by computer_player
# when it decide stops playing
test_reaction = self.computer_player.reaction.get_inti_decision(
self.computer_player, 4)
if not test_reaction:
mock_com_player = Mock(spec=Game)
self.assertIsInstance(mock_com_player, Game)
mock_com_player.switcher()
mock_com_player.switcher.assert_called()
# If game force stop, call switcher
mock_com_player2 = Mock(spec=Game)
game_return = self.game.console(self.computer_player)
if not game_return:
mock_com_player2.switcher()
mock_com_player2.switcher.assert_called()
def test_cheat(self):
"""Test cheat method."""
cheat_method = self.game.cheat()
self.assertEqual(cheat_method, self.game.dice.get_dice())
def test_highscore(self):
"""Test highscore method."""
mock = Mock(spec=Highscore)
self.assertIsInstance(mock, Highscore)
with patch('highscore.Highscore') as fake_obj:
mock.read_file()
fake_obj.asert_called()
# another test
read_file_method = self.highscore.read_file()
self.assertEqual(read_file_method, self.highscore.read_file())
# Test The Instance
self.assertIsInstance(self.highscore, Highscore)
def test_change_name(self):
"""Test changing name feature."""
self.game.change_name("new_name")
res = self.game.playing_now.get_name()
self.assertTrue(res == "new_name")
def test_end_game(self):
"""Test end_game."""
histogram = Histogram()
score = Highscore(self.game.player1, self.game.player2)
self.game.set_game_status(False)
self.assertIsInstance(histogram, Histogram)
# self.assertFalse(self.game.get_game_status())
self.assertIsInstance(score, Highscore)
# The folling two lines work find to test
# the the method change-game.status to false
# exp = self.player1
# self.game.end_game(exp)
# However;
# The followign method-call raise an error
# and may need another tests typ!
# score.write_file() <-----
highscore = Highscore(self.game.player1, self.game.player2)
highscore.write_file = MagicMock(name='write_file')
highscore.write_file()
def test_check_levels(self):
"""Test check_levels."""
# assuming easy level passed:
passed_level = "easy"
levels_list = ("easy")
self.game.check_levels(passed_level)
if passed_level in levels_list:
res = self.computer_player.reaction.level
self.assertEqual(res, passed_level)
def test_print_score(self):
"""Test print_score."""
name_res = self.player1.get_name()
score_res = self.player1.get_score()
res = name_res and score_res
catch_output = io.StringIO()
sys.stdout = catch_output
self.game.print_score(self.player1)
# print player's name and score and catch it.
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(str(res), output)
def test_print_out_dice(self):
"""Test print_out_dice."""
res = str(self.player1.get_name())
catch_output = io.StringIO()
sys.stdout = catch_output
self.game.print_out_dice(self.player1, 5)
# print cube out and catch it.
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(res, output)
def test_get_playing_now(self):
"""Test set And get_playing_now."""
exp = self.player1
self.game.set_playing_now(exp)
res = self.game.get_playing_now()
self.assertEqual(res, exp)
def test_get_game_status(self):
"""Test get_game_status."""
res = self.game.get_game_status()
self.assertIn(res, [True, False])
def test_set_cmputer_controler(self):
"""Test set_computer_controler."""
self.game.set_computer_controler(True)
self.assertTrue(self.game.computer_controlar)
def test_get_computer_controler(self):
"""Test get_computer_controler."""
res = self.game.get_computer_controler()
self.assertIn(res, [True, False])
def test_set_face(self):
"""Test set_face."""
self.game.set_face(2)
res = self.game.get_face()
self.assertEqual(res, 2)
