feat(tests): adicionar testes para validar os limites de pooling de JSON

CAFernandes · CAFernandes · commit 933cd3916f47 · 2025-07-10T21:00:36.000-03:00
diff --git a/src/Http/Response.php b/src/Http/Response.php
@@ -11,68 +11,68 @@
 use InvalidArgumentException;
 
 /**
- * Classe Response híbrida que implementa PSR-7 mantendo compatibilidade Express.js
+ * Hybrid Response class that implements PSR-7 while maintaining Express.js compatibility
  *
- * Esta classe oferece suporte completo a PSR-7 (ResponseInterface)
- * enquanto mantém todos os métodos de conveniência do estilo Express.js
- * para total compatibilidade com código existente.
+ * This class offers complete PSR-7 (ResponseInterface) support
+ * while maintaining all Express.js style convenience methods
+ * for full backward compatibility with existing code.
  */
 class Response implements ResponseInterface
 {
     /**
-     * Flags para encoding JSON consistente
+     * Flags for consistent JSON encoding
      */
     private const JSON_ENCODE_FLAGS = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE;
 
     /**
-     * Instância PSR-7 interna (lazy loaded)
+     * Internal PSR-7 instance (lazy loaded)
      */
     private ?ResponseInterface $psr7Response = null;
 
     /**
-     * Código de status HTTP.
+     * HTTP status code.
      */
     private int $statusCode = 200;
 
     /**
-     * Cabeçalhos da resposta.
+     * Response headers.
      *
      * @var array<string, mixed>
      */
     private array $headers = [];
 
     /**
-     * Corpo da resposta.
+     * Response body.
      */
     private string $body = '';
 
     /**
-     * Indica se a resposta está sendo enviada como stream.
+     * Indicates if the response is being sent as stream.
      */
     private bool $isStreaming = false;
 
     /**
-     * Buffer size para streaming (em bytes).
+     * Buffer size for streaming (in bytes).
      */
     private int $streamBufferSize = 8192;
 
     /**
-     * Indica se está em modo teste (não faz echo direto).
+     * Indicates if in test mode (does not echo directly).
      */
     private bool $testMode = false;
 
     /**
-     * Indica se a resposta já foi enviada.
+     * Indicates if the response has already been sent.
      */
     private bool $sent = false;
 
     /**
-     * Indica se o controle de emissão automática está desabilitado.
+     * Indicates if automatic emission control is disabled.
      */
     private bool $disableAutoEmit = false;
 
     /**
-     * Construtor da classe Response.
+     * Response class constructor.
      */
     public function __construct()
     {
@@ -774,24 +774,24 @@ public function resetSentState(): self
     }
 
     /**
-     * Determina se deve usar pooling para JSON
+     * Determines if JSON pooling should be used for the given data
      */
     private function shouldUseJsonPooling(mixed $data): bool
     {
-        // Usar pooling para arrays/objetos médios e grandes
+        // Use pooling for medium and large arrays/objects
         if (is_array($data)) {
             $count = count($data);
-            return $count >= 10; // Arrays com 10+ elementos
+            return $count >= JsonBufferPool::POOLING_ARRAY_THRESHOLD;
         }
 
         if (is_object($data)) {
             $vars = get_object_vars($data);
-            return $vars && count($vars) >= 5; // Objetos com 5+ propriedades
+            return $vars && count($vars) >= JsonBufferPool::POOLING_OBJECT_THRESHOLD;
         }
 
-        // Usar pooling para strings longas
+        // Use pooling for long strings
         if (is_string($data)) {
-            return strlen($data) > 1024; // Strings > 1KB
+            return strlen($data) > JsonBufferPool::POOLING_STRING_THRESHOLD;
         }
 
         return false;
diff --git a/src/Json/Pool/JsonBufferPool.php b/src/Json/Pool/JsonBufferPool.php
@@ -41,6 +41,11 @@ class JsonBufferPool
     private const MIN_LARGE_BUFFER_SIZE = 65536;     // Minimum size for very large buffers (64KB)
     private const BUFFER_SIZE_MULTIPLIER = 2;        // Multiplier for buffer size calculation
 
+    // Pooling decision thresholds (for determining when to use pooled encoding)
+    public const POOLING_ARRAY_THRESHOLD = 10;       // Arrays with 10+ elements use pooling
+    public const POOLING_OBJECT_THRESHOLD = 5;       // Objects with 5+ properties use pooling
+    public const POOLING_STRING_THRESHOLD = 1024;    // Strings longer than 1KB use pooling
+
     /**
      * Buffer pools organized by capacity
      */
diff --git a/tests/Json/JsonPoolingThresholdsTest.php b/tests/Json/JsonPoolingThresholdsTest.php
@@ -0,0 +1,221 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PivotPHP\Core\Tests\Json;
+
+use PHPUnit\Framework\TestCase;
+use PivotPHP\Core\Http\Response;
+use PivotPHP\Core\Json\Pool\JsonBufferPool;
+
+/**
+ * Test that pooling thresholds are centralized and consistent
+ */
+class JsonPoolingThresholdsTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        JsonBufferPool::clearPools();
+        JsonBufferPool::resetConfiguration();
+    }
+
+    protected function tearDown(): void
+    {
+        JsonBufferPool::clearPools();
+        JsonBufferPool::resetConfiguration();
+    }
+
+    /**
+     * Test that pooling constants are properly defined
+     */
+    public function testPoolingConstantsExist(): void
+    {
+        $this->assertTrue(defined('PivotPHP\Core\Json\Pool\JsonBufferPool::POOLING_ARRAY_THRESHOLD'));
+        $this->assertTrue(defined('PivotPHP\Core\Json\Pool\JsonBufferPool::POOLING_OBJECT_THRESHOLD'));
+        $this->assertTrue(defined('PivotPHP\Core\Json\Pool\JsonBufferPool::POOLING_STRING_THRESHOLD'));
+
+        // Verify values are reasonable
+        $this->assertEquals(10, JsonBufferPool::POOLING_ARRAY_THRESHOLD);
+        $this->assertEquals(5, JsonBufferPool::POOLING_OBJECT_THRESHOLD);
+        $this->assertEquals(1024, JsonBufferPool::POOLING_STRING_THRESHOLD);
+    }
+
+    /**
+     * Test that Response uses centralized thresholds
+     */
+    public function testResponseUsesPoolingThresholds(): void
+    {
+        $response = new Response();
+        $response->setTestMode(true);
+
+        // Test array threshold - just below threshold should not pool
+        $smallArray = array_fill(0, JsonBufferPool::POOLING_ARRAY_THRESHOLD - 1, 'item');
+        $response->json($smallArray);
+
+        $stats = JsonBufferPool::getStatistics();
+        $this->assertEquals(0, $stats['total_operations'], 'Small arrays should not use pooling');
+
+        // Reset
+        JsonBufferPool::clearPools();
+        $response = new Response();
+        $response->setTestMode(true);
+
+        // Test array threshold - at threshold should pool
+        $mediumArray = array_fill(0, JsonBufferPool::POOLING_ARRAY_THRESHOLD, 'item');
+        $response->json($mediumArray);
+
+        $stats = JsonBufferPool::getStatistics();
+        $this->assertEquals(1, $stats['total_operations'], 'Arrays at threshold should use pooling');
+    }
+
+    /**
+     * Test object pooling threshold consistency
+     */
+    public function testObjectPoolingThreshold(): void
+    {
+        $response = new Response();
+        $response->setTestMode(true);
+
+        // Create object just below threshold
+        $smallObject = new \stdClass();
+        for ($i = 0; $i < JsonBufferPool::POOLING_OBJECT_THRESHOLD - 1; $i++) {
+            $smallObject->{"prop{$i}"} = "value{$i}";
+        }
+
+        $response->json($smallObject);
+        $stats = JsonBufferPool::getStatistics();
+        $this->assertEquals(0, $stats['total_operations'], 'Small objects should not use pooling');
+
+        // Reset
+        JsonBufferPool::clearPools();
+        $response = new Response();
+        $response->setTestMode(true);
+
+        // Create object at threshold
+        $mediumObject = new \stdClass();
+        for ($i = 0; $i < JsonBufferPool::POOLING_OBJECT_THRESHOLD; $i++) {
+            $mediumObject->{"prop{$i}"} = "value{$i}";
+        }
+
+        $response->json($mediumObject);
+        $stats = JsonBufferPool::getStatistics();
+        $this->assertEquals(1, $stats['total_operations'], 'Objects at threshold should use pooling');
+    }
+
+    /**
+     * Test string pooling threshold consistency
+     */
+    public function testStringPoolingThreshold(): void
+    {
+        $response = new Response();
+        $response->setTestMode(true);
+
+        // String just under threshold
+        $shortString = str_repeat('x', JsonBufferPool::POOLING_STRING_THRESHOLD);
+        $response->json($shortString);
+
+        $stats = JsonBufferPool::getStatistics();
+        $this->assertEquals(0, $stats['total_operations'], 'Short strings should not use pooling');
+
+        // Reset
+        JsonBufferPool::clearPools();
+        $response = new Response();
+        $response->setTestMode(true);
+
+        // String over threshold
+        $longString = str_repeat('x', JsonBufferPool::POOLING_STRING_THRESHOLD + 1);
+        $response->json($longString);
+
+        $stats = JsonBufferPool::getStatistics();
+        $this->assertEquals(1, $stats['total_operations'], 'Long strings should use pooling');
+    }
+
+    /**
+     * Test that thresholds are reasonable for performance
+     */
+    public function testThresholdsAreReasonable(): void
+    {
+        // Array threshold should be high enough to avoid pooling small arrays
+        $this->assertGreaterThanOrEqual(5, JsonBufferPool::POOLING_ARRAY_THRESHOLD);
+        $this->assertLessThanOrEqual(50, JsonBufferPool::POOLING_ARRAY_THRESHOLD);
+
+        // Object threshold should be reasonable for common objects
+        $this->assertGreaterThanOrEqual(3, JsonBufferPool::POOLING_OBJECT_THRESHOLD);
+        $this->assertLessThanOrEqual(20, JsonBufferPool::POOLING_OBJECT_THRESHOLD);
+
+        // String threshold should be reasonable (around 1KB)
+        $this->assertGreaterThanOrEqual(512, JsonBufferPool::POOLING_STRING_THRESHOLD);
+        $this->assertLessThanOrEqual(4096, JsonBufferPool::POOLING_STRING_THRESHOLD);
+    }
+
+    /**
+     * Test consistency between direct pooling and Response pooling
+     */
+    public function testConsistencyBetweenDirectAndResponsePooling(): void
+    {
+        $testData = array_fill(0, JsonBufferPool::POOLING_ARRAY_THRESHOLD, 'test');
+
+        // Direct pooling
+        JsonBufferPool::clearPools();
+        $directResult = JsonBufferPool::encodeWithPool($testData);
+        $directStats = JsonBufferPool::getStatistics();
+
+        // Response pooling
+        JsonBufferPool::clearPools();
+        $response = new Response();
+        $response->setTestMode(true);
+        $response->json($testData);
+        $responseResult = $response->getBodyAsString();
+        $responseStats = JsonBufferPool::getStatistics();
+
+        // Results should be identical
+        $this->assertEquals($directResult, $responseResult);
+
+        // Both should have used pooling
+        $this->assertEquals(1, $directStats['total_operations']);
+        $this->assertEquals(1, $responseStats['total_operations']);
+    }
+
+    /**
+     * Test that updating centralized constants affects both components
+     */
+    public function testCentralizedConstantsAffectBothComponents(): void
+    {
+        // This test verifies that the constants are truly centralized
+        // by checking that Response uses the same values as JsonBufferPool
+
+        $reflection = new \ReflectionClass('PivotPHP\Core\Http\Response');
+        $shouldUsePoolingMethod = $reflection->getMethod('shouldUseJsonPooling');
+        $shouldUsePoolingMethod->setAccessible(true);
+
+        $response = new Response();
+
+        // Test array threshold boundary
+        $arrayAtThreshold = array_fill(0, JsonBufferPool::POOLING_ARRAY_THRESHOLD, 'item');
+        $arrayBelowThreshold = array_fill(0, JsonBufferPool::POOLING_ARRAY_THRESHOLD - 1, 'item');
+
+        $this->assertTrue($shouldUsePoolingMethod->invoke($response, $arrayAtThreshold));
+        $this->assertFalse($shouldUsePoolingMethod->invoke($response, $arrayBelowThreshold));
+
+        // Test object threshold boundary
+        $objectAtThreshold = new \stdClass();
+        for ($i = 0; $i < JsonBufferPool::POOLING_OBJECT_THRESHOLD; $i++) {
+            $objectAtThreshold->{"prop{$i}"} = "value{$i}";
+        }
+
+        $objectBelowThreshold = new \stdClass();
+        for ($i = 0; $i < JsonBufferPool::POOLING_OBJECT_THRESHOLD - 1; $i++) {
+            $objectBelowThreshold->{"prop{$i}"} = "value{$i}";
+        }
+
+        $this->assertTrue($shouldUsePoolingMethod->invoke($response, $objectAtThreshold));
+        $this->assertFalse($shouldUsePoolingMethod->invoke($response, $objectBelowThreshold));
+
+        // Test string threshold boundary
+        $stringAtThreshold = str_repeat('x', JsonBufferPool::POOLING_STRING_THRESHOLD + 1);
+        $stringBelowThreshold = str_repeat('x', JsonBufferPool::POOLING_STRING_THRESHOLD);
+
+        $this->assertTrue($shouldUsePoolingMethod->invoke($response, $stringAtThreshold));
+        $this->assertFalse($shouldUsePoolingMethod->invoke($response, $stringBelowThreshold));
+    }
+}
