Escapepage/tests/Game/GameDashboardServiceTest.php

<?php
declare(strict_types=1);

namespace App\Tests\Game;

use App\Game\Entity\Game;
use App\Game\Entity\Player;
use App\Game\Entity\Session;
use App\Game\Entity\SessionSetting;
use App\Game\Enum\GameStatus;
use App\Game\Enum\SessionSettingType;
use App\Game\Service\GameDashboardService;
use App\Tech\Entity\User;
use Doctrine\ORM\EntityManagerInterface;
use App\Game\Repository\GameRepository;
use App\Game\Repository\SessionRepository;
use PHPUnit\Framework\TestCase;

class GameDashboardServiceTest extends TestCase
{
    private $entityManager;
    private $gameRepository;
    private $sessionRepository;
    private $service;

    protected function setUp(): void
    {
        $this->entityManager = $this->createMock(EntityManagerInterface::class);
        $this->gameRepository = $this->createMock(GameRepository::class);
        $this->sessionRepository = $this->createMock(SessionRepository::class);

        $this->service = new GameDashboardService(
            $this->gameRepository,
            $this->sessionRepository,
            $this->entityManager
        );
    }

    public function testCreateSessionDoesNotInitializeSettings(): void
    {
        $game = new Game();
        $game->setStatus(GameStatus::OPEN);

        $user = new User();
        $user->setUsername('testuser');

        $this->entityManager->expects($this->exactly(2))
            ->method('persist');
            // 1. Session, 2. Player

        $session = $this->service->createSession($game, $user, false);

        $this->assertInstanceOf(Session::class, $session);
    }

    public function testJoinSessionDoesNotInitializeSettings(): void
    {
        $user = new User();
        $user->setUsername('testuser');
        $game = new Game();
        $game->setNumberOfPlayers(3);
        $session = new Session();
        $session->setGame($game);

        $setting = new SessionSetting();
        $setting->setSession($session);
        $setting->setName(SessionSettingType::INVITE_CODE);
        $setting->setValue('abc-123');

        $repo = $this->createMock(\Doctrine\ORM\EntityRepository::class);
        $this->entityManager->method('getRepository')
            ->willReturn($repo);

        $repo->method('findOneBy')
            ->willReturn($setting);

        $this->entityManager->expects($this->exactly(1))
            ->method('persist');
            // 1. Player

        $result = $this->service->joinSession('abc-123', $user);

        $this->assertTrue($result);
    }

    public function testStartSessionAssignsScreensAndInitializesSettings(): void
    {
        $game = new Game();
        $game->setNumberOfPlayers(2);
        $session = new Session();
        $session->setGame($game);
        $session->setStatus(\App\Game\Enum\SessionStatus::CREATED);

        $user1 = new User();
        $user1->setUsername('user1');
        $player1 = new Player();
        $player1->setUser($user1);
        $session->addPlayer($player1);

        $user2 = new User();
        $user2->setUsername('user2');
        $player2 = new Player();
        $player2->setUser($user2);
        $session->addPlayer($player2);

        // For each player (2):
        // Player (persist)
        // SessionSetting (rights)
        // SessionSetting (pwd)
        // SessionSetting (chat tracking)
        // SessionSetting (verify codes)
        // SessionSetting (verification progress)
        // Total = 2 * 6 = 12
        // PLUS Session (persist)
        // Total = 13

        $this->entityManager->expects($this->exactly(13))
            ->method('persist');

        $result = $this->service->startSession($session);

        $this->assertTrue($result);
        $this->assertEquals(\App\Game\Enum\SessionStatus::READY, $session->getStatus());
        $this->assertNotNull($player1->getScreen());
        $this->assertNotNull($player2->getScreen());
        $this->assertNotEquals($player1->getScreen(), $player2->getScreen());
    }

    public function testStartSessionWithFourPlayers(): void
    {
        $game = new Game();
        $game->setNumberOfPlayers(4);
        $session = new Session();
        $session->setGame($game);
        $session->setStatus(\App\Game\Enum\SessionStatus::CREATED);

        for ($i = 1; $i <= 4; $i++) {
            $user = new User();
            $user->setUsername('user' . $i);
            $player = new Player();
            $player->setUser($user);
            $session->addPlayer($player);
        }

        // For each player (4):
        // Player (persist) + 5 Settings = 6 persists
        // Total = 4 * 6 = 24
        // PLUS Session (persist)
        // Total = 25

        $this->entityManager->expects($this->exactly(25))
            ->method('persist');

        $result = $this->service->startSession($session);

        $this->assertTrue($result);
        foreach ($session->getPlayers() as $player) {
            $this->assertNotNull($player->getScreen());
            $this->assertGreaterThanOrEqual(1, $player->getScreen());
            $this->assertLessThanOrEqual(4, $player->getScreen());
        }
    }

    public function testLeaveSession(): void
    {
        $user = new User();
        $session = new Session();
        $session->setStatus(\App\Game\Enum\SessionStatus::CREATED);
        $session->setTimer(0);

        $player1 = new Player();
        $player1->setUser($user);
        $player1->setSession($session);
        $session->addPlayer($player1);

        $player2 = new Player();
        $player2->setUser(new User());
        $player2->setSession($session);
        $session->addPlayer($player2);

        $setting = new SessionSetting();
        $setting->setPlayer($player1);
        $setting->setSession($session);
        $session->addSetting($setting);

        $this->entityManager->expects($this->exactly(2))
            ->method('remove');
            // 1. SessionSetting, 2. Player

        $result = $this->service->leaveSession($session, $user);

        $this->assertTrue($result);
        $this->assertCount(1, $session->getPlayers());
    }

    public function testLeaveSessionDeletesSessionIfLastPlayer(): void
    {
        $user = new User();
        $session = new Session();
        $session->setStatus(\App\Game\Enum\SessionStatus::CREATED);
        $session->setTimer(0);

        $player = new Player();
        $player->setUser($user);
        $player->setSession($session);
        $session->addPlayer($player);

        $this->entityManager->expects($this->exactly(2))
            ->method('remove');
            // 1. Player, 2. Session

        $result = $this->service->leaveSession($session, $user);

        $this->assertTrue($result);
    }
}