Fix test failures and workload/websocket behavior

backend/app/core/redis.py

@@ -1,12 +1,61 @@
+import logging
+import os
+import fnmatch
+from typing import Any, List, Tuple
+
 import redis
 from app.core.config import settings
 
-redis_client = redis.Redis(
-    host=settings.REDIS_HOST,
-    port=settings.REDIS_PORT,
-    db=settings.REDIS_DB,
-    decode_responses=True,
-)
+logger = logging.getLogger(__name__)
+
+
+class InMemoryRedis:
+    """Minimal in-memory Redis replacement for tests."""
+
+    def __init__(self):
+        self.store = {}
+
+    def get(self, key):
+        return self.store.get(key)
+
+    def set(self, key, value):
+        self.store[key] = value
+        return True
+
+    def setex(self, key, _seconds, value):
+        self.store[key] = value
+        return True
+
+    def delete(self, key):
+        if key in self.store:
+            del self.store[key]
+            return 1
+        return 0
+
+    def scan_iter(self, match=None):
+        if match is None:
+            yield from self.store.keys()
+            return
+        for key in list(self.store.keys()):
+            if fnmatch.fnmatch(key, match):
+                yield key
+
+    def publish(self, _channel, _message):
+        return 1
+
+    def ping(self):
+        return True
+
+
+if os.getenv("TESTING") == "true":
+    redis_client = InMemoryRedis()
+else:
+    redis_client = redis.Redis(
+        host=settings.REDIS_HOST,
+        port=settings.REDIS_PORT,
+        db=settings.REDIS_DB,
+        decode_responses=True,
+    )
 
 
 def get_redis():
@@ -17,3 +66,29 @@ def get_redis():
 def get_redis_sync():
     """Get Redis client synchronously (non-dependency use)."""
     return redis_client
+
+
+class RedisManager:
+    """Lightweight Redis helper with publish fallback for reliability tests."""
+
+    def __init__(self, client=None):
+        self._client = client
+        self._message_queue: List[Tuple[str, Any]] = []
+
+    def get_client(self):
+        return self._client or redis_client
+
+    def _publish_direct(self, channel: str, message: Any):
+        client = self.get_client()
+        return client.publish(channel, message)
+
+    def queue_message(self, channel: str, message: Any) -> None:
+        self._message_queue.append((channel, message))
+
+    def publish_with_fallback(self, channel: str, message: Any):
+        try:
+            return self._publish_direct(channel, message)
+        except Exception as exc:
+            self.queue_message(channel, message)
+            logger.warning("Redis publish failed, queued message: %s", exc)
+            return None