(refactor): drop redundant cache layer and cross-process test for redis adapter

Author: abnegate

.github/workflows/tests.yml

@@ -80,7 +80,6 @@ jobs:
             Mirror,
             Pool,
             Redis,
-            RedisCrossProcess,
             SharedTables/MongoDB,
             SharedTables/MariaDB,
             SharedTables/MySQL,

src/Database/Adapter/Redis/Contract.md

@@ -179,9 +179,8 @@ inverse operations through `rawDeleteDoc()` and `rawRestoreDoc()`.
 Relationship support is split across waves: T1 (this PR) lands the helper
 contract; T2 implements `createRelationship` / `updateRelationship` /
 `deleteRelationship`; T3 wires read-path null surfacing into every decoded
-document path; T4 flips the capability bit and adds a cross-process smoke
-test. The rules below are the locked contract — Wave-2 architects MUST NOT
-deviate.
+document path; T4 flips the capability bit. The rules below are the
+locked contract — Wave-2 architects MUST NOT deviate.
 
 1. **Storage policy.** Relationship attributes ride on the existing
    `meta:{col}` HASH's `attrs` JSON field. The adapter writes a MINIMAL
@@ -247,8 +246,8 @@ deviate.
    | `private function loadMetadataDocument(string $collection): ?Document` | T1 |
 
 7. **Capability bit.** `getSupportForRelationships()` returns `true` —
-   T2 (schema ops), T3 (read-path null surfacing), and T4 (capability flip
-   + cross-process smoke) have all shipped.
+   T2 (schema ops), T3 (read-path null surfacing), and T4 (capability flip)
+   have all shipped.
 
 ## Known limitations
 

tests/e2e/Adapter/RedisBase.php

@@ -3,7 +3,7 @@
 namespace Tests\E2E\Adapter;
 
 use Redis;
-use Utopia\Cache\Adapter\Redis as RedisCacheAdapter;
+use Utopia\Cache\Adapter\None as NoneCacheAdapter;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Redis as RedisAdapter;
 use Utopia\Database\Database;
@@ -21,9 +21,8 @@ abstract class RedisBase extends Base
     public static ?Database $database = null;
     public static ?Redis $redisClient = null;
     public static string $redisNamespace = '';
-    public static ?Redis $cacheRedisClient = null;
-    /** @var array<int, string> Glob patterns the run owns, scrubbed in tearDownAfterClass. */
-    protected static array $cacheKeyPatterns = [];
+    /** @var array<int, string> Adapter-keyspace SCAN patterns the run owns, scrubbed in tearDownAfterClass. */
+    protected static array $keyPatterns = [];
 
     public static function getAdapterName(): string
     {
@@ -58,15 +57,11 @@ public function getDatabase(): Database
         $client->connect($host, $port);
         self::$redisClient = $client;
 
-        $cacheHost = \getenv('CACHE_REDIS_HOST') ?: 'redis';
-        $cachePort = (int) (\getenv('CACHE_REDIS_PORT') ?: 6379);
-        $cacheRedis = new Redis();
-        $cacheRedis->connect($cacheHost, $cachePort);
-        self::$cacheRedisClient = $cacheRedis;
-        // Contract.md forbids FLUSHALL/FLUSHDB — the runner shares the
-        // cache instance across workers. Cache keys are scrubbed at
-        // tearDownAfterClass via the namespace-scoped scan below.
-        $cache = new Cache(new RedisCacheAdapter($cacheRedis));
+        // Redis-as-adapter makes the Cache layer redundant — adapter reads
+        // and cache reads cost the same Redis round trip, and any
+        // invalidation gap between them just becomes a stale-read window.
+        // None() short-circuits the cache so reads always hit Redis.
+        $cache = new Cache(new NoneCacheAdapter());
 
         $adapter = new RedisAdapter($client);
 
@@ -79,12 +74,12 @@ public function getDatabase(): Database
 
         $this->configureDatabase($database);
 
-        // Track every key pattern this run owns so tearDownAfterClass can
-        // scrub both the adapter's keyspace and the cache's keys without
-        // a global FLUSH. The configureDatabase() call above may have
-        // mutated the namespace (shared-tables uses ''), so capture the
-        // post-configure namespace too.
-        self::$cacheKeyPatterns = self::buildKeyPatterns(self::$redisNamespace, $database->getNamespace(), $database->getDatabase());
+        // Track every adapter-keyspace pattern this run owns so
+        // tearDownAfterClass can scrub without a global FLUSH. The
+        // configureDatabase() call above may have mutated the namespace
+        // (shared-tables uses ''), so capture the post-configure namespace
+        // too.
+        self::$keyPatterns = self::buildKeyPatterns(self::$redisNamespace, $database->getNamespace(), $database->getDatabase());
 
         if ($database->exists()) {
             $database->delete();
@@ -96,10 +91,10 @@ public function getDatabase(): Database
     }
 
     /**
-     * Build SCAN MATCH patterns covering both the adapter keyspace and the
-     * cache keyspace for the namespaces this test class actually wrote to.
-     * The two-namespace form (initial + post-configure) covers the
-     * shared-tables case where setNamespace('') is applied before create().
+     * Build SCAN MATCH patterns covering the adapter keyspace for every
+     * namespace this test class actually wrote to. The two-namespace form
+     * (initial + post-configure) covers the shared-tables case where
+     * setNamespace('') is applied before create().
      *
      * @return array<int, string>
      */
@@ -112,9 +107,6 @@ protected static function buildKeyPatterns(string $initialNamespace, string $eff
             // namespace produces a literal double-colon, which is a valid
             // SCAN pattern.
             $patterns[] = RedisAdapter::KEY_PREFIX . ':' . $namespace . ':' . $database . ':*';
-            // Cache writes go through Utopia\Cache\Adapter\Redis which
-            // composes its own keys; scope by namespace+database too.
-            $patterns[] = $namespace . ':' . $database . ':*';
         }
         return \array_values(\array_unique($patterns));
     }
@@ -156,18 +148,14 @@ public function testUpdateAttributeSize(): void
     public static function tearDownAfterClass(): void
     {
         try {
-            if (self::$cacheKeyPatterns !== [] && self::$redisClient instanceof Redis) {
-                self::scrubKeys(self::$redisClient, self::$cacheKeyPatterns);
-            }
-            if (self::$cacheKeyPatterns !== [] && self::$cacheRedisClient instanceof Redis) {
-                self::scrubKeys(self::$cacheRedisClient, self::$cacheKeyPatterns);
+            if (self::$keyPatterns !== [] && self::$redisClient instanceof Redis) {
+                self::scrubKeys(self::$redisClient, self::$keyPatterns);
             }
         } finally {
             self::$database = null;
             self::$redisClient = null;
-            self::$cacheRedisClient = null;
             self::$redisNamespace = '';
-            self::$cacheKeyPatterns = [];
+            self::$keyPatterns = [];
             parent::tearDownAfterClass();
         }
     }