bga-dev-skill 0.1.0

package/harness/php/BgaDatabaseFake.php

@@ -0,0 +1,234 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BgaHarness;
+
+use PDO;
+use PDOStatement;
+use PHPUnit\Framework\Assert;
+
+class BgaDatabaseFake
+{
+    private PDO $pdo;
+
+    public function __construct()
+    {
+        $this->pdo = new PDO('sqlite::memory:');
+        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+    }
+
+    public function DbQuery(string $sql): void
+    {
+        $this->pdo->exec($sql);
+    }
+
+    public function getCollectionFromDB(string $sql, bool $bUniqueValue = false): array
+    {
+        $stmt = $this->query($sql);
+        $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        if (!$bUniqueValue) {
+            return $rows;
+        }
+
+        $unique = [];
+        foreach ($rows as $row) {
+            $values = array_values($row);
+            if (count($values) >= 2) {
+                $unique[$values[0]] = $values[1];
+            }
+        }
+
+        return $unique;
+    }
+
+    public function getObjectFromDB(string $sql): ?array
+    {
+        $stmt = $this->query($sql);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row !== false ? $row : null;
+    }
+
+    public function getUniqueValueFromDB(string $sql): mixed
+    {
+        $stmt = $this->query($sql);
+        $value = $stmt->fetchColumn();
+
+        return $value === false ? null : $value;
+    }
+
+    public function getIntFromDB(string $sql): int
+    {
+        return (int) $this->getUniqueValueFromDB($sql);
+    }
+
+    public function seedTable(string $table, array $rows): void
+    {
+        if ($rows === []) {
+            return;
+        }
+
+        $columns = $this->collectColumns($rows);
+        $this->ensureTableHasColumns($table, $columns, $rows);
+
+        $placeholders = implode(', ', array_fill(0, count($columns), '?'));
+        $columnsSql = implode(', ', array_map(static fn (string $c): string => '"' . $c . '"', $columns));
+        $sql = 'INSERT INTO "' . $table . '" (' . $columnsSql . ') VALUES (' . $placeholders . ')';
+
+        $stmt = $this->pdo->prepare($sql);
+        foreach ($rows as $row) {
+            $values = [];
+            foreach ($columns as $column) {
+                $values[] = $row[$column] ?? null;
+            }
+            $stmt->execute($values);
+        }
+    }
+
+    public function assertRowExists(string $table, array $conditions): void
+    {
+        [$whereSql, $params] = $this->buildWhere($conditions);
+        $sql = 'SELECT COUNT(*) FROM "' . $table . '"' . $whereSql;
+
+        $stmt = $this->pdo->prepare($sql);
+        $stmt->execute($params);
+        $count = (int) $stmt->fetchColumn();
+
+        Assert::assertGreaterThan(
+            0,
+            $count,
+            sprintf('Expected row was not found in table "%s" for conditions: %s', $table, json_encode($conditions))
+        );
+    }
+
+    public function assertRowCount(string $table, int $expected, array $conditions = []): void
+    {
+        [$whereSql, $params] = $this->buildWhere($conditions);
+        $sql = 'SELECT COUNT(*) FROM "' . $table . '"' . $whereSql;
+
+        $stmt = $this->pdo->prepare($sql);
+        $stmt->execute($params);
+        $count = (int) $stmt->fetchColumn();
+
+        Assert::assertSame(
+            $expected,
+            $count,
+            sprintf(
+                'Unexpected row count in table "%s" for conditions %s. Expected %d, got %d.',
+                $table,
+                json_encode($conditions),
+                $expected,
+                $count
+            )
+        );
+    }
+
+    private function query(string $sql): PDOStatement
+    {
+        $stmt = $this->pdo->query($sql);
+        if ($stmt === false) {
+            throw new \RuntimeException('Query failed: ' . $sql);
+        }
+
+        return $stmt;
+    }
+
+    private function collectColumns(array $rows): array
+    {
+        $columns = [];
+        foreach ($rows as $row) {
+            foreach (array_keys($row) as $column) {
+                if (!in_array($column, $columns, true)) {
+                    $columns[] = $column;
+                }
+            }
+        }
+
+        return $columns;
+    }
+
+    private function ensureTableHasColumns(string $table, array $columns, array $rows): void
+    {
+        if (!$this->tableExists($table)) {
+            $this->createTable($table, $columns, $rows);
+
+            return;
+        }
+
+        $existing = $this->listColumns($table);
+        foreach ($columns as $column) {
+            if (in_array($column, $existing, true)) {
+                continue;
+            }
+            $type = $this->inferColumnType($table, $column, $rows);
+            $this->pdo->exec('ALTER TABLE "' . $table . '" ADD COLUMN "' . $column . '" ' . $type);
+        }
+    }
+
+    private function createTable(string $table, array $columns, array $rows): void
+    {
+        $defs = [];
+        foreach ($columns as $column) {
+            $defs[] = '"' . $column . '" ' . $this->inferColumnType($table, $column, $rows);
+        }
+        $sql = 'CREATE TABLE IF NOT EXISTS "' . $table . '" (' . implode(', ', $defs) . ')';
+        $this->pdo->exec($sql);
+    }
+
+    private function tableExists(string $table): bool
+    {
+        $stmt = $this->pdo->prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?");
+        $stmt->execute([$table]);
+
+        return (bool) $stmt->fetchColumn();
+    }
+
+    private function listColumns(string $table): array
+    {
+        $stmt = $this->query('PRAGMA table_info("' . $table . '")');
+        $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        return array_map(static fn (array $row): string => (string) $row['name'], $rows);
+    }
+
+    private function inferColumnType(string $table, string $column, array $rows): string
+    {
+        if ($column === $table . '_id' || str_ends_with($column, '_id')) {
+            return 'INTEGER';
+        }
+
+        foreach ($rows as $row) {
+            if (!array_key_exists($column, $row) || $row[$column] === null) {
+                continue;
+            }
+
+            if (is_int($row[$column]) || is_bool($row[$column])) {
+                return 'INTEGER';
+            }
+
+            if (is_float($row[$column])) {
+                return 'REAL';
+            }
+        }
+
+        return 'TEXT';
+    }
+
+    private function buildWhere(array $conditions): array
+    {
+        if ($conditions === []) {
+            return ['', []];
+        }
+
+        $clauses = [];
+        $params = [];
+        foreach ($conditions as $column => $value) {
+            $clauses[] = '"' . $column . '" = ?';
+            $params[] = $value;
+        }
+
+        return [' WHERE ' . implode(' AND ', $clauses), $params];
+    }
+}

package/harness/php/BgaExceptionTypes.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BgaHarness;
+
+class BgaUserException extends \Exception
+{
+}
+
+class BgaVisibleSystemException extends \Exception
+{
+}
+
+class BgaSystemException extends \Exception
+{
+}

package/harness/php/BgaGameTestCase.php

@@ -0,0 +1,160 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BgaHarness;
+
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+
+abstract class BgaGameTestCase extends TestCase
+{
+    protected BgaStubs $game;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->game = $this->createGame();
+        $this->game->_setPlayers($this->defaultPlayers());
+    }
+
+    abstract protected function createGame(): BgaStubs;
+
+    protected function givenActivePlayer(int $playerId): static
+    {
+        $this->game->_setActivePlayer($playerId);
+        $this->game->_setCurrentPlayer($playerId);
+
+        return $this;
+    }
+
+    protected function givenCurrentPlayer(int $playerId): static
+    {
+        $this->game->_setCurrentPlayer($playerId);
+
+        return $this;
+    }
+
+    protected function givenState(string $stateName): static
+    {
+        $this->game->_setState($stateName);
+
+        return $this;
+    }
+
+    protected function givenDatabaseRows(string $table, array $rows): static
+    {
+        $this->game->_getDb()->seedTable($table, $rows);
+
+        return $this;
+    }
+
+    protected function givenGameStateValue(string $name, int $value): static
+    {
+        $this->game->_setGameStateValue($name, $value);
+
+        return $this;
+    }
+
+    protected function whenAction(string $method, array $args = []): ActionResult
+    {
+        try {
+            $result = $this->game->$method(...array_values($args));
+
+            return ActionResult::success($result);
+        } catch (BgaUserException $e) {
+            return ActionResult::userError($e->getMessage());
+        } catch (BgaVisibleSystemException $e) {
+            return ActionResult::systemError($e->getMessage());
+        }
+    }
+
+    protected function thenStateShouldBe(string $expected): void
+    {
+        Assert::assertSame($expected, $this->game->_getState());
+    }
+
+    protected function thenNotificationSent(string $type, array $dataSubset = []): void
+    {
+        $this->game->_getNotifications()->assertNotified($type, $dataSubset);
+    }
+
+    protected function thenNotificationNotSent(string $type): void
+    {
+        $this->game->_getNotifications()->assertNotNotified($type);
+    }
+
+    protected function thenPlayerNotifiedWith(int $playerId, string $type, array $dataSubset = []): void
+    {
+        $this->game->_getNotifications()->assertNotifiedPlayer($playerId, $type, $dataSubset);
+    }
+
+    protected function thenDatabaseHas(string $table, array $conditions): void
+    {
+        $this->game->_getDb()->assertRowExists($table, $conditions);
+    }
+
+    protected function thenDatabaseCount(string $table, int $count, array $conditions = []): void
+    {
+        $this->game->_getDb()->assertRowCount($table, $count, $conditions);
+    }
+
+    protected function defaultPlayers(): array
+    {
+        return [
+            1 => ['player_id' => 1, 'player_name' => 'Alice', 'player_score' => 0],
+            2 => ['player_id' => 2, 'player_name' => 'Bob', 'player_score' => 0],
+        ];
+    }
+}
+
+class ActionResult
+{
+    public bool $succeeded = false;
+    public ?string $errorCode = null;
+    public mixed $returnValue = null;
+
+    public static function success(mixed $value): self
+    {
+        $result = new self();
+        $result->succeeded = true;
+        $result->errorCode = null;
+        $result->returnValue = $value;
+
+        return $result;
+    }
+
+    public static function userError(string $code): self
+    {
+        $result = new self();
+        $result->succeeded = false;
+        $result->errorCode = $code;
+        $result->returnValue = null;
+
+        return $result;
+    }
+
+    public static function systemError(string $message): self
+    {
+        $result = new self();
+        $result->succeeded = false;
+        $result->errorCode = $message;
+
+        return $result;
+    }
+
+    public function assertSucceeded(): void
+    {
+        Assert::assertTrue($this->succeeded, 'Expected action to succeed.');
+    }
+
+    public function assertFailedWith(string $errorCode): void
+    {
+        Assert::assertFalse($this->succeeded, 'Expected action to fail.');
+        Assert::assertSame(
+            $errorCode,
+            $this->errorCode,
+            sprintf('Expected failure code "%s", got "%s".', $errorCode, (string) $this->errorCode)
+        );
+    }
+}

package/harness/php/BgaNotificationSpy.php

@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BgaHarness;
+
+use PHPUnit\Framework\Assert;
+
+class BgaNotificationSpy
+{
+    private array $notifications = [];
+
+    public function notifyAllPlayers(string $type, string $message, array $data): void
+    {
+        $this->notifications[] = [
+            'target' => 'all',
+            'type' => $type,
+            'message' => $message,
+            'data' => $data,
+        ];
+    }
+
+    public function notifyPlayer(int $playerId, string $type, string $message, array $data): void
+    {
+        $this->notifications[] = [
+            'target' => $playerId,
+            'type' => $type,
+            'message' => $message,
+            'data' => $data,
+        ];
+    }
+
+    public function assertNotified(string $type, array $dataSubset = []): void
+    {
+        foreach ($this->notifications as $notification) {
+            if ($notification['type'] !== $type) {
+                continue;
+            }
+            if ($this->containsSubset($notification['data'], $dataSubset)) {
+                return;
+            }
+        }
+
+        Assert::fail(
+            sprintf(
+                'Expected notification "%s" with subset %s was not sent. Captured notifications: %s',
+                $type,
+                json_encode($dataSubset),
+                json_encode($this->notifications)
+            )
+        );
+    }
+
+    public function assertNotifiedPlayer(int $playerId, string $type, array $dataSubset = []): void
+    {
+        foreach ($this->notifications as $notification) {
+            if ($notification['target'] !== $playerId || $notification['type'] !== $type) {
+                continue;
+            }
+            if ($this->containsSubset($notification['data'], $dataSubset)) {
+                return;
+            }
+        }
+
+        Assert::fail(
+            sprintf(
+                'Expected player %d notification "%s" with subset %s was not sent. Captured notifications: %s',
+                $playerId,
+                $type,
+                json_encode($dataSubset),
+                json_encode($this->notifications)
+            )
+        );
+    }
+
+    public function assertNotNotified(string $type): void
+    {
+        foreach ($this->notifications as $notification) {
+            if ($notification['type'] === $type) {
+                Assert::fail(
+                    sprintf(
+                        'Notification "%s" should not have been sent, but was captured: %s',
+                        $type,
+                        json_encode($notification)
+                    )
+                );
+            }
+        }
+    }
+
+    public function assertNotificationCount(int $expected): void
+    {
+        Assert::assertCount($expected, $this->notifications);
+    }
+
+    public function getNotifications(): array
+    {
+        return $this->notifications;
+    }
+
+    public function reset(): void
+    {
+        $this->notifications = [];
+    }
+
+    private function containsSubset(array $actual, array $subset): bool
+    {
+        foreach ($subset as $key => $value) {
+            if (!array_key_exists($key, $actual) || $actual[$key] !== $value) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}