test: Add valkey-search integration test infrastructure (#5981)

* test: Add valkey-search integration test infrastructure

* fix: ignore valkey_search tests for CI

Author: vyavdoshenko

.gitignore

@@ -23,3 +23,6 @@ cmake-build-debug
 .venv/
 fuzz/artifacts/
 fuzz/corpus/
+
+# Valkey-search integration tests (synced from external repo)
+tests/dragonfly/valkey_search/integration/

tests/dragonfly/requirements.txt

@@ -29,3 +29,4 @@ fakeredis[json]==2.26.2
 hiredis==2.4.0
 PyYAML>=6.0
 testcontainers>=3.7.1
+valkey==6.0.2

tests/dragonfly/valkey_search/README.md

@@ -0,0 +1,59 @@
+# Valkey-Search Integration Tests for Dragonfly
+
+Integration tests from [valkey-search](https://github.com/valkey-io/valkey-search) project, adapted to run on Dragonfly without modifying the original test code.
+
+## Prerequisites
+
+1. Build Dragonfly
+
+2. Install Python dependencies:
+   ```bash
+   pip install -r tests/dragonfly/requirements.txt
+   ```
+
+## Setup
+
+1. Sync tests from valkey-search:
+   ```bash
+   cd tests/dragonfly/valkey_search
+   ./sync-valkey-search-tests.sh
+   ```
+
+2. Set environment variables:
+   ```bash
+   export DRAGONFLY_PATH="/path/to/dragonfly/build-dbg/dragonfly"
+   export ROOT_DIR="/path/to/dragonfly/tests/dragonfly/valkey_search"
+   ```
+
+## Running Tests
+
+```bash
+# All tests
+pytest tests/dragonfly/valkey_search/integration/ -v
+
+# Specific test file
+pytest tests/dragonfly/valkey_search/integration/test_ft_create.py -v
+
+# Specific test
+pytest tests/dragonfly/valkey_search/integration/test_ft_create.py::TestSearchFTCreateCMD::test_ft_create_fails_on_replica_cmd -v
+```
+
+## Structure
+
+```
+tests/dragonfly/valkey_search/
+ __init__.py                          # Mock framework for valkey-search imports
+ conftest.py                          # Pytest configuration
+ util.py                              # Utility functions (waiters)
+ valkey_search_test_case_dragonfly.py # Dragonfly adapter (real replicas, clusters)
+ sync-valkey-search-tests.sh          # Script to sync tests
+ integration/                         # Synced from valkey-search (not in git)
+```
+
+## How It Works
+
+1. **Infrastructure files** (committed to git) provide compatibility layer
+2. **Test files** (in `integration/`, not in git) are synced from valkey-search
+3. **Mock framework** (`__init__.py`) replaces valkey-search imports with Dragonfly equivalents
+4. **Adapter** (`valkey_search_test_case_dragonfly.py`) creates real Dragonfly instances with replicas
+5. **Original tests run unchanged** - all adaptation happens in infrastructure layer

tests/dragonfly/valkey_search/__init__.py

@@ -0,0 +1,70 @@
+"""
+Valkey-search integration tests for Dragonfly
+
+This module automatically adapts original valkey-search tests to run on Dragonfly
+by replacing valkeytestframework imports with Dragonfly equivalents.
+"""
+
+import sys
+import types
+import os
+from . import util
+from .integration import compatibility
+
+# Add current directory to path for imports
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import the Dragonfly-specific test case classes
+exec(open(os.path.join(current_dir, "valkey_search_test_case_dragonfly.py")).read())
+
+# Create a mock module for valkey_search_test_case
+mock_module = types.ModuleType("valkey_search_test_case")
+mock_module.ValkeySearchTestCaseBase = ValkeySearchTestCaseBase
+mock_module.ValkeySearchTestCaseDebugMode = ValkeySearchTestCaseDebugMode
+mock_module.ValkeySearchClusterTestCase = ValkeySearchClusterTestCase
+mock_module.ValkeySearchClusterTestCaseDebugMode = ValkeySearchClusterTestCaseDebugMode
+mock_module.Node = Node
+mock_module.ReplicationGroup = ReplicationGroup
+
+# Replace the module in sys.modules
+sys.modules["valkey_search_test_case"] = mock_module
+
+# Also need to provide valkeytestframework modules
+valkey_test_framework = types.ModuleType("valkeytestframework")
+
+valkey_test_case = types.ModuleType("valkeytestframework.valkey_test_case")
+valkey_test_case.ValkeyTestCase = ValkeyTestCase
+valkey_test_case.ReplicationTestCase = ReplicationTestCase
+valkey_test_case.ValkeyServerHandle = ValkeyServerHandle
+
+util_module = types.ModuleType("valkeytestframework.util")
+waiters_module = types.ModuleType("valkeytestframework.util.waiters")
+
+waiters_module.wait_for_true = util.waiters.wait_for_true
+waiters_module.wait_for_equal = util.waiters.wait_for_equal
+waiters_module.wait_for_not_equal = util.waiters.wait_for_not_equal
+waiters_module.wait_for_condition = util.waiters.wait_for_condition
+util_module.waiters = waiters_module
+
+# Also add direct util module access
+sys.modules["util"] = util_module
+sys.modules["util.waiters"] = waiters_module
+
+conftest_module = types.ModuleType("valkeytestframework.conftest")
+conftest_module.resource_port_tracker = types.ModuleType("resource_port_tracker")
+
+# Setup compatibility as a module in sys.modules
+sys.modules["compatibility"] = compatibility
+
+# Also set up the submodules
+if hasattr(compatibility, "data_sets"):
+    sys.modules["compatibility.data_sets"] = compatibility.data_sets
+
+# Add all modules to sys.modules
+sys.modules["valkeytestframework"] = valkey_test_framework
+sys.modules["valkeytestframework.valkey_test_case"] = valkey_test_case
+sys.modules["valkeytestframework.util"] = util_module
+sys.modules["valkeytestframework.util.waiters"] = waiters_module
+sys.modules["valkeytestframework.conftest"] = conftest_module

tests/dragonfly/valkey_search/conftest.py

@@ -0,0 +1,15 @@
+"""
+Pytest configuration for valkey-search tests on Dragonfly
+"""
+
+from .. import dfly_args
+
+
+# Apply dfly_args to all test classes in this directory
+def pytest_collection_modifyitems(items):
+    """Apply dfly_args decorator to all test classes"""
+    for item in items:
+        if item.cls and not hasattr(item.cls, "_dfly_args_applied"):
+            # Apply the decorator to the class
+            decorated_class = dfly_args({"proactor_threads": 4})(item.cls)
+            item.cls._dfly_args_applied = True

tests/dragonfly/valkey_search/sync-valkey-search-tests.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+INTEGRATION_DIR="$SCRIPT_DIR/integration"
+VALKEY_SEARCH_REPO="https://github.com/valkey-io/valkey-search.git"
+TEMP_DIR=$(mktemp -d)
+
+echo "Syncing valkey-search tests..."
+
+# Remove old integration directory
+rm -rf "$INTEGRATION_DIR"
+
+# Clone to temp directory
+git clone --depth=1 "$VALKEY_SEARCH_REPO" "$TEMP_DIR" >/dev/null 2>&1
+
+# Copy integration directory
+cp -r "$TEMP_DIR/integration" "$INTEGRATION_DIR"
+
+# Cleanup
+rm -rf "$TEMP_DIR"
+
+echo "Done. Synced $(find "$INTEGRATION_DIR" -name '*test*.py' | wc -l) test files."

tests/dragonfly/valkey_search/util.py

@@ -0,0 +1,99 @@
+"""
+Utility module for valkey-search tests running on Dragonfly
+Provides waiters functionality compatible with valkeytestframework.util.waiters
+"""
+
+import time
+
+
+class waiters:
+    """Waiters utility class for test synchronization"""
+
+    @staticmethod
+    def wait_for_true(func, timeout=30, interval=0.1):
+        """
+        Wait for a function to return True
+
+        Args:
+            func: Function to call repeatedly until it returns True
+            timeout: Maximum time to wait in seconds (default: 30)
+            interval: Time between checks in seconds (default: 0.1)
+
+        Returns:
+            True if function returned True within timeout, False otherwise
+        """
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                if func():
+                    return True
+            except Exception:
+                # Ignore exceptions during polling
+                pass
+            time.sleep(interval)
+        return False
+
+    @staticmethod
+    def wait_for_equal(func, value, timeout=30, interval=0.1):
+        """
+        Wait for a function to return a specific value
+
+        Args:
+            func: Function to call repeatedly
+            value: Expected return value
+            timeout: Maximum time to wait in seconds (default: 30)
+            interval: Time between checks in seconds (default: 0.1)
+
+        Returns:
+            True if function returned expected value within timeout, False otherwise
+        """
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                if func() == value:
+                    return True
+            except Exception:
+                # Ignore exceptions during polling
+                pass
+            time.sleep(interval)
+        return False
+
+    @staticmethod
+    def wait_for_not_equal(func, value, timeout=30, interval=0.1):
+        """
+        Wait for a function to return a value different from the specified one
+
+        Args:
+            func: Function to call repeatedly
+            value: Value that should NOT be returned
+            timeout: Maximum time to wait in seconds (default: 30)
+            interval: Time between checks in seconds (default: 0.1)
+
+        Returns:
+            True if function returned different value within timeout, False otherwise
+        """
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            try:
+                if func() != value:
+                    return True
+            except Exception:
+                # Ignore exceptions during polling
+                pass
+            time.sleep(interval)
+        return False
+
+    @staticmethod
+    def wait_for_condition(condition_func, timeout=30, interval=0.1):
+        """
+        Wait for a condition function to return True
+        Alias for wait_for_true for compatibility
+        """
+        return waiters.wait_for_true(condition_func, timeout, interval)
+
+
+# For backward compatibility with direct import style
+wait_for_true = waiters.wait_for_true
+wait_for_equal = waiters.wait_for_equal
+wait_for_not_equal = waiters.wait_for_not_equal
+wait_for_condition = waiters.wait_for_condition