Add comprehensive test scripts for thumbnail generation and xAI collections API

- Implemented `test_thumbnail_generation.py` to validate the complete flow of document thumbnail generation in EspoCRM, including document creation, file upload, webhook triggering, and preview verification.
- Created `test_xai_collections_api.py` to test critical operations of the xAI Collections API, covering file uploads, collection CRUD operations, document management, and response validation.
- Both scripts include detailed logging for success and error states, ensuring robust testing and easier debugging.

services/document_sync_utils.py

@@ -11,14 +11,11 @@ Hilfsfunktionen für Document-Synchronisation mit xAI:
 from typing import Dict, Any, Optional, List, Tuple
 from datetime import datetime, timedelta
 import logging
-import redis
-import os
+
+from services.sync_utils_base import BaseSyncUtils
 
 logger = logging.getLogger(__name__)
 
-# Lock TTL in seconds (prevents deadlocks)
-LOCK_TTL_SECONDS = 900  # 15 minutes
-
 # Max retry before permanent failure
 MAX_SYNC_RETRIES = 5
 
@@ -26,40 +23,12 @@ MAX_SYNC_RETRIES = 5
 RETRY_BACKOFF_MINUTES = [1, 5, 15, 60, 240]  # 1min, 5min, 15min, 1h, 4h
 
 
-class DocumentSync:
+class DocumentSync(BaseSyncUtils):
     """Utility-Klasse für Document-Synchronisation mit xAI"""
     
-    def __init__(self, espocrm_api, redis_client: redis.Redis = None, context=None):
-        self.espocrm = espocrm_api
-        self.context = context
-        self.logger = context.logger if context else logger
-        self.redis = redis_client or self._init_redis()
-    
-    def _init_redis(self) -> redis.Redis:
-        """Initialize Redis client for distributed locking"""
-        try:
-            redis_host = os.getenv('REDIS_HOST', 'localhost')
-            redis_port = int(os.getenv('REDIS_PORT', '6379'))
-            redis_db = int(os.getenv('REDIS_DB_ADVOWARE_CACHE', '1'))
-            
-            client = redis.Redis(
-                host=redis_host,
-                port=redis_port,
-                db=redis_db,
-                decode_responses=True
-            )
-            client.ping()
-            return client
-        except Exception as e:
-            self._log(f"Redis connection failed: {e}", level='error')
-            return None
-    
-    def _log(self, message: str, level: str = 'info'):
-        """Logging mit Context-Support"""
-        if self.context and hasattr(self.context, 'logger'):
-            getattr(self.context.logger, level)(message)
-        else:
-            getattr(logger, level)(message)
+    def _get_lock_key(self, entity_id: str) -> str:
+        """Redis Lock-Key für Documents"""
+        return f"sync_lock:document:{entity_id}"
     
     async def acquire_sync_lock(self, entity_id: str, entity_type: str = 'CDokumente') -> bool:
         """
@@ -74,13 +43,10 @@ class DocumentSync:
         """
         try:
             # STEP 1: Atomic Redis lock (prevents race conditions)
-            if self.redis:
-                lock_key = f"sync_lock:document:{entity_id}"
-                acquired = self.redis.set(lock_key, "locked", nx=True, ex=LOCK_TTL_SECONDS)
-                
-                if not acquired:
-                    self._log(f"Redis lock bereits aktiv für {entity_type} {entity_id}", level='warn')
-                    return False
+            lock_key = self._get_lock_key(entity_id)
+            if not self._acquire_redis_lock(lock_key):
+                self._log(f"Redis lock bereits aktiv für {entity_type} {entity_id}", level='warn')
+                return False
             
             # STEP 2: Update syncStatus (für UI visibility) - nur bei Document Entity
             # CDokumente hat dieses Feld nicht - überspringen
@@ -98,12 +64,8 @@ class DocumentSync:
         except Exception as e:
             self._log(f"Fehler beim Acquire Lock: {e}", level='error')
             # Clean up Redis lock on error
-            if self.redis:
-                try:
-                    lock_key = f"sync_lock:document:{entity_id}"
-                    self.redis.delete(lock_key)
-                except:
-                    pass
+            lock_key = self._get_lock_key(entity_id)
+            self._release_redis_lock(lock_key)
             return False
     
     async def release_sync_lock(
@@ -149,19 +111,14 @@ class DocumentSync:
             self._log(f"Sync-Lock released: {entity_type} {entity_id} → {'success' if success else 'failed'}")
             
             # Release Redis lock
-            if self.redis:
-                lock_key = f"sync_lock:document:{entity_id}"
-                self.redis.delete(lock_key)
+            lock_key = self._get_lock_key(entity_id)
+            self._release_redis_lock(lock_key)
             
         except Exception as e:
             self._log(f"Fehler beim Release Lock: {e}", level='error')
             # Ensure Redis lock is released even on error
-            if self.redis:
-                try:
-                    lock_key = f"sync_lock:document:{entity_id}"
-                    self.redis.delete(lock_key)
-                except:
-                    pass
+            lock_key = self._get_lock_key(entity_id)
+            self._release_redis_lock(lock_key)
     
     async def should_sync_to_xai(self, document: Dict[str, Any]) -> Tuple[bool, List[str], str]:
         """