Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

19.5 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""Tests for schema_models.py - dynamic Pydantic model generation."""

import json
import tempfile
from pathlib import Path

import pytest
import yaml

from openviking.session.memory.dataclass import (
    MemoryField,
    MemoryTypeSchema,
    WikiLink,
)
from openviking.session.memory.memory_type_registry import (
    MemoryTypeRegistry,
    get_default_registry,
)
from openviking.session.memory.merge_op.base import FieldType, MergeOp
from openviking.session.memory.schema_model_generator import (
    SchemaModelGenerator,
    to_pascal_case,
)
from openviking.session.memory.utils.json_parser import parse_json_with_stability


class TestToPascalCase:
    """Tests for to_pascal_case helper function."""

    def test_snake_case(self):
        """Test converting snake_case to PascalCase."""
        assert to_pascal_case("profile_memory") == "ProfileMemory"

    def test_kebab_case(self):
        """Test converting kebab-case to PascalCase."""
        assert to_pascal_case("memory-type") == "MemoryType"

    def test_spaces(self):
        """Test converting space-separated to PascalCase."""
        assert to_pascal_case("user preferences") == "UserPreferences"

    def test_mixed(self):
        """Test mixed separators."""
        assert to_pascal_case("test-case_with spaces") == "TestCaseWithSpaces"


class TestSchemaModelGenerator:
    """Tests for SchemaModelGenerator."""

    @pytest.fixture
    def sample_memory_type(self):
        """Create a sample MemoryTypeSchema for testing."""
        return MemoryTypeSchema(
            memory_type="test_type",
            description="Test memory type",
            fields=[
                MemoryField(
                    name="field1",
                    field_type=FieldType.STRING,
                    description="First test field",
                    merge_op=MergeOp.PATCH,
                ),
                MemoryField(
                    name="field2",
                    field_type=FieldType.INT64,
                    description="Second test field",
                    merge_op=MergeOp.SUM,
                ),
            ],
            filename_template="test.md",
            directory="test://dir",
        )

    @pytest.fixture
    def registry_with_sample(self, sample_memory_type):
        """Create a registry with a sample memory type."""
        registry = MemoryTypeRegistry()
        registry.register(sample_memory_type)
        return registry

    @pytest.fixture
    def real_registry(self):
        """Create a registry with real schemas."""
        return get_default_registry()

    def test_peer_enabled_false_omits_peer_id_field(self):
        memory_type = MemoryTypeSchema(
            memory_type="cases",
            description="Case memory",
            fields=[
                MemoryField(
                    name="case_name",
                    field_type=FieldType.STRING,
                    description="Case name",
                    merge_op=MergeOp.IMMUTABLE,
                )
            ],
            filename_template="{{ case_name }}.md",
            directory="viking://user/{{ user_space }}/memories/cases",
            peer_enabled=False,
        )
        role_scope = type("RoleScope", (), {"peer_ids": ["web-visitor-alice"]})()

        model = SchemaModelGenerator([memory_type]).create_flat_data_model(
            memory_type,
            role_scope=role_scope,
        )

        assert "peer_id" not in model.model_fields

    def test_render_description_template_with_language(self):
        memory_type = MemoryTypeSchema(
            memory_type="templated",
            description="Summary must be written in {{ language }}.",
            fields=[
                MemoryField(
                    name="content",
                    field_type=FieldType.STRING,
                    description="Write this field in {{ language }}.",
                    merge_op=MergeOp.PATCH,
                )
            ],
            filename_template="templated.md",
            directory="test://dir",
        )

        generator = SchemaModelGenerator([memory_type], template_context={"language": "zh-CN"})
        model = generator.create_flat_data_model(memory_type)
        ops_model = generator.create_structured_operations_model(role_scope=None)

        content_description = model.model_fields["content"].description
        memory_description = ops_model.model_fields["templated"].description

        assert "{{ language }}" not in content_description
        assert "{{ language }}" not in memory_description
        assert "zh-CN" in content_description
        assert "zh-CN" in memory_description

    def test_keep_plain_description_unchanged(self, sample_memory_type):
        generator = SchemaModelGenerator([sample_memory_type], template_context={"language": "ja"})
        model = generator.create_flat_data_model(sample_memory_type)

        assert "First test field" in model.model_fields["field1"].description

    def test_events_ranges_description_requires_user_source(self, real_registry):
        events = real_registry.get("events")
        model = SchemaModelGenerator([events]).create_flat_data_model(events)

        description = model.model_fields["ranges"].description

        assert "MUST include at least one user-role message" in description
        assert "include both the originating user message and the assistant message" in description
        assert "Never output assistant-only ranges for events" in description

    def test_render_description_template_conditional_branch(self):
        memory_type = MemoryTypeSchema(
            memory_type="conditional",
            description="{% if language == 'en' %}English summary{% else %}{{ language }} summary{% endif %}",
            fields=[
                MemoryField(
                    name="topic",
                    field_type=FieldType.STRING,
                    description="{% if language == 'en' %}snake_case only{% else %}natural {{ language }} phrase{% endif %}",
                    merge_op=MergeOp.IMMUTABLE,
                )
            ],
            filename_template="conditional.md",
            directory="test://dir",
        )

        en_generator = SchemaModelGenerator([memory_type], template_context={"language": "en"})
        zh_generator = SchemaModelGenerator([memory_type], template_context={"language": "zh-CN"})

        en_model = en_generator.create_flat_data_model(memory_type)
        zh_model = zh_generator.create_flat_data_model(memory_type)
        zh_ops_model = zh_generator.create_structured_operations_model(role_scope=None)

        assert en_model.model_fields["topic"].description == "snake_case only"
        assert zh_model.model_fields["topic"].description == "natural zh-CN phrase"
        assert "zh-CN summary" in zh_ops_model.model_fields["conditional"].description

    def test_create_flat_data_model(self, sample_memory_type, registry_with_sample):
        """Test creating a flat data model for a single memory type."""
        generator = SchemaModelGenerator(registry_with_sample)
        model = generator.create_flat_data_model(sample_memory_type)

        # Check model name
        assert model.__name__ == "TestTypeData"

        # memory_type is represented by the top-level structured output field.
        assert "memory_type" not in model.model_fields

        # Check business fields
        assert "field1" in model.model_fields
        assert "field2" in model.model_fields

    def test_page_id_field_is_emitted_before_mutable_content(self, registry_with_sample):
        """page_id should appear before mutable fields so the model anchors target page first."""
        from unittest.mock import patch

        generator = SchemaModelGenerator(registry_with_sample)
        with patch(
            "openviking_cli.utils.config.get_openviking_config"
        ) as mock_get_openviking_config:
            mock_get_openviking_config.return_value = type(
                "Config",
                (),
                {"memory": type("MemoryCfg", (), {"link_enabled": True})()},
            )()
            model = generator.create_flat_data_model(registry_with_sample.get("test_type"))

        field_names = list(model.model_fields.keys())

        assert "page_id" in field_names
        assert "field1" in field_names
        assert field_names.index("page_id") < field_names.index("field1")

    def test_page_id_field_is_emitted_when_links_disabled(self, registry_with_sample):
        """page_id anchors edits even when link extraction is disabled."""
        from unittest.mock import patch

        generator = SchemaModelGenerator(registry_with_sample)
        with patch(
            "openviking_cli.utils.config.get_openviking_config"
        ) as mock_get_openviking_config:
            mock_get_openviking_config.return_value = type(
                "Config",
                (),
                {"memory": type("MemoryCfg", (), {"link_enabled": False})()},
            )()
            model = generator.create_flat_data_model(registry_with_sample.get("test_type"))

        field_names = list(model.model_fields.keys())
        assert "page_id" in field_names
        assert field_names.index("page_id") < field_names.index("field1")

        page_id_field = model.model_fields["page_id"]
        assert page_id_field.is_required()
        assert (
            page_id_field.description == "Temporary page_id for identifying the target memory item."
        )
        assert model.model_validate({"page_id": 1, "field1": "value"}).page_id == 1
        with pytest.raises(ValueError):
            model.model_validate({"field1": "value"})

    def test_page_id_schema_is_required_and_short_when_links_enabled(self, registry_with_sample):
        from unittest.mock import patch

        generator = SchemaModelGenerator(registry_with_sample)
        with patch(
            "openviking_cli.utils.config.get_openviking_config"
        ) as mock_get_openviking_config:
            mock_get_openviking_config.return_value = type(
                "Config",
                (),
                {"memory": type("MemoryCfg", (), {"link_enabled": True})()},
            )()
            model = generator.create_flat_data_model(registry_with_sample.get("test_type"))

        page_id_field = model.model_fields["page_id"]
        assert page_id_field.is_required()
        assert (
            page_id_field.description == "Temporary page_id for identifying the target memory item."
        )

        schema = model.model_json_schema()
        assert "page_id" in schema["required"]
        assert schema["properties"]["page_id"]["description"] == (
            "Temporary page_id for identifying the target memory item."
        )

    def test_event_page_id_schema_requires_new_page_range(self):
        memory_type = MemoryTypeSchema(
            memory_type="events",
            operation_mode="add_only",
            filename_template="{{ event_name }}.md",
            directory="viking://user/{{ user_space }}/memories/events",
            fields=[
                MemoryField(
                    name="event_name",
                    field_type=FieldType.STRING,
                    merge_op=MergeOp.IMMUTABLE,
                )
            ],
        )

        model = SchemaModelGenerator([memory_type]).create_flat_data_model(memory_type)
        schema = model.model_json_schema()

        assert schema["properties"]["page_id"]["minimum"] == 100
        assert "MUST be at least 100" in schema["properties"]["page_id"]["description"]
        # Runtime resolution normalizes bad model output instead of dropping the event.
        assert model.model_validate({"page_id": 5, "event_name": "demo"}).page_id == 5
        with pytest.raises(ValueError, match="new memory item requires fields: event_name"):
            model.model_validate({"page_id": 5, "event_name": None})

    def test_add_only_page_id_schema_requires_new_page_range(self):
        memory_type = MemoryTypeSchema(
            memory_type="trajectories",
            operation_mode="add_only",
            filename_template="{{ trajectory_name }}.md",
            directory="viking://user/{{ user_space }}/memories/trajectories",
            fields=[],
        )

        model = SchemaModelGenerator([memory_type]).create_flat_data_model(memory_type)
        page_id_schema = model.model_json_schema()["properties"]["page_id"]

        assert page_id_schema["minimum"] == 100
        assert "MUST be at least 100" in page_id_schema["description"]

    def test_existing_patch_can_omit_immutable_fields_but_new_item_cannot(self, real_registry):
        entities = real_registry.get("entities")
        model = SchemaModelGenerator([entities]).create_flat_data_model(entities)

        existing = model.model_validate(
            {
                "page_id": 2,
                "content": {"blocks": [{"search": "old", "replace": "new"}]},
            }
        )

        assert existing.category is None
        assert existing.name is None
        schema = model.model_json_schema()
        assert schema["required"] == ["page_id"]
        assert schema["allOf"][0]["then"]["required"] == ["category", "name"]

        for page_id in (100, "100"):
            with pytest.raises(ValueError, match="category, name"):
                model.model_validate({"page_id": page_id, "content": "new entity"})

        created = model.model_validate(
            {
                "page_id": 100,
                "category": "activity",
                "name": "horse riding",
                "content": "new entity",
            }
        )
        assert created.category == "activity"
        assert created.name == "horse riding"

    def test_parser_keeps_existing_patch_without_immutable_fields_alongside_delete(
        self, real_registry
    ):
        generator = SchemaModelGenerator(
            [real_registry.get("preferences"), real_registry.get("entities")]
        )
        operations_model = generator.create_structured_operations_model()
        content = json.dumps(
            {
                "entities": [
                    {
                        "page_id": 2,
                        "content": {"blocks": [{"search": "一周学习计划", "replace": ""}]},
                    }
                ],
                "delete_ids": [{"delete_page_id": 1, "replacement_page_id": None}],
            }
        )

        parsed, error = parse_json_with_stability(
            content,
            model_class=operations_model,
            expected_fields=list(operations_model.model_fields),
        )

        assert error is None
        assert len(parsed.entities) == 1
        assert parsed.entities[0].page_id == 2
        assert len(parsed.delete_ids) == 1

    def test_links_field_is_not_emitted_when_links_disabled(self, registry_with_sample):
        from unittest.mock import patch

        generator = SchemaModelGenerator([registry_with_sample.get("test_type")])
        with patch(
            "openviking_cli.utils.config.get_openviking_config"
        ) as mock_get_openviking_config:
            mock_get_openviking_config.return_value = type(
                "Config",
                (),
                {"memory": type("MemoryCfg", (), {"link_enabled": False})()},
            )()
            model = generator.create_structured_operations_model(role_scope=None)

        assert "links" not in model.model_fields

    def test_links_field_description_uses_shared_link_rules_when_links_enabled(
        self, registry_with_sample
    ):
        from unittest.mock import patch

        generator = SchemaModelGenerator([registry_with_sample.get("test_type")])
        with patch(
            "openviking_cli.utils.config.get_openviking_config"
        ) as mock_get_openviking_config:
            mock_get_openviking_config.return_value = type(
                "Config",
                (),
                {"memory": type("MemoryCfg", (), {"link_enabled": True})()},
            )()
            model = generator.create_structured_operations_model(role_scope=None)

        links_field = model.model_fields["links"]
        assert links_field.description == (
            "Links between memory pages. Follow the link rules above. "
            "Use page_ids for `f` and `t`. Use `weight` from 0 to 1 to rank competing links."
        )

    def test_generate_all_models(self, real_registry):
        """Test generating models for all real schemas."""
        generator = SchemaModelGenerator(real_registry)
        # Generate all models including disabled ones
        models = generator.generate_all_models(include_disabled=True)

        # Check we have models for all registered types (including disabled)
        assert len(models) == len(real_registry.list_all(include_disabled=True))

        # Check specific types exist
        assert "profile" in models
        assert "preferences" in models

        # Check profile model has 'content' field
        profile_model = models["profile"]
        assert "content" in profile_model.model_fields

    def test_model_caching(self, registry_with_sample, sample_memory_type):
        """Test that models are cached."""
        generator = SchemaModelGenerator(registry_with_sample)

        # Create model twice
        model1 = generator.create_flat_data_model(sample_memory_type)
        model2 = generator.create_flat_data_model(sample_memory_type)

        # Should be the same object
        assert model1 is model2

    def test_dynamic_new_schema(self):
        """Test that adding a new schema at runtime works without code changes."""
        # Create a temporary YAML file for a new memory type
        with tempfile.TemporaryDirectory() as tmpdir:
            tmp_path = Path(tmpdir)
            new_schema_path = tmp_path / "new_type.yaml"

            # Write a new schema
            new_schema = {
                "memory_type": "new_custom_type",
                "description": "A dynamically added custom type",
                "directory": "test://new",
                "filename_template": "custom_{name}.md",
                "fields": [
                    {
                        "name": "custom_field",
                        "type": "string",
                        "description": "Custom field description",
                        "merge_op": "patch",
                    }
                ],
            }

            with open(new_schema_path, "w", encoding="utf-8") as f:
                yaml.dump(new_schema, f)

            # Load it
            registry = MemoryTypeRegistry()
            registry.load_from_yaml(str(new_schema_path))

            # Verify it's loaded
            assert registry.get("new_custom_type") is not None

            # Generate model
            generator = SchemaModelGenerator(registry)
            model = generator.create_flat_data_model(registry.get("new_custom_type"))

            # Verify the model has the custom field
            assert "custom_field" in model.model_fields
            assert "memory_type" not in model.model_fields


class TestWikiLink:
    def test_invalid_link_type_keeps_freeform_short_label(self):
        link = WikiLink.model_validate(
            {
                "f": 1,
                "t": 2,
                "link_type": "inspired_by",
                "weight": 0.7,
                "match_text": "memory",
                "description": "derived by model",
            }
        )

        assert link.link_type == "inspired_by"

    def test_link_type_schema_is_open_string_without_enum(self):
        schema = WikiLink.model_json_schema()
        link_type_schema = schema["properties"]["link_type"]

        assert link_type_schema["type"] == "string"
        assert "enum" not in link_type_schema


class TestIntegration:
    """Integration tests for the complete schema system."""