add unit tests for game and display

Author: ng-lis

projects/Snake Game/tests/test_display.py

@@ -12,6 +12,8 @@ class TestDisplay(unittest.TestCase):
     def setUp(self):
         self.display = Display()
         self.snake = Snake()
+        self.display.width = 640
+        self.display.height = 480
 
     @patch('pygame.init')
     @patch('pygame.font.Font')
@@ -67,12 +69,115 @@ def test_update_ui(self, mock_set_mode, mock_display_flip, mock_font, mock_draw_
         self.score = 10
         self.display.window = mock_window
         self.display.font = mock_font_instance
-        self.display.update_ui(self.snake, self.food, self.score)
+        self.high_score = 100
+        self.display.update_ui(self.snake, self.food, self.score, self.high_score)
 
         mock_draw_rect.assert_called()
         mock_font_instance.render.assert_called()
         mock_display_flip.assert_called()
 
+    @patch('pygame.draw.rect')
+    def test_draw_snake(self, mock_draw_rect):
+        snake = MagicMock()
+        snake.blocks = [Point(0, 0), Point(GameSettings.BLOCK_SIZE, 0), Point(2 * GameSettings.BLOCK_SIZE, 0)]
+
+        self.display.draw_snake(snake)
+
+        # Check for  correct snake block rendering
+        mock_draw_rect.assert_any_call(
+            self.display.window, RgbColors.BLUE1, pygame.Rect(0, 0, GameSettings.BLOCK_SIZE, GameSettings.BLOCK_SIZE)
+        )
+        mock_draw_rect.assert_any_call(
+            self.display.window, RgbColors.BLUE2, pygame.Rect(4, 4, 12, 12)
+        )
+
+    @patch('pygame.draw.rect')
+    def test_draw_food(self, mock_draw_rect):
+        food = Point(0, 0)
+        self.display.draw_food(food)
+        # Check for correct food rendering
+        mock_draw_rect.assert_called_once_with(
+            self.display.window, RgbColors.RED, pygame.Rect(0, 0, GameSettings.BLOCK_SIZE, GameSettings.BLOCK_SIZE)
+        )
+
+    @patch('pygame.font.Font')
+    def test_draw_score(self, mock_font):
+        score = 10
+        mock_font_instance = mock_font.return_value
+        mock_render = MagicMock()
+        mock_font_instance.render.return_value = mock_render
+        mock_render.get_width.return_value = 160
+        mock_render.get_height.return_value = 120
+        mock_window_surface = MagicMock()
+        self.display.window = mock_window_surface
+        self.display.font = mock_font_instance
+        self.display.draw_score(score)
+
+        mock_font_instance.render.assert_called_once()
+        mock_window_surface.blit.assert_called_once()
+
+    @patch('pygame.display.flip')
+    @patch('pygame.font.Font')
+    def test_render_game_over(self, mock_font, mock_flip):
+        mock_font_instance = mock_font.return_value
+        mock_render = MagicMock()
+        mock_font_instance.render.return_value = mock_render
+        mock_render.get_width.return_value = 160
+        mock_render.get_height.return_value = 120
+        mock_window_surface = MagicMock()
+        self.display.window = mock_window_surface
+        self.display.render_game_over()
+
+        mock_font_instance.render.assert_called_once()
+        mock_window_surface.blit.assert_called_once()
+        mock_flip.assert_called_once()
+
+    @patch('pygame.display.flip')
+    @patch('pygame.font.Font')
+    def test_render_play_again(self, mock_font, mock_flip):
+        mock_font_instance = mock_font.return_value
+        mock_render = MagicMock()
+        mock_font_instance.render.return_value = mock_render
+        mock_render.get_rect.return_value = pygame.Rect(0, 0, 100, 50)
+        mock_window_surface = MagicMock()
+        self.display.window = mock_window_surface
+        self.display.render_play_again()
+
+        mock_font_instance.render.assert_called_once()
+        mock_window_surface.blit.assert_called_once()
+        mock_flip.assert_called_once()
+
+    @patch('pygame.font.Font')
+    def test_render_high_score(self, mock_font):
+        high_score = 100
+        mock_font_instance = mock_font.return_value
+        mock_render = MagicMock()
+        mock_font_instance.render.return_value = mock_render
+        mock_render.get_width.return_value = 160
+        mock_render.get_height.return_value = 120
+        mock_window_surface = MagicMock()
+        self.display.window = mock_window_surface
+        self.display.font = mock_font_instance
+        self.display.draw_score(high_score)
+
+        mock_font_instance.render.assert_called_once()
+        mock_window_surface.blit.assert_called_once()
+
+    @patch('pygame.display.flip')
+    @patch('pygame.font.Font')
+    def test_render_new_high_score(self, mock_font, mock_flip):
+        mock_font_instance = mock_font.return_value
+        mock_render = MagicMock()
+        mock_font_instance.render.return_value = mock_render
+        mock_render.get_rect.return_value = pygame.Rect(0, 0, 100, 50)
+        mock_window_surface = MagicMock()
+        self.display.window = mock_window_surface
+        self.display.render_play_again()
+
+        mock_font_instance.render.assert_called_once()
+        mock_window_surface.blit.assert_called_once()
+        mock_flip.assert_called_once()
+
 
 if __name__ == '__main__':
     unittest.main()

projects/Snake Game/tests/test_game.py

@@ -1,5 +1,6 @@
+import io
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch, MagicMock, mock_open
 import pygame
 from game import Game
 from constants import GameSettings, Point
@@ -28,10 +29,12 @@ def test_is_collision(self):
     @patch('pygame.draw.rect')
     @patch('pygame.display.flip')
     @patch('pygame.font.Font')
-    def test_play_step(self, mock_event_get, mock_draw_rect, mock_display_flip, mock_font):
+    def test_play_step(self, mock_font, mock_display_flip, mock_draw_rect, mock_event_get):
         mock_event_get.return_value = []
         mock_font_instance = MagicMock()
-        mock_font_instance.render.return_value = MagicMock()
+        self.game.display.window = MagicMock(spec=pygame.Surface)
+        mock_surface = MagicMock(spec=pygame.Surface)
+        mock_font_instance.render.return_value = mock_surface
         mock_font.return_value = mock_font_instance
 
         init_snake_length = len(self.game.snake.blocks)
@@ -43,6 +46,7 @@ def test_play_step(self, mock_event_get, mock_draw_rect, mock_display_flip, mock
 
         self.assertEqual(len(self.game.snake.blocks), init_snake_length + 1)
         self.assertEqual(self.game.score, init_score + 1)
+        # Check snake head is one block in front of the initial head position
         new_head_position = Point(init_head_position.x + GameSettings.BLOCK_SIZE, init_head_position.y)
         self.assertEqual(self.game.snake.head, new_head_position)
 
@@ -73,11 +77,51 @@ def test_play_again_esc(self, mock_event_get):
     def test_restart_game(self):
         self.game.snake = Snake(init_length=10)
         self.game.score = 10
+        init_high_score = self.game.high_score
 
         self.game.restart_game()
         self.assertEqual(len(self.game.snake.blocks), 3)
         self.assertEqual(self.game.score, 0)
         self.assertIsNotNone(self.game.food)
+        self.assertEqual(init_high_score, self.game.high_score)
+
+    @patch('builtins.open', side_effect=FileNotFoundError)
+    def test_load_high_score_no_json_file(self, mock_open):
+        returned_high_score = self.game.load_high_score()
+        self.assertEqual(returned_high_score, 0)
+
+    @patch('builtins.open', return_value=io.StringIO('{"high_score": 100}'))
+    def test_load_high_score_existing_file(self, mock_open):
+        returned_high_score = self.game.load_high_score()
+        self.assertEqual(returned_high_score, 100)
+
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('json.dump')
+    @patch('json.load', return_value={"high_score": 100})
+    def test_update_high_score(self, mock_load, mock_dump, mock_open):
+        mock_file = mock_open.return_value
+        mock_file.__enter__.return_value = mock_file
+
+        self.game.update_high_score(200)
+
+        # Check file is opened in read-mode for loading high score, and opened in write-mode for updating high score
+        mock_open.assert_any_call('high_score.json', 'r')
+        mock_open.assert_any_call('high_score.json', 'w')
+
+        mock_dump.assert_called_with({"high_score": 200}, mock_file)
+
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('json.dump')
+    @patch('json.load', return_value={"high_score": 100})
+    def test_update_high_score_with_score_lower_than_high_score(self, mock_load, mock_dump, mock_open):
+        mock_file = mock_open.return_value
+        mock_file.__enter__.return_value = mock_file
+
+        self.game.update_high_score(50)
+
+        # Check high score is not changed
+        mock_open.assert_called_once_with('high_score.json', 'r')
+        mock_dump.assert_not_called()
 
 
 if __name__ == '__main__':