refactor: Replace try/except cleanup pattern with proper pytest fixtures

Remove broad 'except Exception: pass' blocks in test cleanup that were
hiding real failures. Instead:

- test_stopwords_integration.py: Created pytest fixtures for each index
  type (stopwords_disabled_index, custom_stopwords_index,
  default_stopwords_index) that handle cleanup automatically

- test_field_modifier_ordering_integration.py: Removed try/finally/except
  blocks and replaced with direct cleanup calls that will fail if there's
  a real problem (connection issues, permissions, etc.)

This matches the pattern used in most other integration tests and ensures
that cleanup failures are visible rather than silently ignored.

Author: nkanu17

tests/integration/test_stopwords_integration.py

@@ -54,196 +54,140 @@ def default_stopwords_schema():
     }
 
 
-def test_create_index_with_stopwords_disabled(client, stopwords_disabled_schema):
-    """Test creating an index with STOPWORDS 0."""
+@pytest.fixture
+def stopwords_disabled_index(client, stopwords_disabled_schema):
+    """Index fixture with stopwords disabled."""
     schema = IndexSchema.from_dict(stopwords_disabled_schema)
     index = SearchIndex(schema, redis_client=client)
+    index.create(overwrite=True, drop=True)
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
-
-        # Verify index was created
-        assert index.exists()
+    yield index
 
-        # Get FT.INFO and verify stopwords_list is empty
-        info = client.ft(index.name).info()
-        assert "stopwords_list" in info
-        assert info["stopwords_list"] == []
+    index.delete(drop=True)
 
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
 
-
-def test_create_index_with_custom_stopwords(client, custom_stopwords_schema):
-    """Test creating an index with custom stopwords list."""
+@pytest.fixture
+def custom_stopwords_index(client, custom_stopwords_schema):
+    """Index fixture with custom stopwords."""
     schema = IndexSchema.from_dict(custom_stopwords_schema)
     index = SearchIndex(schema, redis_client=client)
+    index.create(overwrite=True, drop=True)
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
-
-        # Verify index was created
-        assert index.exists()
-
-        # Get FT.INFO and verify stopwords_list matches
-        info = client.ft(index.name).info()
-        assert "stopwords_list" in info
-
-        # Convert bytes to strings for comparison
-        stopwords_list = [
-            sw.decode("utf-8") if isinstance(sw, bytes) else sw
-            for sw in info["stopwords_list"]
-        ]
-        assert set(stopwords_list) == {"the", "a", "an"}
+    yield index
 
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
+    index.delete(drop=True)
 
 
-def test_create_index_with_default_stopwords(client, default_stopwords_schema):
-    """Test creating an index with default stopwords (no STOPWORDS clause)."""
+@pytest.fixture
+def default_stopwords_index(client, default_stopwords_schema):
+    """Index fixture with default stopwords."""
     schema = IndexSchema.from_dict(default_stopwords_schema)
     index = SearchIndex(schema, redis_client=client)
+    index.create(overwrite=True, drop=True)
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
+    yield index
 
-        # Verify index was created
-        assert index.exists()
+    index.delete(drop=True)
 
-        # When no STOPWORDS clause is used, Redis doesn't include stopwords_list in FT.INFO
-        # (or it may include the default list depending on Redis version)
-        # We just verify the index was created successfully with default behavior
-
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
 
+def test_create_index_with_stopwords_disabled(client, stopwords_disabled_index):
+    """Test creating an index with STOPWORDS 0."""
+    # Verify index was created
+    assert stopwords_disabled_index.exists()
 
-def test_from_existing_preserves_stopwords_disabled(client, stopwords_disabled_schema):
-    """Test that from_existing() correctly reconstructs stopwords=[] configuration."""
-    schema = IndexSchema.from_dict(stopwords_disabled_schema)
-    index = SearchIndex(schema, redis_client=client)
+    # Get FT.INFO and verify stopwords_list is empty
+    info = client.ft(stopwords_disabled_index.name).info()
+    assert "stopwords_list" in info
+    assert info["stopwords_list"] == []
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
 
-        # Reconstruct from existing
-        reconstructed_index = SearchIndex.from_existing(index.name, redis_client=client)
+def test_create_index_with_custom_stopwords(client, custom_stopwords_index):
+    """Test creating an index with custom stopwords list."""
+    # Verify index was created
+    assert custom_stopwords_index.exists()
 
-        # Verify stopwords configuration was preserved
-        assert reconstructed_index.schema.index.stopwords == []
+    # Get FT.INFO and verify stopwords_list matches
+    info = client.ft(custom_stopwords_index.name).info()
+    assert "stopwords_list" in info
 
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
+    # Convert bytes to strings for comparison
+    stopwords_list = [
+        sw.decode("utf-8") if isinstance(sw, bytes) else sw
+        for sw in info["stopwords_list"]
+    ]
+    assert set(stopwords_list) == {"the", "a", "an"}
 
 
-def test_from_existing_preserves_custom_stopwords(client, custom_stopwords_schema):
-    """Test that from_existing() correctly reconstructs custom stopwords configuration."""
-    schema = IndexSchema.from_dict(custom_stopwords_schema)
-    index = SearchIndex(schema, redis_client=client)
+def test_create_index_with_default_stopwords(default_stopwords_index):
+    """Test creating an index with default stopwords (no STOPWORDS clause)."""
+    # Verify index was created
+    assert default_stopwords_index.exists()
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
+    # When no STOPWORDS clause is used, Redis doesn't include stopwords_list in FT.INFO
+    # (or it may include the default list depending on Redis version)
+    # We just verify the index was created successfully with default behavior
 
-        # Reconstruct from existing
-        reconstructed_index = SearchIndex.from_existing(index.name, redis_client=client)
 
-        # Verify stopwords configuration was preserved
-        assert set(reconstructed_index.schema.index.stopwords) == {"the", "a", "an"}
+def test_from_existing_preserves_stopwords_disabled(client, stopwords_disabled_index):
+    """Test that from_existing() correctly reconstructs stopwords=[] configuration."""
+    # Reconstruct from existing
+    reconstructed_index = SearchIndex.from_existing(
+        stopwords_disabled_index.name, redis_client=client
+    )
 
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
+    # Verify stopwords configuration was preserved
+    assert reconstructed_index.schema.index.stopwords == []
 
 
-def test_from_existing_default_stopwords(client, default_stopwords_schema):
-    """Test that from_existing() handles default stopwords (no stopwords_list in FT.INFO)."""
-    schema = IndexSchema.from_dict(default_stopwords_schema)
-    index = SearchIndex(schema, redis_client=client)
+def test_from_existing_preserves_custom_stopwords(client, custom_stopwords_index):
+    """Test that from_existing() correctly reconstructs custom stopwords configuration."""
+    # Reconstruct from existing
+    reconstructed_index = SearchIndex.from_existing(
+        custom_stopwords_index.name, redis_client=client
+    )
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
+    # Verify stopwords configuration was preserved
+    assert set(reconstructed_index.schema.index.stopwords) == {"the", "a", "an"}
 
-        # Reconstruct from existing
-        reconstructed_index = SearchIndex.from_existing(index.name, redis_client=client)
 
-        # Verify stopwords is None (default behavior)
-        assert reconstructed_index.schema.index.stopwords is None
+def test_from_existing_default_stopwords(client, default_stopwords_index):
+    """Test that from_existing() handles default stopwords (no stopwords_list in FT.INFO)."""
+    # Reconstruct from existing
+    reconstructed_index = SearchIndex.from_existing(
+        default_stopwords_index.name, redis_client=client
+    )
 
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
+    # Verify stopwords is None (default behavior)
+    assert reconstructed_index.schema.index.stopwords is None
 
 
 def test_stopwords_disabled_allows_searching_common_words(
-    client, stopwords_disabled_schema
+    client, stopwords_disabled_index
 ):
     """Test that STOPWORDS 0 allows searching for common stopwords like 'the', 'a', 'of'."""
-    schema = IndexSchema.from_dict(stopwords_disabled_schema)
-    index = SearchIndex(schema, redis_client=client)
+    # Add test data with common stopwords
+    test_data = [
+        {"title": "Bank of America", "description": "A major bank"},
+        {"title": "The Great Gatsby", "description": "A classic novel"},
+        {
+            "title": "An Introduction to Python",
+            "description": "A programming guide",
+        },
+    ]
+
+    for i, data in enumerate(test_data):
+        key = f"test_sw_disabled:{i}"
+        client.hset(key, mapping=data)
+
+    # Search for "of" - should find "Bank of America"
+    from redisvl.query import FilterQuery
+
+    query = FilterQuery(
+        filter_expression="@title:(of)",
+        return_fields=["title"],
+    )
+    results = stopwords_disabled_index.search(query.query, query_params=query.params)
 
-    try:
-        # Create the index
-        index.create(overwrite=True, drop=True)
-
-        # Add test data with common stopwords
-        test_data = [
-            {"title": "Bank of America", "description": "A major bank"},
-            {"title": "The Great Gatsby", "description": "A classic novel"},
-            {
-                "title": "An Introduction to Python",
-                "description": "A programming guide",
-            },
-        ]
-
-        for i, data in enumerate(test_data):
-            key = f"test_sw_disabled:{i}"
-            client.hset(key, mapping=data)
-
-        # Search for "of" - should find "Bank of America"
-        from redisvl.query import FilterQuery
-
-        query = FilterQuery(
-            filter_expression="@title:(of)",
-            return_fields=["title"],
-        )
-        results = index.search(query.query, query_params=query.params)
-
-        # With STOPWORDS 0, "of" should be indexed and searchable
-        assert len(results.docs) > 0
-        assert any("of" in doc.title.lower() for doc in results.docs)
-
-    finally:
-        try:
-            index.delete(drop=True)
-        except Exception:
-            # Silently ignore cleanup errors (e.g., index already deleted or never created)
-            pass
+    # With STOPWORDS 0, "of" should be indexed and searchable
+    assert len(results.docs) > 0
+    assert any("of" in doc.title.lower() for doc in results.docs)