Skip to content

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

48.6 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
"""
Tests for MemoryIsolationHandler.
"""

from unittest.mock import MagicMock, patch

import pytest

from openviking.message.message import Message
from openviking.message.part import TextPart
from openviking.server.identity import RequestContext, Role
from openviking.session.memory.dataclass import MemoryOperationSkipCode
from openviking.session.memory.memory_isolation_handler import (
    MemoryIsolationHandler,
)
from openviking.session.memory.memory_updater import ExtractContext
from openviking_cli.session.user_id import UserIdentifier


def create_message(
    role: str,
    content: str = "test",
    peer_id: str | None = None,
) -> Message:
    """Helper to create a test message."""
    return Message(
        id=f"msg_{role}_{peer_id or 'self'}",
        role=role,
        parts=[TextPart(text=content)],
        peer_id=peer_id,
    )


def create_ctx(
    account_id: str = "test_account",
    user_id: str = "user_a",
) -> RequestContext:
    """Helper to create a test RequestContext."""
    user = UserIdentifier(
        account_id=account_id,
        user_id=user_id,
    )
    return RequestContext(user=user, role=Role.USER)


def create_mock_extract_context(messages):
    """Helper to create a mock ExtractContext."""
    mock_ctx = MagicMock()
    mock_ctx.messages = messages
    return mock_ctx


class TestGetReadScope:
    """Tests for get_read_scope."""

    def test_single_user_scope(self):
        """Test extracting the authenticated user scope."""
        ctx = create_ctx()
        messages = [
            create_message("user", "Hello"),
            create_message("assistant", "Hi there"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)

        scope = handler.get_read_scope()

        assert scope.user_ids == ["user_a"]

    def test_message_peer_ids_do_not_expand_self_extraction_scope(self):
        """Message peer_id should not make self extraction read or write peer memory."""
        ctx = create_ctx()
        messages = [
            create_message("user", peer_id="web-visitor-alice"),
            create_message("user", peer_id="web-visitor-bob"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)

        scope = handler.get_read_scope()

        assert scope.user_ids == ["user_a"]
        assert scope.peer_ids == []

    def test_explicit_self_sentinel_message_is_not_a_writable_target(self):
        ctx = create_ctx()
        message = create_message("user", peer_id="__self")
        extract_ctx = create_mock_extract_context([message])
        handler = MemoryIsolationHandler(ctx, extract_ctx, allow_self=True)

        assert handler._message_target_id(message) is None

    def test_writable_message_target_requires_a_resolvable_owner_message(self):
        ctx = create_ctx()
        assistant_only = MemoryIsolationHandler(
            ctx,
            create_mock_extract_context([create_message("assistant")]),
        )
        with_user_message = MemoryIsolationHandler(
            ctx,
            create_mock_extract_context([create_message("user")]),
        )

        assert not assistant_only.has_writable_message_target()
        assert with_user_message.has_writable_message_target()

    def test_deduplicate_users(self):
        """Test that duplicate users are deduplicated."""
        ctx = create_ctx()
        messages = [
            create_message("user", "First message"),
            create_message("user", "Second message"),
            create_message("user", "Third message"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)

        scope = handler.get_read_scope()

        assert scope.user_ids == ["user_a"]

    def test_empty_messages_uses_ctx_defaults(self):
        """Test that empty messages fall back to ctx defaults."""
        ctx = create_ctx(
            user_id="default_user",
        )
        messages = []
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)

        scope = handler.get_read_scope()

        assert scope.user_ids == ["default_user"]

    def test_get_read_scope_filters_self_sentinel_from_peer_scope(self):
        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"__self", "web-visitor-alice"},
        )

        scope = handler.get_read_scope()

        assert scope.user_ids == ["support_bot"]
        assert scope.peer_ids == ["web-visitor-alice"]

    def test_render_schema_directories_self_sentinel_maps_to_user_space(self):
        from openviking.session.memory.dataclass import MemoryTypeSchema
        from openviking.session.memory.memory_isolation_handler import peer_user_space

        assert peer_user_space("support_bot", "__self") == "support_bot"

        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"__self", "web-visitor-alice"},
        )
        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{{ user_space }}/memories",
        )

        dirs = handler.render_schema_directories(schema)

        assert "viking://user/support_bot/memories" in dirs
        assert "viking://user/support_bot/peers/__self/memories" not in dirs
        assert "viking://user/support_bot/peers/web-visitor-alice/memories" in dirs

    def test_render_schema_directories_keep_encoded_peer_isolated(self):
        from openviking.session.memory.dataclass import MemoryTypeSchema

        ctx = create_ctx(user_id="support_bot")
        extract_ctx = create_mock_extract_context(
            [create_message("user", peer_id="ext-5byg5LiJIEFsaWNl")]
        )
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"ext-5byg5LiJIEFsaWNl"},
        )
        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{{ user_space }}/memories",
        )

        assert handler.render_schema_directories(schema) == [
            "viking://user/support_bot/peers/ext-5byg5LiJIEFsaWNl/memories",
        ]

    def test_render_schema_directories_peer_enabled_false_uses_self_only(self):
        from openviking.session.memory.dataclass import MemoryTypeSchema

        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user", peer_id="web-visitor-alice")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"web-visitor-alice"},
        )
        schema = MemoryTypeSchema(
            memory_type="cases",
            filename_template="{{ case_name }}.md",
            directory="viking://user/{{ user_space }}/memories/cases",
            peer_enabled=False,
        )

        dirs = handler.render_schema_directories(schema)

        assert dirs == ["viking://user/support_bot/memories/cases"]


class TestFillIdentityFields:
    """Tests for fill_identity_fields."""

    def test_fill_identity_fields_with_specified_values(self):
        """Test fill_identity_fields keeps writes scoped to the ctx user."""
        ctx = create_ctx()
        messages = [
            create_message("user"),
            create_message("assistant"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        role_scope = handler.get_read_scope()

        item_dict = {"user_id": "user_a"}
        handler.fill_identity_fields(item_dict, role_scope)

        assert item_dict["user_id"] == "user_a"

    def test_fill_identity_fields_without_values_uses_default(self):
        """Test fill_identity_fields without values uses ctx user."""
        ctx = create_ctx()
        messages = [
            create_message("user"),
            create_message("user"),
            create_message("assistant"),
            create_message("assistant"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        role_scope = handler.get_read_scope()

        item_dict = {}
        handler.fill_identity_fields(item_dict, role_scope)

        assert item_dict["user_id"] == "user_a"

    def test_fill_identity_fields_invalid_user_id_ignored(self):
        """Test invalid user_id is ignored, uses default."""
        ctx = create_ctx()
        messages = [
            create_message("user"),
            create_message("assistant"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        role_scope = handler.get_read_scope()

        item_dict = {"user_id": "invalid_user"}
        handler.fill_identity_fields(item_dict, role_scope)

        assert item_dict["user_id"] == "user_a"  # fallback to default

    def test_fill_identity_fields_with_ranges_keeps_ctx_user_only(self):
        """ranges do not create multi-user write scopes."""
        ctx = create_ctx()
        messages = [
            create_message("user"),
            create_message("assistant"),
            create_message("user"),
            create_message("assistant"),
        ]
        extract_ctx = create_mock_extract_context(messages)

        # Mock read_message_ranges
        mock_range = MagicMock()
        mock_range.elements = [messages]
        extract_ctx.read_message_ranges.return_value = mock_range

        handler = MemoryIsolationHandler(ctx, extract_ctx)
        role_scope = handler.get_read_scope()

        item_dict = {"ranges": "0-3"}
        handler.fill_identity_fields(item_dict, role_scope)

        assert item_dict["user_id"] == "user_a"
        assert "user_ids" not in item_dict

    def test_fill_identity_fields_normalizes_explicit_peer_id(self):
        ctx = create_ctx()
        messages = [create_message("user", peer_id="web-visitor-alice")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        role_scope = handler.get_read_scope()

        item_dict = {"peer_id": "web-visitor-alice"}
        handler.fill_identity_fields(item_dict, role_scope)

        assert item_dict["user_id"] == "user_a"
        assert item_dict["peer_id"] == "web-visitor-alice"

    def test_invalid_peer_classification_does_not_change_identity_field_semantics(self):
        ctx = create_ctx()
        extract_ctx = create_mock_extract_context([create_message("user")])
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        role_scope = handler.get_read_scope()

        item_dict = {"peer_id": "web/visitor/alice"}
        resolution_skip = handler._classify_identity_fields(item_dict)
        result = handler.fill_identity_fields(item_dict, role_scope)

        assert resolution_skip is not None
        assert resolution_skip.reason_code == MemoryOperationSkipCode.INVALID_PEER_ID
        assert result is None
        assert item_dict == {"user_id": "user_a"}


class TestPrepareMessages:
    """Tests for prepare_messages under the user/peer model."""

    def test_prepare_messages_keeps_peer_metadata(self):
        ctx = create_ctx(user_id="login_user")
        messages = [
            create_message("user", "Hello"),
            create_message("assistant", "Hi"),
            create_message("user", "Hey", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        handler.prepare_messages()

        assert messages[2].peer_id == "web-visitor-alice"

    def test_get_read_scope_uses_ctx_user(self):
        ctx = create_ctx(user_id="login_user")
        messages = [
            create_message("user", "Hello"),
            create_message("assistant", "Hi"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        handler.prepare_messages()
        scope = handler.get_read_scope()

        assert scope.user_ids == ["login_user"]

    def test_get_read_scope_ignores_message_peer_id_without_target(self):
        ctx = create_ctx(user_id="login_user")
        messages = [
            create_message("user", "Hello", peer_id="web-visitor-alice"),
            create_message("assistant", "Hi"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        handler.prepare_messages()
        scope = handler.get_read_scope()

        assert scope.user_ids == ["login_user"]
        assert scope.peer_ids == []

    def test_get_read_scope_includes_allowed_peer_ids_when_enabled(self):
        ctx = create_ctx(user_id="login_user")
        messages = [
            create_message("user", "Hello", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allowed_peer_ids={"web-visitor-alice"},
        )
        handler.prepare_messages()
        scope = handler.get_read_scope()

        assert scope.user_ids == ["login_user"]
        assert scope.peer_ids == ["web-visitor-alice"]


class TestCalculateMemoryUris:
    """Tests for calculate_memory_uris (integration with URI generation)."""

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_single_user(self, mock_generate_uri):
        """Test calculate_memory_uris with a single user."""
        mock_generate_uri.return_value = "viking://user/user_a/memories/preferences"

        ctx = create_ctx()
        messages = [create_message("user")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )

        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"user_id": "user_a"},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert len(uris) == 1
        assert "user_a" in uris[0]

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_ignores_extracted_user_ids(self, mock_generate_uri):
        """LLM-extracted user_ids cannot redirect memory writes."""
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/test"
        )

        ctx = create_ctx()
        messages = [create_message("user")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(ctx, extract_ctx)

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="test",
            filename_template="test.md",
            directory="viking://user/{user_space}/memories",
        )

        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"user_ids": ["user_a", "user_b"]},
            memory_type="test",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/user_a/memories/test"]
        assert operation.memory_fields["user_id"] == "user_a"

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_routes_explicit_peer_memory(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(
            user_id="support_bot",
        )
        messages = [create_message("user", peer_id="web-visitor-alice")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allowed_peer_ids={"web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={
                "user_id": "alice",
                "peer_id": "web-visitor-alice",
            },
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/peers/web-visitor-alice/memories/preferences"]
        assert operation.memory_fields["user_id"] == "support_bot"
        assert operation.memory_fields["peer_id"] == "web-visitor-alice"

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_routes_ranges_to_self_and_peer(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "self event"),
            create_message("user", "peer event", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [messages]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "0-1"},
            memory_type="events",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert set(uris) == {
            "viking://user/support_bot/memories/events/demo",
            "viking://user/support_bot/peers/web-visitor-alice/memories/events/demo",
        }
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_ranges_ignore_assistant_peer_ids(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("assistant", "bot ack", peer_id="assistant-bot"),
            create_message("user", "peer event", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [messages]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"assistant-bot", "web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "0-1"},
            memory_type="events",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/peers/web-visitor-alice/memories/events/demo"]
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_ranges_without_user_fall_back_to_unique_user_peer(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "peer event", peer_id="peer-a"),
            create_message("assistant", "processed", peer_id="peer-a"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [[messages[1]]]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"peer-a"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "1-1"},
            memory_type="events",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/peers/peer-a/memories/events/demo"]
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_ranges_without_user_fall_back_to_unique_self(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "self event"),
            create_message("assistant", "processed", peer_id="assistant-peer"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [[messages[1]]]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"assistant-peer"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "1-1"},
            memory_type="events",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/memories/events/demo"]
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_ranges_with_unowned_assistant_fall_back_to_unique_user_peer(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "peer event", peer_id="peer-a"),
            create_message("assistant", "processed"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [[messages[1]]]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"peer-a"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "1-1"},
            memory_type="events",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/peers/peer-a/memories/events/demo"]
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_ranges_without_user_do_not_fallback_to_ambiguous_users(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "event a", peer_id="peer-a"),
            create_message("user", "event b", peer_id="peer-b"),
            create_message("assistant", "processed", peer_id="peer-a"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [[messages[2]]]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"peer-a", "peer-b"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "2-2"},
            memory_type="events",
            uris=[],
        )

        assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_ranges_without_user_ignore_assistant_only_peer(self, mock_generate_uri):
        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("assistant", "processed", peer_id="peer-a")]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [messages]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"peer-a"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "0-0"},
            memory_type="events",
            uris=[],
        )

        assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_unallowed_range_user_does_not_fallback_to_another_user(self, mock_generate_uri):
        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "allowed event", peer_id="peer-a"),
            create_message("user", "denied event", peer_id="peer-b"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [[messages[1]]]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"peer-a"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "1-1"},
            memory_type="events",
            uris=[],
        )

        assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_invalid_ranges_do_not_fallback_to_all_messages(self, mock_generate_uri):
        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user", "peer event", peer_id="peer-a")]
        extract_ctx = create_mock_extract_context(messages)
        extract_ctx.read_message_ranges.side_effect = ValueError("invalid ranges")
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"peer-a"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": "invalid"},
            memory_type="events",
            uris=[],
        )

        assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
        mock_generate_uri.assert_not_called()

    @pytest.mark.parametrize("ranges", ["99", "0,99", " , "])
    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_invalid_real_ranges_do_not_fallback_to_conversation_owner(
        self, mock_generate_uri, ranges
    ):
        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("assistant", "processed", peer_id="peer-a"),
            create_message("user", "peer event", peer_id="peer-a"),
        ]
        extract_ctx = ExtractContext(messages, split_long_text_messages=False)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"peer-a"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="events",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/events",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"event_name": "demo", "ranges": ranges},
            memory_type="events",
            uris=[],
        )

        assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_unallowed_peer_id_does_not_fallback(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", peer_id="web-visitor-bob"),
            create_message("user", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allowed_peer_ids={"web-visitor-bob"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"peer_id": "web-visitor-alice"},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == []
        assert operation.resolution_skip is not None
        assert operation.resolution_skip.reason_code == MemoryOperationSkipCode.PEER_NOT_ALLOWED
        assert "peer_id" not in operation.memory_fields
        mock_generate_uri.assert_not_called()

    def test_calculate_memory_uris_classifies_peer_policy_skip(self):
        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        ctx = create_ctx(user_id="support_bot")
        extract_ctx = create_mock_extract_context(
            [create_message("user", peer_id="web-visitor-alice")]
        )
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids=set(),
            peer_memory_enabled=False,
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"peer_id": "web-visitor-alice"},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(
            MemoryTypeSchema(
                memory_type="preferences",
                filename_template="preferences.md",
                directory="viking://user/{user_space}/memories",
            ),
            operation,
            extract_ctx,
        )

        assert uris == []
        assert operation.resolution_skip is not None
        assert operation.resolution_skip.reason_code == (
            MemoryOperationSkipCode.PEER_MEMORY_DISABLED
        )

    def test_calculate_memory_uris_classifies_invalid_ranges(self):
        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        ctx = create_ctx(user_id="support_bot")
        extract_ctx = create_mock_extract_context([create_message("user")])
        handler = MemoryIsolationHandler(ctx, extract_ctx)
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"ranges": "10-20"},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(
            MemoryTypeSchema(
                memory_type="preferences",
                filename_template="preferences.md",
                directory="viking://user/{user_space}/memories",
            ),
            operation,
            extract_ctx,
        )

        assert uris == []
        assert operation.resolution_skip is not None
        assert operation.resolution_skip.reason_code == MemoryOperationSkipCode.INVALID_RANGES
        extract_ctx.read_message_ranges.assert_called_once_with("10-20")

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_missing_peer_id_prefers_self_when_allowed(
        self, mock_generate_uri
    ):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "self turn"),
            create_message("assistant", "ack", peer_id="web-visitor-alice"),
            create_message("user", "peer turn", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/memories/preferences"]
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_missing_peer_id_uses_unique_user_peer_when_self_absent(
        self, mock_generate_uri
    ):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "peer turn one", peer_id="web-visitor-bob"),
            create_message("assistant", "ack", peer_id="web-visitor-bob"),
            create_message("assistant", "bot ack", peer_id="assistant-bot"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"assistant-bot", "web-visitor-bob"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/peers/web-visitor-bob/memories/preferences"]
        assert operation.memory_fields["user_id"] == "support_bot"
        assert operation.memory_fields["peer_id"] == "web-visitor-bob"

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_missing_peer_id_ignores_assistant_peer_when_self_absent(
        self, mock_generate_uri
    ):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("assistant", "bot ack", peer_id="assistant-bot"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"assistant-bot"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == []
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_missing_peer_id_drops_ambiguous_peer_when_self_absent(
        self, mock_generate_uri
    ):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "peer turn one", peer_id="web-visitor-bob"),
            create_message("user", "peer turn two", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"web-visitor-alice", "web-visitor-bob"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == []
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_peer_enabled_false_forces_self_scope_and_strips_peer_id(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/cases/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user", peer_id="web-visitor-alice")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="cases",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/cases",
            peer_enabled=False,
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"case_name": "demo", "peer_id": "web-visitor-alice"},
            memory_type="cases",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/memories/cases/demo"]
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_peer_enabled_false_does_not_write_self_when_self_disabled(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/cases/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user", peer_id="web-visitor-alice")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=False,
            allowed_peer_ids={"web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="cases",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/cases",
            peer_enabled=False,
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"case_name": "demo", "peer_id": "web-visitor-alice"},
            memory_type="cases",
            uris=[],
        )

        assert handler.allows_schema(schema) is False

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == []
        mock_generate_uri.assert_not_called()

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_peer_enabled_false_ignores_ranges_peer_targets(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/cases/demo"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [
            create_message("user", "self turn"),
            create_message("user", "peer turn", peer_id="web-visitor-alice"),
        ]
        extract_ctx = create_mock_extract_context(messages)
        mock_range = MagicMock()
        mock_range.elements = [messages]
        extract_ctx.read_message_ranges.return_value = mock_range
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allow_self=True,
            allowed_peer_ids={"web-visitor-alice"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="cases",
            filename_template="demo.md",
            directory="viking://user/{user_space}/memories/cases",
            peer_enabled=False,
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"case_name": "demo", "ranges": "0-1"},
            memory_type="cases",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == ["viking://user/support_bot/memories/cases/demo"]
        assert operation.memory_fields["user_id"] == "support_bot"
        assert "peer_id" not in operation.memory_fields

    @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
    def test_calculate_memory_uris_invalid_peer_id_does_not_fallback(self, mock_generate_uri):
        mock_generate_uri.side_effect = lambda **kwargs: (
            f"viking://user/{kwargs.get('user_space')}/memories/preferences"
        )

        ctx = create_ctx(user_id="support_bot")
        messages = [create_message("user", peer_id="web-visitor-bob")]
        extract_ctx = create_mock_extract_context(messages)
        handler = MemoryIsolationHandler(
            ctx,
            extract_ctx,
            allowed_peer_ids={"web-visitor-bob"},
        )

        from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation

        schema = MemoryTypeSchema(
            memory_type="preferences",
            filename_template="preferences.md",
            directory="viking://user/{user_space}/memories",
        )
        operation = ResolvedOperation(
            old_memory_file_content=None,
            memory_fields={"peer_id": "web/visitor/alice"},
            memory_type="preferences",
            uris=[],
        )

        uris = handler.calculate_memory_uris(schema, operation, extract_ctx)

        assert uris == []
        assert operation.resolution_skip is not None
        assert operation.resolution_skip.reason_code == MemoryOperationSkipCode.INVALID_PEER_ID
        assert "peer_id" not in operation.memory_fields
        mock_generate_uri.assert_not_called()