Skip to content

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

39.0 KB
Raw Blame
import pytest
import requests
from volcengine.base.Request import Request

from openviking.storage.errors import ConnectionError
from openviking.storage.vectordb.collection.collection import Collection
from openviking.storage.vectordb.collection.volcengine_clients import (
    ClientForConsoleApi,
    ClientForDataApi,
    ClientForDataApiWithApiKey,
)
from openviking.storage.vectordb.collection.volcengine_collection import VolcengineCollection
from openviking.storage.vectordb_adapters.base import VIKINGDB_STRING_FIELD_BYTE_LIMIT
from openviking.storage.vectordb_adapters.local_adapter import LocalCollectionAdapter
from openviking.storage.vectordb_adapters.vikingdb_private_adapter import (
    VikingDBPrivateCollectionAdapter,
)
from openviking.storage.vectordb_adapters.volcengine_adapter import VolcengineCollectionAdapter
from openviking_cli.utils.config.vectordb_config import (
    VectorDBBackendConfig,
    VolcengineConfig,
)


def test_console_client_prepare_request_includes_session_token():
    client = ClientForConsoleApi(
        "test-ak",
        "test-sk",
        "cn-beijing",
        session_token="test-session-token",
    )

    request = client.prepare_request(
        "POST",
        params={"Action": "ListVikingdbCollection", "Version": "2025-06-09"},
        data={"PageNumber": 1, "PageSize": 10},
    )

    assert request.headers["X-Security-Token"] == "test-session-token"
    assert "Authorization" in request.headers


def test_console_client_do_req_uses_signed_query_params(monkeypatch):
    captured = {}

    def fake_request(**kwargs):
        captured.update(kwargs)
        return object()

    def fake_prepare_request(self, method, params=None, data=None):
        request = Request()
        request.method = method
        request.path = "/"
        request.body = '{"PageNumber": 1, "PageSize": 10}'
        request.headers = {"Authorization": "signed-auth"}
        request.query = {
            "Action": "ListVikingdbCollection",
            "Version": "2025-06-09",
            "X-Date": "20260405T091640Z",
            "X-Signature": "signed",
        }
        return request

    monkeypatch.setattr(ClientForConsoleApi, "prepare_request", fake_prepare_request)

    client = ClientForConsoleApi("test-ak", "test-sk", "cn-beijing")
    monkeypatch.setattr(client._session, "request", fake_request)
    client.do_req(
        "POST",
        req_params={"Action": "ListVikingdbCollection", "Version": "2025-06-09"},
        req_body={"PageNumber": 1, "PageSize": 10},
    )

    assert captured["params"]["X-Date"] == "20260405T091640Z"
    assert captured["params"]["X-Signature"] == "signed"


def test_data_client_do_req_uses_signed_query_params(monkeypatch):
    captured = {}

    def fake_request(**kwargs):
        captured.update(kwargs)
        return object()

    def fake_prepare_request(self, method, path, params=None, data=None):
        request = Request()
        request.method = method
        request.path = path
        request.body = '{"project": "default"}'
        request.headers = {"Authorization": "signed-auth"}
        request.query = {
            "Action": "Search",
            "Version": "2025-06-09",
            "X-Date": "20260405T091640Z",
            "X-Signature": "signed",
        }
        return request

    monkeypatch.setattr(ClientForDataApi, "prepare_request", fake_prepare_request)

    client = ClientForDataApi("test-ak", "test-sk", "cn-beijing")
    monkeypatch.setattr(client._session, "request", fake_request)
    client.do_req(
        "POST",
        "/api/vikingdb/data/search/vector",
        req_params={"Action": "Search", "Version": "2025-06-09"},
        req_body={"project": "default"},
    )

    assert captured["params"]["X-Date"] == "20260405T091640Z"
    assert captured["params"]["X-Signature"] == "signed"


def test_clients_keep_pooled_session_reused_across_calls(monkeypatch):
    """Each client owns one keep-alive session that serves every request."""
    from requests.adapters import HTTPAdapter

    for client in (
        ClientForConsoleApi("test-ak", "test-sk", "cn-beijing"),
        ClientForDataApi("test-ak", "test-sk", "cn-beijing"),
        ClientForDataApiWithApiKey(
            api_key="vk-test-token",
            host="api-vikingdb.vikingdb.cn-beijing.volces.com",
        ),
    ):
        adapter = client._session.get_adapter("https://example.com")
        assert isinstance(adapter, HTTPAdapter)
        # HTTP and HTTPS share the same pooled adapter instance.
        assert client._session.get_adapter("http://example.com") is adapter

    seen_sessions = []

    def fake_prepare_request(self, *args, **kwargs):
        request = Request()
        request.method = "POST"
        request.path = "/api/vikingdb/data/search/vector"
        request.body = "{}"
        request.headers = {}
        request.query = {}
        return request

    def fake_request(self, **kwargs):
        seen_sessions.append(self)
        return object()

    monkeypatch.setattr(ClientForDataApi, "prepare_request", fake_prepare_request)
    monkeypatch.setattr(requests.Session, "request", fake_request)

    client = ClientForDataApi("test-ak", "test-sk", "cn-beijing")
    client.do_req("POST", "/api/vikingdb/data/search/vector")
    client.do_req("POST", "/api/vikingdb/data/search/vector")

    assert len(seen_sessions) == 2
    assert seen_sessions[0] is seen_sessions[1] is client._session


def test_data_api_key_client_prepare_request_sets_bearer_auth():
    client = ClientForDataApiWithApiKey(
        api_key="vk-test-token",
        host="api-vikingdb.vikingdb.cn-beijing.volces.com",
    )

    request = client.prepare_request(
        "POST",
        "/api/vikingdb/data/search/vector",
        data={"project": "default"},
    )

    assert request.headers["Authorization"] == "Bearer vk-test-token"
    assert request.headers["Host"] == "api-vikingdb.vikingdb.cn-beijing.volces.com"
    assert request.path == "/api/vikingdb/data/search/vector"


def test_volcengine_adapter_preserves_session_token_from_config():
    config = VectorDBBackendConfig(
        backend="volcengine",
        name="context",
        volcengine=VolcengineConfig(
            ak="test-ak",
            sk="test-sk",
            region="cn-beijing",
            session_token="test-session-token",
        ),
    )

    adapter = VolcengineCollectionAdapter.from_config(config)

    assert adapter._config()["SessionToken"] == "test-session-token"


def test_volcengine_adapter_supports_api_key_mode_from_config():
    config = VectorDBBackendConfig(
        backend="volcengine",
        name="context",
        project="default",
        volcengine=VolcengineConfig(
            api_key="vk-test-token",
            host="api-vikingdb.vikingdb.cn-beijing.volces.com",
        ),
    )

    adapter = VolcengineCollectionAdapter.from_config(config)

    assert adapter.mode == "volcengine"
    assert adapter.collection_name == "context"
    assert adapter.index_name == "default"
    assert adapter.collection_exists() is True
    assert adapter._config()["ApiKey"] == "vk-test-token"


def test_volcengine_collection_get_meta_data_returns_empty_on_signature_error(monkeypatch):
    class _Response:
        status_code = 403
        text = "signature mismatch"

        @staticmethod
        def json():
            return {
                "ResponseMetadata": {
                    "Error": {
                        "Code": "SignatureDoesNotMatch",
                        "Message": "The request signature we calculated does not match",
                    }
                }
            }

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )
    monkeypatch.setattr(collection.console_client, "do_req", lambda *args, **kwargs: _Response())

    assert collection.get_meta_data() == {}


def test_volcengine_collection_get_meta_data_raises_in_strict_mode(monkeypatch):
    from openviking.storage.vectordb.collection.collection import Collection

    class _Response:
        status_code = 503
        text = "service unavailable"

        @staticmethod
        def json():
            return {"ResponseMetadata": {"Error": {"Code": "InternalError"}}}

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )
    monkeypatch.setattr(collection.console_client, "do_req", lambda *args, **kwargs: _Response())

    with pytest.raises(ConnectionError, match="service unavailable"):
        Collection(collection).get_meta_data(raise_on_error=True)


def test_volcengine_collection_get_meta_data_returns_empty_on_collection_not_found(
    monkeypatch,
):
    class _Response:
        status_code = 404
        text = "collection not found"

        @staticmethod
        def json():
            return {
                "ResponseMetadata": {
                    "Error": {
                        "Code": "NotFound.VikingdbCollection",
                        "Message": "The specified collection 'context' of VikingDB does not exist.",
                    }
                }
            }

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )
    monkeypatch.setattr(collection.console_client, "do_req", lambda *args, **kwargs: _Response())

    assert collection.get_meta_data() == {}


def test_volcengine_collection_update_data_posts_to_update_endpoint(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"updated": 1}}

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )

    def _fake_do_req(method, path=None, req_params=None, req_body=None):
        captured["method"] = method
        captured["path"] = path
        captured["req_params"] = req_params
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    result = collection.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == {"updated": 1}
    assert captured["method"] == "POST"
    assert captured["path"] == "/api/vikingdb/data/update"
    assert captured["req_body"] == {
        "project": "default",
        "collection_name": "context",
        "data": [{"id": "doc-1", "name": "updated"}],
        "ignore_unknown_fields": True,
    }


@pytest.mark.parametrize("failure_path", ["/search/scalar", "/delete"])
@pytest.mark.parametrize("response_kind", [429, 500, "invalid_json", "success"])
def test_volcengine_delete_propagates_request_failures(monkeypatch, failure_path, response_kind):
    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )
    adapter = VolcengineCollectionAdapter.from_config(
        VectorDBBackendConfig(
            backend="volcengine",
            name="context",
            volcengine=VolcengineConfig(ak="test-ak", sk="test-sk", region="cn-beijing"),
        )
    )
    adapter._collection = Collection(collection)
    deleted_ids = []

    def fake_request(method, path, req_body):
        response = requests.Response()
        response.status_code = 200
        if path.endswith("/search/scalar"):
            response._content = (
                b'{"result":{"data":[{"id":"doc-1"}]}}'
                if req_body["offset"] == 0
                else b'{"result":{"data":[]}}'
            )
        else:
            assert path.endswith("/delete")
            deleted_ids.extend(req_body["ids"])
            response._content = b'{"result":{}}'
        if path.endswith(failure_path) and response_kind != "success":
            response.status_code = response_kind if isinstance(response_kind, int) else 200
            response._content = b"invalid JSON" if response_kind == "invalid_json" else b"{}"
        return response

    monkeypatch.setattr(collection.data_client, "do_req", fake_request)
    scope = {"op": "must", "field": "uri", "conds": ["/resources/expired"]}
    if response_kind == "success":
        assert adapter.delete(filter=scope) == 1
        assert deleted_ids == ["doc-1"]
    else:
        message = "invalid JSON" if response_kind == "invalid_json" else str(response_kind)
        with pytest.raises(ConnectionError, match=message):
            adapter.delete(filter=scope)
        if failure_path == "/search/scalar":
            assert deleted_ids == []


def test_volcengine_collection_update_data_sanitizes_uri_fields(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"updated": 1}}

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )

    def _fake_do_req(method, path=None, req_params=None, req_body=None):
        captured["method"] = method
        captured["path"] = path
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    collection.update_data(
        [{"id": "doc-1", "uri": "viking://resources/demo", "parent_uri": "viking://resources"}]
    )

    assert captured["path"] == "/api/vikingdb/data/update"
    assert captured["req_body"] == {
        "project": "default",
        "collection_name": "context",
        "data": [{"id": "doc-1", "uri": "/resources/demo", "parent_uri": "/resources"}],
        "ignore_unknown_fields": True,
    }


def test_volcengine_query_preserves_time_filters_and_applies_decay(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {
                "result": {
                    "data": [
                        {"id": "event", "score": 0.4, "origin_score": 0.8, "addition_score": 0.5}
                    ]
                }
            }

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )

    def _fake_do_req(method, path=None, req_params=None, req_body=None):
        captured["path"] = path
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    adapter = VolcengineCollectionAdapter.from_config(
        VectorDBBackendConfig(
            backend="volcengine",
            name="context",
            volcengine=VolcengineConfig(ak="test-ak", sk="test-sk", region="cn-beijing"),
        )
    )
    adapter._collection = Collection(collection)
    # Both date_time fields (created_at, updated_at) must be normalized to
    # time_range, while numeric range nodes are left untouched.
    result = adapter.query(
        query_vector=[1.0],
        limit=10,
        offset=2,
        advance={"time_decay": {"protection": "0", "origin": "2026-08-17T00:00:00Z"}},
        filter={
            "op": "and",
            "conds": [
                {
                    "op": "range",
                    "field": "created_at",
                    "gte": "2026-08-10T00:00:00+00:00",
                    "lt": "2026-08-11T00:00:00+00:00",
                },
                {
                    "op": "range",
                    "field": "updated_at",
                    "gte": "2026-08-10T00:00:00+00:00",
                },
                {"op": "range", "field": "level", "gte": 1},
            ],
        },
    )

    assert captured["path"] == "/api/vikingdb/data/search/vector"
    assert result == [{"id": "event", "_score": 0.4, "_origin_score": 0.8, "_time_score": 0.5}]
    body = captured["req_body"]
    assert (body["limit"], body["offset"]) == (10, 2)
    assert body["return_detail_info"] is True
    assert body["advance"] == {
        "post_process_ops": [
            {
                "op": "score_fusion",
                "fusion_by": "multiply",
                "normalize_for_origin_score": {"enable": False},
                "normalize_for_addition_score": {"enable": False},
                "addition_score": [
                    {
                        "factor": 1,
                        "base_value_from": "decay_func",
                        "field": "updated_at",
                        "func": "exp",
                        "origin": "2026-08-17T00:00:00.000Z",
                        "scale": "7d",
                        "decay": 0.5,
                    }
                ],
            }
        ]
    }
    assert captured["req_body"]["filter"] == {
        "op": "and",
        "conds": [
            {
                "op": "time_range",
                "field": "created_at",
                "gte": "2026-08-10T00:00:00+00:00",
                "lt": "2026-08-11T00:00:00+00:00",
            },
            {
                "op": "time_range",
                "field": "updated_at",
                "gte": "2026-08-10T00:00:00+00:00",
            },
            {"op": "range", "field": "level", "gte": 1},
        ],
    }


def test_volcengine_collection_date_time_filter_is_idempotent(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"data": []}}

    collection = VolcengineCollection(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )

    def _fake_do_req(method, path=None, req_params=None, req_body=None):
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    # Filters already emitted as time_range (e.g. from merge_time_filter) must
    # pass through unchanged.
    collection.search_by_scalar(
        index_name="default",
        field="created_at",
        filters={
            "op": "time_range",
            "field": "updated_at",
            "gte": "2026-08-10T00:00:00+00:00",
        },
    )

    assert captured["req_body"]["filter"] == {
        "op": "time_range",
        "field": "updated_at",
        "gte": "2026-08-10T00:00:00+00:00",
    }


def test_volcengine_api_key_collection_update_data_posts_to_update_endpoint(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"updated": 1}}

    from openviking.storage.vectordb.collection.volcengine_api_key_collection import (
        VolcengineApiKeyCollection,
    )

    collection = VolcengineApiKeyCollection(
        api_key="vk-test-token",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context", "IndexName": "default"},
    )

    def _fake_do_req(method, req_path=None, req_params=None, req_body=None):
        captured["method"] = method
        captured["path"] = req_path
        captured["req_params"] = req_params
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    result = collection.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == {"updated": 1}
    assert captured["method"] == "POST"
    assert captured["path"] == "/api/vikingdb/data/update"
    assert captured["req_body"] == {
        "project": "default",
        "collection_name": "context",
        "data": [{"id": "doc-1", "name": "updated"}],
        "ignore_unknown_fields": True,
    }


def test_volcengine_api_key_collection_update_data_sanitizes_uri_fields(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"updated": 1}}

    from openviking.storage.vectordb.collection.volcengine_api_key_collection import (
        VolcengineApiKeyCollection,
    )

    collection = VolcengineApiKeyCollection(
        api_key="vk-test-token",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context", "IndexName": "default"},
    )

    def _fake_do_req(method, req_path=None, req_params=None, req_body=None):
        captured["path"] = req_path
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    collection.update_data(
        [{"id": "doc-1", "uri": "viking://resources/demo", "parent_uri": "viking://resources"}]
    )

    assert captured["path"] == "/api/vikingdb/data/update"
    assert captured["req_body"] == {
        "project": "default",
        "collection_name": "context",
        "data": [{"id": "doc-1", "uri": "/resources/demo", "parent_uri": "/resources"}],
        "ignore_unknown_fields": True,
    }


def test_volcengine_api_key_collection_uses_date_time_filter_operator(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"agg": {"_total": 1}}}

    from openviking.storage.vectordb.collection.volcengine_api_key_collection import (
        VolcengineApiKeyCollection,
    )

    collection = VolcengineApiKeyCollection(
        api_key="vk-test-token",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context", "IndexName": "default"},
    )

    def _fake_do_req(method, req_path=None, req_params=None, req_body=None):
        captured["path"] = req_path
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    # Both date_time fields (created_at, updated_at) must be normalized to
    # time_range, while numeric range nodes are left untouched.
    collection.aggregate_data(
        index_name="default",
        filters={
            "op": "and",
            "conds": [
                {
                    "op": "range",
                    "field": "created_at",
                    "gte": "2026-08-10T00:00:00+00:00",
                    "lt": "2026-08-11T00:00:00+00:00",
                },
                {
                    "op": "range",
                    "field": "updated_at",
                    "gte": "2026-08-10T00:00:00+00:00",
                },
                {"op": "range", "field": "level", "gte": 1},
            ],
        },
    )

    assert captured["path"] == "/api/vikingdb/data/agg"
    assert captured["req_body"]["filter"] == {
        "op": "and",
        "conds": [
            {
                "op": "time_range",
                "field": "created_at",
                "gte": "2026-08-10T00:00:00+00:00",
                "lt": "2026-08-11T00:00:00+00:00",
            },
            {
                "op": "time_range",
                "field": "updated_at",
                "gte": "2026-08-10T00:00:00+00:00",
            },
            {"op": "range", "field": "level", "gte": 1},
        ],
    }


def test_volcengine_api_key_collection_date_time_filter_is_idempotent(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200

        @staticmethod
        def json():
            return {"result": {"data": []}}

    from openviking.storage.vectordb.collection.volcengine_api_key_collection import (
        VolcengineApiKeyCollection,
    )

    collection = VolcengineApiKeyCollection(
        api_key="vk-test-token",
        region="cn-beijing",
        meta_data={"ProjectName": "default", "CollectionName": "context", "IndexName": "default"},
    )

    def _fake_do_req(method, req_path=None, req_params=None, req_body=None):
        captured["req_body"] = req_body
        return _Response()

    monkeypatch.setattr(collection.data_client, "do_req", _fake_do_req)

    # Filters already emitted as time_range (e.g. from merge_time_filter) must
    # pass through unchanged.
    collection.search_by_scalar(
        index_name="default",
        field="created_at",
        filters={
            "op": "time_range",
            "field": "updated_at",
            "gte": "2026-08-10T00:00:00+00:00",
        },
    )

    assert captured["req_body"]["filter"] == {
        "op": "time_range",
        "field": "updated_at",
        "gte": "2026-08-10T00:00:00+00:00",
    }


def test_volcengine_adapter_update_data_returns_ids():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}]
            return {"updated": 1, "primary_keys": ["doc-1"]}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == ["doc-1"]


@pytest.mark.parametrize("operation", ["upsert", "update_data"])
def test_volcengine_adapter_truncates_abstract_at_remote_string_limit(operation):
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )
    captured = {}

    class _Collection:
        def upsert_data(self, data_list, ttl=0):
            captured["data"] = data_list
            return None

        def update_data(self, data_list):
            captured["data"] = data_list
            return {"updated": 1, "primary_keys": ["doc-1"]}

    adapter._collection = _Collection()
    abstract = "a" * (VIKINGDB_STRING_FIELD_BYTE_LIMIT - 3) + "你好"

    getattr(adapter, operation)([{"id": "doc-1", "abstract": abstract}])

    stored = captured["data"][0]["abstract"]
    assert len(stored.encode("utf-8")) <= VIKINGDB_STRING_FIELD_BYTE_LIMIT
    assert abstract.startswith(stored)
    assert stored.endswith("你")


def test_private_vikingdb_update_normalizes_remote_fields():
    adapter = VikingDBPrivateCollectionAdapter(
        host="unused.invalid",
        headers=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )
    captured = {}

    class _Collection:
        def update_data(self, data_list):
            captured["data"] = data_list
            return {"updated": 1, "primary_keys": ["doc-1"]}

    adapter._collection = _Collection()
    result = adapter.update_data(
        [
            {
                "id": "doc-1",
                "uri": "viking://resources/sample",
                "abstract": "😀" * VIKINGDB_STRING_FIELD_BYTE_LIMIT,
            }
        ]
    )

    stored = captured["data"][0]
    assert stored["uri"] == "/resources/sample"
    assert len(stored["abstract"].encode("utf-8")) <= VIKINGDB_STRING_FIELD_BYTE_LIMIT
    assert result == ["doc-1"]


def test_local_adapter_does_not_apply_remote_abstract_limit():
    adapter = LocalCollectionAdapter(
        collection_name="context", project_path="", index_name="default"
    )
    abstract = "😀" * VIKINGDB_STRING_FIELD_BYTE_LIMIT

    normalized = adapter._normalize_record_for_write({"abstract": abstract})

    assert normalized["abstract"] == abstract


def test_volcengine_adapter_update_data_returns_batch_primary_keys():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [
                {"id": "doc-1", "name": "updated-1"},
                {"id": "doc-2", "name": "updated-2"},
            ]
            return {"updated": 2, "primary_keys": ["doc-1", "doc-2"]}

    adapter._collection = _Collection()

    result = adapter.update_data(
        [
            {"id": "doc-1", "name": "updated-1"},
            {"id": "doc-2", "name": "updated-2"},
        ]
    )

    assert result == ["doc-1", "doc-2"]


def test_volcengine_adapter_update_data_returns_ids_from_ids_key():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}]
            return {"updated": 1, "ids": ["doc-1"]}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == ["doc-1"]


def test_volcengine_adapter_update_data_returns_batch_ids_from_ids_key():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [
                {"id": "doc-1", "name": "updated-1"},
                {"id": "doc-2", "name": "updated-2"},
            ]
            return {"updated": 2, "ids": ["doc-1", "doc-2"]}

    adapter._collection = _Collection()

    result = adapter.update_data(
        [
            {"id": "doc-1", "name": "updated-1"},
            {"id": "doc-2", "name": "updated-2"},
        ]
    )

    assert result == ["doc-1", "doc-2"]


def test_volcengine_adapter_update_data_falls_back_to_request_ids_when_backend_omits_them():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}]
            return {"updated": 1}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == ["doc-1"]


def test_volcengine_adapter_update_data_falls_back_to_batch_request_ids_when_backend_omits_them():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [
                {"id": "doc-1", "name": "updated-1"},
                {"id": "doc-2", "name": "updated-2"},
            ]
            return {"updated": 2}

    adapter._collection = _Collection()

    result = adapter.update_data(
        [
            {"id": "doc-1", "name": "updated-1"},
            {"id": "doc-2", "name": "updated-2"},
        ]
    )

    assert result == ["doc-1", "doc-2"]


def test_volcengine_adapter_update_data_falls_back_when_ids_key_is_not_a_list():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}]
            return {"updated": 1, "ids": "doc-1"}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == ["doc-1"]


def test_volcengine_adapter_update_data_falls_back_when_primary_keys_is_not_a_list():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}]
            return {"updated": 1, "primary_keys": "doc-1"}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == ["doc-1"]


def test_volcengine_adapter_update_data_returns_empty_when_backend_reports_zero_updates():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-404", "name": "updated"}]
            return {"updated": 0}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-404", "name": "updated"}])

    assert result == []


def test_volcengine_adapter_update_data_returns_empty_when_backend_dict_has_no_ids_or_updated_count():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-404", "name": "updated"}]
            return {"status": "ok"}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-404", "name": "updated"}])

    assert result == []


def test_volcengine_adapter_update_data_skips_records_without_id_in_fallback():
    adapter = VolcengineCollectionAdapter(
        ak="test-ak",
        sk="test-sk",
        region="cn-beijing",
        session_token=None,
        api_key=None,
        host=None,
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}, {"name": "missing-id"}]
            return {"updated": 2}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}, {"name": "missing-id"}])

    assert result == ["doc-1"]


def test_volcengine_adapter_update_data_supports_api_key_mode():
    adapter = VolcengineCollectionAdapter(
        ak=None,
        sk=None,
        region="cn-beijing",
        session_token=None,
        api_key="vk-test-token",
        host="api-vikingdb.vikingdb.cn-beijing.volces.com",
        project_name="default",
        collection_name="context",
        index_name="default",
    )

    class _Collection:
        def update_data(self, data_list):
            assert data_list == [{"id": "doc-1", "name": "updated"}]
            return {"updated": 1, "primary_keys": ["doc-1"]}

    adapter._collection = _Collection()

    result = adapter.update_data([{"id": "doc-1", "name": "updated"}])

    assert result == ["doc-1"]


def test_http_collection_update_and_fetch_data(monkeypatch):
    import json
    from dataclasses import asdict
    from types import SimpleNamespace

    from openviking.storage.vectordb.collection.http_collection import HttpCollection
    from openviking.storage.vectordb.collection.result import DataItem, FetchDataInCollectionResult

    record = {"id": "doc-1", "name": "updated"}
    expected = FetchDataInCollectionResult(
        items=[DataItem(id="doc-1", fields=record)], ids_not_exist=["doc-2"]
    )
    captured = {}

    def _fake_post(url, headers=None, json=None, timeout=None):
        captured.update(url=url, json=json)
        return SimpleNamespace(status_code=200, text='{"data": ["doc-1"]}')

    monkeypatch.setattr(requests, "post", _fake_post)
    # The bundled service serializes FetchDataInCollectionResult with asdict().
    monkeypatch.setattr(
        requests,
        "get",
        lambda *args, **kwargs: SimpleNamespace(
            status_code=200, text=json.dumps({"code": 0, "data": asdict(expected)})
        ),
    )
    collection = HttpCollection(
        ip="127.0.0.1",
        port=1933,
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )

    assert collection.update_data([record]) == ["doc-1"]
    assert captured["url"] == "http://127.0.0.1:1933/api/vikingdb/data/update"
    assert captured["json"] == {
        "project": "default",
        "collection_name": "context",
        "fields": json.dumps([record]),
    }
    assert collection.fetch_data(["doc-1", "doc-2"]) == expected


def test_http_adapter_strict_count_propagates_http_failure(monkeypatch):
    from openviking.storage.vectordb.collection.collection import Collection
    from openviking.storage.vectordb.collection.http_collection import HttpCollection
    from openviking.storage.vectordb_adapters.http_adapter import HttpCollectionAdapter

    class _Response:
        status_code = 503
        text = "unavailable"

        @staticmethod
        def raise_for_status():
            raise requests.HTTPError("503 unavailable")

    monkeypatch.setattr(
        "openviking.storage.vectordb.collection.http_collection.requests.post",
        lambda *args, **kwargs: _Response(),
    )
    adapter = HttpCollectionAdapter(
        host="127.0.0.1",
        port=1933,
        project_name="default",
        collection_name="context",
        index_name="default",
    )
    adapter._collection = Collection(
        HttpCollection(
            ip="127.0.0.1",
            port=1933,
            meta_data={"ProjectName": "default", "CollectionName": "context"},
        )
    )

    with pytest.raises(requests.HTTPError, match="503 unavailable"):
        adapter.strict_count()


def test_http_collection_update_index_preserves_explicit_empty_scalar_index(monkeypatch):
    captured = {}

    class _Response:
        status_code = 200
        text = '{"data": {}}'

    def _fake_post(url, headers=None, json=None, timeout=None):
        captured["url"] = url
        captured["json"] = json
        return _Response()

    monkeypatch.setattr(
        "openviking.storage.vectordb.collection.http_collection.requests.post",
        _fake_post,
    )

    from openviking.storage.vectordb.collection.http_collection import HttpCollection

    collection = HttpCollection(
        ip="127.0.0.1",
        port=1933,
        meta_data={"ProjectName": "default", "CollectionName": "context"},
    )

    collection.update_index("default", [])

    assert captured["url"].endswith("UpdateVikingdbIndex")
    assert captured["json"]["ScalarIndex"] == "[]"