Added global random persistent delay simulator

rcalicdan · rcalicdan · commit 6609f60201b9 · 2025-08-25T16:12:14.000+08:00
diff --git a/src/Http/Testing/MockRequestBuilder.php b/src/Http/Testing/MockRequestBuilder.php
@@ -95,6 +95,65 @@ public function delay(float $seconds): self
         return $this;
     }
 
+    /**
+     * Set a random delay range for more realistic network simulation.
+     * Uses aggressive randomization for realistic variation.
+     *
+     * @param float $minSeconds Minimum delay in seconds
+     * @param float $maxSeconds Maximum delay in seconds
+     * @return self
+     */
+    public function randomDelay(float $minSeconds, float $maxSeconds): self
+    {
+        if ($minSeconds > $maxSeconds) {
+            throw new \InvalidArgumentException('Minimum delay cannot be greater than maximum delay');
+        }
+
+        $randomDelay = $this->generateAggressiveRandomFloat($minSeconds, $maxSeconds);
+        $this->request->setDelay($randomDelay);
+
+        return $this;
+    }
+
+    /**
+     * Generate aggressive random float with high precision for realistic network simulation.
+     *
+     * @param float $min Minimum value
+     * @param float $max Maximum value
+     * @return float Random float with microsecond precision
+     */
+    private function generateAggressiveRandomFloat(float $min, float $max): float
+    {
+        $precision = 1000000;
+        $randomInt = random_int(
+            (int)($min * $precision),
+            (int)($max * $precision)
+        );
+
+        return $randomInt / $precision;
+    }
+
+    /**
+     * Create a persistent mock with random delays for each request.
+     * Each request will have a different random delay within the specified range.
+     *
+     * @param float $minSeconds Minimum delay in seconds
+     * @param float $maxSeconds Maximum delay in seconds
+     * @return self
+     */
+    public function randomPersistentDelay(float $minSeconds, float $maxSeconds): self
+    {
+        if ($minSeconds > $maxSeconds) {
+            throw new \InvalidArgumentException('Minimum delay cannot be greater than maximum delay');
+        }
+
+        // Store the delay range in the request for later use
+        $this->request->setRandomDelayRange($minSeconds, $maxSeconds);
+        $this->persistent();
+
+        return $this;
+    }
+
     public function fail(string $error = 'Mocked request failure'): self
     {
         $this->request->setError($error);
diff --git a/src/Http/Testing/MockedRequest.php b/src/Http/Testing/MockedRequest.php
@@ -12,6 +12,8 @@ class MockedRequest
     private array $headerMatchers = [];
     private ?string $bodyMatcher = null;
     private ?array $jsonMatcher = null;
+    private ?float $randomDelayMin = null;
+    private ?float $randomDelayMax = null;
 
     private int $statusCode = 200;
     private string $body = '';
@@ -201,8 +203,54 @@ public function getHeaders(): array
         return $this->headers;
     }
 
+    /**
+     * Set random delay range for persistent mocks.
+     */
+    public function setRandomDelayRange(float $min, float $max): void
+    {
+        $this->randomDelayMin = $min;
+        $this->randomDelayMax = $max;
+    }
+
+    /**
+     * Get random delay range.
+     */
+    public function getRandomDelayRange(): ?array
+    {
+        if ($this->randomDelayMin === null || $this->randomDelayMax === null) {
+            return null;
+        }
+
+        return [$this->randomDelayMin, $this->randomDelayMax];
+    }
+
+    /**
+     * Generate a new random delay for this request.
+     */
+    public function generateRandomDelay(): float
+    {
+        if ($this->randomDelayMin === null || $this->randomDelayMax === null) {
+            return $this->delay;
+        }
+
+        $precision = 1000000;
+        $randomInt = random_int(
+            (int)($this->randomDelayMin * $precision),
+            (int)($this->randomDelayMax * $precision)
+        );
+
+        return $randomInt / $precision;
+    }
+
+    /**
+     * Get delay, generating random delay if range is set.
+     */
     public function getDelay(): float
     {
+        if ($this->randomDelayMin !== null && $this->randomDelayMax !== null) {
+            return $this->generateRandomDelay();
+        }
+
         return $this->timeoutAfter ?? $this->delay;
     }
 
@@ -268,6 +316,8 @@ public function toArray(): array
             'body' => $this->body,
             'headers' => $this->headers,
             'delay' => $this->delay,
+            'randomDelayMin' => $this->randomDelayMin,
+            'randomDelayMax' => $this->randomDelayMax,
             'error' => $this->error,
             'persistent' => $this->persistent,
             'timeoutAfter' => $this->timeoutAfter,
@@ -286,6 +336,8 @@ public static function fromArray(array $data): self
         $request->body = $data['body'];
         $request->headers = $data['headers'] ?? [];
         $request->delay = $data['delay'] ?? 0;
+        $request->randomDelayMin = $data['randomDelayMin'] ?? null;
+        $request->randomDelayMax = $data['randomDelayMax'] ?? null;
         $request->error = $data['error'];
         $request->persistent = $data['persistent'] ?? false;
         $request->timeoutAfter = $data['timeoutAfter'] ?? null;
diff --git a/src/Http/Testing/Services/ResponseFactory.php b/src/Http/Testing/Services/ResponseFactory.php
@@ -9,17 +9,20 @@
 use Rcalicdan\FiberAsync\Http\RetryConfig;
 use Rcalicdan\FiberAsync\Http\StreamingResponse;
 use Rcalicdan\FiberAsync\Http\Testing\MockedRequest;
+use Rcalicdan\FiberAsync\Http\Testing\TestingHttpHandler;
 use Rcalicdan\FiberAsync\Promise\CancellablePromise;
 use Rcalicdan\FiberAsync\Promise\Interfaces\CancellablePromiseInterface;
 use Rcalicdan\FiberAsync\Promise\Interfaces\PromiseInterface;
 
 class ResponseFactory
 {
     private NetworkSimulator $networkSimulator;
+    private ?TestingHttpHandler $handler = null;
 
-    public function __construct(NetworkSimulator $networkSimulator)
+    public function __construct(NetworkSimulator $networkSimulator, ?TestingHttpHandler $handler = null)
     {
         $this->networkSimulator = $networkSimulator;
+        $this->handler = $handler;
     }
 
     public function createMockedResponse(MockedRequest $mock): PromiseInterface
@@ -197,7 +200,17 @@ public function createMockedDownload(MockedRequest $mock, string $destination, F
     private function executeWithNetworkSimulation(CancellablePromise $promise, MockedRequest $mock, callable $callback): void
     {
         $networkConditions = $this->networkSimulator->simulate();
-        $totalDelay = max($mock->getDelay(), $networkConditions['delay']);
+
+        // Get mock delay (which might be random for persistent mocks)
+        $mockDelay = $mock->getDelay();
+
+        // Add global random delay if the handler has it enabled
+        $globalDelay = 0.0;
+        if ($this->handler !== null) {
+            $globalDelay = $this->handler->generateGlobalRandomDelay();
+        }
+
+        $totalDelay = max($mockDelay + $globalDelay, $networkConditions['delay']);
         /** @var string|null $timerId */
         $timerId = null;
 
diff --git a/src/Http/Testing/TestingHttpHandler.php b/src/Http/Testing/TestingHttpHandler.php
@@ -32,6 +32,8 @@ class TestingHttpHandler extends HttpHandler
 
     /** @var array<RecordedRequest> */
     private array $requestHistory = [];
+    private ?float $globalRandomDelayMin = null;
+    private ?float $globalRandomDelayMax = null;
 
     private array $globalSettings = [
         'record_requests' => true,
@@ -99,6 +101,39 @@ public function withGlobalFileCookieJar(?string $filename = null, bool $includeS
         return $this;
     }
 
+    /**
+     * Enable global random delay for all requests.
+     * This adds realistic network variance to all mocked requests.
+     *
+     * @param float $minSeconds Minimum delay in seconds
+     * @param float $maxSeconds Maximum delay in seconds
+     * @return self
+     */
+    public function withGlobalRandomDelay(float $minSeconds, float $maxSeconds): self
+    {
+        if ($minSeconds > $maxSeconds) {
+            throw new \InvalidArgumentException('Minimum delay cannot be greater than maximum delay');
+        }
+
+        $this->globalRandomDelayMin = $minSeconds;
+        $this->globalRandomDelayMax = $maxSeconds;
+
+        return $this;
+    }
+
+    /**
+     * Disable global random delay.
+     *
+     * @return self
+     */
+    public function withoutGlobalRandomDelay(): self
+    {
+        $this->globalRandomDelayMin = null;
+        $this->globalRandomDelayMax = null;
+
+        return $this;
+    }
+
     public function enableNetworkSimulation(array $settings = []): self
     {
         $this->networkSimulator->enable($settings);
@@ -329,10 +364,33 @@ public function getRequestHistory(): array
         return $this->requestHistory;
     }
 
+
+    /**
+     * Generate global random delay if enabled.
+     *
+     * @return float
+     */
+    public function generateGlobalRandomDelay(): float
+    {
+        if ($this->globalRandomDelayMin === null || $this->globalRandomDelayMax === null) {
+            return 0.0;
+        }
+
+        $precision = 1000000;
+        $randomInt = random_int(
+            (int)($this->globalRandomDelayMin * $precision),
+            (int)($this->globalRandomDelayMax * $precision)
+        );
+
+        return $randomInt / $precision;
+    }
+
     public function reset(): void
     {
         $this->mockedRequests = [];
         $this->requestHistory = [];
+        $this->globalRandomDelayMin = null;
+        $this->globalRandomDelayMax = null;
         $this->fileManager->cleanup();
         $this->cookieManager->cleanup();
     }
diff --git a/test21.php b/test21.php
@@ -5,41 +5,49 @@
 
 require __DIR__ . '/vendor/autoload.php';
 
-echo "====== Integration Test for Cookies AND Caching ======\n";
+echo "====== Integration Test for Cookies AND Caching (FIXED) ======\n";
 
 Task::run(function () {
-    // 1. Arrange: Enable testing with a managed CookieJar.
-    $handler = Http::testing()->withGlobalCookieJar();
-    $handler->reset();
+    // 1. Arrange: Get testing handler and reset FIRST
+    $handler = Http::testing();
+    $handler->reset(); // Reset first
+    
+    // THEN enable cookie jar (after reset)
+    $handler->withGlobalCookieJar();
+    
+    // Set as global instance
+    Http::setInstance($handler);
+
+    echo "DEBUG: Testing handler created, reset, and configured with cookie jar\n";
 
     $sessionId = 'session-for-caching-test';
     $domain = 'api.example.com';
     $profileUrl = "https://{$domain}/api/profile";
     $loginUrl = "https://{$domain}/login";
 
-    Http::mock('POST')->url($loginUrl)
+    // Set up mocks
+    $handler->mock('POST')->url($loginUrl)
         ->setCookie('session_id', $sessionId)
         ->json(['status' => 'logged_in'])
         ->register();
 
-    // Mock the /profile endpoint. It MUST expect the cookie.
-    // It is NOT persistent. If it's called more than once, the test will fail.
-    Http::mock('GET')->url($profileUrl)
+    $handler->mock('GET')->url($profileUrl)
         ->withHeader('Cookie', "session_id={$sessionId}")
-        ->delay(0.5) // Add a delay to make the cache hit obvious
+        ->delay(0.5)
         ->json(['user' => 'John Doe', 'timestamp' => microtime(true)])
         ->register();
 
-    echo "--- Step 1: Logging in to establish a session ---\n";
-    await(Http::post($loginUrl));
+    echo "\n--- Step 1: Logging in to establish a session ---\n";
+    $loginResponse = await(Http::post($loginUrl));
+    
+    // Now we can safely assert cookie exists
     $handler->assertCookieExists('session_id');
     echo "   ✓ SUCCESS: Logged in and session cookie was stored.\n";
 
     // -----------------------------------------------------------------
 
     echo "\n--- Step 2: First profile fetch (expecting CACHE MISS) ---\n";
     $start1 = microtime(true);
-    // This request uses BOTH the cookie jar (implicitly) and caching.
     $response1 = await(
         Http::request()
             ->cache(60)
@@ -66,26 +74,22 @@
 
     echo "\n--- Step 4: Verifying Results ---\n";
     
-    // Assertion 1: Verify the second call was a cache hit (instant and same data).
+    // Assertion 1: Verify the second call was a cache hit
     if ($elapsed2 < 0.01 && $data1['timestamp'] === $data2['timestamp']) {
         echo "   ✓ SUCCESS: Second request was an instant cache hit with the correct data.\n";
     } else {
         echo "   ✗ FAILED: Second request was not a cache hit.\n";
     }
 
-    // Assertion 2: Verify the total number of requests made.
+    // Assertion 2: Verify the total number of requests made
     try {
-        // We expect 3 total recorded requests:
-        // 1. POST /login (consumes a mock)
-        // 2. GET /profile (cache miss, consumes a mock)
-        // 3. GET /profile (cache hit, does NOT consume a mock)
         $handler->assertRequestCount(3);
-        echo "   ✓ SUCCESS: Correct number of requests recorded (login, cache miss, cache hit).\n";
+        echo "   ✓ SUCCESS: Correct number of requests recorded.\n";
     } catch (Exception $e) {
         echo "   ✗ FAILED: " . $e->getMessage() . "\n";
     }
     
-    // Final check: Let's see the history to be sure.
+    // Final check: Request history
     $history = $handler->getRequestHistory();
     $profile_miss_found = false;
     $profile_hit_found = false;
@@ -95,11 +99,14 @@
     }
 
     if ($profile_miss_found && $profile_hit_found) {
-        echo "   ✓ SUCCESS: Request history correctly shows one cache miss and one cache hit for the profile.\n";
+        echo "   ✓ SUCCESS: Request history shows cache miss and cache hit.\n";
     } else {
         echo "   ✗ FAILED: Request history is incorrect.\n";
+        echo "   DEBUG: History:\n";
+        foreach($history as $req) {
+            echo "     - {$req->method} {$req->url}\n";
+        }
     }
-
 });
 
 echo "\n====== Cookie and Cache Integration Test Complete ======\n";
diff --git a/test22.php b/test22.php
