map-generator/app/Tests/MapTest.php

<?php

/**
 * Tests unitaires pour la classe Map
 */

// Inclure les classes nécessaires
require_once __DIR__ . '/../Models/Map.php';

/**
 * Classe de tests simples pour la classe Map
 */
class MapTest
{
    private int $passed = 0;
    private int $failed = 0;
    private array $errors = [];

    /**
     * Exécute tous les tests
     */
    public function runAllTests(): void
    {
        echo "=== Tests de la classe Map ===\n\n";

        $this->testMapCreation();
        $this->testTileModification();
        $this->testInvalidCoordinates();
        $this->testStatistics();
        $this->testJsonSerialization();
        $this->testHexagonDistance();
        $this->testTileTypes();

        echo "\n=== Résultats des tests ===\n";
        echo "Tests réussis: {$this->passed}\n";
        echo "Tests échoués: {$this->failed}\n";

        if (!empty($this->errors)) {
            echo "\nErreurs:\n";
            foreach ($this->errors as $error) {
                echo "- $error\n";
            }
        }

        echo "\n" . ($this->failed === 0 ? "✓ Tous les tests sont passés !" : "✗ Certains tests ont échoué") . "\n";
    }

    /**
     * Test de création d'une carte
     */
    private function testMapCreation(): void
    {
        $map = new Map("Test Map", 3, 4);

        $this->assert($map->getName() === "Test Map", "Nom de la carte");
        $this->assert($map->getWidth() === 3, "Largeur de la carte");
        $this->assert($map->getHeight() === 4, "Hauteur de la carte");
        $tile = $map->getTile(0, 0);
        $this->assert($tile !== null && $tile->getType() === "empty", "Tuile par défaut");
    }

    /**
     * Test de modification des tuiles
     */
    private function testTileModification(): void
    {
        $map = new Map("Test", 3, 3);

        $tile = new Tile(['type' => 'forest', 'resources' => ['wood' => 100]]);
        $this->assert($map->setTile(1, 1, $tile), "Modification de tuile valide");
        $retrievedTile = $map->getTile(1, 1);
        $this->assert($retrievedTile !== null && $retrievedTile->getType() === 'forest', "Récupération de tuile modifiée");
        $this->assert($retrievedTile->getProperty('resources')['wood'] === 100, "Récupération des propriétés de la tuile");
    }

    /**
     * Test des coordonnées invalides
     */
    private function testInvalidCoordinates(): void
    {
        $map = new Map("Test", 2, 2);

        $this->assert(!$map->isValidCoordinate(-1, 0), "Coordonnée Q négative invalide");
        $this->assert(!$map->isValidCoordinate(0, -1), "Coordonnée R négative invalide");
        $this->assert(!$map->isValidCoordinate(2, 0), "Coordonnée Q trop grande invalide");
        $this->assert(!$map->isValidCoordinate(0, 2), "Coordonnée R trop grande invalide");

        $this->assert($map->getTile(-1, 0) === null, "Récupération de tuile avec coordonnées invalides");
        $this->assert(!$map->setTile(-1, 0, new Tile(['type' => 'forest'])), "Modification de tuile avec coordonnées invalides");
    }

    /**
     * Test des statistiques
     */
    private function testStatistics(): void
    {
        $map = new Map("Test", 2, 2);
        $map->setTile(0, 0, new Tile(['type' => 'castle']));
        $map->setTile(1, 1, new Tile(['type' => 'forest']));

        $stats = $map->getStatistics();

        $this->assert($stats['total_hexagons'] === 4, "Nombre total d'hexagones");
        $this->assert($stats['tile_type_counts']['castle'] === 1, "Nombre de châteaux");
        $this->assert($stats['tile_type_counts']['forest'] === 1, "Nombre de forêts");
        $this->assert($stats['empty_count'] === 2, "Nombre de cases vides");
    }

    /**
     * Test de sérialisation JSON
     */
    private function testJsonSerialization(): void
    {
        $map = new Map("Test JSON", 2, 2);
        $map->setTile(0, 0, new Tile(['type' => 'castle', 'resources' => ['gold' => 100]]));

        $json = $map->toJson();
        $data = json_decode($json, true);

        $this->assert($data['name'] === "Test JSON", "Nom dans JSON");
        $this->assert($data['width'] === 2, "Largeur dans JSON");
        $this->assert(count($data['hexagons']) === 4, "Nombre d'hexagones dans JSON");
        $this->assert($data['hexagons'][0]['tile']['type'] === 'castle', "Type de tuile dans JSON");
        $this->assert($data['hexagons'][0]['tile']['resources']['gold'] === 100, "Propriétés de tuile dans JSON");

        // Test de désérialisation
        $loadedMap = Map::fromArray($data);
        $this->assert($loadedMap !== null, "Chargement depuis tableau");
        $loadedTile = $loadedMap->getTile(0, 0);
        $this->assert($loadedTile !== null && $loadedTile->getType() === "castle", "Tuile après chargement");
        $this->assert($loadedTile->getProperty('resources')['gold'] === 100, "Propriétés après chargement");
    }

    /**
     * Test du calcul de distance entre hexagones
     */
    private function testHexagonDistance(): void
    {
        $hex1 = new Hexagon(0, 0);
        $hex2 = new Hexagon(1, 1);
        $hex3 = new Hexagon(0, 0);

        $this->assert($hex1->distanceTo($hex2) === 2, "Distance entre (0,0) et (1,1)");
        $this->assert($hex1->distanceTo($hex3) === 0, "Distance entre hexagones identiques");
    }

    /**
     * Test des types de tuiles
     */
    private function testTileTypes(): void
    {
        $map = new Map("Test", 1, 1);

        // Tester quelques types valides
        $validTypes = ['empty', 'castle', 'forest', 'river', 'road'];
        foreach ($validTypes as $type) {
            $tile = new Tile(['type' => $type]);
            $this->assert($map->setTile(0, 0, $tile), "Type valide: $type");
            $retrievedTile = $map->getTile(0, 0);
            $this->assert($retrievedTile !== null && $retrievedTile->getType() === $type, "Récupération du type: $type");
        }
    }

    /**
     * Méthode d'assertion simple
     */
    private function assert(bool $condition, string $description): void
    {
        if ($condition) {
            $this->passed++;
            echo "✓ $description\n";
        } else {
            $this->failed++;
            $this->errors[] = $description;
            echo "✗ $description\n";
        }
    }
}

// Exécuter les tests si le fichier est appelé directement
if (basename(__FILE__) === basename($_SERVER['PHP_SELF'] ?? '')) {
    $test = new MapTest();
    $test->runAllTests();
}