feat: Adicionar suporte a variáveis de ambiente para configuração de testes de desempenho e iterações

Author: CAFernandes

docs/testing/CI_CONFIGURATION.md

@@ -0,0 +1,76 @@
+# CI/CD Configuration for PivotPHP Tests
+
+## Environment Variables for Test Stability
+
+To ensure stable tests across different environments (local development, CI/CD, production), PivotPHP supports the following environment variables:
+
+### Performance Test Configuration
+
+#### `PIVOTPHP_PERFORMANCE_THRESHOLD`
+- **Purpose**: Sets the minimum requests per second threshold for performance tests
+- **Default**: 
+  - Local development: `500` req/s
+  - CI environments: `250` req/s
+- **Usage**: `export PIVOTPHP_PERFORMANCE_THRESHOLD=300`
+
+#### `PIVOTPHP_CONCURRENT_REQUESTS`
+- **Purpose**: Sets the number of concurrent requests for stress tests
+- **Default**: 
+  - Local development: `10000` requests
+  - CI environments: `5000` requests
+- **Usage**: `export PIVOTPHP_CONCURRENT_REQUESTS=3000`
+
+#### `PIVOTPHP_TEST_ITERATIONS`
+- **Purpose**: Sets the number of iterations for integration tests
+- **Default**: 
+  - Local development: `500` iterations
+  - CI environments: `250` iterations
+- **Usage**: `export PIVOTPHP_TEST_ITERATIONS=100`
+
+## CI Environment Detection
+
+The framework automatically detects CI environments by checking for:
+- `CI=true`
+- `GITHUB_ACTIONS=true`
+- `TRAVIS=true`
+
+When a CI environment is detected, more conservative default values are used to prevent flaky tests.
+
+## Example GitHub Actions Configuration
+
+```yaml
+env:
+  PIVOTPHP_PERFORMANCE_THRESHOLD: 200
+  PIVOTPHP_CONCURRENT_REQUESTS: 2000
+  PIVOTPHP_TEST_ITERATIONS: 100
+```
+
+## Example Local Development
+
+```bash
+# For slower development machines
+export PIVOTPHP_PERFORMANCE_THRESHOLD=100
+export PIVOTPHP_CONCURRENT_REQUESTS=1000
+export PIVOTPHP_TEST_ITERATIONS=50
+
+# Run tests
+composer test
+```
+
+## Benefits
+
+1. **Consistent Test Results**: Tests adapt to environment capabilities
+2. **Reduced Flakiness**: Conservative thresholds in CI environments
+3. **Flexibility**: Easy to override for specific needs
+4. **Performance Insights**: Still validates performance while being realistic
+
+## Test Groups
+
+Performance tests are organized into groups:
+- `@group stress` - High-load stress tests
+- `@group high-performance` - Performance validation tests
+
+To skip performance tests in CI:
+```bash
+vendor/bin/phpunit --exclude-group stress,high-performance
+```

tests/Integration/V11ComponentsTest.php

@@ -29,6 +29,25 @@ protected function setUp(): void
         $this->app = new Application();
     }
 
+    /**
+     * Get test iteration count based on environment
+     */
+    private function getTestIterationCount(): int
+    {
+        // Allow environment override
+        if ($envCount = getenv('PIVOTPHP_TEST_ITERATIONS')) {
+            return (int) $envCount;
+        }
+
+        // Reduce iterations for CI environments
+        if (getenv('CI') || getenv('GITHUB_ACTIONS') || getenv('TRAVIS')) {
+            return 250; // Half the iterations for CI
+        }
+
+        // Default for local development
+        return 500;
+    }
+
     /**
      * Test high-performance mode integration
      */
@@ -380,7 +399,8 @@ function ($req, $res) {
         $results = [];
         $startTime = microtime(true);
 
-        for ($i = 0; $i < 500; $i++) {
+        $iterations = $this->getTestIterationCount();
+        for ($i = 0; $i < $iterations; $i++) {
             // Mix of read and write operations
             if ($i % 3 === 0) {
                 $request = new Request('GET', '/api/users/' . $i, '/api/users/' . $i);
@@ -406,7 +426,7 @@ function ($req, $res) {
         $metrics = $monitor->getLiveMetrics();
 
         // Since Application doesn't auto-track requests, we check other metrics
-        // Memory pressure should be reasonable after processing 500 requests
+        // Memory pressure should be reasonable after processing requests
         $this->assertLessThan(1, $metrics['memory_pressure'], 'Memory pressure should be < 100%');
 
         // Verify monitor is initialized and working

tests/Stress/HighPerformanceStressTest.php

@@ -27,6 +27,44 @@ protected function setUp(): void
         $this->metrics = [];
     }
 
+    /**
+     * Get performance threshold based on environment
+     */
+    private function getPerformanceThreshold(): int
+    {
+        // Allow environment override for CI/CD
+        if ($envThreshold = getenv('PIVOTPHP_PERFORMANCE_THRESHOLD')) {
+            return (int) $envThreshold;
+        }
+
+        // Detect CI environment and use more conservative thresholds
+        if (getenv('CI') || getenv('GITHUB_ACTIONS') || getenv('TRAVIS')) {
+            return 250; // More conservative for CI
+        }
+
+        // Default for local development
+        return 500;
+    }
+
+    /**
+     * Get number of concurrent requests based on environment
+     */
+    private function getConcurrentRequestCount(): int
+    {
+        // Allow environment override
+        if ($envCount = getenv('PIVOTPHP_CONCURRENT_REQUESTS')) {
+            return (int) $envCount;
+        }
+
+        // Reduce load for CI environments
+        if (getenv('CI') || getenv('GITHUB_ACTIONS') || getenv('TRAVIS')) {
+            return 5000; // Half the load for CI
+        }
+
+        // Default for local development
+        return 10000;
+    }
+
     /**
      * Test concurrent request handling under extreme load
      *
@@ -38,7 +76,7 @@ public function testConcurrentRequestHandling(): void
         // Enable extreme performance mode
         HighPerformanceMode::enable(HighPerformanceMode::PROFILE_EXTREME);
 
-        $concurrentRequests = 10000;
+        $concurrentRequests = $this->getConcurrentRequestCount();
         $results = [];
         $startTime = microtime(true);
 
@@ -58,7 +96,12 @@ public function testConcurrentRequestHandling(): void
         $duration = (microtime(true) - $startTime) * 1000;
         $throughput = $concurrentRequests / ($duration / 1000);
 
-        $this->assertGreaterThan(500, $throughput, 'Should handle >500 req/s');
+        $threshold = $this->getPerformanceThreshold();
+        $this->assertGreaterThan(
+            $threshold,
+            $throughput,
+            "Should handle >{$threshold} req/s (env: " . (getenv('CI') ? 'CI' : 'local') . ")"
+        );
 
         // Check memory efficiency
         $memoryPerRequest = (memory_get_peak_usage(true) - memory_get_usage(true)) / $concurrentRequests;