Add transform parameter to Redis::withConnection() for raw phpredis support

- Add $transform parameter to Redis::getConnection() and withConnection()
  to control Laravel-style vs raw phpredis behavior (default: true)
- Update StoreContext::withConnection() to delegate to Redis::withConnection()
  with transform: false for coroutine context awareness while maintaining
  raw phpredis behavior needed by cache operations
- Update flushByPattern() to use transform: false for consistency
- Remove unused $poolFactory from StoreContext (no longer needed)
- Add createStoreWithFakeClient() helper to MocksRedisConnections trait
  to eliminate test setup duplication
- Add tests verifying transform parameter behavior

Author: binaryfire

src/cache/src/Redis/Support/StoreContext.php

@@ -4,9 +4,10 @@
 
 namespace Hypervel\Cache\Redis\Support;
 
-use Hyperf\Redis\Pool\PoolFactory;
 use Hypervel\Cache\Redis\TagMode;
+use Hypervel\Context\ApplicationContext;
 use Hypervel\Redis\RedisConnection;
+use Hypervel\Redis\RedisFactory;
 use Redis;
 use RedisCluster;
 
@@ -33,7 +34,6 @@ class StoreContext
     public const TAG_FIELD_VALUE = '1';
 
     public function __construct(
-        private readonly PoolFactory $poolFactory,
         private readonly string $connectionName,
         private readonly string $prefix,
         private readonly TagMode $tagMode,
@@ -126,25 +126,20 @@ public function registryKey(): string
     /**
      * Execute callback with a held connection from the pool.
      *
-     * Use this for operations requiring multiple commands on the same
-     * connection (cluster mode, complex transactions). The connection
-     * is automatically returned to the pool after the callback completes.
+     * Delegates to Redis::withConnection() for context awareness (respects
+     * active pipeline/multi connections). Uses transform: false to provide
+     * raw phpredis behavior for cache operations.
      *
      * @template T
      * @param callable(RedisConnection): T $callback
      * @return T
      */
     public function withConnection(callable $callback): mixed
     {
-        $pool = $this->poolFactory->getPool($this->connectionName);
-        /** @var RedisConnection $connection */
-        $connection = $pool->get();
-
-        try {
-            return $callback($connection);
-        } finally {
-            $connection->release();
-        }
+        return ApplicationContext::getContainer()
+            ->get(RedisFactory::class)
+            ->get($this->connectionName)
+            ->withConnection($callback, transform: false);
     }
 
     /**

src/cache/src/RedisStore.php

@@ -378,7 +378,6 @@ public function setPrefix(string $prefix): void
     public function getContext(): StoreContext
     {
         return $this->context ??= new StoreContext(
-            $this->getPoolFactory(),
             $this->connection,
             $this->prefix,
             $this->tagMode,

src/redis/src/Redis.php

@@ -108,8 +108,11 @@ protected function shouldUseSameConnection(string $methodName): bool
 
     /**
      * Get a connection from coroutine context, or from redis connection pool.
+     *
+     * @param bool $hasContextConnection Whether a connection exists in coroutine context
+     * @param bool $transform Whether to enable Laravel-style result transformation
      */
-    protected function getConnection(bool $hasContextConnection): RedisConnection
+    protected function getConnection(bool $hasContextConnection, bool $transform = true): RedisConnection
     {
         $connection = $hasContextConnection
             ? Context::get($this->getContextKey())
@@ -122,7 +125,7 @@ protected function getConnection(bool $hasContextConnection): RedisConnection
             throw new InvalidRedisConnectionException('The connection is not a valid RedisConnection.');
         }
 
-        return $connection->shouldTransform(true);
+        return $connection->shouldTransform($transform);
     }
 
     /**
@@ -145,12 +148,13 @@ protected function getContextKey(): string
      *
      * @template T
      * @param callable(RedisConnection): T $callback
+     * @param bool $transform Whether to enable Laravel-style result transformation (default: true)
      * @return T
      */
-    public function withConnection(callable $callback): mixed
+    public function withConnection(callable $callback, bool $transform = true): mixed
     {
         $hasContextConnection = Context::has($this->getContextKey());
-        $connection = $this->getConnection($hasContextConnection);
+        $connection = $this->getConnection($hasContextConnection, $transform);
 
         try {
             return $callback($connection);
@@ -191,7 +195,8 @@ public function connection(string $name = 'default'): RedisProxy
     public function flushByPattern(string $pattern): int
     {
         return $this->withConnection(
-            fn (RedisConnection $connection) => $connection->flushByPattern($pattern)
+            fn (RedisConnection $connection) => $connection->flushByPattern($pattern),
+            transform: false
         );
     }
 }

tests/Cache/Redis/AllTagSetTest.php

@@ -5,8 +5,8 @@
 namespace Hypervel\Tests\Cache\Redis;
 
 use Hypervel\Cache\Redis\AllTagSet;
+use Hypervel\Testbench\TestCase;
 use Hypervel\Tests\Cache\Redis\Concerns\MocksRedisConnections;
-use Hypervel\Tests\TestCase;
 
 /**
  * Tests for AllTagSet class.

tests/Cache/Redis/AllTaggedCacheTest.php

@@ -5,8 +5,8 @@
 namespace Hypervel\Tests\Cache\Redis;
 
 use Carbon\Carbon;
+use Hypervel\Testbench\TestCase;
 use Hypervel\Tests\Cache\Redis\Concerns\MocksRedisConnections;
-use Hypervel\Tests\TestCase;
 use Redis;
 use RuntimeException;
 

tests/Cache/Redis/AnyTagSetTest.php

@@ -7,8 +7,8 @@
 use Generator;
 use Hypervel\Cache\Redis\AnyTagSet;
 use Hypervel\Cache\RedisStore;
+use Hypervel\Testbench\TestCase;
 use Hypervel\Tests\Cache\Redis\Concerns\MocksRedisConnections;
-use Hypervel\Tests\TestCase;
 use Mockery as m;
 use Redis;
 

tests/Cache/Redis/AnyTaggedCacheTest.php

@@ -9,8 +9,8 @@
 use Hypervel\Cache\Redis\AnyTaggedCache;
 use Hypervel\Cache\Redis\AnyTagSet;
 use Hypervel\Cache\TaggedCache;
+use Hypervel\Testbench\TestCase;
 use Hypervel\Tests\Cache\Redis\Concerns\MocksRedisConnections;
-use Hypervel\Tests\TestCase;
 use RuntimeException;
 
 /**

tests/Cache/Redis/Concerns/MocksRedisConnections.php

@@ -6,18 +6,22 @@
 
 use Hyperf\Redis\Pool\PoolFactory;
 use Hyperf\Redis\Pool\RedisPool;
-use Hyperf\Redis\RedisFactory;
+use Hyperf\Redis\RedisFactory as HyperfRedisFactory;
 use Hypervel\Cache\RedisStore;
 use Hypervel\Redis\RedisConnection;
+use Hypervel\Redis\RedisFactory as HypervelRedisFactory;
+use Hypervel\Redis\RedisProxy;
+use Hypervel\Tests\Redis\Stub\FakeRedisClient;
 use Mockery as m;
 use Redis;
 use RedisCluster;
 
 /**
  * Shared test infrastructure for Redis cache operation tests.
  *
- * Provides helper methods for mocking Redis connections, pool factories,
- * and creating RedisStore instances for testing.
+ * Provides helper methods for mocking Redis connections and creating
+ * RedisStore instances for testing. Requires tests to extend
+ * `Hypervel\Testbench\TestCase` for proper container setup.
  *
  * ## Usage Examples
  *
@@ -134,6 +138,28 @@ protected function createPoolFactory(
         return $poolFactory;
     }
 
+    /**
+     * Register a RedisFactory mock in the container.
+     *
+     * This sets up the mock that StoreContext::withConnection() uses to get
+     * connections via ApplicationContext::getContainer().
+     */
+    protected function registerRedisFactoryMock(
+        m\MockInterface|RedisConnection $connection,
+        string $connectionName = 'default'
+    ): void {
+        $redisProxy = m::mock(RedisProxy::class);
+        $redisProxy->shouldReceive('withConnection')
+            ->andReturnUsing(fn (callable $callback) => $callback($connection));
+
+        $redisFactory = m::mock(HypervelRedisFactory::class);
+        $redisFactory->shouldReceive('get')
+            ->with($connectionName)
+            ->andReturn($redisProxy);
+
+        $this->instance(HypervelRedisFactory::class, $redisFactory);
+    }
+
     /**
      * Create a RedisStore with a mocked connection.
      *
@@ -148,8 +174,11 @@ protected function createStore(
         string $connectionName = 'default',
         ?string $tagMode = null,
     ): RedisStore {
+        // Register RedisFactory mock for StoreContext::withConnection()
+        $this->registerRedisFactoryMock($connection, $connectionName);
+
         $store = new RedisStore(
-            m::mock(RedisFactory::class),
+            m::mock(HyperfRedisFactory::class),
             $prefix,
             $connectionName,
             $this->createPoolFactory($connection, $connectionName)
@@ -189,8 +218,11 @@ protected function createClusterStore(
         $connection = $this->mockClusterConnection();
         $clusterClient = $connection->_mockClient;
 
+        // Register RedisFactory mock for StoreContext::withConnection()
+        $this->registerRedisFactoryMock($connection, $connectionName);
+
         $store = new RedisStore(
-            m::mock(RedisFactory::class),
+            m::mock(HyperfRedisFactory::class),
             $prefix,
             $connectionName,
             $this->createPoolFactory($connection, $connectionName)
@@ -202,4 +234,43 @@ protected function createClusterStore(
 
         return [$store, $clusterClient, $connection];
     }
+
+    /**
+     * Create a RedisStore with a FakeRedisClient.
+     *
+     * Use this for tests that need proper reference parameter handling (e.g., &$iterator
+     * in SCAN/HSCAN/ZSCAN operations) which Mockery cannot properly propagate.
+     *
+     * @param FakeRedisClient $fakeClient Pre-configured fake client with expected responses
+     * @param string $prefix Cache key prefix
+     * @param string $connectionName Redis connection name
+     * @param null|string $tagMode Optional tag mode ('any' or 'all')
+     */
+    protected function createStoreWithFakeClient(
+        FakeRedisClient $fakeClient,
+        string $prefix = 'prefix:',
+        string $connectionName = 'default',
+        ?string $tagMode = null,
+    ): RedisStore {
+        $connection = m::mock(RedisConnection::class);
+        $connection->shouldReceive('release')->zeroOrMoreTimes();
+        $connection->shouldReceive('serialized')->andReturn(false)->byDefault();
+        $connection->shouldReceive('client')->andReturn($fakeClient)->byDefault();
+
+        // Register RedisFactory mock for StoreContext::withConnection()
+        $this->registerRedisFactoryMock($connection, $connectionName);
+
+        $store = new RedisStore(
+            m::mock(HyperfRedisFactory::class),
+            $prefix,
+            $connectionName,
+            $this->createPoolFactory($connection, $connectionName)
+        );
+
+        if ($tagMode !== null) {
+            $store->setTagMode($tagMode);
+        }
+
+        return $store;
+    }
 }

tests/Cache/Redis/ExceptionPropagationTest.php

@@ -6,8 +6,8 @@
 
 use Hypervel\Cache\Redis\AnyTaggedCache;
 use Hypervel\Cache\Redis\AnyTagSet;
+use Hypervel\Testbench\TestCase;
 use Hypervel\Tests\Cache\Redis\Concerns\MocksRedisConnections;
-use Hypervel\Tests\TestCase;
 use Mockery as m;
 use RedisException;
 

tests/Cache/Redis/Integration/ClusterFallbackIntegrationTest.php

@@ -4,7 +4,6 @@
 
 namespace Hypervel\Tests\Cache\Redis\Integration;
 
-use Hyperf\Redis\Pool\PoolFactory;
 use Hypervel\Cache\Redis\AnyTaggedCache;
 use Hypervel\Cache\Redis\AnyTagSet;
 use Hypervel\Cache\Redis\Support\StoreContext;
@@ -35,17 +34,11 @@ class ClusterModeRedisStore extends RedisStore
     public function getContext(): StoreContext
     {
         return $this->clusterContext ??= new ClusterModeStoreContext(
-            $this->getPoolFactoryInternal(),
             $this->connection,
             $this->getPrefix(),
             $this->getTagMode(),
         );
     }
-
-    public function getPoolFactoryInternal(): PoolFactory
-    {
-        return parent::getPoolFactory();
-    }
 }
 
 /**