add unit tests for game, display and snake

Author: ng-lis

projects/Snake Game/constants.py renamed to projects/Snake Game/src/constants.py

@@ -33,6 +33,3 @@ def update_ui(self, snake, food, score):
         score_display = self.font.render(f"Score: {score}", True, RgbColors.WHITE)
         self.window.blit(score_display, [0, 0])  # score in top left corner of window
         pygame.display.flip()
-
-    def clock_tick(self, speed):
-        self.clock.tick(speed)

projects/Snake Game/display.py renamed to projects/Snake Game/src/display.py

@@ -64,7 +64,7 @@ def play_step(self):
             self.snake.blocks.pop()
         # Update UI and Clock
         self.display.update_ui(self.snake, self.food, self.score)
-        self.display.clock_tick(GameSettings.SPEED)
+        self.display.clock.tick(GameSettings.SPEED)
         game_over = self.is_collision()
         return game_over, self.score
 

projects/Snake Game/game.py renamed to projects/Snake Game/src/game.py

@@ -0,0 +1,78 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import pygame
+import pygame.time
+from display import Display
+from constants import RgbColors, GameSettings, Point
+from snake import Snake
+
+
+class TestDisplay(unittest.TestCase):
+
+    def setUp(self):
+        self.display = Display()
+        self.snake = Snake()
+
+    @patch('pygame.init')
+    @patch('pygame.font.Font')
+    @patch('pygame.display.set_mode')
+    @patch('pygame.display.set_caption')
+    @patch('pygame.time.Clock')
+    def test_init(self, mock_init, mock_font, mock_set_mode, mock_set_caption, mock_clock):
+        mock_init.return_value = True
+        mock_font_instance = MagicMock()
+        mock_font.return_value = mock_font_instance
+        mock_window = MagicMock()
+        mock_set_mode.return_value = mock_window
+        mock_clock_instance = MagicMock()
+        mock_clock.return_value = mock_clock_instance
+
+        mock_set_mode.assert_called_with((GameSettings.WIDTH, GameSettings.HEIGHT))
+        mock_set_caption.assert_called_with("Snake")
+        mock_clock.assert_called()
+
+        self.assertEqual(self.display.width, GameSettings.WIDTH)
+        self.assertEqual(self.display.height, GameSettings.HEIGHT)
+        self.assertIsInstance(self.display.font, pygame.font.Font)
+        self.assertIsInstance(self.display.window, MagicMock)
+        self.assertIsInstance(self.display.clock, MagicMock)
+
+    @patch('pygame.init')
+    @patch('pygame.display.set_mode')
+    @patch('pygame.display.set_caption')
+    @patch('pygame.font.Font')
+    @patch('pygame.time.Clock')
+    def test_init(self, mock_clock, mock_font, mock_set_caption, mock_set_mode, mock_init):
+        display = Display()
+        mock_init.assert_called_once()
+        mock_font.assert_called_once()
+        mock_set_caption.assert_called_with("Snake")
+        mock_set_mode.assert_called_with((GameSettings.WIDTH, GameSettings.HEIGHT))
+        mock_clock.assert_called_once()
+
+        self.assertIsInstance(display.font, MagicMock)
+        self.assertIsInstance(display.window, MagicMock)
+        self.assertIsInstance(display.clock, MagicMock)
+
+    @patch('pygame.draw.rect')
+    @patch('pygame.font.Font')
+    @patch('pygame.display.flip')
+    @patch('pygame.display.set_mode')
+    def test_update_ui(self, mock_set_mode, mock_display_flip, mock_font, mock_draw_rect):
+        mock_window = mock_set_mode.return_value
+        mock_font_instance = mock_font.return_value
+        mock_font_instance.render = MagicMock()
+
+        self.food = Point(100, 100)
+        self.score = 10
+        self.display.window = mock_window
+        self.display.font = mock_font_instance
+        self.display.update_ui(self.snake, self.food, self.score)
+
+        mock_draw_rect.assert_called()
+        mock_font_instance.render.assert_called()
+        mock_display_flip.assert_called()
+
+
+if __name__ == '__main__':
+    unittest.main()

projects/Snake Game/main.py renamed to projects/Snake Game/src/main.py

@@ -0,0 +1,53 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from game import Game
+from constants import GameSettings, Point
+
+
+class TestGame(unittest.TestCase):
+    def setUp(self):
+        self.game = Game()
+
+    def test_init(self):
+        self.assertIsNotNone(self.game.display)
+        self.assertIsNotNone(self.game.snake)
+        self.assertEqual(self.game.score, 0)
+        self.assertIsNotNone(self.game.food)
+
+    def test_is_collision(self):
+        # Snake is out of bounds
+        self.game.snake.head = Point(-1, -1)
+        self.assertTrue(self.game.is_collision())
+        # Snake collides with itself
+        self.game.snake.head = self.game.snake.blocks[1]
+        self.assertTrue(self.game.is_collision())
+
+    @patch('pygame.event.get')
+    @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):
+        mock_event_get.return_value = []
+        mock_font_instance = MagicMock()
+        mock_font_instance.render.return_value = MagicMock()
+        mock_font.return_value = mock_font_instance
+
+        init_snake_length = len(self.game.snake.blocks)
+        init_score = self.game.score
+        init_head_position = self.game.snake.head
+        # Place food in front of snake
+        self.game.food = Point(init_head_position.x + GameSettings.BLOCK_SIZE, init_head_position.y)
+        self.game.play_step()
+
+        self.assertEqual(len(self.game.snake.blocks), init_snake_length + 1)
+        self.assertEqual(self.game.score, init_score + 1)
+        new_head_position = Point(init_head_position.x + GameSettings.BLOCK_SIZE, init_head_position.y)
+        self.assertEqual(self.game.snake.head, new_head_position)
+
+    def test_place_food(self):
+        self.game.place_food()
+        self.assertNotIn(self.game.food, self.game.snake.blocks)
+
+
+if __name__ == '__main__':
+    unittest.main()

projects/Snake Game/snake.py renamed to projects/Snake Game/src/snake.py

@@ -0,0 +1,35 @@
+import unittest
+from snake import Snake, Point, Direction
+from constants import GameSettings
+
+
+class TestSnake(unittest.TestCase):
+    def setUp(self):
+        self.snake = Snake()
+
+    def test_init(self):
+        self.assertEqual(self.snake.head, Point(GameSettings.WIDTH / 2, GameSettings.HEIGHT / 2))
+        self.assertEqual(self.snake.block_size, GameSettings.BLOCK_SIZE)
+        self.assertEqual(len(self.snake.blocks), 3)
+        self.assertEqual(self.snake.direction, Direction.RIGHT)
+
+    def test_move(self):
+        init_head = self.snake.head
+        self.snake.move(Direction.RIGHT)
+        new_head_position = Point(init_head.x + GameSettings.BLOCK_SIZE, init_head.y)
+        self.assertEqual(self.snake.head, new_head_position)
+        self.assertEqual(self.snake.blocks[0], new_head_position)
+
+    def test_self_collision(self):
+        self.snake.head = Point(100, 100)
+        self.snake.blocks = [
+            self.snake.head,
+            Point(80, 100),
+            Point(60, 100),
+            Point(100, 100)
+        ]
+        self.assertTrue(self.snake.self_collision())
+
+
+if __name__ == '__main__':
+    unittest.main()