Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# 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."""