@ngocsangairvds/vsaf 3.2.15 → 4.0.0

package/tools/vds-scripts/memory_orchestrator/tests/service/test_unit_comprehensive.py

@@ -1,1054 +0,0 @@
-"""
-Comprehensive Unit Tests for VDS AI Memory Service
-
-Focus areas:
-1. Exception classes (ai_memory_exceptions.py)
-2. Rule Engine (rule_engine.py)
-3. Content Analyzer (content_analyzer.py)
-4. Model validation (ai_memory_models.py)
-
-These tests target core business logic and infrastructure components
-that are currently under-covered but have high usage across the codebase.
-"""
-
-import pytest
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    AnalyticsError,
-    AuthenticationError,
-    AuthorizationError,
-    CacheError,
-    ConfigurationError,
-    ConnectionError,
-    IntegrationError,
-    MemoryError,
-    NotFoundError,
-    RateLimitError,
-    ResourceError,
-    ServiceUnavailableError,
-    SessionError,
-    ToolExecutionError,
-    ValidationError,
-    VDSError,
-)
-from vds_memory_orchestrator.service.services.storage_strategy.content_analyzer import (
-    ConsolidationAction,
-    ConsolidationCandidate,
-    ContentAnalyzer,
-    ProcessingTier,
-    SemanticFeatures,
-    SimilarityResult,
-)
-from vds_memory_orchestrator.service.services.storage_strategy.rule_engine import (
-    Rule,
-    RuleSet,
-)
-from vds_memory_orchestrator.service.services.storage_strategy.storage_engine import (
-    MemoryFeatures,
-    StorageDecision,
-    StorageTier,
-)
-
-# ============================================================================
-# Test Exception Classes (24% coverage target)
-# ============================================================================
-
-
-class TestVDSError:
-    """Test base exception class."""
-
-    def test_vds_error_basic(self):
-        """Test basic VDSError with message only."""
-        error = VDSError("Test error message")
-        assert error.message == "Test error message"
-        assert error.details is None
-        assert str(error) == "Test error message"
-
-    def test_vds_error_with_details(self):
-        """Test VDSError with message and details."""
-        error = VDSError("Test error", details="Additional context")
-        assert error.message == "Test error"
-        assert error.details == "Additional context"
-
-
-class TestValidationError:
-    """Test validation exception."""
-
-    def test_validation_error_basic(self):
-        """Test ValidationError with message only."""
-        error = ValidationError("Invalid input")
-        assert error.message == "Invalid input"
-        assert error.field is None
-        assert error.value is None
-
-    def test_validation_error_with_field_and_value(self):
-        """Test ValidationError with field and value."""
-        error = ValidationError(message="Validation failed", field="email", value="invalid-email")
-        assert error.field == "email"
-        assert error.value == "invalid-email"
-        assert error.details == "Field 'email' with value 'invalid-email' failed validation"
-        assert error.message == "Validation failed"
-
-
-class TestNotFoundError:
-    """Test not found exception."""
-
-    def test_not_found_error_basic(self):
-        """Test NotFoundError with resource type only."""
-        error = NotFoundError(resource_type="Session")
-        assert error.resource_type == "Session"
-        assert error.resource_id is None
-        assert "Session not found" in str(error)
-
-    def test_not_found_error_with_id(self):
-        """Test NotFoundError with resource type and ID."""
-        error = NotFoundError(resource_type="Memory", resource_id="mem_12345")
-        assert error.resource_type == "Memory"
-        assert error.resource_id == "mem_12345"
-        assert "Memory not found" in str(error)
-        assert "mem_12345" in str(error)
-
-
-class TestServiceUnavailableError:
-    """Test service unavailable exception."""
-
-    def test_service_unavailable_basic(self):
-        """Test ServiceUnavailableError with service name."""
-        error = ServiceUnavailableError(service_name="Mem0API")
-        assert error.service_name == "Mem0API"
-        assert error.reason is None
-        assert "Mem0API" in str(error)
-
-    def test_service_unavailable_with_reason(self):
-        """Test ServiceUnavailableError with reason."""
-        error = ServiceUnavailableError(service_name="PostgreSQL", reason="Connection timeout")
-        assert error.service_name == "PostgreSQL"
-        assert error.reason == "Connection timeout"
-        assert "PostgreSQL" in str(error)
-        assert "Connection timeout" in str(error)
-
-
-class TestRateLimitError:
-    """Test rate limit exception."""
-
-    def test_rate_limit_basic(self):
-        """Test RateLimitError with limit type."""
-        error = RateLimitError(limit_type="API calls")
-        assert error.limit_type == "API calls"
-        assert error.limit_value is None
-        assert "API calls" in str(error)
-
-    def test_rate_limit_with_value(self):
-        """Test RateLimitError with limit value."""
-        error = RateLimitError(limit_type="Requests per minute", limit_value=100)
-        assert error.limit_type == "Requests per minute"
-        assert error.limit_value == 100
-        assert "limit: 100" in str(error)
-
-
-class TestConfigurationError:
-    """Test configuration error exception."""
-
-    def test_configuration_error_basic(self):
-        """Test ConfigurationError with config key."""
-        error = ConfigurationError(config_key="REDIS_URL")
-        assert error.config_key == "REDIS_URL"
-        assert error.reason is None
-        assert "REDIS_URL" in str(error)
-
-    def test_configuration_error_with_reason(self):
-        """Test ConfigurationError with reason."""
-        error = ConfigurationError(config_key="DATABASE_URL", reason="Invalid format")
-        assert error.config_key == "DATABASE_URL"
-        assert error.reason == "Invalid format"
-        assert "Invalid format" in str(error)
-
-
-class TestMemoryError:
-    """Test memory operation error."""
-
-    def test_memory_error_basic(self):
-        """Test MemoryError with operation."""
-        error = MemoryError(operation="create_memory")
-        assert error.operation == "create_memory"
-        assert error.reason is None
-        assert "create_memory" in str(error)
-
-    def test_memory_error_with_reason(self):
-        """Test MemoryError with operation and reason."""
-        error = MemoryError(operation="delete_memory", reason="Memory not found")
-        assert error.operation == "delete_memory"
-        assert error.reason == "Memory not found"
-        assert "Memory not found" in str(error)
-
-
-class TestSessionError:
-    """Test session operation error."""
-
-    def test_session_error_basic(self):
-        """Test SessionError with operation."""
-        error = SessionError(operation="create_session")
-        assert error.operation == "create_session"
-        assert error.session_id is None
-        assert error.reason is None
-
-    def test_session_error_with_session_id(self):
-        """Test SessionError with operation and session_id."""
-        error = SessionError(operation="update_session", session_id="sess_12345")
-        assert error.operation == "update_session"
-        assert error.session_id == "sess_12345"
-        assert "sess_12345" in str(error)
-
-    def test_session_error_full(self):
-        """Test SessionError with all parameters."""
-        error = SessionError(
-            operation="delete_session", session_id="sess_67890", reason="Session expired"
-        )
-        assert error.operation == "delete_session"
-        assert error.session_id == "sess_67890"
-        assert error.reason == "Session expired"
-        assert "Session expired" in str(error)
-
-
-class TestCacheError:
-    """Test cache operation error."""
-
-    def test_cache_error_basic(self):
-        """Test CacheError with operation."""
-        error = CacheError(operation="get")
-        assert error.operation == "get"
-        assert error.cache_key is None
-        assert error.reason is None
-
-    def test_cache_error_with_key(self):
-        """Test CacheError with operation and cache key."""
-        error = CacheError(operation="set", cache_key="user:123:session")
-        assert error.operation == "set"
-        assert error.cache_key == "user:123:session"
-        assert "user:123:session" in str(error)
-
-    def test_cache_error_full(self):
-        """Test CacheError with all parameters."""
-        error = CacheError(
-            operation="delete", cache_key="cache:analytics:summary", reason="Key not found"
-        )
-        assert error.operation == "delete"
-        assert error.cache_key == "cache:analytics:summary"
-        assert error.reason == "Key not found"
-
-
-class TestAnalyticsError:
-    """Test analytics operation error."""
-
-    def test_analytics_error_basic(self):
-        """Test AnalyticsError with operation."""
-        error = AnalyticsError(operation="track_event")
-        assert error.operation == "track_event"
-        assert error.reason is None
-
-    def test_analytics_error_with_reason(self):
-        """Test AnalyticsError with reason."""
-        error = AnalyticsError(operation="calculate_metrics", reason="Insufficient data")
-        assert error.operation == "calculate_metrics"
-        assert error.reason == "Insufficient data"
-
-
-class TestAuthenticationError:
-    """Test authentication error."""
-
-    def test_authentication_error_basic(self):
-        """Test AuthenticationError with service."""
-        error = AuthenticationError(service="Mem0AI")
-        assert error.service == "Mem0AI"
-        assert error.reason is None
-
-    def test_authentication_error_with_reason(self):
-        """Test AuthenticationError with reason."""
-        error = AuthenticationError(service="PostgreSQL", reason="Invalid credentials")
-        assert error.service == "PostgreSQL"
-        assert error.reason == "Invalid credentials"
-
-
-class TestAuthorizationError:
-    """Test authorization error."""
-
-    def test_authorization_error_full(self):
-        """Test AuthorizationError with all parameters."""
-        error = AuthorizationError(
-            resource="/api/v1/memories", action="DELETE", reason="Insufficient permissions"
-        )
-        assert error.resource == "/api/v1/memories"
-        assert error.action == "DELETE"
-        assert error.reason == "Insufficient permissions"
-        assert "DELETE" in str(error)
-        assert "/api/v1/memories" in str(error)
-
-
-class TestIntegrationError:
-    """Test integration error."""
-
-    def test_integration_error_full(self):
-        """Test IntegrationError with all parameters."""
-        error = IntegrationError(
-            service="Mem0Pro", operation="add_memory", reason="Service timeout"
-        )
-        assert error.service == "Mem0Pro"
-        assert error.operation == "add_memory"
-        assert error.reason == "Service timeout"
-
-
-class TestConnectionError:
-    """Test connection error."""
-
-    def test_connection_error_basic(self):
-        """Test ConnectionError with service."""
-        error = ConnectionError(service="Redis")
-        assert error.service == "Redis"
-        assert error.reason is None
-
-    def test_connection_error_with_reason(self):
-        """Test ConnectionError with reason."""
-        error = ConnectionError(service="PostgreSQL", reason="Network unreachable")
-        assert error.service == "PostgreSQL"
-        assert error.reason == "Network unreachable"
-
-
-class TestToolExecutionError:
-    """Test tool execution error."""
-
-    def test_tool_execution_error_basic(self):
-        """Test ToolExecutionError with tool name."""
-        error = ToolExecutionError(tool_name="Bash")
-        assert error.tool_name == "Bash"
-        assert error.reason is None
-
-    def test_tool_execution_error_with_reason(self):
-        """Test ToolExecutionError with reason."""
-        error = ToolExecutionError(tool_name="PythonREPL", reason="Syntax error")
-        assert error.tool_name == "PythonREPL"
-        assert error.reason == "Syntax error"
-
-
-class TestResourceError:
-    """Test resource error."""
-
-    def test_resource_error_full(self):
-        """Test ResourceError with all parameters."""
-        error = ResourceError(
-            resource_type="DatabaseConnection", operation="acquire", reason="Pool exhausted"
-        )
-        assert error.resource_type == "DatabaseConnection"
-        assert error.operation == "acquire"
-        assert error.reason == "Pool exhausted"
-
-
-# ============================================================================
-# Test Rule Engine (44% coverage target)
-# ============================================================================
-
-
-class TestRule:
-    """Test individual rule evaluation."""
-
-    @pytest.fixture
-    def sample_features(self):
-        """Create sample memory features for testing."""
-        return MemoryFeatures(
-            content_length=37,
-            word_count=8,
-            sentence_count=2,
-            memory_category="general",
-            user_role_importance=0.8,
-            has_decision_pattern=False,
-            has_solution_pattern=False,
-            has_code_pattern=False,
-            has_question_pattern=False,
-            complexity_score=0.5,
-            interaction_count=1,
-            business_domain="insurance",
-            hour_of_day=10,
-            day_of_week=2,
-        )
-
-    def test_rule_equality_operator(self, sample_features):
-        """Test rule with equals operator."""
-        rule_data = {
-            "name": "test_equals",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "conditions": [{"field": "memory_category", "operator": "equals", "value": "general"}],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_not_equals_operator(self, sample_features):
-        """Test rule with not_equals operator."""
-        rule_data = {
-            "name": "test_not_equals",
-            "priority": 1,
-            "tier": "postgres",
-            "conditions": [
-                {"field": "memory_category", "operator": "not_equals", "value": "debug"}
-            ],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_greater_than_operator(self, sample_features):
-        """Test rule with greater_than operator."""
-        rule_data = {
-            "name": "test_greater",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "conditions": [
-                {"field": "user_role_importance", "operator": "greater_than", "value": 0.5}
-            ],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_less_than_operator(self, sample_features):
-        """Test rule with less_than operator."""
-        rule_data = {
-            "name": "test_less",
-            "priority": 1,
-            "tier": "postgres",
-            "conditions": [{"field": "content_length", "operator": "less_than", "value": 100}],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_greater_equal_operator(self, sample_features):
-        """Test rule with greater_equal operator."""
-        rule_data = {
-            "name": "test_greater_equal",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "conditions": [
-                {"field": "user_role_importance", "operator": "greater_equal", "value": 0.8}
-            ],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_less_equal_operator(self, sample_features):
-        """Test rule with less_equal operator."""
-        rule_data = {
-            "name": "test_less_equal",
-            "priority": 1,
-            "tier": "postgres",
-            "conditions": [{"field": "complexity_score", "operator": "less_equal", "value": 0.5}],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_contains_operator_string(self, sample_features):
-        """Test rule with contains operator for string."""
-        rule_data = {
-            "name": "test_contains",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "conditions": [{"field": "business_domain", "operator": "contains", "value": "insur"}],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_in_operator(self, sample_features):
-        """Test rule with in operator."""
-        rule_data = {
-            "name": "test_in",
-            "priority": 1,
-            "tier": "redis",
-            "conditions": [
-                {
-                    "field": "business_domain",
-                    "operator": "in",
-                    "value": ["insurance", "lep", "ekyc"],
-                }
-            ],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_regex_operator(self, sample_features):
-        """Test rule with regex operator."""
-        rule_data = {
-            "name": "test_regex",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "conditions": [{"field": "memory_category", "operator": "regex", "value": "^gen.*"}],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_multiple_conditions_all_match(self, sample_features):
-        """Test rule with multiple conditions that all match."""
-        rule_data = {
-            "name": "test_multiple",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "conditions": [
-                {"field": "memory_category", "operator": "equals", "value": "general"},
-                {"field": "content_length", "operator": "less_than", "value": 100},
-                {"field": "user_role_importance", "operator": "greater_than", "value": 0.5},
-            ],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is True
-
-    def test_rule_multiple_conditions_one_fails(self, sample_features):
-        """Test rule with multiple conditions where one fails."""
-        rule_data = {
-            "name": "test_multiple_fail",
-            "priority": 1,
-            "tier": "postgres",
-            "conditions": [
-                {"field": "memory_category", "operator": "equals", "value": "general"},
-                {"field": "has_decision_pattern", "operator": "equals", "value": True},
-            ],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is False
-
-    def test_rule_disabled(self, sample_features):
-        """Test that disabled rules don't match."""
-        rule_data = {
-            "name": "test_disabled",
-            "priority": 1,
-            "tier": "mem0_pro",
-            "enabled": False,
-            "conditions": [{"field": "memory_category", "operator": "equals", "value": "general"}],
-        }
-        rule = Rule(rule_data)
-        assert rule.evaluate(sample_features) is False
-
-    def test_rule_to_dict(self):
-        """Test rule serialization to dictionary."""
-        rule_data = {
-            "name": "test_serialization",
-            "description": "Test description",
-            "priority": 5,
-            "tier": "postgres",
-            "confidence": 0.85,
-            "reasoning": "Test reasoning",
-            "enabled": True,
-            "conditions": [{"field": "memory_category", "operator": "equals", "value": "general"}],
-        }
-        rule = Rule(rule_data)
-        rule_dict = rule.to_dict()
-        assert rule_dict["name"] == "test_serialization"
-        assert rule_dict["priority"] == 5
-        assert rule_dict["tier"] == "postgres"
-        assert len(rule_dict["conditions"]) == 1
-
-
-class TestRuleSet:
-    """Test rule set management."""
-
-    def test_rule_set_initialization(self):
-        """Test RuleSet initialization."""
-        rule_set = RuleSet()
-        assert len(rule_set.rules) == 0
-        assert rule_set.default_tier == StorageTier.REDIS
-        assert rule_set.default_confidence == 0.5
-
-    def test_rule_set_add_rule(self):
-        """Test adding rules to rule set."""
-        rule_set = RuleSet()
-        rule_data = {
-            "name": "test_rule",
-            "priority": 1,
-            "tier": "postgres",
-            "conditions": [{"field": "memory_category", "operator": "equals", "value": "general"}],
-        }
-        rule = Rule(rule_data)
-        rule_set.add_rule(rule)
-        assert len(rule_set.rules) == 1
-
-    def test_rule_set_get_enabled_rules(self):
-        """Test getting enabled rules sorted by priority."""
-        rule_set = RuleSet()
-        rule_data1 = {"name": "low_priority", "priority": 1, "tier": "postgres", "conditions": []}
-        rule_data2 = {"name": "high_priority", "priority": 10, "tier": "mem0_pro", "conditions": []}
-        rule_data3 = {
-            "name": "disabled_rule",
-            "priority": 5,
-            "tier": "redis",
-            "enabled": False,
-            "conditions": [],
-        }
-
-        rule_set.add_rule(Rule(rule_data1))
-        rule_set.add_rule(Rule(rule_data2))
-        rule_set.add_rule(Rule(rule_data3))
-
-        enabled_rules = rule_set.get_enabled_rules()
-        assert len(enabled_rules) == 2
-        assert enabled_rules[0].name == "high_priority"  # Priority 10 first
-        assert enabled_rules[1].name == "low_priority"  # Priority 1 second
-
-    @pytest.fixture
-    def sample_features(self):
-        """Create sample memory features."""
-        return MemoryFeatures(
-            content_length=4,
-            word_count=1,
-            sentence_count=1,
-            memory_category="general",
-            user_role_importance=0.5,
-            has_decision_pattern=False,
-            has_solution_pattern=False,
-            has_code_pattern=False,
-            has_question_pattern=False,
-            complexity_score=0.5,
-            interaction_count=1,
-            business_domain="insurance",
-            hour_of_day=10,
-            day_of_week=2,
-        )
-
-    def test_rule_set_evaluate_matching_rule(self, sample_features):
-        """Test rule set evaluation with matching rule."""
-        rule_set = RuleSet()
-        rule_data = {
-            "name": "match_rule",
-            "priority": 10,
-            "tier": "mem0_pro",
-            "conditions": [{"field": "memory_category", "operator": "equals", "value": "general"}],
-        }
-        rule_set.add_rule(Rule(rule_data))
-
-        matching_rule = rule_set.evaluate(sample_features)
-        assert matching_rule is not None
-        assert matching_rule.name == "match_rule"
-
-    def test_rule_set_evaluate_no_match(self, sample_features):
-        """Test rule set evaluation with no matching rule."""
-        rule_set = RuleSet()
-        rule_data = {
-            "name": "no_match_rule",
-            "priority": 10,
-            "tier": "mem0_pro",
-            "conditions": [{"field": "memory_category", "operator": "equals", "value": "debug"}],
-        }
-        rule_set.add_rule(Rule(rule_data))
-
-        matching_rule = rule_set.evaluate(sample_features)
-        assert matching_rule is None
-
-    def test_rule_set_get_stats(self):
-        """Test getting rule set statistics."""
-        rule_set = RuleSet()
-        rule_data1 = {"name": "rule1", "priority": 1, "tier": "postgres", "conditions": []}
-        rule_data2 = {
-            "name": "rule2",
-            "priority": 2,
-            "tier": "mem0_pro",
-            "enabled": False,
-            "conditions": [],
-        }
-
-        rule_set.add_rule(Rule(rule_data1))
-        rule_set.add_rule(Rule(rule_data2))
-
-        stats = rule_set.get_rule_stats()
-        assert stats["total_rules"] == 2
-        assert stats["enabled_rules"] == 1
-        assert stats["rules_by_tier"]["postgres"] == 1
-        assert stats["rules_by_tier"]["mem0_pro"] == 0
-
-
-# ============================================================================
-# Test Content Analyzer (29% coverage target)
-# ============================================================================
-
-
-class TestContentAnalyzer:
-    """Test content analyzer algorithms."""
-
-    @pytest.fixture
-    def mock_pattern_matcher(self):
-        """Create mock pattern matcher."""
-
-        class MockFeatures:
-            def __init__(self):
-                self.has_decision_pattern = False
-                self.has_solution_pattern = False
-                self.has_code_pattern = False
-                self.has_question_pattern = False
-
-        class MockPatternMatcher:
-            def extract_features(self, _content, _context):
-                return MockFeatures()
-
-        return MockPatternMatcher()
-
-    def test_content_analyzer_initialization(self, mock_pattern_matcher):
-        """Test ContentAnalyzer initialization."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        assert analyzer.pattern_matcher is not None
-        assert analyzer._stats["lexical_processing_count"] == 0
-
-    @pytest.mark.asyncio
-    async def test_analyze_content_lexical_tier(self, mock_pattern_matcher):
-        """Test content analysis with lexical processing tier."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        content = "Test content about API design"
-        context = {}
-
-        results, candidates = await analyzer.analyze_content(
-            content, context, ProcessingTier.LEXICAL
-        )
-
-        assert "lexical" in results
-        assert "patterns_matched" in results["lexical"]
-        assert len(candidates) == 0  # No semantic tier, no candidates
-
-    @pytest.mark.asyncio
-    async def test_analyze_content_semantic_tier(self, mock_pattern_matcher):
-        """Test content analysis with semantic processing tier."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        content = "Important decision about system architecture"
-        context = {}
-
-        results, candidates = await analyzer.analyze_content(
-            content, context, ProcessingTier.SEMANTIC
-        )
-
-        assert "lexical" in results
-        assert "semantic" in results
-        assert "content_hash" in results["semantic"]
-
-    @pytest.mark.asyncio
-    async def test_preprocess_text(self, mock_pattern_matcher):
-        """Test text preprocessing."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        # Test normal text
-        words = analyzer._preprocess_text("The quick brown fox jumps over the lazy dog.")
-        assert "quick" in words
-        assert "brown" in words
-        assert "the" not in words  # Stop word removed
-
-        # Test empty text
-        assert analyzer._preprocess_text("") == []
-
-    def test_calculate_tfidf(self, mock_pattern_matcher):
-        """Test TF-IDF calculation."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        # Test normal calculation
-        words = ["api", "database", "api", "architecture"]
-        tfidf = analyzer._calculate_tfidf(words)
-
-        assert "api" in tfidf
-        assert "database" in tfidf
-        assert "architecture" in tfidf
-        # "api" appears twice, should have higher TF
-        assert tfidf["api"] > tfidf["database"]
-
-    def test_calculate_tfidf_empty(self, mock_pattern_matcher):
-        """Test TF-IDF with empty word list."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        tfidf = analyzer._calculate_tfidf([])
-        assert tfidf == {}
-
-    def test_calculate_tfidf_technical_boost(self, mock_pattern_matcher):
-        """Test technical term boosting in TF-IDF."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        # Include technical term "api"
-        words = ["api", "test", "system"]
-        tfidf = analyzer._calculate_tfidf(words)
-
-        # "api" should be boosted (multiplied by 2.0)
-        assert tfidf["api"] > tfidf["test"]
-
-    def test_generate_min_hash_fingerprint(self, mock_pattern_matcher):
-        """Test MinHash fingerprint generation."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        words = ["test", "content", "analysis"]
-        fingerprint = analyzer._generate_min_hash_fingerprint(words)
-
-        assert isinstance(fingerprint, str)
-        assert len(fingerprint) == 16  # Truncated to 16 chars
-        assert fingerprint != ""
-
-    def test_generate_min_hash_empty(self, mock_pattern_matcher):
-        """Test MinHash with empty word list."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        fingerprint = analyzer._generate_min_hash_fingerprint([])
-        assert fingerprint == ""
-
-    def test_calculate_semantic_importance(self, mock_pattern_matcher):
-        """Test semantic importance calculation."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        # Test with technical terms
-        words = ["api", "database", "architecture", "implementation"]
-        context = {"user_role": "developer"}
-
-        score = analyzer._calculate_semantic_importance(words, context)
-        assert 0.0 <= score <= 1.0
-        assert score > 0.5  # Should be high due to technical terms and developer role
-
-    def test_calculate_semantic_importance_empty(self, mock_pattern_matcher):
-        """Test semantic importance with empty words."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        score = analyzer._calculate_semantic_importance([], {})
-        assert score == 0.0
-
-    def test_calculate_cosine_similarity(self, mock_pattern_matcher):
-        """Test cosine similarity calculation."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        vector1 = {"api": 0.5, "database": 0.3, "test": 0.2}
-        vector2 = {"api": 0.4, "database": 0.4, "system": 0.2}
-
-        similarity = analyzer._calculate_cosine_similarity(vector1, vector2)
-        assert 0.0 <= similarity <= 1.0
-        assert similarity > 0.5  # Should be similar (share "api" and "database")
-
-    def test_calculate_cosine_similarity_no_common_terms(self, mock_pattern_matcher):
-        """Test cosine similarity with no common terms."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        vector1 = {"api": 0.5, "test": 0.5}
-        vector2 = {"database": 0.5, "system": 0.5}
-
-        similarity = analyzer._calculate_cosine_similarity(vector1, vector2)
-        assert similarity == 0.0
-
-    def test_calculate_cosine_similarity_empty_vectors(self, mock_pattern_matcher):
-        """Test cosine similarity with empty vectors."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        similarity = analyzer._calculate_cosine_similarity({}, {})
-        assert similarity == 0.0
-
-    def test_lsh_lookup(self, mock_pattern_matcher):
-        """Test LSH lookup (placeholder implementation)."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        fingerprint = "test_fingerprint_123"
-
-        candidates = analyzer._lsh_lookup(fingerprint)
-        assert candidates == []  # Placeholder returns empty list
-
-    def test_register_content_signature(self, mock_pattern_matcher):
-        """Test registering content signature."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        semantic_features = SemanticFeatures(
-            content_hash="abc123",
-            tfidf_vector={},
-            content_fingerprint="fp123",
-            semantic_score=0.5,
-            processing_time_ms=1.0,
-        )
-
-        analyzer.register_content_signature("mem_001", semantic_features)
-        assert "fp123" in analyzer._content_signatures
-        assert "mem_001" in analyzer._content_signatures["fp123"]
-
-    def test_get_analytics(self, mock_pattern_matcher):
-        """Test getting analytics."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-        analytics = analyzer.get_analytics()
-
-        assert "lexical_processing_count" in analytics
-        assert "semantic_processing_count" in analytics
-        assert analytics["lexical_processing_count"] == 0
-
-    @pytest.mark.asyncio
-    async def test_analyze_consolidation_opportunities(self, mock_pattern_matcher):
-        """Test consolidation opportunity analysis."""
-        analyzer = ContentAnalyzer(mock_pattern_matcher)
-
-        semantic_features = SemanticFeatures(
-            content_hash="abc123",
-            tfidf_vector={"test": 0.5},
-            content_fingerprint="fp123",
-            semantic_score=0.8,
-            processing_time_ms=1.0,
-        )
-
-        similarity_result = SimilarityResult(
-            similarity_score=0.9,
-            candidate_memory_ids=["mem_001", "mem_002"],
-            processing_time_ms=5.0,
-            lsh_candidates_found=2,
-        )
-
-        candidates = await analyzer._analyze_consolidation_opportunities(
-            "Test content", semantic_features, similarity_result
-        )
-
-        assert len(candidates) == 2
-        # High similarity (>0.85) should trigger LINK action
-        assert candidates[0].action == ConsolidationAction.LINK
-
-
-# ============================================================================
-# Test Storage Engine Models
-# ============================================================================
-
-
-class TestMemoryFeatures:
-    """Test MemoryFeatures model."""
-
-    def test_memory_features_creation(self):
-        """Test creating MemoryFeatures."""
-        features = MemoryFeatures(
-            content_length=19,
-            word_count=4,
-            sentence_count=1,
-            memory_category="general",
-            user_role_importance=0.8,
-            has_decision_pattern=False,
-            has_solution_pattern=False,
-            has_code_pattern=False,
-            has_question_pattern=False,
-            complexity_score=0.5,
-            interaction_count=1,
-            business_domain="insurance",
-            hour_of_day=10,
-            day_of_week=2,
-        )
-        assert features.content_length == 19
-        assert features.memory_category == "general"
-        assert features.word_count == 4
-
-    def test_memory_features_defaults(self):
-        """Test MemoryFeatures with minimal required fields."""
-        # Only test fields that have defaults
-        features = MemoryFeatures(
-            content_length=4,
-            word_count=1,
-            sentence_count=1,
-            memory_category="general",
-            hour_of_day=14,
-            day_of_week=3,
-        )
-        assert features.has_decision_pattern is False  # Default
-        assert features.has_solution_pattern is False  # Default
-        assert features.readability_score == 0.5  # Default
-
-
-class TestStorageDecision:
-    """Test StorageDecision model."""
-
-    def test_storage_decision_creation(self):
-        """Test creating StorageDecision."""
-        decision = StorageDecision(
-            tier=StorageTier.POSTGRES,
-            confidence=0.9,
-            reasoning="Test reasoning",
-            applied_rules=["test_rule"],
-            processing_time_ms=1.5,
-            metadata={"test": "value"},
-        )
-        assert decision.tier == StorageTier.POSTGRES
-        assert decision.confidence == 0.9
-        assert decision.reasoning == "Test reasoning"
-        assert decision.applied_rules == ["test_rule"]
-
-
-class TestStorageTier:
-    """Test StorageTier enum."""
-
-    def test_storage_tier_values(self):
-        """Test StorageTier enum values."""
-        assert StorageTier.POSTGRES.value == "postgres"
-        assert StorageTier.MEM0_PRO.value == "mem0_pro"
-        assert StorageTier.REDIS.value == "redis"
-
-
-# ============================================================================
-# Test Semantic Features Models
-# ============================================================================
-
-
-class TestSemanticFeatures:
-    """Test SemanticFeatures model."""
-
-    def test_semantic_features_creation(self):
-        """Test creating SemanticFeatures."""
-        features = SemanticFeatures(
-            content_hash="abc123def456",
-            tfidf_vector={"test": 0.5, "content": 0.3},
-            content_fingerprint="fp789",
-            semantic_score=0.75,
-            processing_time_ms=2.5,
-        )
-        assert features.content_hash == "abc123def456"
-        assert features.tfidf_vector["test"] == 0.5
-        assert features.content_fingerprint == "fp789"
-        assert features.semantic_score == 0.75
-
-    def test_semantic_features_defaults(self):
-        """Test SemanticFeatures with defaults."""
-        features = SemanticFeatures(
-            content_hash="abc",
-            tfidf_vector={},
-            content_fingerprint="fp123",
-            semantic_score=0.5,
-            processing_time_ms=1.0,
-        )
-        assert features.semantic_score == 0.5
-
-
-class TestSimilarityResult:
-    """Test SimilarityResult dataclass."""
-
-    def test_similarity_result_creation(self):
-        """Test creating SimilarityResult."""
-        result = SimilarityResult(
-            similarity_score=0.85,
-            candidate_memory_ids=["mem_001", "mem_002"],
-            processing_time_ms=3.0,
-            lsh_candidates_found=5,
-        )
-        assert result.similarity_score == 0.85
-        assert len(result.candidate_memory_ids) == 2
-        assert result.processing_time_ms == 3.0
-        assert result.lsh_candidates_found == 5
-
-
-class TestConsolidationCandidate:
-    """Test ConsolidationCandidate model."""
-
-    def test_consolidation_candidate_creation(self):
-        """Test creating ConsolidationCandidate."""
-        candidate = ConsolidationCandidate(
-            memory_id="mem_001",
-            similarity_score=0.92,
-            action=ConsolidationAction.MERGE,
-            reasoning="Very high similarity",
-            confidence=0.9,
-        )
-        assert candidate.memory_id == "mem_001"
-        assert candidate.similarity_score == 0.92
-        assert candidate.action == ConsolidationAction.MERGE
-        assert candidate.reasoning == "Very high similarity"
-        assert candidate.confidence == 0.9
-
-
-class TestConsolidationAction:
-    """Test ConsolidationAction enum."""
-
-    def test_consolidation_action_values(self):
-        """Test ConsolidationAction enum values."""
-        assert ConsolidationAction.MERGE.value == "merge"
-        assert ConsolidationAction.LINK.value == "link"
-        assert ConsolidationAction.NONE.value == "none"
-
-
-class TestProcessingTier:
-    """Test ProcessingTier enum."""
-
-    def test_processing_tier_values(self):
-        """Test ProcessingTier enum values."""
-        assert ProcessingTier.LEXICAL.value == "lexical"
-        assert ProcessingTier.SEMANTIC.value == "semantic"
-        assert ProcessingTier.DEEP.value == "deep"