knowledge-platform/tests/unit/test_provider_wiring.py
2026-09-02 11:28:13 +08:00

193 lines
6.1 KiB
Python

"""Tests for secret-safe runtime provider composition."""
import pytest
from pydantic import SecretStr
from ekp_api.providers import (
ProviderConfigurationError,
create_dense_retrieval_service,
create_embedding_provider,
create_index_profile,
create_object_storage,
create_reranker_provider,
create_search_service,
create_vector_store,
)
from ekp_core.config import Settings
from ekp_embedding import FakeEmbeddingProvider
from ekp_object_storage import BosObjectStorage, LocalObjectStorage
from ekp_vector_store import FakeVectorStore
def test_provider_wiring_builds_profile_and_qianfan_without_network(
isolated_settings_environment: None,
) -> None:
settings = Settings(baidu_qianfan_api_key=SecretStr("test-key"))
profile = create_index_profile(settings)
embedding = create_embedding_provider(settings)
assert profile.profile_id == "demo-bge-large-zh-structure-v1-oceanbase-v1"
assert profile.chunk_strategy_version == "structure_v1"
assert profile.vector_dimension == 1024
assert embedding.model_name == profile.embedding_model
def test_provider_wiring_resolves_canonical_active_profile(
isolated_settings_environment: None,
) -> None:
from sqlalchemy import create_engine
from ekp_core.database import create_session_factory
from ekp_domain import Base, IndexProfileStatus, StoredIndexProfile
engine = create_engine("sqlite+pysqlite:///:memory:")
Base.metadata.create_all(engine)
session_factory = create_session_factory(engine)
with session_factory() as session:
session.add(
StoredIndexProfile(
profile_id="activated-oceanbase-v2",
chunk_strategy_version="structure_v1",
embedding_model="bge-large-zh",
vector_dimension=1024,
status=IndexProfileStatus.ACTIVE,
)
)
session.commit()
profile = create_index_profile(Settings(), session_factory)
assert profile.profile_id == "activated-oceanbase-v2"
def test_provider_wiring_requires_complete_oceanbase_target(
isolated_settings_environment: None,
) -> None:
settings = Settings()
with pytest.raises(ProviderConfigurationError, match="OCEANBASE_VECTOR_URI"):
create_vector_store(settings)
def test_provider_wiring_builds_oceanbase_from_secret_safe_settings(
monkeypatch: pytest.MonkeyPatch,
isolated_settings_environment: None,
) -> None:
captured: dict[str, object] = {}
expected = FakeVectorStore()
def fake_factory(**kwargs: object) -> FakeVectorStore:
captured.update(kwargs)
return expected
monkeypatch.setattr("ekp_api.providers.create_oceanbase_vector_store", fake_factory)
settings = Settings(
oceanbase_vector_uri="db.example:2881",
oceanbase_vector_user="test-user@test-tenant",
oceanbase_vector_password=SecretStr("test-password"),
oceanbase_vector_database="test_database",
)
vector_store = create_vector_store(settings)
assert vector_store is expected
assert captured["uri"] == "db.example:2881"
assert captured["password"] == "test-password"
assert captured["index_name"] == "vidx_knowledge_chunks_embedding"
assert captured["vector_dimension"] == 1024
def test_provider_wiring_keeps_local_storage_for_explicit_development_use(
isolated_settings_environment: None,
) -> None:
storage = create_object_storage(Settings(object_storage_provider="local"))
assert isinstance(storage, LocalObjectStorage)
def test_provider_wiring_requires_complete_bos_target(
isolated_settings_environment: None,
) -> None:
settings = Settings(object_storage_provider="bos")
with pytest.raises(ProviderConfigurationError, match="BOS_ENDPOINT"):
create_object_storage(settings)
def test_provider_wiring_builds_bos_without_network(
isolated_settings_environment: None,
) -> None:
settings = Settings(
object_storage_provider="bos",
bos_endpoint="https://bj.bcebos.com",
bos_access_key_id=SecretStr("test-access-key"),
bos_secret_access_key=SecretStr("test-secret-key"),
bos_bucket="ekp-test-bucket",
bos_key_prefix="tenant/demo",
)
storage = create_object_storage(settings)
assert isinstance(storage, BosObjectStorage)
def test_provider_wiring_builds_dense_retrieval_without_network(
isolated_settings_environment: None,
) -> None:
settings = Settings(dense_top_n=7)
profile = create_index_profile(settings)
embedding = FakeEmbeddingProvider(
model_name=profile.embedding_model,
dimensions=profile.vector_dimension,
)
service = create_dense_retrieval_service(
settings,
embedding,
FakeVectorStore(),
profile,
)
assert service.search("测试查询").candidates == ()
def test_provider_wiring_reuses_qianfan_key_for_demo_reranker(
isolated_settings_environment: None,
) -> None:
settings = Settings(baidu_qianfan_api_key=SecretStr("shared-test-key"))
reranker = create_reranker_provider(settings)
assert reranker.model_name == "bce-reranker-base"
assert reranker.max_documents == 64
def test_search_wiring_uses_configured_top_k(
isolated_settings_environment: None,
) -> None:
"""Keep the REST-facing default in typed configuration, not route code."""
from sqlalchemy import create_engine
from ekp_core.database import create_session_factory
from ekp_core.dense_retrieval import DenseRetrievalService
from ekp_domain import Base, IndexProfile
from ekp_reranker import FakeRerankerProvider
engine = create_engine("sqlite+pysqlite:///:memory:")
Base.metadata.create_all(engine)
session_factory = create_session_factory(engine)
settings = Settings(search_top_k=3, dense_top_n=20)
embedding = FakeEmbeddingProvider("fake", dimensions=4)
profile = IndexProfile("profile-v1", "structure_v1", "fake", 4)
dense = DenseRetrievalService(embedding, FakeVectorStore(), profile)
service = create_search_service(
settings,
session_factory,
dense,
FakeRerankerProvider(),
)
assert service.search("测试").results == ()