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
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"] == "[]"