feat: Add comprehensive unit testing template and documentation

- Add test_dialog_service_template.py with 17/17 passing tests
- Implement correct testing pattern: test real services, mock only dependencies
- Add comprehensive documentation (Quick Start, Strategy Guide, Summary)
- Align with owner feedback: test actual business logic, not mocks
- Ready-to-use template for refactoring other service tests

test/unit_test/services/test_dialog_service_actual.py

@@ -0,0 +1,370 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+"""
+Test DialogService and its actual business logic functions.
+
+This tests the real business logic that exists in the codebase:
+1. Database operations in DialogService (CRUD)
+2. Business logic functions like meta_filter, repair_bad_citation_formats
+3. Query building and data transformation logic
+"""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+import sys
+import os
+
+# Mock external dependencies before importing
+sys.modules['nltk'] = MagicMock()
+sys.modules['nltk.tokenize'] = MagicMock()
+sys.modules['nltk.corpus'] = MagicMock()
+sys.modules['nltk.stem'] = MagicMock()
+sys.modules['tiktoken'] = MagicMock()
+sys.modules['transformers'] = MagicMock()
+sys.modules['torch'] = MagicMock()
+sys.modules['agentic_reasoning'] = MagicMock()
+sys.modules['langfuse'] = MagicMock()
+sys.modules['trio'] = MagicMock()
+
+# Mock database connection
+mock_db = MagicMock()
+mock_db.connect = Mock()
+mock_db.close = Mock()
+mock_db.execute_sql = Mock()
+mock_db.atomic = Mock()
+mock_db.transaction = Mock()
+mock_db.connection_context = Mock()
+# Make atomic and connection_context work as context managers
+mock_db.atomic.return_value.__enter__ = Mock(return_value=None)
+mock_db.atomic.return_value.__exit__ = Mock(return_value=None)
+mock_db.connection_context.return_value.__enter__ = Mock(return_value=None)
+mock_db.connection_context.return_value.__exit__ = Mock(return_value=None)
+
+with patch('api.db.db_models.DB', mock_db):
+    from api.db.services.dialog_service import DialogService, meta_filter, repair_bad_citation_formats, convert_conditions
+    from api.db.db_models import Dialog
+    from common.constants import StatusEnum
+
+
+class TestDialogServiceActual:
+    """Test the actual DialogService business logic"""
+
+    @pytest.fixture(autouse=True)
+    def setup_mocks(self):
+        """Setup database mocks"""
+        with patch('api.db.db_models.Dialog') as mock_dialog_model:
+            mock_dialog_instance = MagicMock()
+            mock_dialog_instance.id = "test_id"
+            mock_dialog_instance.save = Mock(return_value=mock_dialog_instance)
+            
+            mock_dialog_model.get = Mock(return_value=mock_dialog_instance)
+            mock_dialog_model.select = Mock()
+            mock_dialog_model.update = Mock()
+            mock_dialog_model.delete = Mock()
+            mock_dialog_model.where = Mock(return_value=mock_dialog_model)
+            mock_dialog_model.order_by = Mock(return_value=mock_dialog_model)
+            mock_dialog_model.limit = Mock(return_value=mock_dialog_model)
+            mock_dialog_model.paginate = Mock(return_value=[mock_dialog_instance])
+            mock_dialog_model.dicts = Mock(return_value=[mock_dialog_instance])
+            mock_dialog_model.count = Mock(return_value=1)
+            mock_dialog_model.first = Mock(return_value=mock_dialog_instance)
+            mock_dialog_model.execute = Mock(return_value=1)
+            
+            DialogService.model = mock_dialog_model
+            yield mock_dialog_model
+
+    def test_dialog_service_save_method(self, setup_mocks):
+        """Test the actual save method - just database operation"""
+        dialog_data = {
+            "name": "Test Dialog",
+            "tenant_id": "tenant_123",
+            "status": StatusEnum.VALID.value
+        }
+        
+        # The actual save method calls cls.model(**kwargs).save()
+        result = DialogService.save(**dialog_data)
+        
+        # Verify it instantiated the model with the correct data
+        setup_mocks.assert_called_once_with(**dialog_data)
+        # Verify save was called on the instance
+        setup_mocks.return_value.save.assert_called_once_with(force_insert=True)
+        assert result is not None
+
+    def test_dialog_service_get_list_with_filters(self, setup_mocks):
+        """Test get_list method with actual query building logic"""
+        tenant_id = "tenant_123"
+        page_number = 1
+        items_per_page = 10
+        orderby = "create_time"
+        desc = True
+        dialog_id = "test_id"
+        name = "Test Dialog"
+        
+        # Mock the query chain
+        mock_query = MagicMock()
+        mock_query.where.return_value = mock_query
+        mock_query.order_by.return_value = mock_query
+        mock_query.paginate.return_value = [MagicMock()]
+        mock_query.dicts.return_value = [MagicMock()]
+        setup_mocks.select.return_value = mock_query
+        
+        # Call the actual method
+        result = DialogService.get_list(tenant_id, page_number, items_per_page, orderby, desc, dialog_id, name)
+        
+        # Verify query building logic
+        setup_mocks.select.assert_called_once()
+        # Should filter by tenant_id and status
+        assert mock_query.where.call_count >= 1
+        # Should apply ordering
+        mock_query.order_by.assert_called_once()
+        # Should apply pagination
+        mock_query.paginate.assert_called_once_with(page_number, items_per_page)
+
+    def test_dialog_service_update_many_by_id(self, setup_mocks):
+        """Test update_many_by_id method with timestamp logic"""
+        data_list = [
+            {"id": "1", "name": "Updated Dialog 1"},
+            {"id": "2", "name": "Updated Dialog 2"}
+        ]
+        
+        # Mock the update query chain
+        mock_query = MagicMock()
+        mock_query.where.return_value = mock_query
+        mock_query.execute.return_value = 1
+        setup_mocks.update.return_value = mock_query
+        
+        # Call the actual method
+        DialogService.update_many_by_id(data_list)
+        
+        # Verify it was called with timestamp updates
+        assert setup_mocks.update.call_count == 2
+        # Verify atomic transaction was used
+        mock_db.atomic.assert_called_once()
+
+    def test_meta_filter_function_and_logic(self):
+        """Test the actual meta_filter business logic function"""
+        # Test data: metadata values to document IDs mapping
+        metas = {
+            "category": {
+                "technology": ["doc1", "doc2", "doc3"],
+                "business": ["doc2", "doc4"],
+                "science": ["doc5"]
+            },
+            "status": {
+                "published": ["doc1", "doc3", "doc5"],
+                "draft": ["doc2", "doc4"]
+            }
+        }
+        
+        # Test filters
+        filters = [
+            {"key": "category", "op": "=", "value": "technology"},
+            {"key": "status", "op": "=", "value": "published"}
+        ]
+        
+        # Test AND logic (intersection)
+        result_and = meta_filter(metas, filters, logic="and")
+        expected_and = ["doc1", "doc3"]  # docs that are both technology AND published
+        assert sorted(result_and) == sorted(expected_and)
+        
+        # Test OR logic (union)
+        result_or = meta_filter(metas, filters, logic="or")
+        expected_or = ["doc1", "doc2", "doc3", "doc5"]  # docs that are technology OR published
+        assert sorted(result_or) == sorted(expected_or)
+
+    def test_meta_filter_operators(self):
+        """Test various filter operators in meta_filter"""
+        metas = {
+            "price": {
+                "10.99": ["doc1"],
+                "25.50": ["doc2"],
+                "100.00": ["doc3"]
+            },
+            "name": {
+                "Apple iPhone": ["doc1"],
+                "Samsung Galaxy": ["doc2"],
+                "Google Pixel": ["doc3"]
+            }
+        }
+        
+        # Test greater than operator
+        filters = [{"key": "price", "op": ">", "value": "20"}]
+        result = meta_filter(metas, filters, logic="and")
+        expected = ["doc2", "doc3"]  # price > 20
+        assert sorted(result) == sorted(expected)
+        
+        # Test contains operator
+        filters = [{"key": "name", "op": "contains", "value": "Galaxy"}]
+        result = meta_filter(metas, filters, logic="and")
+        expected = ["doc2"]
+        assert result == expected
+        
+        # Test empty operator
+        metas_with_empty = {
+            "description": {
+                "": ["doc1", "doc3"],  # empty descriptions
+                "Some description": ["doc2"]
+            }
+        }
+        filters = [{"key": "description", "op": "empty", "value": ""}]
+        result = meta_filter(metas_with_empty, filters, logic="and")
+        expected = ["doc1", "doc3"]
+        assert sorted(result) == sorted(expected)
+
+    def test_repair_bad_citation_formats(self):
+        """Test the actual citation format repair function"""
+        # Test knowledge base info
+        kbinfos = {
+            "chunks": [
+                {"doc_id": "doc1", "content": "Content 1"},
+                {"doc_id": "doc2", "content": "Content 2"},
+                {"doc_id": "doc3", "content": "Content 3"}
+            ]
+        }
+        
+        # Test various bad citation formats
+        test_cases = [
+            ("According to research (ID: 1), this is important.", {1}),
+            ("The study shows [ID: 2] that this works.", {2}),
+            ("Results from 【ID: 3】 are significant.", {3}),
+            ("Reference ref1 shows the method.", {1}),
+            ("Multiple citations (ID: 1) and [ID: 2] appear.", {1, 2}),
+        ]
+        
+        for answer, expected_indices in test_cases:
+            idx = set()
+            repaired_answer, final_idx = repair_bad_citation_formats(answer, kbinfos, idx)
+            # Should extract the correct document indices
+            assert len(final_idx) > 0
+            assert final_idx == expected_indices
+            # Should repair the format to use [ID:x] format
+            assert "[ID:" in repaired_answer
+
+    def test_repair_bad_citation_formats_bounds_checking(self):
+        """Test citation repair handles out-of-bounds references"""
+        kbinfos = {
+            "chunks": [
+                {"doc_id": "doc1", "content": "Content 1"},
+                {"doc_id": "doc2", "content": "Content 2"}
+            ]
+        }
+        
+        # Test out-of-bounds citation
+        answer = "This references (ID: 999) which doesn't exist."
+        idx = set()
+        repaired_answer, final_idx = repair_bad_citation_formats(answer, kbinfos, idx)
+        
+        # Should not add invalid ID
+        assert 999 not in [i for i in range(len(kbinfos["chunks"]))]
+        # Should handle gracefully without crashing
+        assert isinstance(repaired_answer, str)
+
+    def test_convert_conditions_function(self):
+        """Test the convert_conditions business logic"""
+        # Test metadata condition structure
+        metadata_condition = {
+            "conditions": [
+                {
+                    "name": "category",
+                    "comparison_operator": "is",
+                    "value": "technology"
+                },
+                {
+                    "name": "status", 
+                    "comparison_operator": "not is",
+                    "value": "draft"
+                }
+            ]
+        }
+        
+        result = convert_conditions(metadata_condition)
+        
+        expected = [
+            {"op": "=", "key": "category", "value": "technology"},
+            {"op": "≠", "key": "status", "value": "draft"}
+        ]
+        
+        assert result == expected
+
+    def test_convert_conditions_empty_input(self):
+        """Test convert_conditions handles None/empty input"""
+        # Test None input
+        result = convert_conditions(None)
+        assert result == []
+        
+        # Test empty conditions
+        metadata_condition = {"conditions": []}
+        result = convert_conditions(metadata_condition)
+        assert result == []
+
+    def test_dialog_service_get_by_tenant_ids_complex_query(self, setup_mocks):
+        """Test complex query building in get_by_tenant_ids"""
+        joined_tenant_ids = ["tenant1", "tenant2"]
+        user_id = "user123"
+        page_number = 1
+        items_per_page = 10
+        orderby = "create_time"
+        desc = False
+        keywords = "test"
+        
+        # Mock the complex query chain
+        mock_query = MagicMock()
+        mock_query.join.return_value = mock_query
+        mock_query.where.return_value = mock_query
+        mock_query.order_by.return_value = mock_query
+        mock_query.count.return_value = 5
+        mock_query.paginate.return_value = [MagicMock()]
+        mock_query.dicts.return_value = [MagicMock()]
+        setup_mocks.select.return_value = mock_query
+        
+        # Call the actual method
+        result, count = DialogService.get_by_tenant_ids(
+            joined_tenant_ids, user_id, page_number, items_per_page, 
+            orderby, desc, keywords
+        )
+        
+        # Verify complex query building
+        setup_mocks.select.assert_called_once()
+        mock_query.join.assert_called_once()  # Should join with User table
+        mock_query.where.assert_called()  # Should apply tenant and status filters
+        mock_query.order_by.assert_called_once()  # Should apply ordering
+        mock_query.count.assert_called_once()  # Should count total results
+        
+        # Should return tuple of (results, count)
+        assert isinstance(result, list)
+        assert isinstance(count, int)
+
+    def test_dialog_service_pagination_logic(self, setup_mocks):
+        """Test pagination logic in get_list"""
+        tenant_id = "tenant_123"
+        page_number = 2
+        items_per_page = 5
+        
+        # Mock pagination
+        mock_query = MagicMock()
+        mock_query.where.return_value = mock_query
+        mock_query.order_by.return_value = mock_query
+        mock_query.paginate.return_value = [MagicMock(), MagicMock()]
+        mock_query.dicts.return_value = [MagicMock(), MagicMock()]
+        setup_mocks.select.return_value = mock_query
+        
+        # Call with pagination
+        result = DialogService.get_list(tenant_id, page_number, items_per_page, "create_time", False, None, None)
+        
+        # Verify pagination was applied correctly
+        mock_query.paginate.assert_called_once_with(page_number, items_per_page)
+        assert len(result) == 2

test/unit_test/services/test_dialog_service_template.py

@@ -0,0 +1,425 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+"""
+Template for testing RAGFlow services following owner's feedback.
+
+This demonstrates the correct approach:
+1. Instantiate real service classes (don't mock them)
+2. Mock only external dependencies (database, APIs, file system)
+3. Test actual business logic that exists in the codebase
+
+Use this as a template for testing other services.
+"""
+
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+import sys
+
+# =============================================================================
+# STEP 1: Mock all heavy dependencies BEFORE any RAGFlow imports
+# =============================================================================
+sys.modules['nltk'] = MagicMock()
+sys.modules['nltk.tokenize'] = MagicMock()
+sys.modules['nltk.corpus'] = MagicMock()
+sys.modules['nltk.stem'] = MagicMock()
+sys.modules['tiktoken'] = MagicMock()
+sys.modules['transformers'] = MagicMock()
+sys.modules['torch'] = MagicMock()
+sys.modules['agentic_reasoning'] = MagicMock()
+sys.modules['langfuse'] = MagicMock()
+sys.modules['trio'] = MagicMock()
+
+# =============================================================================
+# STEP 2: Mock database connection with context manager support
+# =============================================================================
+mock_db = MagicMock()
+mock_db.connect = Mock()
+mock_db.close = Mock()
+mock_db.execute_sql = Mock()
+# Make atomic() work as context manager
+mock_db.atomic.return_value.__enter__ = Mock(return_value=None)
+mock_db.atomic.return_value.__exit__ = Mock(return_value=None)
+# Make connection_context() work as context manager
+mock_db.connection_context.return_value.__enter__ = Mock(return_value=None)
+mock_db.connection_context.return_value.__exit__ = Mock(return_value=None)
+
+# =============================================================================
+# STEP 3: Import RAGFlow modules with mocked dependencies
+# =============================================================================
+with patch('api.db.db_models.DB', mock_db):
+    from api.db.services.dialog_service import (
+        DialogService,
+        meta_filter,
+        repair_bad_citation_formats,
+        convert_conditions
+    )
+    from api.db.db_models import Dialog
+    from common.constants import StatusEnum
+
+
+# =============================================================================
+# STEP 4: Write test class
+# =============================================================================
+class TestDialogServiceTemplate:
+    """
+    Template test class demonstrating correct testing approach.
+    
+    Key principles:
+    - Test real service instance (DialogService)
+    - Mock only database model (Dialog)
+    - Test actual business logic functions directly
+    """
+
+    @pytest.fixture(autouse=True)
+    def setup_database_mocks(self):
+        """
+        Setup database mocks for all tests.
+        
+        This mocks the Dialog model to avoid actual database operations
+        while allowing us to test the service's business logic.
+        """
+        with patch('api.db.db_models.Dialog') as mock_dialog_model:
+            # Create a mock instance that will be returned by the model
+            mock_dialog_instance = MagicMock()
+            mock_dialog_instance.id = "test_dialog_id"
+            mock_dialog_instance.name = "Test Dialog"
+            mock_dialog_instance.save = Mock(return_value=mock_dialog_instance)
+            
+            # Setup model class methods
+            mock_dialog_model.return_value = mock_dialog_instance
+            mock_dialog_model.get = Mock(return_value=mock_dialog_instance)
+            mock_dialog_model.select = Mock()
+            mock_dialog_model.update = Mock()
+            mock_dialog_model.delete = Mock()
+            
+            # Replace the service's model with our mock
+            DialogService.model = mock_dialog_model
+            
+            yield mock_dialog_model
+
+    # =========================================================================
+    # Test Service Methods (Database Operations)
+    # =========================================================================
+
+    def test_save_method_calls_database_correctly(self, setup_database_mocks):
+        """
+        Test that save() method correctly calls the database.
+        
+        The actual implementation is:
+            sample_obj = cls.model(**kwargs).save(force_insert=True)
+        
+        We verify:
+        1. Model is instantiated with correct parameters
+        2. save() is called with force_insert=True
+        """
+        # Arrange
+        dialog_data = {
+            "name": "Test Dialog",
+            "tenant_id": "tenant_123",
+            "status": StatusEnum.VALID.value
+        }
+        
+        # Act
+        result = DialogService.save(**dialog_data)
+        
+        # Assert
+        setup_database_mocks.assert_called_once_with(**dialog_data)
+        setup_database_mocks.return_value.save.assert_called_once_with(force_insert=True)
+        assert result is not None
+
+    def test_update_many_by_id_uses_atomic_transaction(self, setup_database_mocks):
+        """
+        Test that update_many_by_id() uses atomic transaction.
+        
+        The actual implementation uses:
+            with DB.atomic():
+                for data in data_list:
+                    # update with timestamps
+        
+        We verify the atomic transaction is used.
+        """
+        # Arrange
+        data_list = [
+            {"id": "1", "name": "Updated 1"},
+            {"id": "2", "name": "Updated 2"}
+        ]
+        
+        # Mock the update chain
+        mock_query = MagicMock()
+        mock_query.where.return_value = mock_query
+        mock_query.execute.return_value = 1
+        setup_database_mocks.update.return_value = mock_query
+        
+        # Act
+        DialogService.update_many_by_id(data_list)
+        
+        # Assert
+        assert setup_database_mocks.update.call_count == 2
+        mock_db.atomic.assert_called_once()
+
+    # =========================================================================
+    # Test Business Logic Functions
+    # =========================================================================
+
+    def test_meta_filter_with_and_logic(self):
+        """
+        Test meta_filter() function with AND logic.
+        
+        This tests the actual business logic for metadata filtering.
+        The function should return documents that match ALL filters.
+        """
+        # Arrange
+        metas = {
+            "category": {
+                "technology": ["doc1", "doc2", "doc3"],
+                "business": ["doc2", "doc4"]
+            },
+            "status": {
+                "published": ["doc1", "doc3"],
+                "draft": ["doc2", "doc4"]
+            }
+        }
+        
+        filters = [
+            {"key": "category", "op": "=", "value": "technology"},
+            {"key": "status", "op": "=", "value": "published"}
+        ]
+        
+        # Act
+        result = meta_filter(metas, filters, logic="and")
+        
+        # Assert - should return intersection (docs that are technology AND published)
+        expected = ["doc1", "doc3"]
+        assert sorted(result) == sorted(expected)
+
+    def test_meta_filter_with_or_logic(self):
+        """
+        Test meta_filter() function with OR logic.
+        
+        The function should return documents that match ANY filter.
+        """
+        # Arrange
+        metas = {
+            "category": {
+                "technology": ["doc1", "doc2"],
+                "business": ["doc3", "doc4"]
+            }
+        }
+        
+        filters = [
+            {"key": "category", "op": "=", "value": "technology"},
+            {"key": "category", "op": "=", "value": "business"}
+        ]
+        
+        # Act
+        result = meta_filter(metas, filters, logic="or")
+        
+        # Assert - should return union (docs that are technology OR business)
+        expected = ["doc1", "doc2", "doc3", "doc4"]
+        assert sorted(result) == sorted(expected)
+
+    def test_meta_filter_comparison_operators(self):
+        """
+        Test meta_filter() with various comparison operators.
+        
+        Tests: >, <, contains, empty, etc.
+        """
+        # Test greater than operator
+        metas = {
+            "price": {
+                "10.99": ["doc1"],
+                "25.50": ["doc2"],
+                "100.00": ["doc3"]
+            }
+        }
+        
+        filters = [{"key": "price", "op": ">", "value": "20"}]
+        result = meta_filter(metas, filters, logic="and")
+        expected = ["doc2", "doc3"]  # Prices > 20
+        assert sorted(result) == sorted(expected)
+        
+        # Test contains operator
+        metas = {
+            "name": {
+                "Apple iPhone": ["doc1"],
+                "Samsung Galaxy": ["doc2"],
+                "Google Pixel": ["doc3"]
+            }
+        }
+        
+        filters = [{"key": "name", "op": "contains", "value": "Galaxy"}]
+        result = meta_filter(metas, filters, logic="and")
+        assert result == ["doc2"]
+
+    def test_convert_conditions_transforms_operators(self):
+        """
+        Test convert_conditions() function.
+        
+        This function transforms metadata conditions from UI format
+        to internal format, including operator mapping.
+        """
+        # Arrange
+        metadata_condition = {
+            "conditions": [
+                {
+                    "name": "category",
+                    "comparison_operator": "is",
+                    "value": "technology"
+                },
+                {
+                    "name": "status",
+                    "comparison_operator": "not is",
+                    "value": "draft"
+                }
+            ]
+        }
+        
+        # Act
+        result = convert_conditions(metadata_condition)
+        
+        # Assert
+        expected = [
+            {"op": "=", "key": "category", "value": "technology"},
+            {"op": "≠", "key": "status", "value": "draft"}
+        ]
+        assert result == expected
+
+    def test_convert_conditions_handles_empty_input(self):
+        """Test convert_conditions() handles None and empty inputs."""
+        # Test None input
+        result = convert_conditions(None)
+        assert result == []
+        
+        # Test empty conditions
+        result = convert_conditions({"conditions": []})
+        assert result == []
+
+    def test_repair_bad_citation_formats_standardizes_citations(self):
+        """
+        Test repair_bad_citation_formats() function.
+        
+        This function finds various citation formats and standardizes them
+        to [ID:x] format while tracking which document indices are referenced.
+        """
+        # Arrange
+        kbinfos = {
+            "chunks": [
+                {"doc_id": "doc1", "content": "Content 1"},
+                {"doc_id": "doc2", "content": "Content 2"}
+            ]
+        }
+        
+        answer = "According to research (ID: 1), this is important."
+        idx = set()
+        
+        # Act
+        repaired_answer, final_idx = repair_bad_citation_formats(answer, kbinfos, idx)
+        
+        # Assert
+        assert "[ID:1]" in repaired_answer  # Standardized format
+        assert 1 in final_idx  # Tracked the reference
+
+    def test_repair_bad_citation_formats_handles_out_of_bounds(self):
+        """Test citation repair handles invalid indices gracefully."""
+        # Arrange
+        kbinfos = {
+            "chunks": [
+                {"doc_id": "doc1", "content": "Content 1"}
+            ]
+        }
+        
+        answer = "This references (ID: 999) which doesn't exist."
+        idx = set()
+        
+        # Act
+        repaired_answer, final_idx = repair_bad_citation_formats(answer, kbinfos, idx)
+        
+        # Assert - should not crash, should not add invalid index
+        assert isinstance(repaired_answer, str)
+        assert 999 not in final_idx
+
+    # =========================================================================
+    # Test Edge Cases
+    # =========================================================================
+
+    def test_meta_filter_with_no_matching_documents(self):
+        """Test meta_filter returns empty list when no documents match."""
+        metas = {
+            "category": {
+                "technology": ["doc1", "doc2"]
+            }
+        }
+        
+        filters = [{"key": "category", "op": "=", "value": "nonexistent"}]
+        result = meta_filter(metas, filters, logic="and")
+        
+        assert result == []
+
+    def test_meta_filter_with_empty_filters(self):
+        """Test meta_filter with empty filter list."""
+        metas = {
+            "category": {
+                "technology": ["doc1", "doc2"]
+            }
+        }
+        
+        filters = []
+        result = meta_filter(metas, filters, logic="and")
+        
+        # With no filters, should return empty (no documents match nothing)
+        assert result == []
+
+    # =========================================================================
+    # Parameterized Tests
+    # =========================================================================
+
+    @pytest.mark.parametrize("operator,value,expected_docs", [
+        (">", "50", ["doc3"]),  # Greater than (only 75 > 50)
+        ("<", "50", ["doc1"]),  # Less than (only 25 < 50)
+        ("≥", "50", ["doc2", "doc3"]),  # Greater than or equal (50 and 75)
+        ("≤", "50", ["doc1", "doc2"]),  # Less than or equal (25 and 50)
+        ("=", "50", ["doc2"]),  # Equal (only 50)
+        ("≠", "50", ["doc1", "doc3"]),  # Not equal (25 and 75)
+    ])
+    def test_meta_filter_numeric_operators(self, operator, value, expected_docs):
+        """Test all numeric comparison operators."""
+        metas = {
+            "score": {
+                "25": ["doc1"],
+                "50": ["doc2"],
+                "75": ["doc3"]
+            }
+        }
+        
+        filters = [{"key": "score", "op": operator, "value": value}]
+        result = meta_filter(metas, filters, logic="and")
+        
+        assert sorted(result) == sorted(expected_docs)
+
+
+# =============================================================================
+# How to run these tests:
+# =============================================================================
+# cd /root/74/ragflow
+# python -m pytest test/unit_test/services/test_dialog_service_template.py -v
+#
+# Run with coverage:
+# python -m pytest test/unit_test/services/test_dialog_service_template.py --cov=api.db.services.dialog_service -v
+#
+# Run specific test:
+# python -m pytest test/unit_test/services/test_dialog_service_template.py::TestDialogServiceTemplate::test_meta_filter_with_and_logic -v
+# =============================================================================