basic-memory

"""Tests for datetime serialization in memory schema models."""

import json
from datetime import datetime


from basic_memory.schemas.memory import (
    EntitySummary,
    RelationSummary,
    ObservationSummary,
    MemoryMetadata,
    GraphContext,
    ContextResult,
)


class TestDateTimeSerialization:
    """Test datetime serialization for MCP schema compliance."""

    def test_entity_summary_datetime_serialization(self):
        """Test EntitySummary serializes datetime as ISO format string."""
        test_datetime = datetime(2023, 12, 8, 10, 30, 0)

        entity = EntitySummary(
            external_id="550e8400-e29b-41d4-a716-446655440000",
            entity_id=1,
            permalink="test/entity",
            title="Test Entity",
            file_path="test/entity.md",
            created_at=test_datetime,
        )

        # Test model_dump_json() produces ISO format
        json_str = entity.model_dump_json()
        data = json.loads(json_str)

        assert data["created_at"] == "2023-12-08T10:30:00"
        assert data["type"] == "entity"
        assert data["title"] == "Test Entity"
        assert data["external_id"] == "550e8400-e29b-41d4-a716-446655440000"
        # entity_id is excluded from serialization
        assert "entity_id" not in data

    def test_relation_summary_datetime_serialization(self):
        """Test RelationSummary serializes datetime as ISO format string."""
        test_datetime = datetime(2023, 12, 8, 15, 45, 30)

        relation = RelationSummary(
            relation_id=1,
            entity_id=1,
            title="Test Relation",
            file_path="test/relation.md",
            permalink="test/relation",
            relation_type="relates_to",
            from_entity="entity1",
            to_entity="entity2",
            created_at=test_datetime,
        )

        # Test model_dump_json() produces ISO format
        json_str = relation.model_dump_json()
        data = json.loads(json_str)

        assert data["created_at"] == "2023-12-08T15:45:30"
        assert data["type"] == "relation"
        assert data["relation_type"] == "relates_to"
        # Internal IDs excluded from serialization
        assert "relation_id" not in data
        assert "entity_id" not in data
        assert "from_entity_id" not in data
        assert "from_entity_external_id" not in data
        assert "to_entity_id" not in data
        assert "to_entity_external_id" not in data

    def test_observation_summary_serialization(self):
        """Test ObservationSummary keeps file_path/created_at, excludes internal IDs."""
        test_datetime = datetime(2023, 12, 8, 20, 15, 45)

        observation = ObservationSummary(
            observation_id=1,
            entity_id=1,
            title="Test Observation",
            file_path="test/observation.md",
            permalink="test/observation",
            category="note",
            content="Test content",
            created_at=test_datetime,
        )

        json_str = observation.model_dump_json()
        data = json.loads(json_str)

        # Internal ID fields excluded
        assert "observation_id" not in data
        assert "entity_id" not in data
        assert "entity_external_id" not in data
        assert "title" not in data
        # file_path and created_at kept (needed when observation is primary_result)
        assert data["file_path"] == "test/observation.md"
        assert data["created_at"] == "2023-12-08T20:15:45"
        # Other kept fields
        assert data["type"] == "observation"
        assert data["category"] == "note"
        assert data["content"] == "Test content"
        assert data["permalink"] == "test/observation"

    def test_memory_metadata_datetime_serialization(self):
        """Test MemoryMetadata excludes generated_at and total_results."""
        test_datetime = datetime(2023, 12, 8, 12, 0, 0)

        metadata = MemoryMetadata(
            depth=2, generated_at=test_datetime, primary_count=5, related_count=3
        )

        # Test model_dump_json() excludes internal fields
        json_str = metadata.model_dump_json()
        data = json.loads(json_str)

        # Excluded fields
        assert "generated_at" not in data
        assert "total_results" not in data
        # Kept fields
        assert data["depth"] == 2
        assert data["primary_count"] == 5
        assert data["related_count"] == 3

    def test_context_result_with_datetime_serialization(self):
        """Test ContextResult with nested models serializes correctly."""
        test_datetime = datetime(2023, 12, 8, 9, 30, 15)

        entity = EntitySummary(
            external_id="550e8400-e29b-41d4-a716-446655440000",
            entity_id=1,
            permalink="test/entity",
            title="Test Entity",
            file_path="test/entity.md",
            created_at=test_datetime,
        )

        observation = ObservationSummary(
            observation_id=1,
            entity_id=1,
            title="Test Observation",
            file_path="test/observation.md",
            permalink="test/observation",
            category="note",
            content="Test content",
            created_at=test_datetime,
        )

        context_result = ContextResult(
            primary_result=entity, observations=[observation], related_results=[]
        )

        # Test model_dump_json() produces ISO format for nested models
        json_str = context_result.model_dump_json()
        data = json.loads(json_str)

        # Entity created_at kept, entity_id excluded
        assert data["primary_result"]["created_at"] == "2023-12-08T09:30:15"
        assert "entity_id" not in data["primary_result"]
        # Observation created_at kept (needed for primary_result use), internal IDs excluded
        assert data["observations"][0]["created_at"] == "2023-12-08T09:30:15"
        assert "observation_id" not in data["observations"][0]
        assert "entity_id" not in data["observations"][0]

    def test_graph_context_full_serialization(self):
        """Test full GraphContext serialization with all datetime fields."""
        test_datetime = datetime(2023, 12, 8, 14, 20, 10)

        entity = EntitySummary(
            external_id="550e8400-e29b-41d4-a716-446655440000",
            entity_id=1,
            permalink="test/entity",
            title="Test Entity",
            file_path="test/entity.md",
            created_at=test_datetime,
        )

        metadata = MemoryMetadata(
            depth=1, generated_at=test_datetime, primary_count=1, related_count=0
        )

        context_result = ContextResult(primary_result=entity, observations=[], related_results=[])

        graph_context = GraphContext(
            results=[context_result], metadata=metadata, page=1, page_size=10
        )

        # Test full serialization
        json_str = graph_context.model_dump_json()
        data = json.loads(json_str)

        # Metadata excluded fields
        assert "generated_at" not in data["metadata"]
        assert "total_results" not in data["metadata"]
        # Entity created_at kept, entity_id excluded
        assert data["results"][0]["primary_result"]["created_at"] == "2023-12-08T14:20:10"
        assert "entity_id" not in data["results"][0]["primary_result"]

    def test_datetime_with_microseconds_serialization(self):
        """Test datetime with microseconds serializes correctly."""
        test_datetime = datetime(2023, 12, 8, 10, 30, 0, 123456)

        entity = EntitySummary(
            external_id="550e8400-e29b-41d4-a716-446655440000",
            entity_id=1,
            permalink="test/entity",
            title="Test Entity",
            file_path="test/entity.md",
            created_at=test_datetime,
        )

        json_str = entity.model_dump_json()
        data = json.loads(json_str)

        # Should include microseconds in ISO format
        assert data["created_at"] == "2023-12-08T10:30:00.123456"

    def test_mcp_schema_validation_compatibility(self):
        """Test that serialized datetime format is compatible with MCP schema validation."""
        test_datetime = datetime(2023, 12, 8, 10, 30, 0)

        entity = EntitySummary(
            external_id="550e8400-e29b-41d4-a716-446655440000",
            entity_id=1,
            permalink="test/entity",
            title="Test Entity",
            file_path="test/entity.md",
            created_at=test_datetime,
        )

        # Serialize to JSON
        json_str = entity.model_dump_json()
        data = json.loads(json_str)

        # Verify the format matches expected MCP "date-time" format
        datetime_str = data["created_at"]

        # Should be parseable back to datetime (ISO format validation)
        parsed_datetime = datetime.fromisoformat(datetime_str)
        assert parsed_datetime == test_datetime

        # Should match the expected ISO format pattern
        assert "T" in datetime_str  # Contains date-time separator
        assert len(datetime_str) >= 19  # At least YYYY-MM-DDTHH:MM:SS format

    def test_entity_and_relation_serializers_still_active(self):
        """Test that EntitySummary and RelationSummary datetime serializers work with model_dump."""
        test_datetime = datetime(2023, 12, 8, 10, 30, 0)

        entity = EntitySummary(
            external_id="550e8400-e29b-41d4-a716-446655440000",
            entity_id=1,
            permalink="test",
            title="Test",
            file_path="test.md",
            created_at=test_datetime,
        )

        relation = RelationSummary(
            relation_id=1,
            entity_id=1,
            title="Test",
            file_path="test.md",
            permalink="test",
            relation_type="test",
            created_at=test_datetime,
        )

        # model_dump should serialize datetimes via field_serializer
        entity_data = entity.model_dump()
        assert entity_data["created_at"] == "2023-12-08T10:30:00"
        assert "entity_id" not in entity_data  # excluded

        relation_data = relation.model_dump()
        assert relation_data["created_at"] == "2023-12-08T15:45:30" or True  # serializer active
        assert relation_data["created_at"] == "2023-12-08T10:30:00"
        assert "relation_id" not in relation_data  # excluded

    def test_related_results_serialization_round_trip(self):
        """Test that related_results serialize correctly with identifying fields preserved.

        This validates the fix for #627: related_results must retain title, file_path,
        and created_at so consumers can identify them without the parent entity context.
        """
        test_datetime = datetime(2023, 12, 8, 14, 0, 0)

        # Primary entity
        primary = EntitySummary(
            external_id="aaa",
            entity_id=1,
            permalink="test/primary",
            title="Primary",
            file_path="test/primary.md",
            created_at=test_datetime,
        )

        # Related entity — should keep title, file_path, created_at
        related_entity = EntitySummary(
            external_id="bbb",
            entity_id=2,
            permalink="test/related",
            title="Related Entity",
            file_path="test/related.md",
            created_at=test_datetime,
        )

        # Related relation — should keep title, file_path, created_at, relation_type
        related_relation = RelationSummary(
            relation_id=10,
            entity_id=1,
            title="Related Via",
            file_path="test/primary.md",
            permalink="test/primary",
            relation_type="relates_to",
            from_entity="Primary",
            from_entity_id=1,
            to_entity="Related Entity",
            to_entity_id=2,
            created_at=test_datetime,
        )

        # Observation nested under primary
        obs = ObservationSummary(
            observation_id=100,
            entity_id=1,
            title="Primary",
            file_path="test/primary.md",
            permalink="test/primary",
            category="note",
            content="Some observation",
            created_at=test_datetime,
        )

        context_result = ContextResult(
            primary_result=primary,
            observations=[obs],
            related_results=[related_entity, related_relation],
        )

        graph = GraphContext(
            results=[context_result],
            metadata=MemoryMetadata(
                depth=1, generated_at=test_datetime, primary_count=1, related_count=2
            ),
            page=1,
            page_size=10,
        )

        # Serialize via model_dump (same path as build_context tool)
        data = graph.model_dump()

        result = data["results"][0]

        # Primary entity: created_at present, entity_id excluded
        assert result["primary_result"]["title"] == "Primary"
        assert result["primary_result"]["created_at"] == "2023-12-08T14:00:00"
        assert "entity_id" not in result["primary_result"]

        # Observation: internal IDs excluded, file_path/created_at kept
        obs_data = result["observations"][0]
        assert obs_data["category"] == "note"
        assert obs_data["content"] == "Some observation"
        assert obs_data["permalink"] == "test/primary"
        assert obs_data["file_path"] == "test/primary.md"
        assert obs_data["created_at"] == "2023-12-08T14:00:00"
        assert "observation_id" not in obs_data
        assert "entity_id" not in obs_data
        assert "title" not in obs_data

        # Related entity: identifying fields present
        rel_entity = result["related_results"][0]
        assert rel_entity["type"] == "entity"
        assert rel_entity["title"] == "Related Entity"
        assert rel_entity["file_path"] == "test/related.md"
        assert rel_entity["created_at"] == "2023-12-08T14:00:00"
        assert "entity_id" not in rel_entity

        # Related relation: identifying fields present, internal IDs excluded
        rel_relation = result["related_results"][1]
        assert rel_relation["type"] == "relation"
        assert rel_relation["relation_type"] == "relates_to"
        assert rel_relation["title"] == "Related Via"
        assert rel_relation["file_path"] == "test/primary.md"
        assert rel_relation["created_at"] == "2023-12-08T14:00:00"
        assert "relation_id" not in rel_relation
        assert "entity_id" not in rel_relation
        assert "from_entity_id" not in rel_relation
        assert "to_entity_id" not in rel_relation
        assert "from_entity_external_id" not in rel_relation
        assert "to_entity_external_id" not in rel_relation

        # Metadata: excluded fields absent
        assert "generated_at" not in data["metadata"]
        assert "total_results" not in data["metadata"]
        assert data["metadata"]["depth"] == 1
        assert data["metadata"]["primary_count"] == 1
        assert data["metadata"]["related_count"] == 2

        # Round-trip: re-parse from JSON
        json_str = graph.model_dump_json()
        reparsed = json.loads(json_str)
        assert reparsed["results"][0]["related_results"][0]["title"] == "Related Entity"
        assert reparsed["results"][0]["related_results"][1]["relation_type"] == "relates_to"

    def test_observation_as_primary_result_preserves_fields(self):
        """Test that ObservationSummary retains file_path and created_at when used as primary_result.

        This covers the case raised in PR review: recent_activity uses
        primary_result.created_at and primary_result.file_path for activity
        tracking. These fields must survive the JSON round-trip.
        """
        test_datetime = datetime(2023, 12, 8, 16, 0, 0)

        obs_primary = ObservationSummary(
            observation_id=42,
            entity_id=7,
            entity_external_id="obs-ext-id",
            title="Parent Entity Title",
            file_path="notes/daily.md",
            permalink="notes/daily",
            category="status",
            content="Shipped the feature today",
            created_at=test_datetime,
        )

        context_result = ContextResult(
            primary_result=obs_primary,
            observations=[],
            related_results=[],
        )

        graph = GraphContext(
            results=[context_result],
            metadata=MemoryMetadata(
                depth=1, generated_at=test_datetime, primary_count=1, related_count=0
            ),
            page=1,
            page_size=10,
        )

        # Serialize and round-trip through JSON (same path as API responses)
        json_str = graph.model_dump_json()
        data = json.loads(json_str)

        primary = data["results"][0]["primary_result"]

        # file_path and created_at must be present for recent_activity tracking
        assert primary["file_path"] == "notes/daily.md"
        assert primary["created_at"] == "2023-12-08T16:00:00"
        assert primary["permalink"] == "notes/daily"
        assert primary["category"] == "status"
        assert primary["content"] == "Shipped the feature today"
        assert primary["type"] == "observation"

        # Internal IDs still excluded
        assert "observation_id" not in primary
        assert "entity_id" not in primary
        assert "entity_external_id" not in primary
        assert "title" not in primary

        # Round-trip: deserialize back into GraphContext
        reparsed = GraphContext.model_validate_json(json_str)
        reparsed_primary = reparsed.results[0].primary_result
        assert reparsed_primary.file_path == "notes/daily.md"
        assert reparsed_primary.created_at == test_datetime