create-prisma-php-app 5.1.0-alpha.23 → 5.1.0-alpha.24

package/dist/tests/SocketPoolTest.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests;
+
+use Lib\Websocket\Socket;
+use Lib\Websocket\SocketPool;
+use PHPUnit\Framework\TestCase;
+use Tests\Support\FakeConnection;
+use Tests\Support\RequiresFeature;
+
+/**
+ * A broadcast pool: one value to everyone, with gone connections pruned on
+ * the way.
+ */
+final class SocketPoolTest extends TestCase
+{
+    use RequiresFeature;
+
+    protected function setUp(): void
+    {
+        $this->requireFeature('websocket');
+    }
+
+    public function testBroadcastReachesEveryOpenSocket(): void
+    {
+        $pool = new SocketPool();
+        $connA = new FakeConnection();
+        $connB = new FakeConnection();
+
+        $pool->add(new Socket($connA, 'chat'));
+        $pool->add(new Socket($connB, 'chat'));
+
+        $pool->broadcast(['text' => 'hello room']);
+
+        self::assertSame([['text' => 'hello room']], $connA->sentFrames);
+        self::assertSame([['text' => 'hello room']], $connB->sentFrames);
+    }
+
+    public function testClosedSocketsArePrunedByBroadcast(): void
+    {
+        $pool = new SocketPool();
+        $connA = new FakeConnection();
+        $gone = new Socket(new FakeConnection(), 'chat');
+
+        $pool->add(new Socket($connA, 'chat'));
+        $pool->add($gone);
+        $gone->handleClose();
+
+        $pool->broadcast('first');
+
+        self::assertSame(1, $pool->count(), 'the closed connection was forgotten');
+        self::assertSame(['first'], $connA->sentFrames);
+    }
+
+    public function testDiscardRemovesOnlyThatSocket(): void
+    {
+        $pool = new SocketPool();
+        $keep = new Socket(new FakeConnection(), 'chat');
+        $drop = new Socket(new FakeConnection(), 'chat');
+
+        $pool->add($keep);
+        $pool->add($drop);
+        $pool->discard($drop);
+
+        self::assertSame(1, $pool->count());
+    }
+}

package/dist/tests/SocketRegistryTest.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests;
+
+use InvalidArgumentException;
+use Lib\Websocket\SocketRegistry;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use Tests\Support\RequiresFeature;
+
+/**
+ * The named-socket registry: names are the whole address, so they are unique
+ * application-wide and a duplicate is refused at registration time.
+ */
+final class SocketRegistryTest extends TestCase
+{
+    use RequiresFeature;
+
+    protected function setUp(): void
+    {
+        $this->requireFeature('websocket');
+        self::resetRegistry();
+    }
+
+    protected function tearDown(): void
+    {
+        self::resetRegistry();
+    }
+
+    public static function resetRegistry(): void
+    {
+        // tearDown() still runs after a feature skip, and in an app without
+        // the websocket scaffold the class does not exist — nothing to reset.
+        if (!class_exists(SocketRegistry::class)) {
+            return;
+        }
+
+        $reflection = new ReflectionClass(SocketRegistry::class);
+        $reflection->getProperty('sockets')->setValue(null, []);
+    }
+
+    public function testRegisterAndResolveByName(): void
+    {
+        $handler = static function (): void {};
+
+        SocketRegistry::register('chat', $handler, requireAuth: true, allowedRoles: ['admin']);
+
+        $entry = SocketRegistry::get('chat');
+        self::assertNotNull($entry);
+        self::assertSame('chat', $entry['name']);
+        self::assertSame($handler, $entry['handler']);
+        self::assertTrue($entry['requireAuth']);
+        self::assertSame(['admin'], $entry['allowedRoles']);
+        self::assertSame(['chat'], SocketRegistry::names());
+    }
+
+    public function testUnknownNameResolvesToNull(): void
+    {
+        self::assertNull(SocketRegistry::get('nope'));
+    }
+
+    public function testDuplicateNameIsRefused(): void
+    {
+        SocketRegistry::register('chat', static function (): void {});
+
+        $this->expectException(InvalidArgumentException::class);
+        SocketRegistry::register('chat', static function (): void {});
+    }
+
+    public function testEmptyNameIsRefused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        SocketRegistry::register('', static function (): void {});
+    }
+}

package/dist/tests/SocketTest.php

@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests;
+
+use InvalidArgumentException;
+use Lib\Websocket\Socket;
+use PHPUnit\Framework\TestCase;
+use Tests\Support\FakeConnection;
+use Tests\Support\RequiresFeature;
+
+/**
+ * One open connection, as a socket handler holds it: JSON frames out, the
+ * reserved `{"error": ...}` shape refused, and close semantics.
+ */
+final class SocketTest extends TestCase
+{
+    use RequiresFeature;
+
+    protected function setUp(): void
+    {
+        $this->requireFeature('websocket');
+    }
+
+    public function testSendEncodesOneJsonValuePerFrame(): void
+    {
+        $conn = new FakeConnection();
+        $socket = new Socket($conn, 'echo');
+
+        self::assertTrue($socket->send(['text' => 'hello']));
+        self::assertTrue($socket->send('plain'));
+        self::assertTrue($socket->send(42));
+
+        self::assertSame([['text' => 'hello'], 'plain', 42], $conn->sentFrames);
+    }
+
+    public function testSendRefusesTheReservedErrorShape(): void
+    {
+        $socket = new Socket(new FakeConnection(), 'echo');
+
+        $this->expectException(InvalidArgumentException::class);
+        $socket->send(['error' => 'looks like a failure frame']);
+    }
+
+    public function testAPayloadThatMerelyContainsAnErrorKeyIsSendable(): void
+    {
+        $conn = new FakeConnection();
+        $socket = new Socket($conn, 'echo');
+
+        self::assertTrue($socket->send(['error' => 'mine', 'other' => 1]));
+        self::assertSame(['error' => 'mine', 'other' => 1], $conn->lastFrame());
+    }
+
+    public function testSendAfterCloseReturnsFalse(): void
+    {
+        $conn = new FakeConnection();
+        $socket = new Socket($conn, 'echo');
+
+        $socket->handleClose();
+
+        self::assertFalse($socket->send('late'));
+        self::assertSame([], $conn->sentFrames);
+    }
+
+    public function testMessageListenerReceivesDecodedValues(): void
+    {
+        $socket = new Socket(new FakeConnection(), 'echo');
+
+        $seen = [];
+        $socket->onMessage(function (mixed $value) use (&$seen): void {
+            $seen[] = $value;
+        });
+
+        $socket->handleMessage(['text' => 'hi']);
+        $socket->handleMessage('plain');
+
+        self::assertSame([['text' => 'hi'], 'plain'], $seen);
+    }
+
+    public function testCloseListenerFiresExactlyOnce(): void
+    {
+        $socket = new Socket(new FakeConnection(), 'echo');
+
+        $closes = 0;
+        $socket->onClose(function () use (&$closes): void {
+            $closes++;
+        });
+
+        $socket->handleClose();
+        $socket->handleClose();
+
+        self::assertSame(1, $closes);
+        self::assertFalse($socket->isOpen());
+    }
+
+    public function testErrorSendsTheReservedFrameThenCloses(): void
+    {
+        $conn = new FakeConnection();
+        $socket = new Socket($conn, 'echo');
+
+        $socket->error('no such room');
+
+        self::assertSame(['error' => 'no such room'], $conn->lastFrame());
+        self::assertSame([1008], $conn->closeCodes);
+    }
+
+    public function testCloseUsesNormalClosure(): void
+    {
+        $conn = new FakeConnection();
+        $socket = new Socket($conn, 'echo');
+
+        $socket->close();
+
+        self::assertSame([1000], $conn->closeCodes);
+    }
+
+    public function testPayloadIsHandedToTheHandler(): void
+    {
+        $socket = new Socket(new FakeConnection(), 'echo', ['role' => 'admin']);
+
+        self::assertSame(['role' => 'admin'], $socket->payload());
+    }
+}

package/dist/tests/SocketsRegistrationTest.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests;
+
+use Lib\Websocket\SocketRegistry;
+use PHPUnit\Framework\TestCase;
+use Tests\Support\RequiresFeature;
+
+/**
+ * The app's real registration file loads cleanly and registers every socket
+ * the frontend connects to. A socket the browser names but the server never
+ * registered is a refused connection in production — catch it here instead.
+ */
+final class SocketsRegistrationTest extends TestCase
+{
+    use RequiresFeature;
+
+    protected function setUp(): void
+    {
+        $this->requireFeature('websocket');
+        SocketRegistryTest::resetRegistry();
+    }
+
+    protected function tearDown(): void
+    {
+        SocketRegistryTest::resetRegistry();
+    }
+
+    public function testTheRegistrationFileLoadsAndNamesItsSockets(): void
+    {
+        require DOCUMENT_PATH . '/src/Lib/Websocket/sockets.php';
+
+        $names = SocketRegistry::names();
+
+        self::assertContains('echo', $names);
+        self::assertContains('chat', $names);
+    }
+}

package/dist/tests/Support/FakeConnection.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Support;
+
+use Ratchet\ConnectionInterface;
+use GuzzleHttp\Psr7\Request as Psr7Request;
+
+/**
+ * A Ratchet connection stand-in that records what the server sends.
+ *
+ * The named-socket wire is frames and closes, so a test only needs to see
+ * both: `$sentFrames` collects every `send(...)` payload (decoded from JSON
+ * when possible) and `$closeCodes` collects every `close(...)` code. The
+ * `httpRequest` property mirrors how Ratchet exposes the handshake request.
+ */
+final class FakeConnection implements ConnectionInterface
+{
+    /** @var list<mixed> Decoded JSON frames (raw string when not JSON). */
+    public array $sentFrames = [];
+
+    /** @var list<string> Raw frames exactly as sent. */
+    public array $rawFrames = [];
+
+    /** @var list<int> */
+    public array $closeCodes = [];
+
+    public bool $isClosed = false;
+
+    public ?Psr7Request $httpRequest = null;
+
+    /**
+     * @param array<string, string> $headers Handshake headers (e.g. Origin, Cookie).
+     */
+    public function __construct(string $uri = '/__pulsepoint/ws', array $headers = [])
+    {
+        $this->httpRequest = new Psr7Request('GET', $uri, $headers);
+    }
+
+    public function send($data): ConnectionInterface
+    {
+        $this->rawFrames[] = (string) $data;
+
+        $decoded = json_decode((string) $data, true);
+        $this->sentFrames[] = json_last_error() === JSON_ERROR_NONE ? $decoded : (string) $data;
+
+        return $this;
+    }
+
+    public function close($code = 1000): void
+    {
+        $this->closeCodes[] = (int) $code;
+        $this->isClosed = true;
+    }
+
+    /** The last frame the server sent, decoded. */
+    public function lastFrame(): mixed
+    {
+        return $this->sentFrames === [] ? null : end($this->sentFrames);
+    }
+}

package/dist/tests/Support/Features.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Support;
+
+/**
+ * Feature flags for the test suite, read from `prisma-php.json`.
+ *
+ * `prisma-php.json` is the single source of truth for which optional Prisma
+ * PHP features are enabled in the current app (`websocket`, `mcp`,
+ * `swaggerDocs`, `prisma`, `tailwindcss`, `typescript`, `backendOnly`).
+ * Tests that exercise an optional feature's scaffold must guard on the flag —
+ * when the feature is off, its files do not exist and the test must skip,
+ * not fatal.
+ */
+final class Features
+{
+    /** @var array<string, mixed>|null */
+    private static ?array $config = null;
+
+    /** @return array<string, mixed> The parsed prisma-php.json. */
+    public static function config(): array
+    {
+        if (self::$config === null) {
+            $raw = @file_get_contents(DOCUMENT_PATH . '/prisma-php.json');
+            $decoded = is_string($raw) ? json_decode($raw, true) : null;
+            self::$config = is_array($decoded) ? $decoded : [];
+        }
+
+        return self::$config;
+    }
+
+    public static function enabled(string $feature): bool
+    {
+        return (self::config()[$feature] ?? false) === true;
+    }
+}

package/dist/tests/Support/RequiresFeature.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Support;
+
+/**
+ * Skip guard for tests of optional Prisma PHP features.
+ *
+ * Call `$this->requireFeature('websocket')` as the FIRST line of `setUp()`,
+ * before touching any class from the feature's scaffold — a disabled
+ * feature's files are not generated, so reaching them would fatal instead
+ * of failing cleanly. A skipped test reports why and how to enable it.
+ */
+trait RequiresFeature
+{
+    protected function requireFeature(string $feature): void
+    {
+        if (!Features::enabled($feature)) {
+            self::markTestSkipped(
+                "The `$feature` feature is disabled in prisma-php.json; "
+                    . "enable it and run `npx pp update project -y` to use this suite."
+            );
+        }
+    }
+}

package/dist/tests/bootstrap.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Shared PHPUnit setup for the app-level test suite.
+ *
+ * Mirrors what the runtime gives app code — the composer autoloader and the
+ * path constants from `settings/paths.php` — without booting the framework:
+ * `bootstrap.php` (route resolution, CSRF cookie, rendering) is NOT loaded
+ * here, so tests exercise app classes directly.
+ *
+ * The real `.env` is deliberately NOT loaded. Tests run against deterministic
+ * environment defaults so the suite behaves the same on any machine and can
+ * never depend on (or leak) real secrets. Each default is only applied when
+ * the variable is not already set, so CI can still override.
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/settings/paths.php';
+
+// Keep the app in its non-production code paths during tests (dev origin
+// relaxations, readable error messages).
+if (getenv('APP_ENV') === false) {
+    putenv('APP_ENV=development');
+    $_ENV['APP_ENV'] = 'development';
+}
+
+// Deterministic secrets so Auth and Csrf construct without a real .env.
+// HS256 requires at least 32 bytes of key material.
+if (getenv('AUTH_SECRET') === false) {
+    putenv('AUTH_SECRET=test-secret-not-for-production-32bytes');
+    $_ENV['AUTH_SECRET'] = 'test-secret-not-for-production-32bytes';
+}
+
+if (getenv('FUNCTION_CALL_SECRET') === false) {
+    putenv('FUNCTION_CALL_SECRET=test-function-call-secret');
+    $_ENV['FUNCTION_CALL_SECRET'] = 'test-function-call-secret';
+}
+
+// Auth::signIn writes the session payload; give CLI tests a session store.
+if (!isset($_SESSION)) {
+    $_SESSION = [];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma-php-app",
-  "version": "5.1.0-alpha.23",
+  "version": "5.1.0-alpha.24",
   "description": "Prisma-PHP: A Revolutionary Library Bridging PHP with Prisma ORM",
   "main": "dist/index.js",
   "type": "module",