MCP Memory Service

"""
Unit tests for Memory Type Ontology

Tests the formal ontology layer for memory classification and type validation.
"""

import sys
from pathlib import Path
import importlib.util
import pytest

# Load ontology module directly without importing the package
ontology_path = Path(__file__).parent.parent / "src" / "mcp_memory_service" / "models" / "ontology.py"
spec = importlib.util.spec_from_file_location("ontology", ontology_path)
ontology = importlib.util.module_from_spec(spec)
spec.loader.exec_module(ontology)

BaseMemoryType = ontology.BaseMemoryType
TAXONOMY = ontology.TAXONOMY
RELATIONSHIPS = ontology.RELATIONSHIPS
validate_memory_type = ontology.validate_memory_type
get_parent_type = ontology.get_parent_type
get_all_types = ontology.get_all_types
validate_relationship = ontology.validate_relationship
is_symmetric_relationship = ontology.is_symmetric_relationship
MemoryTypeOntology = ontology.MemoryTypeOntology


class TestBurst11BaseMemoryTypes:
    """Tests for Burst 1.1: Base Memory Types Enum"""

    def test_enum_has_exactly_twelve_base_types(self):
        """Base type enum should have exactly 12 types (5 original + 7 new)"""
        assert len(BaseMemoryType) == 12

    def test_each_type_is_valid_string_constant(self):
        """Each base type should be a valid string constant"""
        expected_types = {
            # Software Development (original 5)
            "observation",
            "decision",
            "learning",
            "error",
            "pattern",
            # Project Management - Agile (2 new)
            "planning",
            "ceremony",
            # Project Management - Traditional (2 new)
            "milestone",
            "stakeholder",
            # General Knowledge Work (3 new)
            "meeting",
            "research",
            "communication"
        }
        actual_types = {member.value for member in BaseMemoryType}
        assert actual_types == expected_types

    def test_base_types_are_lowercase(self):
        """All base type values should be lowercase for consistency"""
        for member in BaseMemoryType:
            assert member.value.islower()

    def test_base_types_accessible_as_enum_members(self):
        """Base types should be accessible as enum members"""
        # Original types
        assert BaseMemoryType.OBSERVATION.value == "observation"
        assert BaseMemoryType.DECISION.value == "decision"
        assert BaseMemoryType.LEARNING.value == "learning"
        assert BaseMemoryType.ERROR.value == "error"
        assert BaseMemoryType.PATTERN.value == "pattern"
        # New types
        assert BaseMemoryType.PLANNING.value == "planning"
        assert BaseMemoryType.CEREMONY.value == "ceremony"
        assert BaseMemoryType.MILESTONE.value == "milestone"
        assert BaseMemoryType.STAKEHOLDER.value == "stakeholder"
        assert BaseMemoryType.MEETING.value == "meeting"
        assert BaseMemoryType.RESEARCH.value == "research"
        assert BaseMemoryType.COMMUNICATION.value == "communication"


class TestBurst12TaxonomyHierarchy:
    """Tests for Burst 1.2: Taxonomy Hierarchy Dictionary"""

    def test_each_base_type_has_at_least_two_subtypes(self):
        """Each base type should have at least 2 subtypes for meaningful classification"""
        for base_type in BaseMemoryType:
            subtypes = TAXONOMY.get(base_type.value, [])
            assert len(subtypes) >= 2, f"{base_type.value} has {len(subtypes)} subtypes, expected >= 2"

    def test_all_subtypes_are_unique_across_taxonomy(self):
        """No subtype should appear under multiple base types"""
        all_subtypes = []
        for base_type, subtypes in TAXONOMY.items():
            all_subtypes.extend(subtypes)

        # Check for duplicates
        assert len(all_subtypes) == len(set(all_subtypes)), \
            f"Found duplicate subtypes: {[s for s in all_subtypes if all_subtypes.count(s) > 1]}"

    def test_taxonomy_covers_all_base_types(self):
        """TAXONOMY dict should have entries for all base types"""
        base_type_values = {member.value for member in BaseMemoryType}
        taxonomy_keys = set(TAXONOMY.keys())
        assert base_type_values == taxonomy_keys

    def test_all_subtypes_are_lowercase_with_underscores(self):
        """Subtypes should follow snake_case naming convention"""
        for base_type, subtypes in TAXONOMY.items():
            for subtype in subtypes:
                assert subtype.islower() or '_' in subtype, \
                    f"Subtype '{subtype}' should be lowercase with underscores"
                assert ' ' not in subtype, f"Subtype '{subtype}' should not contain spaces"


class TestBurst13RelationshipTypes:
    """Tests for Burst 1.3: Relationship Types Definition"""

    def test_six_relationship_types_defined(self):
        """Should have exactly 6 relationship types"""
        expected_types = {"causes", "fixes", "contradicts", "supports", "follows", "related"}
        actual_types = set(RELATIONSHIPS.keys())
        assert actual_types == expected_types

    def test_each_type_has_description(self):
        """Each relationship type should have a description"""
        for rel_type, config in RELATIONSHIPS.items():
            assert "description" in config, f"{rel_type} missing description"
            assert len(config["description"]) > 0, f"{rel_type} has empty description"

    def test_each_type_has_valid_patterns(self):
        """Each relationship type should define valid source→target patterns"""
        for rel_type, config in RELATIONSHIPS.items():
            assert "valid_patterns" in config, f"{rel_type} missing valid_patterns"
            assert len(config["valid_patterns"]) > 0, f"{rel_type} has no valid patterns"

    def test_related_type_accepts_any_pattern(self):
        """The 'related' type should accept any→any pattern (default fallback)"""
        related_patterns = RELATIONSHIPS["related"]["valid_patterns"]
        assert "any → any" in related_patterns, "related type should accept any→any pattern"


class TestBurst14MemoryTypeValidation:
    """Tests for Burst 1.4: Memory Type Validation"""

    def test_base_types_validate_correctly(self):
        """All base types should validate as True"""
        assert validate_memory_type("observation") is True
        assert validate_memory_type("decision") is True
        assert validate_memory_type("learning") is True
        assert validate_memory_type("error") is True
        assert validate_memory_type("pattern") is True

    def test_subtypes_validate_correctly(self):
        """All subtypes should validate as True"""
        # Test a few subtypes from each category
        assert validate_memory_type("code_edit") is True  # observation subtype
        assert validate_memory_type("architecture") is True  # decision subtype
        assert validate_memory_type("insight") is True  # learning subtype
        assert validate_memory_type("bug") is True  # error subtype
        assert validate_memory_type("code_smell") is True  # pattern subtype

    def test_invalid_types_return_false(self):
        """Invalid types should return False"""
        assert validate_memory_type("invalid_type") is False
        assert validate_memory_type("not_a_type") is False
        assert validate_memory_type("") is False
        assert validate_memory_type("ObSeRvAtIoN") is False  # Case sensitive


class TestBurst15GetParentType:
    """Tests for Burst 1.5: Get Parent Type Function"""

    def test_subtype_returns_correct_parent(self):
        """Subtypes should return their parent base type"""
        assert get_parent_type("code_edit") == "observation"
        assert get_parent_type("architecture") == "decision"
        assert get_parent_type("insight") == "learning"
        assert get_parent_type("bug") == "error"
        assert get_parent_type("code_smell") == "pattern"

    def test_base_type_returns_itself(self):
        """Base types should return themselves (they are their own parent)"""
        assert get_parent_type("observation") == "observation"
        assert get_parent_type("decision") == "decision"
        assert get_parent_type("learning") == "learning"
        assert get_parent_type("error") == "error"
        assert get_parent_type("pattern") == "pattern"

    def test_invalid_type_returns_none(self):
        """Invalid types should return None"""
        assert get_parent_type("invalid_type") is None
        assert get_parent_type("not_a_type") is None
        assert get_parent_type("") is None


class TestBurst16GetAllTypes:
    """Tests for Burst 1.6: Get All Types Function"""

    def test_returns_correct_count(self):
        """Should return the correct total count of base and subtypes"""
        all_types = get_all_types()
        expected_count = len(BaseMemoryType) + sum(len(subtypes) for subtypes in TAXONOMY.values())
        assert len(all_types) == expected_count

    def test_no_duplicates_in_list(self):
        """Should not have duplicate types in the list"""
        all_types = get_all_types()
        assert len(all_types) == len(set(all_types))

    def test_includes_base_types(self):
        """Should include all base types"""
        all_types = get_all_types()
        assert "observation" in all_types
        assert "decision" in all_types
        assert "learning" in all_types
        assert "error" in all_types
        assert "pattern" in all_types

    def test_includes_subtypes(self):
        """Should include subtypes from all categories"""
        all_types = get_all_types()
        assert "code_edit" in all_types
        assert "architecture" in all_types
        assert "insight" in all_types
        assert "bug" in all_types
        assert "code_smell" in all_types

    def test_document_types_are_valid(self):
        """Document-related types should be valid observation subtypes"""
        # Validate that new document types are recognized
        assert validate_memory_type("document") is True
        assert validate_memory_type("note") is True
        assert validate_memory_type("reference") is True

        # Validate parent type hierarchy
        assert get_parent_type("document") == "observation"
        assert get_parent_type("note") == "observation"
        assert get_parent_type("reference") == "observation"

        # Validate they appear in the full type list
        all_types = get_all_types()
        assert "document" in all_types
        assert "note" in all_types
        assert "reference" in all_types


class TestBurst17RelationshipTypeValidation:
    """Tests for Burst 1.7: Relationship Type Validation"""

    def test_valid_types_return_true(self):
        """All 6 defined relationship types should validate as True"""
        assert validate_relationship("causes") is True
        assert validate_relationship("fixes") is True
        assert validate_relationship("contradicts") is True
        assert validate_relationship("supports") is True
        assert validate_relationship("follows") is True
        assert validate_relationship("related") is True

    def test_invalid_types_return_false(self):
        """Invalid relationship types should return False"""
        assert validate_relationship("invalid_relationship") is False
        assert validate_relationship("not_a_rel") is False
        assert validate_relationship("") is False


class TestBurst18OntologyClassIntegration:
    """Tests for Burst 1.8: Ontology Class Integration"""

    def test_class_methods_accessible(self):
        """All ontology methods should be accessible via the class"""
        # Test that class has all expected methods
        assert hasattr(MemoryTypeOntology, 'validate_memory_type')
        assert hasattr(MemoryTypeOntology, 'get_parent_type')
        assert hasattr(MemoryTypeOntology, 'get_all_types')
        assert hasattr(MemoryTypeOntology, 'validate_relationship')

    def test_validate_memory_type_via_class(self):
        """validate_memory_type should work via class method"""
        assert MemoryTypeOntology.validate_memory_type("observation") is True
        assert MemoryTypeOntology.validate_memory_type("code_edit") is True
        assert MemoryTypeOntology.validate_memory_type("invalid") is False

    def test_get_parent_type_via_class(self):
        """get_parent_type should work via class method"""
        assert MemoryTypeOntology.get_parent_type("code_edit") == "observation"
        assert MemoryTypeOntology.get_parent_type("observation") == "observation"
        assert MemoryTypeOntology.get_parent_type("invalid") is None

    def test_get_all_types_via_class(self):
        """get_all_types should work via class method"""
        all_types = MemoryTypeOntology.get_all_types()
        expected_count = len(BaseMemoryType) + sum(len(subtypes) for subtypes in TAXONOMY.values())
        assert len(all_types) == expected_count
        assert "observation" in all_types
        assert "code_edit" in all_types

    def test_validate_relationship_via_class(self):
        """validate_relationship should work via class method"""
        assert MemoryTypeOntology.validate_relationship("causes") is True
        assert MemoryTypeOntology.validate_relationship("invalid") is False


class TestBurst19SymmetricRelationshipClassification:
    """Tests for is_symmetric_relationship() - PR #348"""

    def test_is_symmetric_relationship_symmetric_types(self):
        """Test symmetric relationship types return True"""
        assert is_symmetric_relationship("related") is True
        assert is_symmetric_relationship("contradicts") is True

    def test_is_symmetric_relationship_asymmetric_types(self):
        """Test asymmetric relationship types return False"""
        assert is_symmetric_relationship("causes") is False
        assert is_symmetric_relationship("fixes") is False
        assert is_symmetric_relationship("supports") is False
        assert is_symmetric_relationship("follows") is False

    def test_is_symmetric_relationship_invalid_type(self):
        """Test invalid relationship type raises ValueError"""
        with pytest.raises(ValueError, match="Invalid relationship type"):
            is_symmetric_relationship("invalid_type")

    def test_is_symmetric_relationship_via_class(self):
        """Test is_symmetric_relationship works via class method"""
        assert MemoryTypeOntology.is_symmetric_relationship("related") is True
        assert MemoryTypeOntology.is_symmetric_relationship("causes") is False

        with pytest.raises(ValueError):
            MemoryTypeOntology.is_symmetric_relationship("invalid")


class TestBurst20NewProjectManagementTypes:
    """Test new project management base types (Issue #464)."""

    def test_new_base_types_exist(self):
        """Verify all 7 new base types are defined."""
        new_base_types = [
            "planning", "ceremony", "milestone", "stakeholder",
            "meeting", "research", "communication"
        ]

        all_types = get_all_types()
        for base_type in new_base_types:
            assert base_type in all_types, f"New base type '{base_type}' missing"

    def test_planning_subtypes(self):
        """Verify planning subtypes."""
        expected = [
            "sprint_goal", "backlog_item", "story_point_estimate",
            "velocity", "retrospective", "standup_note", "acceptance_criteria"
        ]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "planning"

    def test_ceremony_subtypes(self):
        """Verify ceremony subtypes."""
        expected = [
            "sprint_review", "sprint_planning", "daily_standup",
            "retrospective_action", "demo_feedback"
        ]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "ceremony"

    def test_milestone_subtypes(self):
        """Verify milestone subtypes."""
        expected = [
            "deliverable", "dependency", "risk", "constraint", "assumption", "deadline"
        ]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "milestone"

    def test_stakeholder_subtypes(self):
        """Verify stakeholder subtypes."""
        expected = [
            "requirement", "feedback", "escalation", "approval",
            "change_request", "status_update"
        ]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "stakeholder"

    def test_meeting_subtypes(self):
        """Verify meeting subtypes."""
        expected = ["action_item", "attendee_note", "agenda_item", "follow_up", "minutes"]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "meeting"

    def test_research_subtypes(self):
        """Verify research subtypes."""
        expected = ["finding", "comparison", "recommendation", "source", "hypothesis"]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "research"

    def test_communication_subtypes(self):
        """Verify communication subtypes."""
        expected = ["email_summary", "chat_summary", "announcement", "request", "response"]

        all_types = get_all_types()
        for subtype in expected:
            assert subtype in all_types
            assert get_parent_type(subtype) == "communication"

    def test_total_type_count(self):
        """Verify total type count is 75 (12 base + 63 subtypes)."""
        all_types = get_all_types()
        assert len(all_types) == 75, f"Expected 75 types, got {len(all_types)}"


class TestBurst21CustomMemoryTypeConfiguration:
    """Test configurable memory types via MCP_CUSTOM_MEMORY_TYPES."""

    def setup_method(self):
        """Clear caches and environment before each test."""
        import os
        # Remove any custom types from environment to ensure clean state
        os.environ.pop('MCP_CUSTOM_MEMORY_TYPES', None)
        ontology.clear_ontology_caches()

    def teardown_method(self):
        """Clear caches and environment after each test."""
        import os
        # Remove any custom types from environment
        os.environ.pop('MCP_CUSTOM_MEMORY_TYPES', None)
        ontology.clear_ontology_caches()

    def test_load_custom_types_json(self, monkeypatch):
        """Test loading custom types from JSON environment variable."""
        import json

        # Set custom types
        custom_config = json.dumps({
            "legal": ["contract", "clause", "obligation"],
            "sales": ["opportunity", "objection", "competitor"]
        })
        monkeypatch.setenv('MCP_CUSTOM_MEMORY_TYPES', custom_config)

        # Clear all caches to force reload
        ontology.clear_ontology_caches()

        # Verify custom types loaded
        all_types = ontology.get_all_types()
        assert "legal" in all_types
        assert "contract" in all_types
        assert "sales" in all_types
        assert "opportunity" in all_types

        # Verify parent relationships
        assert ontology.get_parent_type("contract") == "legal"
        assert ontology.get_parent_type("opportunity") == "sales"

    def test_merge_with_builtin_types(self, monkeypatch):
        """Test that custom types merge with (not replace) built-in types."""
        import json

        custom_config = json.dumps({"meeting": ["board_meeting"]})
        monkeypatch.setenv('MCP_CUSTOM_MEMORY_TYPES', custom_config)

        # Clear caches to force reload
        ontology.clear_ontology_caches()

        all_types = ontology.get_all_types()

        # Built-in meeting subtypes should still exist
        assert "action_item" in all_types
        assert "follow_up" in all_types

        # Custom subtype should be added
        assert "board_meeting" in all_types

    def test_invalid_json_graceful_fallback(self, monkeypatch):
        """Test graceful fallback on invalid JSON."""
        monkeypatch.setenv('MCP_CUSTOM_MEMORY_TYPES', '{invalid json}')

        # Clear caches to force reload
        ontology.clear_ontology_caches()

        # Should fall back to built-in types
        all_types = ontology.get_all_types()
        assert "observation" in all_types  # Built-in type still works

    def test_no_custom_types_default_behavior(self, monkeypatch):
        """Test default behavior when no custom types configured."""
        import os

        # Ensure env var is not set - must be done BEFORE clearing caches
        # Use both monkeypatch AND direct removal to ensure clean state
        monkeypatch.delenv('MCP_CUSTOM_MEMORY_TYPES', raising=False)
        os.environ.pop('MCP_CUSTOM_MEMORY_TYPES', None)

        # Now clear caches to force reload with no custom types
        ontology.clear_ontology_caches()

        all_types = ontology.get_all_types()

        # Should have at least 75 built-in types (might have test pollution from previous tests)
        # The key thing is that custom types from test_load_custom_types_json are NOT present
        assert len(all_types) >= 75, f"Expected at least 75 types, got {len(all_types)}"

        # Verify that the custom types from other tests in this class are NOT present
        # (These are the custom types that should only appear when MCP_CUSTOM_MEMORY_TYPES is set)
        assert "legal" not in all_types, "Custom base type 'legal' should not be present"
        assert "contract" not in all_types, "Custom subtype 'contract' should not be present"
        assert "sales" not in all_types, "Custom base type 'sales' should not be present"
        assert "opportunity" not in all_types, "Custom subtype 'opportunity' should not be present"

        # Verify standard types work
        assert "observation" in all_types
        assert "planning" in all_types
        assert "meeting" in all_types