test_space_invaders.py

import unittest
import pygame
from pygame.sprite import Group
from gun import Gun
from shift import Shift
from statistics import Statistics
from scores import Scores
from controls import create_invaders, update_screen, update_bullets, pause
from unittest.mock import patch
from unittest.mock import MagicMock


class TestGun(unittest.TestCase):

    def setUp(self):
        pygame.init()
        self.screen = pygame.display.set_mode((800, 600))
        self.gun = Gun(self.screen)

    def tearDown(self):
        pygame.quit()

    def test_initial_position(self):
        """Test that gun is positioned in the center bottom of the screen initially"""
        self.assertEqual(self.gun.rect.centerx, self.screen.get_rect().centerx)
        self.assertEqual(self.gun.rect.bottom, self.screen.get_rect().bottom)

    def test_move_right(self):
        """Test that gun moves right when move_right is True"""
        initial_center = self.gun.center
        self.gun.move_right = True
        self.gun.update()
        self.assertGreater(self.gun.center, initial_center)

    def test_move_left(self):
        """Test that gun moves left when move_left is True"""
        initial_center = self.gun.center
        self.gun.move_left = True
        self.gun.update()
        self.assertLess(self.gun.center, initial_center)

    def test_no_movement(self):
        """Test that gun does not move if no keys are pressed"""
        initial_center = self.gun.center
        self.gun.update()
        self.assertEqual(self.gun.center, initial_center)

class TestStatistics(unittest.TestCase):

    def setUp(self):
        self.stats = Statistics()

    def test_initial_lives(self):
        self.assertEqual(self.stats.lives, 3)

    def test_score_initialization(self):
        self.assertEqual(self.stats.score, 0)

    def test_top_score_read(self):
        with open("top_score.txt", "w") as f:
            f.write("100")
        stats = Statistics()
        self.assertEqual(stats.top_score, 100)

class TestUpdateBullets(unittest.TestCase):

    def setUp(self):
        pygame.init()
        self.screen = pygame.display.set_mode((800, 600))
        self.gun = Gun(self.screen)
        self.shooter_bullets = MagicMock()
        self.bullets = MagicMock()
        self.invaders = Group()
        self.walls = Group()
        self.shift = MagicMock()
        self.level_info = "easy"
        self.statistics = Statistics()
        self.score = Scores(self.screen, self.statistics, "")
        self.mistery = MagicMock()
        self.machine_guns = MagicMock()
        self.invincibilities = MagicMock()
        self.freezes = MagicMock()

    def test_bullet_removal(self):
        bullet = pygame.sprite.Sprite()
        bullet.rect = pygame.Rect(0, 0, 5, 5)
        bullet.rect.bottom = -10

        self.bullets.add(bullet)

        update_bullets(self.screen, self.statistics, self.score, self.bullets,
                       self.invaders, self.shooter_bullets, self.walls,
                       self.shift, self.level_info, self.mistery, self.machine_guns,
        self.gun, self.invincibilities, self.freezes)

        self.assertNotIn(bullet, self.bullets)

class TestInvaders(unittest.TestCase):

    def test_create_invaders(self):
        screen = MagicMock()
        invaders = MagicMock()
        shooter_bullets = MagicMock()
        shift = MagicMock()
        level_info = "easy"
        create_invaders(screen, invaders, shooter_bullets, shift, level_info)
        self.assertTrue(invaders.add.called)
        level_info = "middle"
        create_invaders(screen, invaders, shooter_bullets, shift, level_info)
        self.assertTrue(invaders.add.called)
        level_info = "hard"
        create_invaders(screen, invaders, shooter_bullets, shift, level_info)
        self.assertTrue(invaders.add.called)


class TestPause(unittest.TestCase):

    def setUp(self):
        pygame.init()
        pygame.font.init()

        self.screen = pygame.display.set_mode((800, 600))
        self.statistics = Statistics()
        self.gun = Gun(self.screen)
        self.bullets = pygame.sprite.Group()
        self.shooter_bullets = pygame.sprite.Group()
        self.invaders = pygame.sprite.Group()
        self.walls = pygame.sprite.Group()
        self.shift = Shift()
        self.level_info = "easy"
        self.score = Scores(self.screen, self.statistics, "Player1")
        self.mistery = MagicMock()

    def tearDown(self):
        pygame.quit()

    @patch('pygame.key.get_pressed', return_value=[0] * 323)
    @patch('pygame.event.get', return_value=[])
    def test_pause_escape(self, mock_event, mock_get_pressed):
        mock_get_pressed.return_value[pygame.K_ESCAPE] = 1
        with patch('pygame.display.update'), patch('time.sleep', return_value=None):
            pause(self.screen, self.score, self.statistics, self.gun, self.bullets,
                  self.shooter_bullets, self.invaders, self.walls, self.shift, self.level_info, self.mistery)

        self.assertFalse(self.statistics.is_pressed_return_to_menu)

    @patch('pygame.key.get_pressed', return_value=[0] * 323)
    @patch('pygame.event.get', return_value=[])
    def test_pause_return_to_menu(self, mock_event, mock_get_pressed):
        mock_get_pressed.return_value[pygame.K_m] = 1
        with patch('pygame.display.update'), patch('time.sleep', return_value=None):
            pause(self.screen, self.score, self.statistics, self.gun, self.bullets,
                  self.shooter_bullets, self.invaders, self.walls, self.shift, self.level_info, self.mistery)

        self.assertTrue(self.statistics.is_pressed_return_to_menu)

class TestUpdateScreen(unittest.TestCase):

    @patch('pygame.display.flip')
    def test_update_screen(self, mock_flip):
        screen = MagicMock()
        score = MagicMock()
        gun = MagicMock()
        invaders = MagicMock()
        color = (0, 0, 0)
        bullets = MagicMock()
        shooter_bullets = MagicMock()
        walls = MagicMock()
        clock = MagicMock()
        mistery = MagicMock()
        statistics = MagicMock()

        machine_gun = MagicMock()
        invincibility = MagicMock()
        freeze = MagicMock()

        machine_guns = [machine_gun]
        invincibilities = [invincibility]
        freezes = [freeze]

        update_screen(screen, score, gun, invaders, color, bullets, shooter_bullets, walls, clock, mistery, statistics,
                      machine_guns, invincibilities, freezes)

        screen.fill.assert_called_once_with(color)
        score.print.assert_called_once()
        score.print_superpower.assert_called_once_with(gun)
        gun.print.assert_called_once()
        mistery.update.assert_called_once()
        mock_flip.assert_called_once()
        clock.tick.assert_called_once_with(60)

        bullets.sprites.assert_called_once()
        shooter_bullets.sprites.assert_called_once()

        machine_gun.update.assert_called_once()
        invincibility.update.assert_called_once()
        freeze.update.assert_called_once()